फिक्स्ड लंबाई ढेर संरचना

Question

क्या एक निश्चित लंबाई ढेर के लिए सबसे अच्छा डेटा संरचना है (मैं मूल रूप से यह एक कतार कहा जाता है, लेकिन क्या मैं चाहता हूँ एक ढेर है) जहां आइटम सामने से जुड़ जाते हैं, और हर बार एक आइटम जोड़ा जाता है सामने से एक आइटम अंत से हटा दिया गया है? मोर्चे से विभिन्न लंबाई के उप-वर्गों का भी उपयोग किया जाएगा। मैं वैक्टर का उपयोग कर रहा था, अब clojure.lang.PersistentQueue और उंगली के पेड़ के बारे में सोच रहा था।

संपादित करें, स्पष्ट करने के लिए, की तरह कुछ:

> (def q (queue [1 2 3 4])) 
[1 2 3 4] 
> (push q 9 8 7) 
[7 8 9 1] 
> (peek (push q 9 8 7)) 
7 

EDIT2: आपके सभी सवालों के जवाब अब तक, इस मूल बातें करने के लिए वापस जा रहा और Clojure की खुशी पढ़ने में एक अभ्यास में बदल गया है, उदाहरण के लिए सीखने के लिए धन्यवाद कि subvec की subvec पहले subvec के वेक्टर के लिए एक संदर्भ को बरकरार रखे हुए है, जबकि तरह (vec (विपक्ष एक्स (कुछ subvec ... होगा अगर बार-बार इस्तेमाल सभी मध्यवर्ती subvecs के लिए संदर्भ अर्जित करते हैं। इस के प्रकाश में, कैसे एक वेक्टर के लिए धक्का के इस कार्यान्वयन के बारे में आधारित कतार?:

(defn push [v i n] (if (>= (count v) n) (conj (subvec v 1 n) i) (conj v i))) 

फिर परिणामी वेक्टर rseq जो मेरा मानना ​​है कि वैक्टर के साथ तेज है के माध्यम से पहुँचा जा सकता है (के अपने प्रयोग के कारण सूची ऑफसेट?)

Answer 1

https://github.com/amalloy/ring-buffer

Answer 2

पर Amalloy की अंगूठी बफर पर एक नज़र डालें IMO तुम सिर्फ उपयोग कर सकते हैं एक सूची:

(defn create-queue [len] 
    (atom (repeat len nil))) 

(defn push [queue new-items] 
    (let [len (count @queue) 
     len2 (count new-items)] 
    (if (>= len2 len) 
     (let [res (concat (take-last (- len2 len) new-items) 
         @queue)] 
     (reset! queue (take len new-items)) 
     res) 
     (let [res (take-last len2 @queue)] 
     (reset! queue (concat new-items 
           (drop-last len2 @queue))) 
     res)))) 

परीक्षण:

(def q (create-queue 4)) 

(take 4 @q) 
-> (nil nil nil nil) 
(push q [1 2 3]) 
-> (nil nil nil) 
(take 4 @q) 
-> (1 2 3 nil) 
(push q [4 5]) 
-> (3 nil) 
(take 4 @q) 
-> (4 5 1 2) 
(push q [6 7 8 9]) 
-> (4 5 1 2) 
(take 4 @q) 
-> (6 7 8 9) 
(push q [10 11 12 13 15 16]) 
-> (15 16 6 7 8 9) 
(take 4 @q) 
-> (10 11 12 13)