算法题型：二叉树（leetcode+剑指offer）

最新推荐文章于 2022-08-22 08:20:14 发布
最新推荐文章于 2022-08-22 08:20:14 发布
阅读量859 收藏
点赞数
分类专栏： 算法学习 文章标签： 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37768971/article/details/97981359
版权

目录

一、111. 二叉树的最小深度

 二、100. 相同的树

三、101. 对称二叉树

四、110. 平衡二叉树

五、剑指offer（24）二叉树中和为某一值的路径

六、剑指offer（三十八）计算二叉树的最大深度

七、剑指offer（五十六）二叉树的下一个节点

八、剑指offer（五十八）按照Z型打印二叉树

九、剑指offer（五十九）层序遍历二叉树（改进版，需存进双层链表中）

十、剑指offer（六十）序列化二叉树

十一、剑指offer（六十一）二叉树的第K个节点

一、111. 二叉树的最小深度


1.题目描述
评论 (282)
题解(30)New
提交记录
给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明: 叶子节点是指没有子节点的节点。

示例:

给定二叉树 [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7
返回它的最小深度  2.

2.分析：

刚开始我的方法是：
 

public int minDepth(TreeNode root) {
        if (root==null)return 0;
        return Math.min(1+minDepth(root.left),1+minDepth(root.right));
    }

乍一看没什么毛病，提交之后发现
    1
   /  \
2      null
这种情况，我的代码返回1，而正确答案是2。
原来，题目要求的是根节点到叶子节点的最小距离，而1->null，不属于这个范畴，因为1不是叶子节点。

---->于是重新冷静分析一下：
题目应该分成以下四种情况：
（1）当前节点为null，return 0;

（2）左孩子节点与右孩子节点都为null，代表当前节点为叶子节点，return 1;

（3）左孩子或者右孩子节点有一个为空，此时只要递归调用不为空的孩子节点，这样才能到达叶子节点

（4）左右孩子都不为空，此时需要左右孩子同时递归，并且判断二者返回结果较小的一方。

通过以上分析，我们将（3）（4）两点通过if语句整合在一起：

3.代码如下：

public class Solution111 {
    public int minDepth(TreeNode root) {
        if (root==null)return 0;
        if (root.left==null&&root.right==null)return 1;
        int min = Integer.MAX_VALUE;
        if (root.left!=null){
            min=Math.min(min,minDepth(root.left));
        }
        if (root.right!=null){
            min=Math.min(min,minDepth(root.right));
        }
        return min+1;
    }
}

 二、100. 相同的树

1.题目描述
给定两个二叉树，编写一个函数来检验它们是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

示例 1:

输入:  1         1
           / \       / \
         2   3   2   3

        [1,2,3],   [1,2,3]

输出: true
示例 2:

输入:  1        1
          /           \
         2             2

        [1,2],     [1,null,2]

输出: false
示例 3:

输入:  1        1
          / \       / \
         2   1     1   2

        [1,2,1],   [1,1,2]

输出: false

2.分析：

看代码，分为四种情况，然后递归判断。

3.代码：

class Solution {
public boolean isSameTree(TreeNode p, TreeNode q) {
        if (p==null&&q==null)return true;
        //if (p==null&&q!=null)return false;
        //if (q==null&&p!=null)return false;
        if (p==null||q==null)return false;
        if(p.val!=q.val)return false;
        return isSameTree(p.left,q.left)&&isSameTree(p.right,q.right);
    }
}

三、101. 对称二叉树

1.题目描述
给定一个二叉树，检查它是否是镜像对称的。

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

    1
   / \
  2   2
 / \ / \
3  4 4  3
但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

    1
   / \
  2   2
   \   \
   3    3
 

2.分析：

核心思想是判断左子树的右子树 和 右子树的左子树是否相等  以及 左子树的左子树 和 右子树的右子树 是否相等

由于是判断对称，所以需要存储左右子树的信息，因此我们需要再创建一个函数，用来判断是否对称。

3.代码：

public class Solution101 {
    public boolean isSymmetric(TreeNode root) {
        return isMirror(root,root);
    }
    public boolean isMirror(TreeNode left,TreeNode right){
        if (left==null&&right==null)return true;
        if (left==null||right==null)return false;//在第一个判断的基础上，第二个判断的真实含义就变成：只有一个节点为null
        boolean valEqul = left.val==right.val;
        boolean mirror = isMirror(left.left,right.right)//左子树的左子树，右子树的右子树
                &&isMirror(left.right,right.left);//左子树的右子树，右子树的左子树，是否对称？
        return valEqul&&mirror;
    }
}

四、110. 平衡二叉树

1.题目描述

给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：

一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。

示例 1:

给定二叉树 [3,9,20,null,null,15,7]

    3
   / \
  9  20
    /  \
   15   7

返回 true 。

示例 2:

给定二叉树 [1,2,2,3,3,null,null,4,4]

       1
      / \
     2   2
    / \
   3   3
  / \
 4   4

2.分析：

（方法1）：
high函数用于计算当前传入节点的高度值，isBalanced函数递归调用左右子树，并且判断左右子树高度差

（方法2）：

从底层往上的过程中，每一次都判断是否不符合条件（即renturn -1），如果不符合，会一路返回-1，如果全部符合，才返回值。

3.代码： 

/**
 * IMUHERO
 * 2019/8/1
 */
package IMUHERO;

//public class Solution110 {
//    public boolean isBalanced(TreeNode root) {
//        if (root==null)return true;
//        return Math.abs(depth(root.left) - depth(root.right)) <= 1 
//               && isBalanced(root.left) 
//               && isBalanced(root.right);
//    }

//    public int high(TreeNode root){
//        if (root==null)return 0;
//        return Math.max(1+high(root.left),1+high(root.right));
//    }
//}

//方法二：
public class Solution110 {
    public boolean isBalanced(TreeNode root) {
        return high(root)!=-1;
    }
    //以下事实上就是计算深度
    public int high(TreeNode root){
        if (root==null)return 0;
        int left = high(root.left);
        if (left==-1)return -1;
        int right = high(root.right);
        if (right==-1)return -1;
        //只要从底层来的判断，有一个为-1，则不再递归，直接返回-1；
        return (Math.abs(left-right)<=1)?(Math.max(left,right)+1):-1;
    }
}

五、剑指offer（24）二叉树中和为某一值的路径

1.题目描述

输入一颗二叉树的根节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中，数组长度大的数组靠前)

2.分析：

见注释，主要是递归判断target是否为0,满足条件就添加进listAll中。不管是否添加，都要将队尾删除，回退到根节点，然后去另一个节点判断。

3.代码：

//存储计算结果
    ArrayList<ArrayList<Integer>> listAll = new ArrayList<>();
    //存储计算过程值
    ArrayList<Integer>list = new ArrayList<>();
    public ArrayList<ArrayList<Integer>> FindPath(TreeNode root, int target) {
        if (root==null)return listAll;
        //每到一个节点，减去节点的值，target为0时为正确结果
        target-=root.val;
        list.add(root.val);
        //注意题意是叶子结点，因此还要有后面两个判断
        if (target==0&&root.left==null&&root.right==null){
            //注意此处是new了一个list，不能直接listAll.add(list),否则是一直指向同一个链表了
            listAll.add(new ArrayList<Integer>(list));
            //注意此处不能直接return，因为底下还要删除队尾元素，以便进行下一次判断
            //return listAll;
        }
        //递归遍历所有情况
        FindPath(root.left,target);
        FindPath(root.right,target);
        //删除队尾元素，下一次判断相当于回退到根节点，判断另一个子节点。
        list.remove(list.size()-1);
        return listAll;
    }

六、剑指offer（三十八）计算二叉树的最大深度

1.题目：

计算二叉树的最大深度
输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。

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

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

    }

}
*/
public class Solution {
    public int TreeDepth(TreeNode root) {
        if(root==null)return 0;
        int left=TreeDepth(root.left)+1;
        int right=TreeDepth(root.right)+1;
        return Math.max(left,right);
    }
}

七、剑指offer（五十六）二叉树的下一个节点


1题目描述
给定一个二叉树和其中的一个结点，
请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。
 

2.我的方法：（不建议）

使用一个链表存储中序遍历的所有节点，然后按顺序遍历
如果当前节点等于题目所给的节点，那么当前节点之后的节点就是我们需要的答案。

56二叉树的下一个节点
题目描述
给定一个二叉树和其中的一个结点，
请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。


package IMUHERO;

import java.util.LinkedList;

class TreeLinkNode {
    int val;
    TreeLinkNode left = null;
    TreeLinkNode right = null;
    TreeLinkNode next = null;
    TreeLinkNode(int val) {
        this.val = val;
    }
}

public class Sword56_GetNext {
    LinkedList<TreeLinkNode> list =new LinkedList<>();
    public TreeLinkNode GetNext(TreeLinkNode pNode)
    {
        if(pNode==null)return null;
        //找到根节点
        TreeLinkNode cur = pNode;
        while(cur.next!=null){
            cur=cur.next;
        }
        TreeLinkNode root = cur ;
        midOrder(root);
        TreeLinkNode ret = null ;
        for(int i=0;i<list.size();i++){
            if(list.get(i)==pNode&&i+1<list.size()){
                ret=list.get(i+1);
            }
        }
        return ret;
    }
    private void midOrder(TreeLinkNode node){
        if(node== null)return;
        midOrder(node.left);
        list.add(node);
        midOrder(node.right);
    }
}

3.别人的方法（推荐）


思路：

（1） 若该节点存在右子树：则下一个节点为右子树最左子节点（如图节点 B ）

（2） 若该节点不存在右子树：这时分两种情况：

2.1 该节点为父节点的左子节点，则下一个节点为其父节点（如图节点 D ）

2.2 该节点为父节点的右子节点，则沿着父节点向上遍历，知道找到一个节点的父节点的左子节点为该节点，则该节点的父节点下一个节点（如图节点 I ，沿着父节点一直向上查找找到 B （ B 为其父节点的左子节点），则 B 的父节点 A 为下一个节点）。

package IMUHERO;
public class Solution {    
    public TreeLinkNode GetNext(TreeLinkNode pNode) {     
        if (pNode == null)       
            return pNode;    
        if (pNode.right != null) {
            // 节点有右子树            
            pNode = pNode.right;         
            while (pNode.left != null) {  
                pNode = pNode.left;          
            }            return pNode;    
        } 
        else if ( pNode.next != null && pNode.next.left == pNode) { 
            // 节点无右子树且该节点为父节点的左子节点         
            return pNode.next; 
        } else if (pNode.next != null && pNode.next .right == pNode) { 
            // 节点无右子树且该节点为父节点的右子节点         
            while(pNode.next != null && pNode .next .left != pNode){       
                pNode = pNode.next ;       
            }           
            return pNode.next ;     
        }else{        
            return pNode.next ;
            //节点无父节点 ，即节点为根节点       
            }  
    }
}

八、剑指offer（五十八）按照Z型打印二叉树

1.题目描述

请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。

2.分析：

1.使用两个栈S1和S2存储奇数层和偶数层节点

2.奇数层从左到右push进左右子树（出队时就可以是先右后左了）

3.偶数层从右到左push进左右子树（出队时就可以是先左后右）

package IMUHERO;
import java.util.ArrayList;
import java.util.Stack;

public class Sword58_PrintZ {
    package IMUHERO;

import java.util.ArrayList;
import java.util.Stack;

public class Solution {
    public static ArrayList<ArrayList<Integer>> Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer>>res = new ArrayList<>();
        if (pRoot==null)return res;
        Stack<TreeNode> stack1 = new Stack<>();
        Stack<TreeNode> stack2 = new Stack<>();
        int deepth = 1;
        stack1.push(pRoot);
        while (!stack1.isEmpty()||!stack2.isEmpty()){
            //奇数层
            if (deepth%2!=0){
                ArrayList<Integer>list1 = new ArrayList<>(); //用来暂存结果
                while (!stack1.isEmpty()){
                    TreeNode cur = stack1.pop();
                    list1.add(cur.val);
                    if (cur.left!=null){
                        stack2.push(cur.left);
                    }
                    if (cur.right!=null){
                        stack2.push(cur.right);
                    }
                }
                if (!list1.isEmpty()){
                    res.add(list1);
                    deepth++;
                }
            }
            //偶数层
            else {
                ArrayList<Integer>list2 = new ArrayList<>(); //用来暂存结果
                while (!stack2.isEmpty()){
                    TreeNode cur = stack2.pop();
                    list2.add(cur.val);
                    if (cur.right!=null){
                        stack1.push(cur.right);
                    }
                    if (cur.left!=null){
                        stack1.push(cur.left);
                    }
                }
                if (!list2.isEmpty()){
                    res.add(list2);
                    deepth++;
                }
            }
        }
        return res;
    }
}
}

九、剑指offer（五十九）层序遍历二叉树（改进版，需存进双层链表中）

1.题目描述

从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。

2.分析：

（1）我的方法：

1.使用一个自定义类Pair存储深度deepth和节点信息。

2.按照通常的方法层序遍历，并在添加的时候加一层判断，根据深度存储在链表的不同位置。

import java.util.ArrayList;
import java.util.LinkedList;

public class Solution {
    ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer>> res = new ArrayList<>();  //用于返回结果
        if(pRoot==null)return res;                      //特殊情况，根节点为空则直接返回空表
        LinkedList<Pair> list = new LinkedList<>();     //用于遍历，存储Pair
        list.addLast(new Pair(0,pRoot));        //先添加第一个节点

        while(!list.isEmpty()){
            Pair cur = list.removeFirst();
            int deep = cur.deepth;
            //如果该表还没有初始化，则初始化
            if(res.size()<=deep){
                ArrayList<Integer> al = new ArrayList<>();
                al.add(cur.node.val);
                res.add(deep,al);
            }
            else{
                res.get(deep).add(cur.node.val);
            }//已经初始化的直接往后添加
            if(cur.node.left!=null){
                list.addLast(new Pair(deep+1,cur.node.left));
            }
            if(cur.node.right!=null){
                list.addLast(new Pair(deep+1,cur.node.right));
            }
        }
        return res;
    }
    private class Pair{
        int deepth;
        TreeNode node;
        public Pair(int deepth,TreeNode node){
            this.deepth = deepth;
            this.node = node;
        }
    }
}

（2）其他方法：

与上题的不同在于，将两个栈变为两个队列，即实现了不同的共能

当然，在具体偶数层的时候也是不一样，前一题是变为先入右子树，再入左子树，这题则无需改变

package IMUHERO;

        import java.util.ArrayList;
        import java.util.LinkedList;
public class Solution {
    ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer>>res = new ArrayList<>();
        if (pRoot==null)return res;
        LinkedList<TreeNode> queue1 = new LinkedList<>();
        LinkedList<TreeNode> queue2 = new LinkedList<>();
        int deepth = 1;
        queue1.add(pRoot);
        while (!queue1.isEmpty()||!queue2.isEmpty()){
            //奇数层
            if (deepth%2!=0){
                ArrayList<Integer>list1 = new ArrayList<>(); //用来暂存结果
                while (!queue1.isEmpty()){
                    TreeNode cur = queue1.pop();
                    list1.add(cur.val);
                    if (cur.left!=null){
                        queue2.add(cur.left);
                    }
                    if (cur.right!=null){
                        queue2.add(cur.right);
                    }
                }
                if (!list1.isEmpty()){
                    res.add(list1);
                    deepth++;
                }
            }
            //偶数层
            else {
                ArrayList<Integer>list2 = new ArrayList<>(); //用来暂存结果
                while (!queue2.isEmpty()){
                    TreeNode cur = queue2.pop();
                    list2.add(cur.val);
                    if (cur.left!=null){
                        queue1.add(cur.left);
                    }
                    if (cur.right!=null){
                        queue1.add(cur.right);
                    }
                }
                if (!list2.isEmpty()){
                    res.add(list2);
                    deepth++;
                }
            }
        }
        return res;
    }
}

十、剑指offer（六十）序列化二叉树

1.题目描述
请实现两个函数，分别用来序列化和反序列化二叉树 
二叉树的序列化是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，
从而使得内存中建立起来的二叉树可以持久保存。
序列化可以基于先序、中序、后序、层序的二叉树遍历方式来进行修改，
序列化的结果是一个字符串，序列化时通过 某种符号表示空节点（#），
以 ！ 表示一个结点值的结束（value!）。
二叉树的反序列化是指：根据某种遍历顺序得到的序列化字符串结果str，重构二叉树。

2.分析

1.序列化：采用递归前序遍历，将val添加到StringBuffer中，“，”进行分隔，“#”代表null

2.反序列化：类似于二叉树添加节点的操作，使用递归返回结果，并用左右子树接住改变。

3.注意此解法的灵活运用，如index设立在外围，并且初值为-1，node初值设立为null,if语句过滤掉null,如果到达Null，直接返回node

package IMUHERO;

public class Sword65_robot_moving {
    int index = -1;
    String Serialize(TreeNode root) {
        StringBuffer stb = new StringBuffer();
        if(root==null){
            stb.append("#,");
            return stb.toString();
        }
        stb.append(root.val);
        stb.append(",");
        stb.append(Serialize(root.left));
        stb.append(Serialize(root.right));
        return stb.toString();
    }
    TreeNode Deserialize(String str) {
        index++;
        TreeNode node = null;
        String [] s = str.split(",");
        if(!s[index].equals("#")){
            node = new TreeNode(Integer.parseInt(s[index]));
            node.left = Deserialize(str);
            node.right = Deserialize(str);
        }
        return node;
    }
}

 

十一、剑指offer（六十一）二叉树的第K个节点

1.题目描述

给定一棵二叉搜索树，请找出其中的第k小的结点。例如， （5，3，7，2，4，6，8）    中，按结点数值大小顺序第三小结点的值为4。

2.分析：

1.二叉树的中序遍历就是从小到大排序的，所以只要找到中序遍历的第K个节点即可 

2.可以使用链表存储节点

3.要注意边界条件，K可能不是一个有效值

import java.util.ArrayList;
public class Solution {
    ArrayList<TreeNode> list = new ArrayList<>();
    TreeNode KthNode(TreeNode pRoot, int k)
    {
        inOrder(pRoot,k);
        if(k>0&&list.size()>=k){
            return list.get(k-1);
        }
        else return null;
    }
    private void inOrder(TreeNode pRoot,int k){
        if(pRoot==null)return;
        inOrder(pRoot.left,k);
        list.add(pRoot);
        if(list.size()==k)return;
        inOrder(pRoot.right,k);
    }
}

 

IMUHERO
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
leetcode迷宫问题-LeetCode:LeetCode刷题之剑指offer系列
06-30
LeetCode之剑指offer系列刷题 剑指offer系列题目列表（C++实现） 题目名称和题号 题目链接 题目博客 刷题次数 类型 面试题01.06：字符串压缩 +2 查找+双指针 面试题03：数组中重复的数字 +2 查找 面试题04：二维数组...
二叉搜索树中最小的数字
韩绘锦的博客
10-06 1016
给定一个二叉搜索树，编写一个函数 kthSmallest 来查找其中第 k 个最小的元素。 说明： 你可以假设 k 总是有效的，1 ≤ k ≤ 二叉搜索树元素个数。 示例 1: 输入: root = [3,1,4,null,2], k = 1 3 / 1 4 2 输出: 1 示例 2: 输入: root = [5,3,6,2,4,null,null,1], k = 3 5 / 3 6...
二叉树需要掌握的基本知识
weixin_43164548的博客
02-26 1503
二叉树的基本知识：二叉树的特点、性质、结构、遍历等
树结构理论知识
qq_31990987的博客
07-03 1088
一、树结构特点：树结构是非线性结构，一个直接前驱，可能有多个直接后继（1：n）。二、树的定义：由一个或多个（n&gt;=0）节点组成的有限集合T，有且仅有一个节点称为根（root），当n&gt;1时，其余的节点为m（m&gt;=0）个互不相交的有限集合T1，T2，...，Tm。每个集合本身又是棵树，称其为根的子树。注意：空树也是树，树具有递归性（树中有树）。三、树的相关术语：    1. 根：根节...
leetcode之按之字形顺序打印二叉树
weixin_44602933的博客
08-25 276
题目： 给定一个二叉树，返回该二叉树的之字形层序遍历，（第一层从左向右，下一层从右向左，一直这样交替） 例如： 给定的二叉树是{1,2,3,#,#,4,5} 该二叉树之字形层序遍历的结果是 [ [1], [3,2], [4,5] ] 思路：比照层序遍历的方法。 这里使用两个栈来实现存储每层节点。答案要求分层输出，是一个二维数组的形式，所以对于其中的一层来说，先利用stack1中的数据（这是上一层遍历时存到栈中的这一层的值）存到list中，然后按照层数分辨出左右子节...
二叉树和其他树
weixin_43572802的博客
01-31 388
树 一棵树t是一个非空的有限元素的集合，其中一个元素为根，其余的元素（如果有的话）组成t的子树，数根是1级，孩子是2级，一个树的高度或深度为数树中级的个数。一个元素的度是指其孩子的个数。叶节点的度为0，一棵树的度是指其元素度的最大值。 二叉树 一棵二叉树是t个有限元素的集合，当二叉树为空时，其中有一个元素称为根，余下的元素被划分成两科二叉树，分别称为t的左子树和右子树。 二叉树和树的根本区别是： 二叉树的每个元素都恰好有两棵子树(其中一个或两个可能为空)。而树的每个元素可有任意数量的子树。 在二叉树中，每
leetcode围棋-leetcode:Leetcode&剑指offer部分题解
07-01
最后一章主要是《剑指offer》上的题目，其中有一部分题目是与之前章节重合的。 目前只有Java语言的实现，后续考虑会加入Javascript以及Go语言的实现。但是鉴于个人有限的精力和时间，也可能不会实施...... 如果有...
leetcode题库-leetcode:leetcode、剑指offer刷题集
06-29
LeetCode的题型包括但不限于单链表操作、二叉树遍历、动态规划、图论问题、排序与查找算法等。 **刷题策略** 1. **按难度进阶**：LeetCode题目按照难度分为简单、中等和困难三个级别，初学者可以从简单的题目开始...
javalruleetcode-onlinejudge-solutions:LeetCode、剑指Offer
06-29
1.牛客网(剑指Offer、笔试题) 解决问题 提交时间 状态 运行时间 占用内存 使用语言 代码链接 重建二叉树 2019-10-07 答案正确 218ms 22404K Java 数组中的逆序对 2019-09-21 答案正确 524ms 52020K Java 二叉树中和...
leetcodetreenode-TreeNode:二叉树leetcode挑战
07-01
在IT领域，特别是数据结构与算法的学习中，LeetCode是一个非常重要的在线平台，它提供了大量的编程挑战，包括但不限于二叉树问题。在这个“leetcodetreenode-TreeNode”项目中，我们关注的是与二叉树相关的LeetCode...
二叉树
weixin_34242509的博客
09-28 277
2019独角兽企业重金招聘Python工程师标准>>> ...
二叉树复习笔记
Sha0w的博客
08-03 529
到目前为止，我们已经介绍了线性数据结构和表数据结构。这些数据结构一般不适用与描述具有层次结构的数据… 树树是一个非空的有限元素的集合，其中一个元素为根（root），余下的元素组成t的子数（subtree） 层次中最高层元素为根，其下一级的元素是余下元素所构成的子数的根二叉树定义 ： 二叉树（binary tree） t 是有限个元素的集合（可以为空）。当二叉树非空时，其中有一个称为根的元素，余下的
leetcode z形遍历二叉树
github_38818603的博客
08-14 743
key:  use two stack s1,s2  /** * Definition for binary tree * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NU...
[二叉树遍历]Z 字形遍历二叉树
weixin_57971183的博客
07-18 1159
题目描述 假设一个二叉树上各结点的权值互不相同。 我们就可以通过其后序遍历和中序遍历来确定唯一二叉树。 请你输出该二叉树的 Z 字形遍历序列----也就是说，从根结点开始，逐层遍历，第一层从右到左遍历，第二层从左到右遍历，第三层从右到左遍历，以此类推。 输入格式 第一行包含整数 N，表示二叉树结点数量。 第二行包含 N 个整数，表示二叉树的中序遍历序列。 第三行包含 N 个整数，表示二叉树的后序遍历序列。 输出格式 输出二叉树的 Z 字形遍历序列。 样例 样例输入 8 12 1..
入门力扣自学笔记131 C++ （题目编号655）
最新发布
DK_Sorhic的博客
08-22 352
655. 输出二叉树
数据结构（六）二叉树
qq_60980658的博客
07-22 272
数据结构（六）二叉树
36.二叉树的最小高度（简单）
SCU-JJkinging的博客
10-23 7067
给定一个二叉树，找出其最小深度。 最小深度是从根节点到最近叶子节点的最短路径上的节点数量。 说明：叶子节点是指没有子节点的节点。 示例 1： 输入：root = [3,9,20,null,null,15,7] 输出：2 示例 2： 输入：root = [2,null,3,null,4,null,5,null,6] 输出：5 # Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, lef
书面作业： 第五章 树与二叉树
Self-den1al的博客
11-22 6302
判断 1-1 如果完全二叉树从根结点开始按层次遍历的输入序列为1,2,3,4,5,6,7，则该完全二叉树是二叉排序树。 1-2 二叉树是一种特殊的树。 1-3 用链表(llink-rlink)存储包含n个结点的二叉树，结点的2n个指针区域中有n-1个空指针。 1-4 完全二叉树中，若一个结点没有左孩子，则它必是树叶。 1-5 将一棵完全二叉树存于数组中（根结点的下标为1）。则下标为23和24的两个结点是兄弟。 1-6 在一棵由包含4、5、6等等一系列整数结点构成的二叉搜索树中，如果结点4和6在树的同一层，那
关于二叉树的一些题
jhcconan614的博客
05-16 1390
二叉树的创建我们已经了解了，现在我们在这一个基础上来拓展一些常出现的题1、在二叉树中寻找一个节点——>存在，返回节点，不存在返回NULL2、求一个节点的双亲节点——>存在，返回节点，不存在返回NULL3、求二叉树的高度4、求叶子节点的个数5、求第K层的节点个数6、求一个二叉树的镜像……不过在这这钱我们先来补充一下二叉树的性质：1、若规定根节点的层次为0，南无一个非空的二叉树的第i个节点最多有2^i（

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

IMUHERO

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值