Question

Say I have a tree defined as per the recommendation in this post, although it’s a vector in my case, which hopefully shouldn’t matter (they’re vectors in Programming Clojure book):

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

which should be something like:

      1
     / \
    2   3
   / \  |
  4   5 6

Now, I’d like to do a breadth-first traversal of the tree without any of the traditional means such as the queue, and instead use exclusively the stack to pass information around. I know this isn’t the easiest route, but I’m doing it mostly as exercise. Also at this point I’m not planning to return a collection (I’ll figure that out afterwards as exercise) but instead just print out the nodes as I travel through them.

My current solution (just starting out with Clojure, be nice):

(defn breadth-recur
  [queue]
  (if (empty? queue)
    (println "Done!")
    (let [collections (first (filter coll? queue))]
      (do
        ; print out nodes on the current level, they will not be wrapped'
        ; in a [] vector and thus coll? will return false
        (doseq [node queue] (if (not (coll? node)) (println node)))
        (recur (reduce conj (first collections) (rest collections)))))))

The last line is not working as intended and I’m stumped about how to fix it. I know exactly what I want: I need to peel each layer of vectors and then concatenate the results to pass into recur.

The issue I’m seeing is mostly a:

IllegalArgumentException Don't know how to create ISeq from: java.lang.Long 

Basically conj doesn’t like appending a vector to a long, and if I swap conj for concat, then I fail when one of the two items I’m concatenating isn’t a vector. Both conj and concat fail when facing:

[2 [4] [5] [3 [6]]]

I feel like I’m missing a really basic operation here that would work both on vectors and primitives in both positions.

Any suggestions?

Edit 1:

The tree should actually be (thanks Joost!):

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

However we still haven’t found a breadth-first solution.

Answer 1

Since apparently there is still no breadth-first solution posted, here is a simple algorithm, implemented first eagerly, and then transformed to be lazy:

(defn bfs-eager [tree]
  (loop [ret [], queue (conj clojure.lang.PersistentQueue/EMPTY tree)]
    (if (seq queue)
      (let [[node & children] (peek queue)]
        (recur (conj ret node) (into (pop queue) children)))
      ret)))

(defn bfs-lazy [tree]
  ((fn step [queue]
     (lazy-seq
      (when (seq queue)
        (let [[node & children] (peek queue)]
          (cons node
                (step (into (pop queue) children)))))))
   (conj clojure.lang.PersistentQueue/EMPTY tree)))