“逆序”中二进制树的级别顺序遍历，具有O（n）时间复杂度

Question

I want to traverse the given binary tree in reverse order using level order traversal (I have successfully implemented this part, I am unable to add new line after each level)

The output should be : (need not be in a formatted manner but each level should be in next/new line

 4     5
  2   3
    1

Here is my implementation

public void levelOrderTraversalInReverseOrderUsingStackAndQueue(Node root) {
    Stack<Node> stack = new Stack<>();
    Queue<Node> queue = new LinkedList<>();
    Node temp;

    queue.add(root);
    while (!queue.isEmpty()) {
        temp = queue.poll();
        stack.push(temp);
        // Enqueue first Right then left because we are storing the end result in stack which is actually LIFO
        if (temp.right != null) {
            queue.add(temp.right);
        }
        if (temp.left != null) {
            queue.add(temp.left);
        }
    }
    while (!stack.isEmpty()) {
        temp = stack.pop();
        System.out.print(temp.data + "\t");
    }
}

Node class

static class Node {
        int data;
        Node left;
        Node right;

        Node(int data) {
            this.data = data;
        }
    }

Output comes from my implementation

4   5   2   3   1

I thought of adding the null as a delimiter to identify each level, like how I did in Level Order Traversal from Top-to-Bottom but that attempt was not successful, can anyone suggest if this can be achieved.

Note With recursive solution I was able to add the new line, so there it's not a problem.

The running implementation is here: https://ideone.com/CSShmp

Answer 1

You just need to modify your loop like this:

    queue.add(root);
    while (!queue.isEmpty()) {
        if (stack.size()>0) {
            stack.push(null);
        }
        int sz = queue.size();
        for (int i=0; i<sz; ++i) {
            temp = queue.poll();
            stack.push(temp);
            // Enqueue first Right then left because we are storing the end result in stack which is actually LIFO
            if (temp.right != null) {
                queue.add(temp.right);
            }
            if (temp.left != null) {
                queue.add(temp.left);
            }
        }
    }

This way you process each level separately and stick nulls in the stack between them.

Answer 2

I have changed your code to use 2 queues to marks the levels with a special node with value(-99999). It is a standard implementation to identify end of levels. The following code worked for me.

public void levelOrderTraversalInReverseOrderUsingStackAndQueue(Node root) {
    Stack<Node> stack = new Stack<>();
    Queue<Node> queue1 = new LinkedList<>();
    Queue<Node> queue2 = new LinkedList<>();
    Node temp;

    queue1.add(root);
    while (!queue1.isEmpty() || !queue1.isEmpty()) {

        while (!queue1.isEmpty()) {
            temp = queue1.poll();
            stack.push(temp);
            // Enqueue first Right then left because we are storing the end result in stack which is actually LIFO
            if (temp.right != null) {
                queue2.add(temp.right);
            }
            if (temp.left != null) {
                queue2.add(temp.left);
            }
        }

        stack.push(new Node(-99999));

        while (!queue2.isEmpty()) {
            temp = queue2.poll();
            stack.push(temp);
            // Enqueue first Right then left because we are storing the end result in stack which is actually LIFO
            if (temp.right != null) {
                queue1.add(temp.right);
            }
            if (temp.left != null) {
                queue1.add(temp.left);
            }
        }

        stack.push(new Node(-99999));

    }

    while (!stack.isEmpty()) {
        temp = stack.pop();

        if (temp.data == -99999) {
            System.out.println();
            continue;
        }
        System.out.print(temp.data + "\t");
    }
}

Hope it helps!

Answer 3

I slightly changed your implementation and used a TreeMap with a custom Comparator to mark levels in reverse order.Although you are not actually traversing in reverse order in the first place, but it still remains O(n).

   public void levelOrderTraversalInReverseOrderUsingStackAndQueue(Node root) {
    Map<Integer,Stack<Node>> levelMap = new TreeMap<>((a,b)->{return -(a-b);});
    Queue<Node> queue = new LinkedList<>();
    Node temp;
    int level = 0;
    queue.add(root);
    levelMap.put(level,new Stack<>());
    levelMap.get(level).push(root);
    while (!queue.isEmpty()) {
        temp = queue.poll();
        if (temp.left != null) {
            level++;
            queue.add(temp.left);
            levelMap.put(level,new Stack<>());
            levelMap.get(level).push(temp.left);
        }
        if (temp.right != null) {
            queue.add(temp.right);
            levelMap.get(level).push(temp.right);
        }
    }
    for (Integer lvl : levelMap.keySet()){
        System.out.print("level "+lvl+"\t:");
        for (Node node: levelMap.get(lvl)){
            System.out.print(node+"\t");
        }
        System.out.println();
    }
}

I also managed to make it work using null separator as you'd like, but I prefer the 1st solution because it is more neat as a concept.

public static void levelOrderTraversalInReverseOrderUsingStackAndQueue(Node root) {
        Stack<Node> stack = new Stack<>();
        Queue<Node> queue = new LinkedList<>();
        Node temp;

        queue.add(root);
        stack.push(root);
        while (!queue.isEmpty()) {
            temp = queue.poll();
            if (temp.left != null) {
                stack.push(null);
                queue.add(temp.left);
                stack.push(temp.left);
            }
            if (temp.right != null) {
                queue.add(temp.right);
                stack.push(temp.right);
            }

        }
        while (!stack.isEmpty()) {
            temp = stack.pop();
            if (temp == null) {
                System.out.println();
            } else {
                System.out.print(temp.data + "\t");
            }
        }
    }

Hope it helps. Choose what best fits your purpose.