0511-2020-LEETCODE-二叉树各种总结

大部分代码来源：LEETCODE

二叉树的性质

来源：大话数据结构
1：在二叉树的第i层最多有2的(i - 1)次方个节点
2：深度为k的二叉树最多有2的k次方 - 1个节点
3：对于任意一颗二叉树，叶子节点数等于度为2的节点数加1
4：具有n个节点的完全二叉树的深度是{log2(n) } 向下取整+1
5：编号（堆排序有用到）n个节点的二叉树从i = 1到n层序排序
i == 1,i就是二叉树的根，无双亲。i > 1,则其双亲是节点（i / 2）向下取整
2i > n ,说明i节点没有左孩子，否则2i就是i的左孩子
2i + 1 > n,说明i节点没有右孩子，否则2i + 1就是i的右孩子

Pre 二叉树的前中后层序遍历

ArrayList<Integer> res = new ArrayList<Integer>();

    public ArrayList<Integer> preOrder(TreeNode root) {
   
        if (root != null) {
   
            res.add(root.val);
            preOrder(root.left);
            preOrder(root.right);
        }
        return res;
    }

    public ArrayList<Integer> midOrder(TreeNode root) {
   
        if (root != null) {
   
            preOrder(root.left);
            res.add(root.val);
            preOrder(root.right);
        }
        return res;
    }

    public ArrayList<Integer> postOrder(TreeNode root) {
   
        if (root != null) {
   
            preOrder(root.left);
            preOrder(root.right);
            res.add(root.val);
        }
        return res;
    }

    public ArrayList<Integer> floorOrder(TreeNode root) {
   
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int size = 1;
        while (size > 0){
   
            for (int i = 0; i < size; i++) {
   
                TreeNode node = queue.poll();
                if (node.left != null){
   
                    queue.offer(node.left);
                    res.add(node.left.val);
                }
                if (node.right != null){
   
                    queue.offer(node.right);
                    res.add(node.right.val);
                }
            }
            size = queue.size();
        }
        return res;
    }

非递归

前序

	public List<Integer> preorderTraversal(TreeNode root) {
   
        if(root == null) return new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        List<Integer> list = new ArrayList<>();
        stack.add(root);
        while(!stack.isEmpty()) {
   
            TreeNode node = stack.pop();
            list.add(node.val);
            if(node.right != null) {
   
                stack.push(node.right);
            }
            if(node.left != null) {
   
                stack.push(node.left);
            }
        }
        return list;
    }

中序

	public List<Integer> inorderTraversal(TreeNode root) {
   
        List<Integer> list = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        while(cur != null || !stack.isEmpty()) {
   
            while(cur != null) {
   
                stack.push(cur);
                cur = cur.left;
            }
            cur = stack.pop();
            list.add(cur.val);
            cur = cur.right;
        }
        return list;
    }

后序

	public List<Integer> postorderTraversal(TreeNode root) {
   
        if(root == null) return new ArrayList<>();
        LinkedList<Integer> output = new LinkedList<>();
        Deque<TreeNode> list = new ArrayDeque<>();
        list.addLast(root);
        while(!list.isEmpty()) {
   
            TreeNode node = list.pollLast();
            output.addFirst(node.val);
            if(node.left != null) {
   
                list.addLast(node.left);
            }
            if(node.right != null) {
   
                list.addLast(node.right);
            }
        }
        return output;
    }



	public List<List<Integer>> levelOrder(TreeNode root) {
   
        List<List<Integer>> res = new ArrayList<>();
        if(root == null) return res;
        dfs(res,root,0);
        return res; 
    }
    public void dfs(List<List<Integer>> res,TreeNode root,int level) {
   
        if(res.size() - 1 < level) {
   
            res.add(new ArrayList<>());
        }
        res.get(level).add(root.val);
        if(root.left != null) {
   
            dfs(res,root.left,level + 1);