[Day13]二叉树

用户939882835814
82 阅读5分钟

今日内容：二叉树的理论基础、递归遍历、迭代遍历、统一遍历 代码随想录链接：代码随想录 (programmercarl.com)

二叉树理论基础

基础知识都在代码随想录里，就不多讲了，写一下二叉树的定义：

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. 确定单层递归的逻辑：  确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。

前序，中序，后序，其实就是一个二叉树读取节点数值的位置，前序就是先读取val再遍历左节点右节点，中序就是先遍历左节点，然后读取val再遍历右节点，以此类推。

144.二叉树前序递归遍历

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        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);
    }
}

145.二叉树的后序递归遍历

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        postorder(root,result);
        return result;
    }

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

94.二叉树的中序递归遍历

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        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);
    }
}

二叉树迭代遍历

代码随想录说用栈来存储，不看答案试试看（激起了数据结构课的回忆）。

144.二叉树的前序迭代遍历

  1. 创建一个栈，把根节点入栈，当栈中非空，则开始迭代。

  2. 前序遍历则先将节点中的数值添加到result中

  3. 然后将左右节点压入栈中用以下一轮遍历，因为先进先出，所以先把右节点压入栈中，再压左节点。

  4. 最后为了避免root是空节点，然后第一次迭代时val为空报错，因此开头加上if语句。

得到代码如下：

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        Stack<TreeNode> treeStack = new Stack<TreeNode>();
        if (root == null){
            return result;
        }
        treeStack.push(root);
        while(!treeStack.isEmpty() ){
            TreeNode temp = treeStack.pop();
            result.add(temp.val);
            if(temp.right != null){
                treeStack.push(temp.right);
            }
            if(temp.left != null){
                treeStack.push(temp.left);
            }
        }
        return result;
    }
}

这种写法是出于栈的角度，开始写的。

94.二叉树的中序迭代遍历

中序的思路就不一样了，用前序的思路不太好写。

  1. 如果当前节点非空或者栈非空的时候，开始while循环，while循环内部的逻辑是，

  2. 如果当前节点非空，则将左节点压入栈，并指向左节点

  3. 如果当前节点空了，那么从栈中取出一个节点（返回上一个节点），读取val值，将右节点压入栈然后指向右节点。

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        Stack<TreeNode> treeStack = new Stack<TreeNode>();
        if (root == null){
            return result;
        }
        TreeNode temp = root;
        while(temp != null || !treeStack.isEmpty() ){
            if(temp != null){
                treeStack.push(temp);
                temp = temp.left;
            }
            else{
                temp = treeStack.pop();
                result.add(temp.val);
                temp = temp.right;
            }            
        }
        return result;
    }
}

这种写法是基于指针的角度开始写，栈只是中间的辅助。 我就想能不能用基于指针的角度写前序遍历，代码如下：

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        Stack<TreeNode> treeStack = new Stack<TreeNode>();
        if (root == null){
            return result;
        }
        TreeNode temp = root;
        while(temp != null || !treeStack.isEmpty() ){
            if(temp != null){
                result.add(temp.val);
                treeStack.push(temp);
                temp = temp.left;
            }
            else{
                temp = treeStack.pop();
                temp = temp.right;
            }
        }
        return result;
    }
}

145.二叉树的后序迭代遍历

用前面那个指针角度的写法直接改，好像不太行。

看答案，妙啊

再来看后序遍历，先序遍历是中左右，后续遍历是左右中，那么我们只需要调整一下先序遍历的代码顺序，就变成中右左的遍历顺序，然后在反转result数组，输出的结果顺序就是左右中了，如下图：

前序到后序

所以后序遍历只需要前序遍历的代码稍作修改就可以了，代码如下：

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        Stack<TreeNode> treeStack = new Stack<TreeNode>();
        if (root == null){
            return result;
        }
        treeStack.push(root);
        while(!treeStack.isEmpty() ){
            TreeNode temp = treeStack.pop();
            result.add(temp.val);
            if(temp.left != null){
                treeStack.push(temp.left);
            }
            if(temp.right != null){
                treeStack.push(temp.right);
            }
        }
        Collections.reverse(result);
        return result;
    }
}

二叉树的统一迭代法

就是用迭代法写出统一风格的代码

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

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

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

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        Stack<TreeNode> treeStack = new Stack<TreeNode>();
        if (root != null){
            treeStack.push(root);
        }
        while(!treeStack.isEmpty() ){
            TreeNode temp = treeStack.peek();
            if(temp != null){
                treeStack.pop();
                if(temp.right  != null){
                    treeStack.push(temp.right);
                }
                treeStack.push(temp);
                treeStack.push(null);
                if(temp.left  != null){
                    treeStack.push(temp.left);
                }
                temp = temp.left;
            }
            else{
                treeStack.pop();
                temp = treeStack.peek();
                treeStack.pop();
                result.add(temp.val);
            }            
        }
        return result;
    }
}

只要更改中间if(temp != null)下的前中后顺序即可切换前中后序。

结束！

avatar
文章
阅读
粉丝