day14【二叉树】递归遍历、迭代遍历 144. 二叉树的前序遍历 | 145. 二叉树的后序遍历 | 94. 二叉树的中序遍历

1.理论基础

• 代码随想录 | 基础讲解链接

1.1 二叉树的种类

1. 满二叉树

   • 节点数量：可以说深度为k，有2^k-1个节点的二叉树
   • 满二叉树是一种完全二叉树

2. 完全二叉树

   • 在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置，且底层节点从左到右是连续的
   • 若最底层为第 h 层，则该层包含 1~ 2^(h-1) 个节点。
   • 如下图③，它是一个完全二叉树。堆其实就是一个完全二叉树，同时保证父子节点的顺序关系。
   • 

3. 二叉搜索树：节点便于搜索，搜索一个节点的时间复杂度是log n级别的。

   • 满二叉树和完全二叉树是没有数值的，而二叉搜索树有数值，是一个有序树。
     • 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
     • 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
     • 它的左、右子树也分别为二叉排序树
   • 这两个棵树都是二叉排序树

4. 平衡二叉搜索树

   • 又被称为AVL（Adelson-Velsky and Landis）树，且具有以下性质：
   • 它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。
   • 下图最后一棵 不是平衡二叉树，因为它的左右两个子树的高度差的绝对值超过了1。

1.2 二叉树的存储方式

1.2.1 链式存储

• 用指针，通过指针把分布在各个地址的节点串联一起
  

1.2.2 线式存储（了解，用的不多）

• 用数组，顺序存储的元素在内存是连续分布的
  
• 如果父节点的数组下标是 i，那么它的左孩子就是 i * 2 + 1，右孩子就是 i * 2 + 2。

1.3 遍历方式

• 深度优先遍历：常用递归实现
  • 前序遍历（递归法，迭代法）：中左右
  • 中序遍历（递归法，迭代法）：左中右
  • 后序遍历（递归法，迭代法）：左右中
  • 栈其实是递归的一种实现结构，故前中后序遍历的逻辑可以接着组栈使用非递归的方式来实现。
• 广度优先遍历
  • 层次遍历（迭代法）

1.4 二叉树的定义

• 链式存储的二叉树节点的定义方式

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;
	}
}

2. 二叉树的递归遍历

2.1 递归三要素

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

2. 确定终止条件
   写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。

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

144. 二叉树的前序遍历

• 144.二叉树的前序遍历 | 题目链接

/**
 * Definition for a binary tree node.
 * 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;
 *     }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        preorder(root, result);
        return result;
    }

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

145. 二叉树的后序遍历

• 145.二叉树的后序遍历 | 题目链接

/**
 * Definition for a binary tree node.
 * 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;
 *     }
 * }
 */
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        postorder(root, result);
        return result;
    }
	
	//返回值是void，因为把结果放到res里了
    public void postorder(TreeNode root, List<Integer> result) {
    	//确定终止条件，当往下找遇到null的时候，就结束了
        if(root == null) {
            return;
        }
        //调换顺序
        postorder(root.left, result);
        postorder(root.right, result);
        result.add(root.val);
    }
}

94. 二叉树的中序遍历

• 94.二叉树的中序遍历 | 题目链接

/**
 * Definition for a binary tree node.
 * 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;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        inorder(root, result);
        return result;
    }

    public void inorder(TreeNode root, List<Integer> result) {
        if(root == null) {
            return;
        }
        //调换位置
        inorder(root.left, result);
        result.add(root.val);
        inorder(root.right, result);
    }
}

3.二叉树的迭代遍历（非递归）

3.1 迭代法前序遍历、后续遍历

• 144.二叉树的前序遍历
• 代码随想录 | 讲解链接
• 思路，笔记：
  • 用栈来实现迭代遍历，栈是先进后出
  • 如前序遍历，中左右。 先放中，然后出中。放右（因为右会后出），再放左（先出），左出了后再放左的右孩子……以此类推。可以看代码随想录的动画演示。
  • 前序和后序可以改变代码顺序完成，但中序的逻辑不一样。
• 前序迭代遍历：中-左-右，入栈顺序：中-右-左，出栈顺序：中-左-右

/**
 * Definition for a binary tree node.
 * 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;
 *     }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {      
        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.right != null) {
                stack.push(node.right);
            }
            if(node.left != null) {
                stack.push(node.left);
            }
        }
        return res;
    }
}

• 145.二叉树的后序遍历 | 题目链接
• 迭代法后序遍历：左-右-中，入栈顺序：中-左-右，出栈顺序：中-右-左，最后翻转结果：左-右-中

/**
 * Definition for a binary tree node.
 * 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;
 *     }
 * }
 */
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        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;
    }
}

3.2 迭代法中序遍历

• 94.二叉树的中序遍历 | 题目链接
• 迭代法中，中序遍历和前后序遍历的代码逻辑不同，中序遍历首先访问左孩子，但是我们不可能最先访问一个非根节点。所以，遍历的顺序和处理的顺序（入栈、出栈进结果数组）不一样了
• 迭代法中序遍历：左-中-右，入栈顺序：中-左-右，出栈顺序：中-右-左，最后翻转结果：左-右-中

/**
 * Definition for a binary tree node.
 * 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;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if(root == null) {
            return res;
        }

        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(); //如果当前访问的元素为空，cur就退回前节点
                res.add(cur.val); //先把它自己加进结果，相当于这个小二叉树的中，左已经没有了，就先加中。这一步就是在处理中。
                cur = cur.right; //再访问他自己的右孩子；
            }
        }
        return res;
    }
}

统一迭代遍历

• 代码随想录 | 讲解链接

• 思路：无法同时解决访问节点（遍历节点）和处理节点（将元素放进结果集）不一致的情况。

  那我们就将访问的节点放入栈中，把要处理的节点也放入栈中但是要做标记。

  如何标记呢，就是要处理的节点放入栈之后，紧接着放入一个空指针作为标记。 这种方法也可以叫做标记法。

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new LinkedList<>();
        Stack<TreeNode> st = new Stack<>();
        if (root != null) st.push(root);
        while (!st.empty()) {
            TreeNode node = st.peek();
            if (node != null) {
                st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
                if (node.right!=null) st.push(node.right);  // 添加右节点（空节点不入栈）
                if (node.left!=null) st.push(node.left);    // 添加左节点（空节点不入栈）
                st.push(node);                          // 添加中节点
                st.push(null); // 中节点访问过，但是还没有处理，加入空节点做为标记。
                
            } else { // 只有遇到空节点的时候，才将下一个节点放进结果集
                st.pop();           // 将空节点弹出
                node = st.peek();    // 重新取出栈中元素
                st.pop();
                result.add(node.val); // 加入到结果集
            }
        }
        return result;
    }
}