二叉树相关算法题

1.二叉树前序遍历非递归版

思路：使用一个栈（为了让遍历的节点可以从树的底层回到上层），先添加右子树再添加左子树

    public static void preOrder(Node root) {
        Stack<Node> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()) {
            Node node = stack.pop();
            System.out.println(node.val);
            if (node.right != null) {
                stack.push(node.right);
            }
            if (node.left != null) {
                stack.push(node.left);
            }
        }
    }

2.二叉树中序遍历非递归版

思路：同样利用栈结构，每次入栈一个节点的左边界

    public static void infixOrder(Node root) {
        Stack<Node> stack = new Stack<>();
        stack.push(root);
        Node node = root;
        while (!stack.isEmpty()) {
            if (node.left != null) {
                while (node.left != null) {
                    stack.push(node.left);
                    node = node.left;
                }
            } else {
                //当某个节点的左子节点为空时，输出该节点
                node = stack.pop();
                System.out.println(node.val);
                //开始压栈当前节点右子树的左边界
                if (node.right != null) {
                    stack.push(node.right);
                    node = node.right;
                }
            }
        }
    }

3.二叉树后序遍历非递归版

思路，因为前序遍历是中左右，如果将上述的前序遍历先压左孩子再压右孩子那么得到的遍历结过将为中右左，将这个顺序反过来就是左右中，即后序遍历，因此想要两个栈来实现。

public static void postOrder(Node root) {
        Stack<Node> stack1 = new Stack<>();
        Stack<Node> stack2 = new Stack<>();
        stack1.push(root);
        while (!stack1.isEmpty()) {
            Node node = stack1.pop();
            stack2.push(node);
            if (node.left != null) {
                stack1.push(node.left);
            }
            if (node.right != null) {
                stack1.push(node.right);
            }
        }
        while (!stack2.isEmpty()) {
            System.out.println(stack2.pop().val);
        }
    }

4.不带层次结构的层次遍历

思路：采用队列（因为层次遍历是从上到下不需要回到上层）的结构来实现，先入队左孩子，再入队右孩子。

    public static void levelOrder(Node root) {
        Queue<Node> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            Node node = queue.poll();
            System.out.println(node.val);
            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
        }
    }

5.带层次结构的层次遍历

思路：在上述基础上使用一个整数变量来记录当前层的节点个数，第一轮循环时size为1（root节点），后续每次出队size都减一，当size为0时，队列中的元素全部都是下一次层次的节点个数，因此将size置为队列的长度。

    public static void levelOrder1(Node root) {
        Queue<Node> queue = new LinkedList<>();
        queue.offer(root);
        ArrayList<ArrayList<Node>> res = new ArrayList<>();
        ArrayList<Node> list = new ArrayList<>();
        int size = 1;
        while (!queue.isEmpty()) {
            Node node = queue.poll();
            list.add(node);
            size--;
            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
            if (size == 0) {
                res.add(list);
                list = new ArrayList<>();
                size = queue.size();
            }
        }
        for (ArrayList<Node> re : res) {
            for (Node node : re) {
                System.out.print(node.val + " ");
            }
            System.out.println();
        }
    }

6.在二叉树中找到一个节点的后继节点

二叉树的节点类型如下：

public static class Node {
    public int value;
    public Node left;
    public Node right;
    public Node parent;

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

思路：
两个条件
（1）如果当前节点的右子树不为空，则返回右子树的最左节点
（2）否则判断当前节点是否是其父节点的左孩子，如果是则其父节点为后继节点，如果不是，则当前节点移动到父节点位置继续判断。

    public Node getNextNode(Node node){
        if (node == null)
            return null;
        if(node.right!=null){
            return getLeftMost(node.right);
        }
        while (node.parent!=null&&node!=node.parent.left){
            node = node.parent;
        }
        return node.parent;
    }
    public Node getLeftMost(Node node){
        if (node.left==null){
            return node;
        }
        while (node.left!=null){
            node = node.left;
        }
        return node;
    }