二叉树精选习题 !!!

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

*

前序遍历打印二叉树

链接：力扣
递归版本

/**
 * 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 {
    ArrayList<Integer> list = new ArrayList<>();//注意要定义全局链表
    public List<Integer> preorderTraversal(TreeNode root) {
        
        if(root == null){
            return list;
        }
        list.add(root.val);
        preorderTraversal(root.left);
        preorderTraversal(root.right);
        return list;
    }
}

非递归版本：

/**
 * 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> list = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        if(root == null) return list;
        TreeNode cur = root;
        while(cur != null || !stack.isEmpty()){
            while(cur != null){
                stack.push(cur);
                list.add(cur.val);
                cur = cur.left;
            }
            cur = stack.pop();
            cur = cur.right;
        }
        return list;
    }
}

中序遍历二叉树

链接：力扣
递归版本：

/**
 * 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 {
    List<Integer> list = new ArrayList<>();
    public List<Integer> inorderTraversal(TreeNode root) {
        if(root == null) return list;
        inorderTraversal(root.left);
        list.add(root.val);
        inorderTraversal(root.right);
        return list;
    }
}

非递归版本：

/**
 * 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> list = new ArrayList<>();
        if(root == null)return list;
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        while(cur != null || !stack.isEmpty()){
            while(cur != null){
                stack.push(cur);
                cur = cur.left;
            }
            cur = stack.pop();
            list.add(cur.val);
            cur = cur.right;
        }
        return list;
    }
}

后续遍历二叉树

链接：力扣

递归版本：

/**
 * 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 {
    List<Integer> list = new ArrayList<>();
    public List<Integer> postorderTraversal(TreeNode root) {
        if(root == null) return list;
        postorderTraversal(root.left);
        postorderTraversal(root.right);
        list.add(root.val);
        return list;
    }
}

非递归版本：

/**
 * 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> list = new ArrayList<>();
        if(root == null) return list;
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        TreeNode prev = null;
        while(cur != null || !stack.isEmpty()){
            while(cur != null){
                stack.push(cur);
                cur = cur.left;
            }
            TreeNode tmp = stack.peek();
            if(tmp.right == null || tmp.right == prev){
                list.add(tmp.val);
                stack.pop();
                prev = tmp;
            }else{
                cur = tmp.right;
            }
        }
        return list;
    }
}

相同的树

链接：力扣
在这里插入图片描述

/**
 * 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 boolean isSameTree(TreeNode p, TreeNode q) {
        if(p == null && q != null || p != null && q == null){
            return false;
        }
        if(p == null && q == null){
            return true;
        }
        if(p.val != q.val){
            return false;
        }
        return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
    }
}

另一个树的子树

链接：力扣

class Solution {

    public boolean isSubtree(TreeNode s, TreeNode t){
        if(s == null || t ==null) return false;
        if(isSameTree(s,t)) return true;
        if(isSubtree(s.left,t)) return true;
        if(isSubtree(s.right,t)) return true;
        return false;
    }

     public boolean isSameTree(TreeNode s, TreeNode t) {
        if(s == null && t == null) return true;
        if(s == null || t == null) return false;
        if(s.val != t.val) return false;
        return isSameTree(s.left,t.left) && isSameTree(s.right,t.right);
    }
}

二叉树的最大深度

链接：力扣

/**
 * 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 int maxDepth(TreeNode root) {
        if(root == null) return 0;
        int leftHigh = maxDepth(root.left)+1; 
        int rightHigh = maxDepth(root.right)+1;
        return Math.max(leftHigh,rightHigh);
    }
}

平衡二叉树

链接：力扣

/**
 * 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 boolean isBalanced(TreeNode root) {
        if(root == null) return true;
        int left = high(root.left);
        int right = high(root.right);
        //int ret = Math.abs(left-right);
        if(Math.abs(left-right)>1) return false;
        return isBalanced(root.left) && isBalanced(root.right);
        
    }
    public int high(TreeNode root){
        if(root == null) return 0;
        int left = high(root.left)+1;
        int right = high(root.right)+1;
        return Math.max(left,right);
    }
}

对称二叉树

链接：添加链接描述

/**
 * 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 boolean isSymmetric(TreeNode root) {
        if(root == null) return true;
        return isSymmetricChid(root.left,root.right);
    }

    public boolean isSymmetricChid(TreeNode rootleft, TreeNode rootright){
        if(rootleft == null && rootright ==null){
            return true;
        }
        if(rootleft == null || rootright == null){
            return false;
        }
        if(rootleft.val != rootright.val){
             return false;
        }
        return isSymmetricChid(rootleft.left, rootright.right) &&
         isSymmetricChid(rootleft.right, rootright.left);
          
    }
}

前序遍历创建二叉树并中序遍历输出

链接:牛客

import java.util.*;

class TreeNode{
    public char val;
    public TreeNode left;
    public TreeNode right;
    
    public TreeNode(char val){
        this.val = val;
    }
}
public class Main{
    public static int i = 0;
    public static TreeNode createTree(String str){
        if(str == null || str.length() <= 0) return null;
        //int i = 0;
        TreeNode root = null;
        if(str.charAt(i) != '#'){
            root = new TreeNode(str.charAt(i));
            i++;
            root.left = createTree(str);
            root.right = createTree(str);
        }else{
            i++;
        }
        return root;//返回值返回null时递归结束
    }
    
    public static void inOrderTraverser(TreeNode root){
        if(root == null) return;
        inOrderTraverser(root.left);
        System.out.print(root.val+" ");
        inOrderTraverser(root.right);
    }
        
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        TreeNode root = createTree(str);
        inOrderTraverser(root);
    }
}

二叉树的最近公共祖先

链接：添加链接描述
（LCA）

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
    
        if(root == null|| root == p || root == q) return root; 
        TreeNode left = lowestCommonAncestor(root.left,p,q);//第一次找到q 或 p 就return了 所以第一次找到的就是公共祖先
        TreeNode right = lowestCommonAncestor(root.right,p,q);
        if(left==null){
        return right;
        }
        if(right==null){
        return left;
        }
        return root;
    }
}

二叉搜索树转为双向链表

链接：牛客

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

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

    }

}
*/
public class Solution {
    public TreeNode prev = null;
    public void ConverChild(TreeNode cur){
        if(cur == null) return;
        ConverChild(cur.left);
        
        cur.left = prev;
        if(prev != null){
            prev.right = cur;
        }
        prev = cur;
        
        ConverChild(cur.right);
    }
    public TreeNode Convert(TreeNode pRootOfTree) {
        if(pRootOfTree == null) return null;
        ConverChild(pRootOfTree);
        TreeNode head = pRootOfTree;
        while(head.left != null){
            head = head.left;
        }
        return head;
        
    }
}

前序遍历与中序遍历序列创建二叉树

链接：添加链接描述

/**
 * 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  int preindex = 0;
    public TreeNode buildChildTree(int[] preorder,int[] inorder,int inbegin, int inend) {
        if(inbegin > inend)return null;
        TreeNode root =new TreeNode(preorder[preindex]);
        
        //在中序遍数组 中找到当前位置所在节点
        int index = findpreorder(inorder,root.val,inbegin,inend);
        preindex++;
        root.left = buildChildTree(preorder,inorder,inbegin,index-1);
        root.right = buildChildTree(preorder,inorder,index+1,inend);
        return root;
        
    }

    
    public int findpreorder(int[] inorder, int key,int inbegin, int inend){
        for(int i = inbegin;i <= inend;i++){
            if(inorder[i] == key){
                return i;
            }
        }
        return -1;
    }
    
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        if(preorder == null || inorder == null)return null;
        if(preorder.length == 0 || inorder.length == 0)return null;

        return buildChildTree(preorder,inorder,0,inorder.length-1);

    }
}

后序遍历与中序遍历序列创建二叉树

链接：力扣

/**
 * 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 int postindex = 0;
    public TreeNode buildChildTree(int[] postorder,int[] inorder,int inbegin, int inend) {
        if(inbegin > inend)return null;
        TreeNode root = new TreeNode(postorder[postindex]);
        
        //在中序遍数组 中找到当前位置所在节点
        int index = findpostorder(inorder,root.val,inbegin,inend);
        postindex--;
        root.right = buildChildTree(postorder,inorder,index+1,inend);
        root.left = buildChildTree(postorder,inorder,inbegin,index-1);
        
        return root;
        
    }

    
    public int findpostorder(int[] inorder, int key,int inbegin, int inend){
        for(int i = inbegin;i >= 0;i++){
            if(inorder[i] == key){
                return i;
            }
        }
        return -1;
    }
    
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        if(postorder == null || inorder == null)return null;
        if(postorder.length == 0 || inorder.length == 0)return null;
        postindex = inorder.length-1;
        return buildChildTree(postorder,inorder,0,inorder.length-1);

    }
}

根据二叉树创建字符创串

链接：力扣

你需要采用前序遍历的方式，将一个二叉树转换成一个由括号和整数组成的字符串。
空节点则用一对空括号 “()” 表示。而且你需要省略所有不影响字符串与原始二叉树之间的一对一映射关系的空括号对。
在这里插入图片描述

/**
 * 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 String tree2str(TreeNode root) {
        StringBuilder sb = new StringBuilder();
        tree2strChild(root,sb);
        return sb.toString();

    }
    public void tree2strChild(TreeNode t, StringBuilder sb) {
        if(t == null) return;
        sb.append(t.val);
        if(t.left == null){
            if(t.right == null){
                return;
            }else{
              sb.append("()");  
            }
        }else{
            sb.append("(");
            tree2strChild(t.left,sb);
            sb.append(")");
        }

        if(t.right == null){
            return;
        }else{
            sb.append("(");
            tree2strChild(t.right,sb);
            sb.append(")");
        }
    }
}

二叉树的层序遍历

链接：力扣
在这里插入图片描述

/**
 * 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;
 *     }
 * }
 */
public class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> list=new ArrayList<>();
        if (root==null)
            return list;
        Queue<TreeNode> q1=new LinkedList<>();
        Queue<TreeNode> q2=new LinkedList<>();
        q1.offer(root);
        while (!q1.isEmpty()){
            List<Integer> ret = new ArrayList<>();
            while (!q1.isEmpty()){
                TreeNode cur = q1.poll();
                ret.add(cur.val);
                if (cur.left != null)
                    q2.offer(cur.left);
                if (cur.right!=null)
                    q2.offer(cur.right);
            }
            list.add(ret);
            Queue<TreeNode> tmp = new LinkedList<>(q1);
            q1 = q2;
            q2 = tmp;
        }
        return list;
    }
}

按之字形顺序打印二叉树

题目描述
链接

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

示例1
输入： {8,6,10,5,7,9,11}
返回值： [[8],[10,6],[5,7,9,11]]

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 {
    public ArrayList<ArrayList<Integer>> Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer>> ret = new ArrayList<>();
        if (pRoot == null) return ret;
        Stack<TreeNode> s1 = new Stack<>();
        Stack<TreeNode> s2 = new Stack<>();
        ArrayList<Integer> list = new ArrayList<>();
        list.add(pRoot.val);
        ret.add(list);
        s1.push(pRoot);
 
        while (!s1.isEmpty() || !s2.isEmpty()){
            ArrayList<Integer> tmp = new ArrayList<>();
              if (!s1.isEmpty()) {
                  while (!s1.isEmpty()) {
                      if (s1.peek().right != null) {
                          tmp.add(s1.peek().right.val);
                          s2.push(s1.peek().right);
                      }
                      if (s1.peek().left != null) {
                          tmp.add(s1.peek().left.val);
                          s2.push(s1.peek().left);
                      }
                      s1.pop();
                  }
              }else {
                  while (!s2.isEmpty()) {
                      if (s2.peek().left != null) {
                          tmp.add(s2.peek().left.val);
                          s1.push(s2.peek().left);
                      }
                      if (s2.peek().right != null) {
                          tmp.add(s2.peek().right.val);
                          s1.push(s2.peek().right);
                      }
                      s2.pop();
                  }
              }
                  if(tmp.size()>0){
                      ret.add(tmp);
                  }
        }
        return ret;
    }
}

二叉树的镜像

题目描述：
在这里插入图片描述

示例1 输入： {8,6,10,5,7,9,11}
返回值： {8,10,6,11,9,7,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 {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pRoot TreeNode类 
     * @return TreeNode类
     */
    public TreeNode Mirror (TreeNode pRoot) {
        // write code here
        if(pRoot == null) return null;
        if(pRoot.left == null && pRoot.right == null) return pRoot;
        TreeNode tmp = pRoot.left;
        pRoot.left = pRoot.right;
        pRoot.right = tmp;
        Mirror(pRoot.left);
        Mirror(pRoot.right);
        return pRoot;
    }
}
DavenPortChen.
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树练习题及答案.docx
12-05
通过这些练习题，我们可以深入理解二叉树的基本概念和性质，这对于计算机科学的学习，尤其是数据结构和算法分析非常重要。熟练掌握这些知识点将有助于解决更复杂的二叉树问题和设计高效的算法。
【数据结构】二叉树经典习题
weixin_61932507的博客
04-17 3441
【数据结构】二叉树经典习题
二叉树练习题及答案解析
m0_52322019的博客
11-18 6521
二叉树练习一、选择题1. 某二叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该二叉树中的叶子结点数为（ ）2.在具有 2n 个结点的完全二叉树中，叶子结点个数为（ ）3.一棵完全二叉树的节点数位为531个，那么这棵树的高度为（ ）4.一个具有767个节点的完全二叉树，其叶子节点个数为（）5. 某完全二叉树按层次输出（同一层从左到右）的序列为 ABCDEFGH 。该完全二叉树的前序序列为()6. 二叉树的先序遍历和中序遍历如下：先序遍历：EFHIGJK;中序遍历：HFIEJKG.则二叉树根结
二叉树的题目练习总集（一次做到爽）
雀黑够呛哥
04-14 2876
摘要：建立二叉树、前中后层序、求树高度、叶子结点个数、k层结点个数、结点是否存在于二叉树、两个叶子最近公共祖先、判断平衡树、求二叉树最远两个结点距离。 目录 分析需求： 一、节点 二、队列 三、树 1、树的基本方法：建立二叉树。 2、求前中后层遍历 3、求树的高度： 4、求叶子节点个数 5、求二叉树第k层的结点个数 6、判断一个结点是否在二叉树中？ 7、求两个结点的...
【数据结构】——树和二叉树的相关习题
小宇y的博客
06-01 3436
另外，由于每个结点中包含2个指针域（左指针域lchild、右指针域rchild），总指针域数量减去非空指针数即为空指针数，2n-(n-1)=n+1。考虑第1层到第6层结点都是满的情况，即第1层到第6层结点的结点数量为1+2+4+8+16+32=63个。最少的情况下，除了根结点该层为1个结点以外，其余h-1层都有2个结点，得2(h-1)，即2(h-1)+1=2h-1。1、设高度为h的二叉树上只有度为0和度为2的结点，则该二叉树中所包含的结点数至少为（），最多为（）。B、中序遍历序列与后序遍历序列相同，为（）
C++数据结构——习题7-2 二叉排序树(二叉搜索树)
weixin_44546342的博客
05-22 1919
HLOJ 9576，习题7-2 二叉排序树 输入一个整数关键字序列，生成一棵用链式存储结构存储的二叉排序树，对该二叉排序树能进行查找和插入结点的操作，并对该二叉排序树中结点的关键字按递增和递减顺序输出。 要求依次完成以下工作： (1) 以这n个整数生成（建立）一棵用链式存储结构存储的二叉排序树； (2) 按递增顺序输出该二叉排序树中的整数（关键字）； (3) 输入一个整数key1，对该二叉排序树进行查找，给出“find”（找到）或“not find”（没找到）的信息； (4) 输入一个整数key2，若该二
[C++算法入门]-二叉树打印练习题
09-26
文档中包含了一系列的练习题，涵盖了二叉树的构建、遍历和打印等方面。 通过完成这些练习，读者将能够掌握二叉树的基本概念和常用操作，并学会使用C++编写代码来解决与二叉树相关的算法问题。此外，文档还提供了...
二叉树练习题及答案.pdf
12-05
二叉树是一种特殊的树结构，每个节点最多有两个子节点，分别称为左子节点和右子节点。...通过这些练习题，我们可以深入理解二叉树的基本概念、性质及其应用，这对于理解和实现涉及二叉树的算法至关重要。
二叉树习题
01-16
二叉树是计算机科学中一种重要的数据结构，它在很多领域有着广泛的应用，如文件系统、编译器设计、图形处理等。二叉树的概念基于树的定义，但具有更特殊的性质，使得它们更容易被处理和操作。 首先，我们要理解树的...
数据结构考研试题集锦非常全！
06-26
数据结构是计算机科学与技术...考生在复习时，不仅要掌握理论知识，还要通过大量练习来提升解决问题的能力。这份题集锦无疑是宝贵的复习资源，可以帮助考生系统地梳理和巩固数据结构的知识体系，为考试做好充分准备。
数据结构——二叉树练习题
weixin_49449676的博客
08-13 2732
4道二叉树OJ练习题
二叉树习题总结二
weixin_47651920的博客
07-26 499
二叉树习题
二叉树习题-小记
xy199931的博客
11-17 373
二叉树
二叉树经典题题解（超全题目）（力扣）
最新发布
2301_79293429的博客
02-05 1883
二叉树超全题目
【初级数据结构】二叉树习题
BebopPrimer的博客
01-14 416
【初级数据结构】二叉树习题
十道二叉树面试题，对二叉树理解更进一步
weixin_46016019的博客
05-06 3024
学习二叉树有一个很重要的思想就是分治（将一个大问题划分为最小规模的子问题），常用方法之一就是递归，而递归是很抽象的，当对递归过程不理解时，建议多画图将递归过程实例化，拒绝人脑压栈...
二叉树经典的选择题（带你轻松理解）
weixin_72040293的博客
04-03 2578
讲解二叉树常见的三种选择题题型
二叉树相关题目汇总
那一抹天空蓝的博客
07-26 745
目录 二叉树相关性质 1.求二叉树的最大深度 2.求二叉树的最小深度 3.求二叉树中节点的个数 4.求二叉树中的叶子节点的个数 5.求二叉树中第k层节点的个数 6.判断二叉树是否是平衡二叉树 7.判断是否完全二叉树 8.判断是否相同的二叉树 9.判断是否是互为镜像的二叉树 10.翻转二叉树or镜像二叉树 11.求两个二叉树的最低公共祖先节点 12.输入一个二叉树和一个整数...
二叉树习题集
btzxlin的博客
04-07 779
1.单值二叉树 965. 单值二叉树 - 力扣（LeetCode） (leetcode-cn.com) 如果二叉树每个节点都具有相同的值，那么该二叉树就是单值二叉树。 只有给定的树是单值二叉树时，才返回 true；否则返回 false。 /** * Definition for a binary tree node. * struct TreeNode { * int val; * struct TreeNode *left; * struct TreeNode *rig
数据结构：树与二叉树习题解析
"数据结构练习题目，包括了关于树和二叉树的多项选择题，涉及转换、性质和计算等知识点。" 以下是相关知识点的详细解释： 1. **中缀、后缀和前缀表达式**： - 中缀表达式是我们常用的运算符在操作数之间的形式，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值