二叉树常见算法

前序遍历-递归

 public static void preOrder(TreeNode root){
        if(root == null)
            return;
        System.out.println(root.val);
        preOrder(root.left);
        preOrder(root.right);
    }

前序遍历-非递归

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

中序遍历-递归

 public static void inOrder(TreeNode root){
        if(root == null)return;
        inOrder(root.left);
        System.out.println(root.val);
        inOrder(root.right);
    }

中序遍历-非递归

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

            }

    }

后序遍历-递归

public static void postOrder(TreeNode root){
        if(root == null)return;
        postOrder(root.left);
        postOrder(root.right);
        System.out.println(root.val);
    }

后序遍历-非递归-两个栈

public static List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> ret = new ArrayList<Integer>();
        Stack<TreeNode> s1 = new Stack<>();
        Stack<TreeNode> s2 = new Stack<>();

        s1.push(root);
        while(!s1.isEmpty()){
            TreeNode node = s1.pop();
            if(node == null) continue;
            s2.push(node);
            s1.push(node.left);
            s1.push(node.right);
        }
        while(!s2.isEmpty()){
            ret.add(s2.pop().val);
        }
        return ret;
    }

后序遍历-非递归-一个栈

//解法一
public static List<Integer> postOrderTraversal(TreeNode root){
        ArrayList<Integer> list = new ArrayList<Integer>();
        if(root == null)return list;
        Stack<TreeNode> stack = new Stack<>();
        TreeNode lastNode = null;
        stack.push(root);
        while (!stack.isEmpty()){
            while (stack.peek().left != null){
               stack.push(stack.peek().left);
            }
            while(!stack.isEmpty()){
                if(lastNode == stack.peek().right || stack.peek().right == null){
                    TreeNode node = stack.pop();
                    list.add(node.val);
                    lastNode = node;
                }else if(stack.peek().right != null){
                    stack.push(stack.peek().right);
                    break;
                }
            }
        }
        return list;
    }

	//解法二
	 //按照前序遍历的思路 先求：root->right->left
    //然后再反转left -> right -> root
    public static List<Integer> postOrder(TreeNode root){
        ArrayList<Integer> list = new ArrayList<>();
        if(root == null)return list;
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()){
            TreeNode node = stack.pop();
            if(node == null)continue;
            list.add(node.val);
            stack.push(node.left);
            stack.push(node.right);
        }
        Collections.reverse(list);
        return list;
    }

二叉树按行打印

public static void BFSByLine(TreeNode root){
        if(root == null) return;
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.addLast(root);
        TreeNode preLast = root;
        TreeNode nextLast = null;
        while (!queue.isEmpty()){
            TreeNode node = queue.pollFirst();
            if(node == null)continue;
            System.out.println(node.val);
            if(node.left != null){
                queue.addLast(node.left);//注意不能用push,这里push是addFirst()
                nextLast = node.left;
            }
            if(node.right != null){
                queue.addLast(node.right);
                nextLast = node.right;
            }
            if(nextLast == preLast.right)
                preLast = nextLast;
        }
    }