代码随想录day14

第9天

前言

主要知识点

● 理论基础
● 递归遍历
● 迭代遍历
● 统一迭代
满二叉树
满二叉树：如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。

如图所示：

完全二叉树
什么是完全二叉树？

完全二叉树的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2^(h-1) 个节点。

大家要自己看完全二叉树的定义，很多同学对完全二叉树其实不是真正的懂了。

我来举一个典型的例子如题：

前置知识

二叉树的种类：

二叉树的前中后序遍历

• 144. 二叉树的前序遍历
• 145. 二叉树的后序遍历
• 94. 二叉树的中序遍历

二叉树的递归排序

class Solution {
    // 前序递归遍历
    List<Integer> list = new ArrayList<>();
    public List<Integer> preorderTraversal(TreeNode root) {
        if(root!=null){
            list.add(root.val);
            if(root.left!=null){
                preorderTraversal(root.left);
            }
            if(root.right != null){
                preorderTraversal(root.right);
            }
        }
        return list;
    }
    //中序递归排序
     List<Integer> list = new ArrayList<Integer>();
    public List<Integer> inorderTraversal(TreeNode root) {
        
        if(root!=null){
            if(root.left != null) inorderTraversal(root.left);
            list.add(root.val);
            if(root.right != null) inorderTraversal(root.right);
            
        }
        return list;
    }
    //后序递归遍历
     List<Integer> list = new ArrayList<>();
    public List<Integer> postorderTraversal(TreeNode root) {
        if(root!=null){
            if(root.left!=null){
                postorderTraversal(root.left);
            }
            if(root.right!=null){
                postorderTraversal(root.right);
            }
            list.add(root.val);
        }
        return list;

    }
}

二叉树的迭代遍历

• 144. 二叉树的前序遍历
• 145. 二叉树的后序遍历
• 94. 二叉树的中序遍历

二叉树的递归遍历：

// 迭代前序遍历  
    // 前序遍历-->根左右  迭代前序遍历：根左右 
	//现在栈中存取根节点，判断当前栈内是否为空，不空，加入栈顶的值，然后加入左子节点，在加入右子节点
    public List<Integer> preorderTraversal(TreeNode root){
        List<Integer> res = new ArrayList<Integer>();
        if(root==null){
            return res;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);  
        while(!stack.isEmpty()){
            TreeNode node = stack.pop();
            res.add(node.val);
            if(node.left!=null){
                stack.push(node.left);
            }
            if(node.right!=null){
                stack.push(node.right);
            }
        }
        return res;
	}
//迭代后序遍历
 // 后序遍历
    public List<Integer> postorderTraversal(TreeNode root) {
        /*
            1、添加根结点
            2、判断栈是否为空，不空弹出栈顶数据，然后添加该元素的左节点和右节点入栈   中-->左-->右
            3、最后在反转
        */
        List<Integer> res = new ArrayList<>();
        if(root==null) return res;
        Stack<TreeNode> stack = new Stack<>();
        // 加入根节点
        stack.push(root);
        while(!stack.isEmpty()){
        //    将栈中的数据弹出
            TreeNode node = stack.pop();
            res.add(node.val);
            if(node.left!=null){
                stack.push(node.left);
            }
            if(node.right!=null){
                stack.push(node.right);
            }
        }
        Collections.reverse(res);
        return res;
    }
//迭代中序遍历
//中序遍历
public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null){
            return result;
        }
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        while (cur != null || !stack.isEmpty()){
           if (cur != null){
               stack.push(cur);
               cur = cur.left;
           }else{
               cur = stack.pop();
               result.add(cur.val);
               cur = cur.right;
           }
        }
        return result;
    }