नोड्स संपादित करने के लिए clojure.zip के साथ पोस्टऑर्डर पेड़ ट्रैवर्सल

Question

मेरे पास एक पेड़ है जो नेस्टेड वेक्टर के रूप में दर्शाया गया है। मैं पेड़ों के लिए indexed, इस तरह प्रत्येक नोड के सूचकांक दिखाने का एक सामान्यीकरण करना चाहते हैं,

(visit 42); => [0 42] 
(visit [6 7]); => [0 
       ;  [[0 6] 
       ;  [1 7]]] 

अनुभवहीन कार्यान्वयन clojure.zip सीधे (as already asked here)

(defn visit [tree] 
    (loop [loc (vector-zip tree)] 
    (if (end? loc) 
     (root loc) 
     (recur 
     (next (edit loC#(conj 
          [(count (lefts loc))] 
          %))))))) 

का प्रयोग करेंगे लेकिन clojure.zip/next साथ आवर्ती एक प्रीऑर्डर ट्रैवर्सल करता है, जिसके परिणामस्वरूप इस मामले में एक अनंत लूप होता है (अवांछित नोड conj एड [:found] वेक्टर असीमित रूप में) प्राप्त करते हैं। एक और दृष्टिकोण clojure.walk/postwalk का उपयोग करेगा, लेकिन यह सूचकांक जैसे संरचनात्मक जानकारी प्रदान नहीं करता है।

आप इसे कैसे कार्यान्वित करेंगे? क्या ज़िप के लिए postorder-next है जो इसे तुरंत हल करेगा?

Answer 1

मुझे यकीन नहीं है कि मैं समझ रहा हूं कि आप क्या करने की कोशिश कर रहे हैं, लेकिन उदाहरण मुझे सुझाव देते हैं कि नोड्स को सौंपा गया सूचकांक उनके बाएं भाई बहनों की संख्या से मेल खाता है (क्योंकि दूसरे उदाहरण में रूट नोड और 6 बच्चे को 0 के साथ लेबल किया गया है)। अपडेट: जाहिर है, मैंने पहली बार visit उदाहरण को गलत तरीके से गलत तरीके से पढ़ा है - यह इरादा स्पष्ट रूप से स्पष्ट करता है ... सौभाग्य से अब मैंने इसे ठीक से पढ़ा है, ऐसा लगता है कि नीचे दिया गया जवाब सही है।

(defn index-vec-tree [vt] 
    [0 (walk/postwalk 
     (fn [node] 
     (if-not (vector? node) 
      node 
      (vec (map-indexed vector node)))) 
     vt)]) 

दिया उदाहरण के साथ

:

user> (index-vec-tree [6 7]) 
[0 [[0 6] [1 7]]] 
user> (index-vec-tree 42) 
[0 42] 

अद्यतन: एक सरल समाधान map-indexed का उपयोग कर (1.2 में उपलब्ध

अगर वह सही है, तो यह एक clojure.walk/postwalk आधारित समाधान है ; map + clojure.contrib.seq-utils/indexed 1.1 में उपयोग करें):

(defn index-vec-tree [vt] 
    (letfn [(iter [i vt] [i (if (vector? vt) 
           (vec (map-indexed iter vt)) 
           vt)])] 
    (iter 0 vt)))