二叉树系统刷题1

最新推荐文章于 2024-05-16 10:23:10 发布
最新推荐文章于 2024-05-16 10:23:10 发布
阅读量194 收藏
点赞数
分类专栏： leetcode 文章标签： java 算法 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42836388/article/details/129691086
版权

文章目录

BM26 求二叉树的层序遍历

请添加图片描述

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     *
     * @param root TreeNode类
     * @return int整型ArrayList<ArrayList<>>
     */
    public ArrayList<ArrayList<Integer>> levelOrder (TreeNode root) {
        // write code here
        ArrayList<ArrayList<Integer>> res = new ArrayList();
        if (root == null) return res;
        //使用队列存储，进行层序遍历
        Queue<TreeNode> q = new ArrayDeque<TreeNode>();
        q.add(root);//将root插入到队列的末尾
        while (!q.isEmpty()) {
            //记录二叉树的某一行
            ArrayList<Integer> row = new ArrayList();
            int n = q.size();
            //因先进入队列的是根节点，故每层节点多少，队列大小就是多少
            for (int i = 0; i < n; i++) {
                TreeNode cur = q.poll(); //出，同时记录cur节点
                row.add(cur.val);
                //若左右孩子存在，则存入左右孩子作为下一次层次
                if (cur.left != null) q.add(cur.left);
                if (cur.right != null) q.add(cur.right);
            }
            //每一层加入
            res.add(row);
        }
        return res;
    }
}

BM27 按之字形顺序打印二叉树

请添加图片描述

import java.util.ArrayList;
import java.util.Queue;
import java.util.ArrayDeque;
import java.util.Collections;
/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    public ArrayList<ArrayList<Integer>> Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
        if (pRoot == null) return res;
        //使用队列存储，进行层序遍历
        Queue<TreeNode> q = new ArrayDeque<TreeNode>();

        q.add(pRoot);//先将头节点放入
        boolean flag = false;
        while (!q.isEmpty()) {
            ArrayList<Integer> row = new ArrayList<>();
            int n = q.size();

            for (int i = 0; i < n; i++) {
                TreeNode cur = q.poll();//弹出q，并记录
                row.add(cur.val);//存入值

                //看是否有左右还在
                if (cur.left != null) q.add(cur.left);
                if (cur.right != null) q.add(cur.right);
            }
            //要实现奇数层从左到由，偶数层从右到左,即偶数时要逆序q队列
            if (flag) Collections.reverse(row);
            flag = !flag;
            res.add(row);
        }
        return res;
    }

}

BM28 二叉树的最大深度

在这里插入图片描述

层序法 空间复杂度O(1),时间复杂度 O*(*n)

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     *
     * @param root TreeNode类
     * @return int整型
     */
    public int maxDepth (TreeNode root) {
        // write code here

        if (root == null) return 0;
        //使用队列存储，进行层序遍历
        Queue<TreeNode> q = new ArrayDeque<TreeNode>();
        q.add(root);//将root插入到队列的末尾
        int h = 0;
        while (!q.isEmpty()) {
            //记录二叉树的某一行
            ArrayList<Integer> row = new ArrayList();
            int n = q.size();
            //因先进入队列的是根节点，故每层节点多少，队列大小就是多少
            for (int i = 0; i < n; i++) {
                TreeNode cur = q.poll(); //出，同时记录cur节点
                row.add(cur.val);
                //若左右孩子存在，则存入左右孩子作为下一次层次
                if (cur.left != null) q.add(cur.left);
                if (cur.right != null) q.add(cur.right);
            }
            h++;
        }
        return h;
    }
}

递归法 O(2^h)

  public int maxDepth (TreeNode root) {
        //使用递归法则需要，分别计算左右子数中最高的值
        if (root == null) return 0;
        int leftH =  maxDepth(root.left);
        int rightH = maxDepth(root.right);
        return leftH > rightH ? (leftH + 1) : (rightH + 1);
    }

BM29 二叉树中和为某一值的路径(一)

在这里插入图片描述

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     *
     * @param root TreeNode类
     * @param sum int整型
     * @return bool布尔型
     */
    public boolean hasPathSum (TreeNode root, int sum) {
        // write code here
        // //执行思路，使用dfs遍历每个，同时变化sum，找到满足的值就返回真
        // if(root == null) return false;
        // //叶子路径，且路径和为sum
        // if(root.left==null&&root.right==null&&sum-root.val == 0){
        //     return true;
        // }
        // //递归进去子节点
        // return hasPathSum(root.left,sum-root.val)||hasPathSum(root.right,sum-root.val);
        if (root == null) return false;
        return dfs(root, sum, 0);// 深度优先遍历
    }

    private boolean dfs(TreeNode root, int sum, int res) {
        if (root == null) return false;
        //迭代目标值
        res += root.val;
        // 当当前节点为叶子节点并且目标路径存在时，返回 true
        if (res == sum && root.left == null && root.right == null) {
            return true;
        }
        // 对左右分支进行 dfs
        return dfs(root.left, sum, res) || dfs(root.right, sum, res);
    }
}

BM30 二叉搜索树与双向链表

在这里插入图片描述

二叉搜索树是一种特殊的二叉树，它的每个节点值大于它的左子节点，且大于全部左子树的节点值，小于它右子节点，且小于全部右子树的节点值。因此二叉搜索树一定程度上算是一种排序结构。

思路：

二叉搜索树最左端的元素一定最小，最右端的元素一定最大，符合“左中右”的特性，因此二叉搜索树的中序遍历就是一个递增序列，我们只要对它中序遍历就可以组装称为递增双向链表。

具体做法：

  • step 1：创建两个指针，一个指向题目中要求的链表头（head），一个指向当前遍历的前一节点（pre)。
  • step 2：首先递归到最左，初始化head与pre。
  • step 3：然后处理中间根节点，依次连接pre与当前节点，连接后更新pre为当前节点。
  • step 4：最后递归进入右子树，继续处理。
  • step 5：递归出口即是节点为空则返回。

在这里插入图片描述

/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    //返回第一个指针，即最小值，先定为null
    public TreeNode head = null;
    //中序遍历当前值的上一位，初值为最小值，先定为null
    public TreeNode pre = null;
    public TreeNode Convert(TreeNode pRootOfTree) {
        if (pRootOfTree == null) {
            //中序递归，叶子为空则返回
            return null;
        }
        //首先递归到最左最小值
        Convert(pRootOfTree.left); //左

        //中
        //找到最小值，初始化head和pre;
        if (pre == null) {
            head = pRootOfTree;
            pre = pRootOfTree;
        } else {
            //当前节点与上一结点建立连接，将pre设置为当前值
            pre.right = pRootOfTree;
            pRootOfTree.left = pre;
            pre = pRootOfTree;
        }

        Convert(pRootOfTree.right); //右
        return head;

    }
}

BM31 对称的二叉树

思路：

前序遍历的时候我们采用的是“根左右”的遍历次序，如果这棵二叉树是对称的，即相应的左右节点交换位置完全没有问题，那我们是不是可以尝试“根右左”遍历，按照轴对称图像的性质，这两种次序的遍历结果应该是一样的。

不同的方式遍历两次，将结果拿出来比较看起来是一种可行的方法，但也仅仅可行，太过于麻烦。我们不如在遍历的过程就结果比较了。而遍历方式依据前序递归可以使用递归：

  • 终止条件： 当进入子问题的两个节点都为空，说明都到了叶子节点，且是同步的，因此结束本次子问题，返回true；当进入子问题的两个节点只有一个为空，或是元素值不相等，说明这里的对称不匹配，同样结束本次子问题，返回false。
  • 返回值： 每一级将子问题是否匹配的结果往上传递。
  • 本级任务： 每个子问题，需要按照上述思路，“根左右”走左边的时候“根右左”走右边，“根左右”走右边的时候“根右左”走左边，一起进入子问题，需要两边都是匹配才能对称。

具体做法：

  • step 1：两种方向的前序遍历，同步过程中的当前两个节点，同为空，属于对称的范畴。
  • step 2：当前两个节点只有一个为空或者节点值不相等，已经不是对称的二叉树了。
  • step 3：第一个节点的左子树与第二个节点的右子树同步递归对比，第一个节点的右子树与第二个节点的左子树同步递归比较。

在这里插入图片描述

/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    boolean isSymmetrical(TreeNode pRoot) {
        return recursion(pRoot, pRoot);
    } 
    public boolean recursion(TreeNode root1, TreeNode root2) {
        //可以两个都为空
        if (root1 == null && root2 == null)
            return true;
        //只有一个为空或者节点值不同，必定不对称
        if (root1 == null || root2 == null || root1.val != root2.val)
            return false;
        //每层对应的节点进入递归比较
        return recursion(root1.left, root2.right) && recursion(root1.right, root2.left);
    }
}

BM32 合并二叉树

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     *
     * @param t1 TreeNode类
     * @param t2 TreeNode类
     * @return TreeNode类
     */
    public TreeNode mergeTrees (TreeNode t1, TreeNode t2) {
        // write code here
        //思路：同时遍历左右，相同就加上，为空就指向
        if (t1 == null) return t2;
        if (t2 == null) return t1;
        //根左右遍历
        TreeNode head = new TreeNode(t1.val + t2.val);
        head.left = mergeTrees(t1.left, t2.left);
        head.right = mergeTrees(t1.right, t2.right);
        return head;
    }
}

BM34 判断是不是二叉搜索树

思路：

二叉搜索树的特性就是中序遍历是递增序。既然是判断是否是二叉搜索树，那我们可以使用中序递归遍历。只要之前的节点是二叉树搜索树，那么如果当前的节点小于上一个节点值那么就可以向下判断。只不过在过程中我们要求反退出。比如一个链表1->2->3->4，只要for循环遍历如果中间有不是递增的直接返回false即可。

if(root.val < pre)
    return false;

具体做法：

  • step 1：首先递归到最左，初始化maxLeft与pre。
  • step 2：然后往后遍历整棵树，依次连接pre与当前节点，并更新pre。
  • step 3：左子树如果不是二叉搜索树返回false。
  • step 4：判断当前节点是不是小于前置节点，更新前置节点。
  • step 5：最后由右子树的后面节点决定。
import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 *   public TreeNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    int pre = Integer.MIN_VALUE;
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return bool布尔型
     */
    public boolean isValidBST (TreeNode root) {
        // write code here
        //中序遍历
        if(root ==  null) return true;
        //先进入左子树
        if(!isValidBST(root.left)){
            return false;
        }
        if(root.val<pre){
            return false;
        }
        //更新最值
        pre = root.val;
        //在进入右子树
        return isValidBST(root.right);
        
    }
}

BM35 判断是不是完全二叉树

思路：

对完全二叉树最重要的定义就是叶子节点只能出现在最下层和次下层，所以我们想到可以使用队列辅助进行层次遍历——从上到下遍历所有层，每层从左到右，只有次下层和最下层才有叶子节点，其他层出现叶子节点就意味着不是完全二叉树。

具体做法：

  • step 1：先判断空树一定是完全二叉树。
  • step 2：初始化一个队列辅助层次遍历，将根节点加入。
  • step 3：逐渐从队列中弹出元素访问节点，如果遇到某个节点为空，进行标记，代表到了完全二叉树的最下层，若是后续还有访问，则说明提前出现了叶子节点，不符合完全二叉树的性质。
  • step 4：否则，继续加入左右子节点进入队列排队，等待访问。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PlMO085A-1679386637750)(C:\Users\jquery\Desktop\国密算法\八股文\assets\07986E476EB2CECD3C5F81D0BCADBE12.gif)]

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 *   public TreeNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return bool布尔型
     */
    public boolean isCompleteTree (TreeNode root) {
        // write code here
        //左右都为null
        
        //空树一定为完全二叉树
        if(root == null) return true;
        //辅助队列
        Queue<TreeNode> q = new LinkedList<>();
        q.add(root);

        //定义一个首次出现的标记位
        boolean notComplete = false;
        while(!q.isEmpty()){
            TreeNode cur = q.poll();
            if(cur == null){
                //标记第一次遇到空节点
                notComplete = true;
                continue;
            }
            //后续访问以及已经遇到空节点了，说明经过了叶子
            if(notComplete) return false;
            q.add(cur.left);
            q.add(cur.right);
        }
        return true;
    }
}

BM36 判断是不是平衡二叉树

在这里插入图片描述

public class Solution {
    public boolean IsBalanced_Solution(TreeNode root) {
        //空树为平衡树
        if (root == null) return true;
        int left = deep(root.left);
        int right = deep(root.right);
        //左子树深度减去右子树相差绝对值大于1
        if (left - right > 1 || left - right < -1) {
            return false;
        }
        //同时左右子树还必须是平衡的
        return IsBalanced_Solution(root.left) && IsBalanced_Solution(root.right);
    }

    private int deep(TreeNode root) {
        //空节点深度为0
        if (root == null) return 0;

        //递归计算左右子树的深度
        int left = deep(root.left);
        int right = deep(root.right);

        //子树最大深度加上自己
        return (left > right) ? left + 1 : right + 1;
    }
}

BM37 二叉搜索树的最近公共祖先

思路：

二叉搜索树没有相同值的节点，因此分别从根节点往下利用二叉搜索树较大的数在右子树，较小的数在左子树，可以轻松找到p、q：

//节点值都不同，可以直接用值比较
while(node.val != target) { 
    path.add(node.val);
    //小的在左子树
    if(target < node.val) 
        node = node.left;
    //大的在右子树
    else 
        node = node.right;
}

直接得到从根节点到两个目标节点的路径，这样我们利用路径比较就可以找到最近公共祖先。

具体做法：

  • step 1：根据二叉搜索树的性质，从根节点开始查找目标节点，当前节点比目标小则进入右子树，当前节点比目标大则进入左子树，直到找到目标节点。这个过程成用数组记录遇到的元素。
  • step 2：分别在搜索二叉树中找到p和q两个点，并记录各自的路径为数组。
  • step 3：同时遍历两个数组，比较元素值，最后一个相等的元素就是最近的公共祖先。

在这里插入图片描述

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 *   public TreeNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param root TreeNode类
     * @param p int整型
     * @param q int整型
     * @return int整型
     */
    public int lowestCommonAncestor (TreeNode root, int p, int q) {
        // write code here
        //求根节点到两个节点的路径
        ArrayList<Integer> path_p = getPasth(root, p);
        ArrayList<Integer> path_q = getPasth(root, q);

        int res = 0;
        //比较元素值，最后一个相等的元素就是最近的公共祖先。
        for (int i = 0; i < path_p.size() && i < path_q.size(); i++) {
            int x = path_p.get(i);
            int y = path_q.get(i);
            //最后一个相同的节点就是最近公共祖先
            if (x == y) {
                res = path_p.get(i);
            } else {
                break;
            }

        }
        return res;
    }

    //求得根节点到目标节点的路径
    public ArrayList<Integer> getPasth(TreeNode root, int target) {
        ArrayList<Integer> path = new ArrayList<Integer>();
        TreeNode node = root;
        //节点值都不同，可以直接比较
        while (node.val != target) {
            path.add(node.val);
            //小的在左子树
            if (target < node.val) {
                node = node.left;
            } else {
                //大的在右子树
                node = node.right;
            }

        }
        path.add(node.val);
        return path;
    }
}

BM38 在二叉树中找到两个节点的最近公共祖先

在这里插入图片描述

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     *
     * @param root TreeNode类
     * @param o1 int整型
     * @param o2 int整型
     * @return int整型
     */
    public int lowestCommonAncestor (TreeNode root, int o1, int o2) {
        // write code here
        ArrayList<Integer> path1 = new ArrayList<>();
        ArrayList<Integer> path2 = new ArrayList<>();
        //求根节点到两个节点的路径
        dfs(root,path1,o1);
        //重置
        flag = false;
        dfs(root,path2,o2);
        int res=0;
        //比较两个路径，找到第一个不同的点
        for(int i=0;i<path1.size()&&i<path2.size();i++){
            int x = path1.get(i);
            int y = path2.get(i);
            if(x==y){
                //最后一个相同的节点就是最近公共祖先
                res = x;
            }else{
                break;
            }
        }
        return res;
    }
    //记录是否找到到o的路径
    public boolean flag = false;
    //求得根节点到目标节点的路径
    public void dfs(TreeNode root, ArrayList<Integer> path, int o) {
        if (flag || root == null) {
            return;
        }
        path.add(root.val);
        //节点不同值都不同，可以直接用值比较
        if (root.val == o) {
            flag = true;
            return;
        }
        //dfs 遍历查找
        dfs(root.left, path, o);
        dfs(root.right, path, o);
        if (flag) return;
        path.remove(path.size() - 1);
    }
}

BM39 序列化二叉树

/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/

import java.util.*;

public class Solution {
    String SEP = ",";
    String NULL = "#";
    String Serialize(TreeNode root) {
        StringBuilder sb = new StringBuilder();
        serialize(root, sb);
        return sb.toString();
    }
    //辅助函数，将二叉树存入StringBuilder中
    void serialize(TreeNode root, StringBuilder sb) {
        if(root == null){
            sb.append(NULL).append(SEP);
            return;
        }
        //前序遍历位置
        sb.append(root.val).append(SEP);

        serialize(root.left,sb);
        serialize(root.right,sb);
    }

    TreeNode Deserialize(String str) {
        //将字符串转成列表
        LinkedList<String> nodes = new LinkedList<>();
        for(String s:str.split(SEP)){
            nodes.addLast(s);
        }
        return deserialize(nodes);

    }

    TreeNode deserialize( LinkedList<String> nodes){
        if(nodes.isEmpty()) return null;
        //前序遍历位置,列表最左侧就是和根节点
        String first = nodes.removeFirst();
        if(first.equals(NULL)) return null;
        TreeNode root = new TreeNode(Integer.parseInt(first));
        root.left = deserialize(nodes);
        root.right =deserialize(nodes);

        return root;
    }
}

BM40 重建二叉树

在这里插入图片描述

import java.util.*;
/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public TreeNode reConstructBinaryTree(int [] pre, int [] vin) {
        int n = pre.length;
        int m = vin.length;
        //每个遍历都不能为0
        if (n == 0 || m == 0) {
            return null;
        }
        //构建根节点 根节点必定在pre中选
        TreeNode root = new TreeNode(pre[0]);
        for (int i = 0; i < n; i++) {
            //找到中序遍历中的前序第一个元素,依据它划分左右子树
            if (pre[0] == vin[i]) {
                //构建左子树
                root.left = reConstructBinaryTree(Arrays.copyOfRange(pre,1,i+1),Arrays.copyOfRange(vin,0,i));
                //构建右子树
                root.right = reConstructBinaryTree(Arrays.copyOfRange(pre,i+1,pre.length),Arrays.copyOfRange(vin,i+1,vin.length));
                break;
            }
        }
        return root;
    }
}

BM41 输出二叉树的右视图

在这里插入图片描述

思路：

首先根据前序遍历和中序遍历生成二叉树

然后使用层序遍历得到每一层的一个数组

针对每一层的数组，取最后一个数，即可完成

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 求二叉树的右视图
     * @param xianxu int整型一维数组 先序遍历
     * @param zhongxu int整型一维数组 中序遍历
     * @return int整型一维数组
     */

    public int[] solve (int[] xianxu, int[] zhongxu) {
        TreeNode root = reConstructBinaryTree(xianxu, zhongxu);
        ArrayList<ArrayList<Integer>> res = getLevelList(root);
        ArrayList<Integer> list = new ArrayList<>();
        //将二叉树 层次便利的 每层的额最后一个 值存入新的 ArrayList 中 转化为 数组
        for (int i = 0; i < res.size(); i++) {
            list.add(res.get(i).get(res.get(i).size() - 1));
        }
        // int arr[] = new int[list.size()];
        // for (int i = 0; i < list.size(); i++) {
        //     arr[i] = list.get(i);
        // }
        int arr[] = list.stream().mapToInt(Integer::valueOf).toArray();
        return arr;
    }

    public TreeNode reConstructBinaryTree(int[] pre, int[] vin) {
        int n = pre.length;
        int m = vin.length;
        //每个遍历都不能为0
        if (n == 0 || m == 0) return null;

        //构建根节点，根节点必定在pre中选\
        TreeNode root = new TreeNode(pre[0]);
        for (int i = 0; i < n; i++) {
            //找到中序遍历中的前序第一个元素，依据它划分左右子树
            if (pre[0] == vin[i]) {
                //构建左子树
                root.left = reConstructBinaryTree(Arrays.copyOfRange(pre, 1, i + 1),
                                                  Arrays.copyOfRange(vin, 0, i));
                //构建右子树
                root.right = reConstructBinaryTree(Arrays.copyOfRange(pre, i + 1, pre.length),
                                                   Arrays.copyOfRange(vin, i + 1, vin.length));
                break;
            }
        }
        return root;
    }

    //此方法用来 二叉树的 层次遍历到 ArrayList<ArrayList<Integer>>中
    private  ArrayList<ArrayList<Integer>> getLevelList(TreeNode root) {
        ArrayList<ArrayList<Integer>> result = new ArrayList<>();
        Queue<TreeNode> q = new LinkedList<>();
        q.add(root);
        while (!q.isEmpty()) {
            ArrayList<Integer> row = new ArrayList<>();
            int n = q.size();
            for (int i = 0; i < n; i++) {
                TreeNode cur = q.poll();
                row.add(cur.val);
                if (cur.left != null) q.add(cur.left); //是cur，不是root
                if (cur.right != null) q.add(cur.right);//是cur，不是root
            }
            result.add(row);
        }
        return result;
    }

    
}
扶我起来继续学习
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【刷题笔记】二叉树
weixin_42761454的博客
01-21 714
二叉树 Binary Tree 常见种类 刷题时的常见二叉树：满二叉树和完全二叉树 满二叉树 如果一棵二叉树只有度为 0 的结点和度为 2 的结点，并且度为 0 的结点在同一层上，则这棵二叉树为满二叉树。 深度为k，有2^k-1个节点。 完全二叉树 除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含1~2^h - 1个节点。 优先级队列其实是一个堆，堆是一棵完全二叉树，同时保证父子节点的顺序关系。 二叉搜索树 BST
Leetcode刷题总结——二叉树
weixin_47883447的博客
04-06 388
二叉树节点的定义： 1、二叉树的遍历 前序遍历（中左右）、中序遍历（左中右）、后序遍历（左右中） 递归三要素： 1）确定递归函数的参数和返回值：确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。 2）确定终止条件：写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。 3）.
二叉树力扣刷题（递归法）
2301_79368422的博客
04-25 792
递归法是二叉树算法题中一种很常见的解法，由于二叉树的特殊结构，用递归法解题时往往会比迭代法省时省力很多。先来明确一下递归通用的三步法：确定递归函数的参数和返回值确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。确定终止条件写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。
tag二叉树-刷题预备知识-1. 深入浅出深度优先遍历(DFS)和广度优先遍历(BFS) + lt. 102. 二叉树的层序遍历 1
菜菜的大数据开发の路
03-21 661
零, BFS, DFS 基本知识扫盲 Java实现图的深度优先遍历(DFS)和广度优先遍历(BFS) 一, BFS和DFS的比较 DFS（深度优先搜索）和 BFS（广度优先搜索）就像孪生兄弟，提到一个总是想起另一个。然而在实际使用中，我们用 DFS 的时候远远多于 BFS。那么，是不是 BFS 就没有什么用呢？ 如果我们使用 DFS/BFS 只是为了遍历一棵树、一张图上的所有结点的话，那么 DFS 和 BFS 的能力没什么差别，我们当然更倾向于更方便写、空间复杂度更低的 DFS 遍历。不过，某些使用场景是
[力扣刷题总结]（二叉树篇）
weixin_38800498的博客
12-29 1327
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录二叉树理论基础篇1.二叉树的种类2.二叉树的存储方式3.二叉树的遍历方式4.二叉树的定义////////////二叉树的遍历方式///////////////二叉树的递归遍历二叉树的迭代遍历1. 迭代法中序遍历2.迭代法前序遍历3.迭代法后序遍历144. 二叉树的前序遍历解法1：递归遍历解法2：迭代遍历二叉树的层序遍历////////////二叉树的属性///////////////////////////二叉树的修改与改造////
leetcode——二叉树刷题笔记【更新中】
qq_50714222的博客
10-30 208
​ 跟着代码随想录博主在leetcode上刷题并学习二叉树相关知识点，二叉树的类型和相关的操作比较多，所以这部分需要做的题也比较多，后面会随着做题的进度更新该篇文章，如果有该博主不涉及的题目但和二叉树是相关的，也会加入到这篇文章中。秉持着【学有留痕】的学习方法，所以通过博客的方式来进行记录。与诸君共享并祝学有所成！ ​
刷题2--二叉树
zhaojiazb的博客
05-04 102
二叉树相关力扣刷题
二叉树的知识总结与刷题
weixin_43949046的博客
03-25 113
二叉树的理论基础 二叉树分为满二叉树和完全二叉树。自己要在心里理解什么是满二叉树，什么是完全二叉树。 给树赋予数值，就变成了二叉搜索树，二叉搜索树是一个有序树。二叉搜索树的左右子树也是有序树。并且，如果左子树不空，则左子树上的所有节点的值都小于它的根节点的值；相反，右子树都大于，二叉搜索树简称搜索树。 C++中map、set、multimap，multiset的底层实现都是平衡二叉搜索树 二叉树可以以我们平时常见的链表来链式存储，也可以顺序存储。 数组中的存储，类似于深度遍历中的前序遍历。 但是用链式表示
LeetCode刷题小记——二叉树的中序遍历
xie1131726190的博客
11-30 268
二叉树的中序遍历 没事就练练 方法：两大类 递归 非递归 模仿系统栈（模仿递归的过程） 手工辅助栈（利用栈的特点） 递归写法 代码奉上 /** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this
leetcode中国-leetcode:刷题
06-29
刷题 使用git 判断一个链表是否为回文结构 准备一个栈，遍历链表到栈中，从栈中弹出，和链表一一比较，相同则是回文。 荷兰国旗问题可以用去优化快排算法。 因为荷兰国旗问题中间是一堆数确定了位置，而普通的...
leetcodelrucache-leetcode:leetcode刷题
06-30
leetcode刷题 三数之和 threeSum fourSum 四数之和 threeSumClosest 三数之和最接近 myAtoi->字符串转换整数 (atoi) reverseString->反转字符串 hasCycle->环形链表 deleteNode->删除链表中的节点 detectCycle->环形...
leetcode刷题账号-leetcode:leetcode
07-06
1.MoveZeroes |-- codedrinker |-- MoveZeroes.java 访问 官网，注册账号 编码完成以后，在LeetCode官网运行结果通过以后再提交代码到我们的仓库。 如果不理解 Git 怎么使用可以观看这个视频 加群 QQ 免费 607313352...
lrucacheleetcode-LeetCode:LeetCode刷题
06-29
翻转二叉树（Invert Binary Tree） 2018.9.25 环形链表（Linked List Cycle） 2018.9.25 环形链表 II（Linked List Cycle II） 2018.9.26 删除排序链表中的重复元素 II（Remove Duplicates from Sorted List II） ...
leetcode中国-My-LeetCode:力扣刷题笔记，暂时只刷了二叉树、字典树、数组、链表，后续会继续刷题
06-29
leetcode中国 My-LeetCode 力扣刷题笔记，包括官网和中国官网
jar包增量更新分析
最新发布
junlaiyan的专栏
05-16 268
借助jdeps分析出jar包的增量文件
Spring-Cloud 微服务
weixin_65127444的博客
05-15 900
先来思考一个问题*通过上一章的操作，我们已经可以实现微服务之间的调用。但是我们把服务提供者的网络地址（ip，端口）等硬编码到了代码中，这种做法存在许多问题：1.一旦服务提供者地址变化，就需要手工修改代码2. 一旦是多个服务提供者，无法实现负载均衡功能3.一旦服务变得越来越多，人工维护调用关系困难那么应该怎么解决呢，这时候就需要通过注册中心动态的实现。
java实现拼图小游戏
monkey108的博客
05-16 629
本文主要提供用java实现的拼图小游戏源代码。
命令执行漏洞（二）
XLbb的博客
05-15 909
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
c语言二叉树 管理系统
09-28
C语言二叉树管理系统是一个基于C语言编写的程序，用于管理二叉树数据结构的创建、插入、删除、查找等操作。该系统提供了一系列的功能，以方便用户对二叉树进行操作和管理。 在该系统中，可以通过创建二叉树的初始化...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值