Question

简介

以下函数迭代地遍历由嵌套向量组成的树结构。它针对谓词测试每个叶子。通过该真值测试的所有叶子的路径在Trie structure中返回。后者以非冗余方式描述了所有找到的路径。

(defn get-trie-of-matches [is? tree]
  (loop [[tree i path fk] [tree 0 [] nil]
         accum {}]
    (cond
      (>= i (count tree)) ;; end of level / go up
      (if (nil? fk) accum (recur fk accum))

      (vector? (tree i)) ;; level down
      (recur [(tree i) 0 (conj path i) [tree (inc i) path fk]] accum)

      (is? (tree i)) ;; match
      (let [new-accum (assoc-in accum (conj path i) {})]
        (recur [tree (inc i) path fk] new-accum))

      :else ;; next on same level
      (recur [tree (inc i) path fk] accum))))

有关详细说明，请参阅this post。

示例

考虑以下树

(def tree [7 9 [7 5 3 [4 6 9] 9 3] 1 [2 7 9 9]])

应用于函数，使用even?作为谓词：

(get-trie-of-matches even? tree)
=> {2 {3 {0 {}, 1 {}}}, 4 {0 {}}}

结果描述了tree中偶数的三条路径。即2-3-0，2-3-1和4-0。

问题

即使上面的函数有效，但在遍历树时可能有更好的方法来构造Trie。目前，哈希映射被淹没了。通过assoc-in进行每场比赛。算法从一个级别到另一个级别相对遍历树结构，但是以全局方式将每个路径附加到accum，这不是必需的。此方法也是可行的，因为使用了散列映射。无论如何，为Trie使用顺序数据结构可能更好，以便于对其进行进一步的迭代。这不能用于上述方法。

问题

如何在上述函数get-trie-of-matches中创建Trie而不依赖于特定于散列图的'全局''写'函数？

Answer 1

我建议你看看clojure的walk api。

它允许您以递归方式将某些函数应用于嵌套集合。在这种情况下，您可以使用postwalk：

user> (require '[clojure.walk :as w])
user> (w/postwalk-demo [1 3 [4 [6] 7] [[8]]])
Walked: 1
Walked: 3
Walked: 4
Walked: 6
Walked: [6]
Walked: 7
Walked: [4 [6] 7]
Walked: 8
Walked: [8]
Walked: [[8]]
Walked: [1 3 [4 [6] 7] [[8]]]

[1 3 [4 [6] 7] [[8]]]

关键是你可以在每一步都替换任何项目：

user> (w/postwalk #(if (coll? %) (reverse %) (inc %))
                  [1 3 [4 [6] 7] [[8]]])

(((9)) (8 (7) 5) 4 2)

这里我们递增所有数字，并反转所有集合，保持嵌套结构。

现在适用于您的任务：您可以遍历您的树，保留偶数数字的索引而不是空集合（例如，包含偶数的集合，而不是空集合）：

;; helper function
(defn empty-coll? [item]
  (and (coll? item) (not (seq item))))

(defn make-trie [pred tree]
  (w/postwalk
   #(if (coll? %)
      (keep-indexed (fn [idx item]
                      (cond (empty-coll? item) nil
                            (coll? item) (list idx item)
                            item idx
                            :else nil))
                    %)
      (pred %))
   tree))

在repl中：

user> (def tree [7 9 [7 5 3 [4 6 9] 9 3] 1 [2 7 9 9]])
#'user/tree

user> (make-trie even? tree)
((2 ((3 (0 1)))) (4 (0)))

user> (make-trie #(> % 7) tree)
(1 (2 ((3 (2)) 4)) (4 (2 3)))

结构类似于您的地图。实际上，您可以通过对函数进行微小更改来生成所需的任何结构，例如地图结构：

(defn make-trie-map [pred tree]
  (w/postwalk
   #(if (coll? %)
      (into {}
            (keep-indexed (fn [idx item]
                            (cond (empty-coll? item) nil
                                  (coll? item) {idx item}
                                  item {idx {}}
                                  :else nil))
                          %))
      (pred %))
   tree))

user> (make-trie-map even? tree)
{2 {3 {0 {}, 1 {}}}, 4 {0 {}}}

从树上迭代地构造Trie

1 个答案: