代码随想录day14

二叉树理论基础篇

二叉树的种类

满二叉树

如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树

这棵二叉树为满二叉树，也可以说深度为k，有2^k-1个节点的二叉树

完全二叉树

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

二叉树的存储方式

二叉树可以链式存储，也可以顺序存储。

那么链式存储方式就用指针， 顺序存储的方式就是用数组

二叉树的遍历方式

• 深度优先遍历
  • 前序遍历（递归法，迭代法）
  • 中序遍历（递归法，迭代法）
  • 后序遍历（递归法，迭代法）
• 广度优先遍历
  • 层次遍历（迭代法）

二叉树的定义

public class TreeNode {
    int val;
  	TreeNode left;
  	TreeNode right;
  	TreeNode() {}
  	TreeNode(int val) { this.val = val; }
  	TreeNode(int val, TreeNode left, TreeNode right) {
    		this.val = val;
    		this.left = left;
    		this.right = right;
  	}
}

二叉树的递归遍历

1.确定递归函数的参数和返回值：

​ 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。

2.确定终止条件：

​ 写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，

​ 操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。

3.确定单层递归的逻辑：

​ 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。

//前序遍历
public List<Integer> preorderTraversal(TreeNode root){
    List<Integer> result = new ArrayList<>();
    preorder(root,result);
    return result;
}

private void preorder(TreeNode root, List<Integer> result) {
    if (root==null){
        return;
    }
    result.add(root.val);
    preorder(root.left,result);
    preorder(root.right,result);
}

//中序遍历
public List<Integer> inorderTraversal(TreeNode root){
    List<Integer> result = new ArrayList<>();
    inorder(root,result);
    return result;
}

private void inorder(TreeNode root, List<Integer> result) {
    if (root==null){
        return;
    }
    inorder(root.left,result);
    result.add(root.val);
    inorder(root.right,result);
}

//后序遍历
public List<Integer> postorderTraversal(TreeNode root){
    List<Integer> result = new ArrayList<>();
    postorder(root,result);
    return result;
}

private void postorder(TreeNode root, List<Integer> result) {
    if (root==null){
        return;
    }
    inorder(root.left,result);
    inorder(root.right,result);
    result.add(root.val);
}

二叉树的迭代遍历

前序遍历（中左右）

用一个栈存储需要处理的节点，前序遍历是中左右，每次先处理的是中间节点，那么先将根节点放入栈中，然后将右节点加入栈，再加入左节点

后序遍历（左右中）

和前序遍历差不多

因为将前序遍历处理后面两个节点的顺序变一下，变成中右左

此时在reverse一下，就能得到后序遍历了

中序遍历（左中右）

和前后序遍历不同，中序遍历处理元素不一样

因为前序遍历的顺序是中左右，先访问的元素是中间节点，要处理的元素也是中间节点，所以刚刚才能写出相对简洁的代码，因为要访问的元素和要处理的元素顺序是一致的，都是中间节点

中序需要借用指针的遍历来帮助访问节点，栈则用来处理节点上的元素

//前序遍历
public List<Integer> preorderTraversal(TreeNode root){
    List<Integer> result = new ArrayList<>();
    Stack<TreeNode> stack=new Stack<>();
    stack.push(root);
    while (stack.size()!=0){
        TreeNode pop = stack.pop();
        if (pop==null)
            continue;
        result.add(pop.val);
        stack.push(pop.right);
        stack.push(pop.left);
    }
    return result;
}
//后序遍历
public List<Integer> postorderTraversal(TreeNode root) {
    List<Integer> result = new ArrayList<>();

    Stack<TreeNode> stack=new Stack<>();
    stack.push(root);
    while (stack.size()!=0){
        TreeNode pop = stack.pop();
        if (pop==null)
            continue;
        result.add(pop.val);
        stack.push(pop.left);
        stack.push(pop.right);

    }
    Collections.reverse(result);
    return result;
}
//中续遍历
public List<Integer> inorderTraversal(TreeNode root){
    List<Integer> result = new ArrayList<>();
    if (root==null){
        return result;
    }
    Stack<TreeNode> stack=new Stack<>();
    TreeNode node=root;
    while (node!=null||!stack.isEmpty()){
        if (node!=null){
            stack.push(node);
            node=node.left;
        }else {
            node=stack.pop();
            result.add(node.val);
            node=node.right;
        }
    }
    return result;
}