在嵌套数据结构中查找第一次出现的路径

Question

考虑以下由向量嵌套在树形结构中的数字

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

我的目标是通过遍历树找到第一个偶数的路径：在上面的示例中，这将是 4，从根到该节点的路径将是 [2 3 0]

(def result [2 3 0])

我在编写一个函数来归档它时遇到了一些困难。但是，下面的函数会找到第一个偶数，而不是它的路径：

(defn find-even [x]
  (if (vector? x)
    (some #(when-let [subresult (find-even %)]
             (when (even? subresult)
               subresult)) x)
    x))

(find-even tree) ;; 4   

我需要做什么才能获得结果的路径？

---

编辑

我想出了一个办法。这是一个 - 至少 - 有效的函数：

(defn find-even-path [x]
  (letfn [(traverse [x]
            (if (vector? x)
              (some (fn [[i v]] (when-let [subresult (traverse v)]
                                  (when (even? (:value subresult))
                                    (update subresult :path conj i))))
                    (map-indexed vector x))
              {:path '()
               :value x}))]
    (when-let [result (traverse x)]
      (vec (:path result)))))

(find-even-path tree) ;; [2 3 0]

但是，我仍然很想知道这里可以优化什么。它在我看来仍然很复杂，而且还不是尾递归的。

Answer 1

这是一个选项。这个想法是在遍历列表时保留索引的“堆栈跟踪”（r 参数）。每次我们找到满足p 谓词的项目时，我们都会返回那个“stacktrace”。如果没有找到，我们简单地返回 nil。 mapcat 将所有非空（非零）列表连接到一个结果列表中：

(defn findt [t p r]
  (mapcat (fn[i c]
            (if (coll? c)
              (findt c p (cons i r))
              (when (p c) [(reverse (cons i r))]))) (range) t))

它仍然不是尾递归，但它可以找到所有路径（懒惰，由于使用mapcat）：

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

(findt tree even? [])
=> ((2 3 0) (2 3 1) (4 0))

我们可以通过以下方式对其进行测试：

(->> (findt tree odd? [])
 (map #(get-in tree %))
 (every? odd?))

Answer 2

这是一种尾递归的方法：

(defn tailrec-depth-first-path [is? tree]
  (loop [[tree i path fk] [tree 0 [] nil]]
    (cond
      (>= i (count tree))
        (if (nil? fk) nil (recur fk))
      (vector? (tree i))
        (recur [(tree i) 0 (conj path i) [tree (inc i) path fk]])
      (is? (tree i))
        (conj path i)
      :else
        (recur [tree (inc i) path fk]))))

(tailrec-depth-first-path even? [7 9 [7 5 3 [4 6 9] 9 3] 1 [2 7 9 9]])
=> [2 3 0]

该函数在path 每次下降到树的下方时都会向其添加一个索引。这里要注意的主要技巧是使用“失败延续”，由变量fk 表示。 fk 是传递给 loop 以在子树搜索失败后继续搜索的下一组参数，如果搜索位于顶层，则为 nil。这可以在不违反尾递归的情况下进行回溯。换句话说，在非尾递归版本中，完成递归调用后剩余工作所需的信息在尾递归版本中累积在 fk 中。

---

对我的 2009 MacBook Air（1.86 GHz Core 2 Duo）的快速测试表明，尾递归版本是迄今为止发布的答案中最快的：

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

(time (dotimes [_ 100000] (find-even-path tree)))
"Elapsed time: 1153.137475 msecs"

(time (dotimes [_ 100000] (first (findt tree even? []))))
"Elapsed time: 1413.502082 msecs"

(time (dotimes [_ 100000] (depth-first-path even? tree)))
"Elapsed time: 690.56115 msecs"

(time (dotimes [_ 100000] (tailrec-depth-first-path even? tree)))
"Elapsed time: 524.332278 msecs"

Answer 3

这不是尾递归，但很简单：

(defn depth-first-path 
 ([is? tree]
  (depth-first-path is? tree []))
 ([is? tree path-so-far]
  (cond
    (vector? tree)
      (some identity (map #(depth-first-path is? %1 (conj path-so-far %2))
                          tree
                          (range)))
    (is? tree)
      path-so-far
    :else
      nil)))

(depth-first-path even? [7 9 [7 5 3 [4 6 9] 9 3] 1 [2 7 9 9]])
=> [2 3 0]

我称之为depth-first-path，因为在搜索树时还有其他合理的方式来定义“第一”。

注意：我是 Clojure 的新手，我什至没有看过 clojure.walk 或 Specter。可能有更简单的方法。