day14 二叉树part1

统一迭代法只搞懂了大概,真的没时间再写了。二刷的你如果有时间可以再琢磨琢磨,思路我理了个大概了。

ac是啥意思?
day14 二叉树part1_第1张图片

(labuladong)先在开头总结一下,二叉树解题的思维模式分两类:
1、是否可以通过遍历一遍二叉树得到答案?如果可以,用一个 traverse 函数配合外部变量来实现,这叫「遍历」的思维模式。
2、是否可以定义一个递归函数,通过子问题(子树)的答案推导出原问题的答案?如果可以,写出这个递归函数的定义,并充分利用这个函数的返回值,这叫「分解问题」的思维模式。

C++中map、set、multimap,multiset的底层实现都是平衡二叉搜索树,所以map、set的增删操作时间时间复杂度是logn,注意我这里没有说unordered_map、unordered_set,unordered_map、unordered_set底层实现是哈希表。(这个我还真不清楚,等以后再补吧,先记下了)

所以大家使用自己熟悉的编程语言写算法,一定要知道常用的容器底层都是如何实现的,最基本的就是map、set等等,否则自己写的代码,自己对其性能分析都分析不清楚!

前置知识

①度:(我的理解:就是这个节点有几条边的意思)
day14 二叉树part1_第2张图片
②在我们解题过程中二叉树有两种主要的形式:满二叉树和完全二叉树。
图片引自:满二叉树和完全二叉树 - 书耳的文章 - 知乎
https://zhuanlan.zhihu.com/p/152285992
day14 二叉树part1_第3张图片
day14 二叉树part1_第4张图片
day14 二叉树part1_第5张图片
day14 二叉树part1_第6张图片
二叉树主要有两种遍历方式:
①深度优先遍历:先往深走,遇到叶子节点再往回走。
②广度优先遍历:一层一层的去遍历。

day14 二叉树part1_第7张图片
day14 二叉树part1_第8张图片

以下内容来自:
一文搞懂二叉树的前序遍历,中序遍历,后序遍历 - 育树霖疯的文章 - 知乎
https://zhuanlan.zhihu.com/p/404837352
所谓前序,中序,后续遍历命名的由来是我们访问二叉树,根节点的顺序。前序遍历就是优先访问根节点,中序遍历是第二个访问根节点,后续遍历就是访问完左右节点之后,最后访问根节点。注意访问二字。访问和获取是两个不同的概念,我们可以获取一个节点,但是不访问他。对应在计算机里的概念是,获取一个节点表示将他入栈,访问一个节点是他处于栈顶,我们即将让他出栈。
day14 二叉树part1_第9张图片
以下内容来自labuladong:https://labuladong.github.io/algo/di-yi-zhan-da78c/shou-ba-sh-66994/dong-ge-da-334dd/#%E6%B7%B1%E5%85%A5%E7%90%86%E8%A7%A3%E5%89%8D%E4%B8%AD%E5%90%8E%E5%BA%8F
day14 二叉树part1_第10张图片
day14 二叉树part1_第11张图片
二叉树的所有问题,就是让你在前中后序位置注入巧妙的代码逻辑,去达到自己的目的,你只需要单独思考每一个节点应该做什么,其他的不用你管,抛给二叉树遍历框架,递归会在所有节点上做相同的操作。

递归遍历

难点:什么时候记录(访问)本节点的值?

肯定不能写什么 res.add(root.left.val); 因为每个结点我们都能访问到,那么每个结点的值我们也能访问到,就不应该用root.left.val(左节点的值),就应该是res.add(root.val)来记录,只不过是什么时候来记录的问题。
比如下列后序遍历的写法(左右中),意思就是,先遍历左边结点,再遍历右边结点,然后记录当前结点。所以res.add(root.val);放在最后。

		postorder(root.left, res);
        postorder(root.right, res);
        res.add(root.val);

前序

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        preorder(root, res);

        return res;
    }
    public void preorder(TreeNode root, List<Integer> res){
        //退出条件
        if (root == null){
            return;
        }
        res.add(root.val);
        preorder(root.left, res);
        preorder(root.right, res);
    }
}

中序

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        inorder(root, res);

        return res;
    }
    public void inorder(TreeNode root, List<Integer> res){
        if (root == null){
            return;
        }
        inorder(root.left, res);
        res.add(root.val);      // 注意这句
        inorder(root.right, res);
    }
}

后序

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

        return res;
    }
    public void postorder(TreeNode root, List<Integer> res){
        if (root == null){
            return;
        }
        postorder(root.left, res);
        postorder(root.right, res);
        res.add(root.val);      // 注意这句
    }
}

迭代遍历

前序

整体的过程就是:先顺着最左边走到底,然后逆着这个顺序不断回退,如果有右树,就进入右树。这个过程其实就是一个先进后出的过程,是符合stack栈的数据结构。

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        Stack<TreeNode> stk = new Stack<>();

        if (root == null){
            return res;
        }
        stk.push(root);
        while (!stk.isEmpty()){  
            TreeNode cur = stk.pop();
            res.add(cur.val);
//要先加入右孩子,再加入左孩子, 因为这样出栈的时候才是中左右的顺序
            if (cur.right != null){
                stk.push(cur.right);
            }
            if (cur.left != null) {
                stk.push(cur.left);
            }
        }

        return res;
    }
}

中序

遇到当前节点,不能立刻遍历,而是需要先在栈中保存,然后顺着最左边不断向下,如果无法向下了,就把栈顶元素取出来,访问栈顶元素,然后转向栈顶元素的右子树。

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        Stack<TreeNode> stk = new Stack<>();
    //每一个节点都是一个中间节点,哪怕它度为0,那也是左右结点为空的中间节点,所以每次都add一个中间节点是能访问完所有元素的,如果还是不懂,建议画个二叉树跟着走一遍
        if (root == null){
            return res;
        }
        TreeNode cur = root;
        while (cur != null || !stk.isEmpty()){
            if (cur != null){    // 如果当前结点不为空,那就将它压入栈,并移动当前结点为它的左结点
                stk.push(cur);
                cur = cur.left;
            } else{ // 此时当前结点为空(代表栈顶元素的左节点为空,说明左边无法继续向下了,该回到栈顶元素了)
                cur = stk.pop();
                res.add(cur.val); //访问完当前中间节点了,该访问右边了
                cur = cur.right;
            }
        }
        return res;
    }
}

后序(后序遍历其实比较麻烦,比较简单的就是改动前序遍历,然后反转了,记住就行)

day14 二叉树part1_第12张图片

// 后序遍历顺序 左-右-中 入栈顺序:中-左-右 出栈顺序:中-右-左, 最后翻转结果
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null){
            return result;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()){
            TreeNode node = stack.pop();
            result.add(node.val);
            if (node.left != null){
                stack.push(node.left);
            }
            if (node.right != null){
                stack.push(node.right);
            }
        }
        Collections.reverse(result);
        return result;
    }
}

统一版本的迭代法(前中后序几乎不用改代码就能迭代遍历):

!!!!其本质是用显示栈去模拟递归, 这里的模拟是真正做到了完全模拟递归,递归是怎么递归的,栈就是怎么模拟的。 NULL的意思是,该节点刚才已经走过了,这次再遇到它要取出来记录了
day14 二叉树part1_第13张图片
day14 二叉树part1_第14张图片

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

你可能感兴趣的:(java,leetcode)