树 和 二叉树

已于 2024-04-09 19:34:27 修改
阅读量938 收藏 28
点赞数 21
分类专栏： Java数据结构与算法 文章标签： java 数据结构 算法
于 2024-04-08 17:53:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61731585/article/details/137394875
版权

目录

一、树

1、初识树

2、树的一些概念

3、树的表示形式

二、二叉树

1、初识二叉树

2、两种特殊的二叉树

3、二叉树的性质 

4、二叉树的遍历

5、实现一棵二叉树 

6、二叉树题目（没代码的后面会给补上）

一、树

1、初识树

（1）根节点没有前驱。

（2）子树的根节点只有一个前驱，可以有0个或多个后继。

（3）每个子树都是不相交的，子树之间不能有交集。

（4）N个结点有N-1条边

2、树的一些概念

1、结点的度：这个结点有几个子树，度就为几

2、树的度：所有结点度的最大值就是树的度

3、根结点：没有前驱的结点

4、叶子结点或终端结点：没有后继的结点（没有子树），即度为0的结点

5、分支结点或非终端结点：有后继的结点（有子树），即度不为0的结点

6、双亲结点或父结点：结点的前驱就是该结点的父结点

7、孩子结点或子结点：结点的后继就是该结点的子结点

8、兄弟结点：具有相同父结点的结点互为兄弟结点

9、堂兄弟结点：父结点在同一层的结点互为堂兄弟结点

10、结点的祖先：从根结点到该结点一路上经过的所有结点都是该结点的祖先，如：根结点是除自身外所有结点的祖先

11、子孙：该结点后面的所有结点都是该结点的子孙，如：除根结点外所有结点都是根结点的子孙

12、结点的层次：根为第1层，以此类推

13、深度：该结点的层次就是深度

14、树的高度：树中结点的最大层次就是树的高度

15、森林：由m（m>=0）棵互不相交的树组成的集合称为森林，空树也叫森林

3、树的表示形式

树可以有：双亲表示法，孩子表示法，孩子双亲表示法，孩子兄弟表示法等等

二、二叉树

1、初识二叉树

（1）二叉树是树

（2）二叉树的每个根结点都只有两棵子树，分别为左子树和右子树

（3）二叉树也可以是空树

（4）二叉树的度 <=2，所以二叉树的结点个数 = 度为0的结点个数+度为1的结点个数+度为2的结点个数

2、两种特殊的二叉树

（1）满二叉树

除叶子结点外，结点的度都为2，结点总数为：(2^k)-1，k为树的高度

（2）完全二叉树

从上到下，从左到右，中间不少结点。

满二叉树是特殊的完全二叉树。

完全二叉树中，度为1的结点个数 要么为0，要么为1 —— 结点总数是偶数时，度为1的结点个数为 1，结点总数是奇数时，度为1的结点个数为 0

3、二叉树的性质 

1、二叉树的第 k 层，最多有 2^(k-1) 个结点（空树除外）

2、深度为 k 的二叉树，最多有(2^k)-1个结点

3、任意一棵二叉树，叶子结点的个数 比 度为2的结点的个数 多 1

4、n个结点的完全二叉树，深度k为：(2^k) -1= n，k为 log以2为底n+1的对数，向上取整

5、完全二叉树，

若父结点下标为 i，则 左孩子下标为：2*i+1，右孩子下标为：2*i+2

若子结点下标为 i，则父结点下标为：​​​​​​​（i-1）/2

题目：

1. 某二叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该二叉树中的叶子结点数为（B、 200 ）199+1

2.在具有 2n 个结点的完全二叉树中，叶子结点个数为（A、n）2n = n0+1+n0-1

3.一个具有767个节点的完全二叉树，其叶子节点个数为（B、384）767 = n0+0+n0-1

4、二叉树的遍历

前序遍历：根，左子树，右子树

中序遍历：左子树，根，右子树

后序遍历：左子树，右子树，根

层序遍历：从上到下，从左到右

如：写出下面这棵二叉树的前序遍历，中序遍历，后序遍历，层序遍历的结果

前序遍历：A B D E H C F G

中序遍历：D B E H A F C G

后序遍历：D H E B F G C A

层序遍历：A B C D E F G H

题目：

1、设一课二叉树的中序遍历序列：badce，后序遍历序列：bdeca，则二叉树前序遍历序列为(D)

A: adbce B: decab C: debac D: abcde

后序遍历，从后往前，每一个结点都是根结点。拿着根结点，去中序遍历里看，根结点的左边属于左子树的结点，根结点的右边属于右子树的结点。

如，后序遍历从后往前第一个结点就是整棵树的根结点 a，然后看中序遍历，则，b 属于左子树的结点，dce 属于右子树的结点。然后再看后序遍历从后往前第二个结点，以此类推。

由此题引出两个问题，

问题一：如果只给一个遍历，能否创建一棵二叉树？

不能。因为有可能存在两棵不同的树，某一个遍历是一样的。

问题二：如果只给前序遍历和后序遍历，能否创建一棵二叉树？

不能。前序遍历和后序遍历都是只能确定根的位置，但不能确定左子树或右子树。

5、实现一棵二叉树 

二叉树的存储结构（物理结构）有：顺序存储和链式存储

这里我们使用孩子表示法来实现一个链式存储结构的二叉树。

1、前序遍历 2、中序遍历 3、后序遍历
4、获取树中结点的个数 5、获取叶子结点的个数 6、获取第 k层 结点的个数
7、获取二叉树的高度
8、获取第k层的所有结点：有点 带返回值的前序遍历 和 获取第 k层 结点的个数 的结合版
9、找到值为value的元素
10、层序遍历：和层序遍历相关的想到用 队列，用队列会比较方便
11、判断这棵树是不是完全二叉树：用 队列
public class MyBinaryTree {
    static class TreeNode{
        public char val;
        public TreeNode leftTree;//存储左子树的引用
        public TreeNode rightTree;//存储右子树的引用
        public TreeNode(char val){
            this.val = val;
        }
    }
    //创建一棵树
    public TreeNode createTree(){
        TreeNode A = new TreeNode('A');
        TreeNode B = new TreeNode('B');
        TreeNode C = new TreeNode('C');
        TreeNode D = new TreeNode('D');
        TreeNode E = new TreeNode('E');
        TreeNode F = new TreeNode('F');
        TreeNode G = new TreeNode('G');
        TreeNode H = new TreeNode('H');
        A.leftTree = B;
        A.rightTree = C;
        B.leftTree = D;
        B.rightTree = E;
        C.leftTree = F;
        C.rightTree = G;
        E.rightTree = H;
        return A;
    }
    //前序遍历
    public void preOrder(TreeNode root){
        if(root == null){
            return;
        }
        System.out.print(root.val+" ");
        preOrder(root.leftTree);
        preOrder(root.rightTree);
    }
    //带返回值
    public List<Character> preorderTraversal(TreeNode root) {
        //子问题思路：先放根，然后放左子树，然后放右子树
        List<Character> list = new ArrayList<>();
        //递归的终止条件
        if(root == null){
            return list;
        }
        list.add(root.val);
        list.addAll(preorderTraversal(root.leftTree));
        list.addAll(preorderTraversal(root.rightTree));
        return list;
    }
    //中序遍历
    public void inOrder(TreeNode root){
        if(root == null){
            return;
        }
        inOrder(root.leftTree);
        System.out.print(root.val+" ");
        inOrder(root.rightTree);
    }
    //后序遍历
    public void postOrder(TreeNode root){
        if(root == null){
            return;
        }
        postOrder(root.leftTree);
        postOrder(root.rightTree);
        System.out.print(root.val+" ");
    }
    //获取树中结点的个数
    public int size(TreeNode root){
        //左子树结点的个数+右子树结点的个数+1
        //递归的终止条件
        if(root == null){
            return 0;
        }
        return size(root.leftTree)+size(root.rightTree)+1;
    }
    //获取叶子结点的个数
    public int getLeafNodeCount(TreeNode root){
        //左子树叶子结点的个数+右子树叶子结点的个数
        if(root == null){
            return 0;
        }
        //满足下面条件的就是叶子结点,递归的终止条件
        if(root.leftTree == null && root.rightTree == null){
            return 1;
        }
        return getLeafNodeCount(root.leftTree) + getLeafNodeCount(root.rightTree);
    }
    //获取第 k层 结点的个数
    public int getKLevelNodeCount(TreeNode root,int k){
        //第k层结点的个数 = 左子树第k-1层结点的个数+右子树第k-1层结点的个数
        if(k <= 0){
            throw new KWrongFulException("k不合法异常");
        }
        //如果k大于树的高度，k还没减到0，root先变成null，返回0
        //下面两个都算循环的终止条件
        if(root == null){
            return 0;
        }
        if(k == 1){
            return 1;
        }
        return getKLevelNodeCount(root.leftTree,k-1)
                +getKLevelNodeCount(root.rightTree,k-1);
    }
    //获取二叉树的高度
    public int getHeight(TreeNode root){
        //左子树的高度，右子树的高度的最大值 +1
        if(root == null){
            return 0;
        }
        int leftHeight = getHeight(root.leftTree);
        int rightHeight = getHeight(root.rightTree);
        return leftHeight > rightHeight ? leftHeight+1 : rightHeight+1;
    }
    //获取第 k 层的所有结点
    //有点像 带返回值的前序遍历 和 获取第 k层 结点的个数 的结合
    public List<Character> KLevel(TreeNode root,int k){
        List<Character> list = new LinkedList<>();
        if(root == null){
            return list;
        }
        //把 第 k 层的每一个结点都 add 进 list，返回给父结点
        if(k == 1){
            list.add(root.val);
            return list;
        }
        //父结点接收到两个子结点返回的 list，add到自己的list里
        list.addAll(KLevel(root.leftTree,k-1));
        list.addAll(KLevel(root.rightTree,k-1));
        //然后返回给他的父结点，于是层层递进，最后根结点的list里 放的就是 第k层 的所有结点
        return list;
    }
    //找到值为value的元素
    public TreeNode find(TreeNode root,char val){
        //先找根，然后找左子树，然后找右子树，找到就返回，找不到返回null
        //下面两个都是递归的终止条件
        if(root == null){
            return null;
        }
        if(root.val == val){
            return root;
        }
        TreeNode ret1 = find(root.leftTree,val);
        //如果 ret1 里面不是空，说明找到了
        //如果 ret1 里面是空，说明没找到
        if (ret1 != null){
            return ret1;
        }
        TreeNode ret2 = find(root.rightTree,val);
        if (ret2 != null){
            return ret2;
        }
        return null;
    }
    //层序遍历：用到队列，先进先出
    //层序遍历不用递归比较方便，本来就是按顺序（从上到下，从左到右）输出的呀，
    // 不像前序中序和后序遍历，必须得递归
    public void levelOrder(TreeNode root){
        Queue<TreeNode> queue = new LinkedList<>();
        if(root == null){
            return;
        }
        queue.offer(root);
        while(!queue.isEmpty()){
            TreeNode ret = queue.poll();
            System.out.print(ret+" ");
            if(ret.leftTree != null){
                queue.offer(ret.leftTree);
            }
            if(ret.leftTree != null){
                queue.offer(ret.rightTree);
            }
        }
    }
    //有返回值的层序遍历：用到队列比较方便
    //难点在如何确定每一层，这里我们用到了队列中的size
    //每一轮都要定义一个size
    public List<List<Character>> levelOrderTraversal(TreeNode root){
        List<List<Character>> tmp = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        if(root == null){
            return tmp;
        }
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            List<Character> list = new ArrayList<>();
            while(size > 0) {
                TreeNode ret = queue.poll();
                size--;
                list.add(ret.val);
                if (ret.leftTree != null) {
                    queue.offer(ret.leftTree);
                }
                if (ret.rightTree != null) {
                    queue.offer(ret.rightTree);
                }
            }
            tmp.add(list);
        }
        return tmp;
    }
    //判断这棵树是不是完全二叉树：用队列
    public boolean isCompleteTree(TreeNode root){
        Queue<TreeNode> queue = new LinkedList<>();
        if(root == null){
            return true;
        }
        queue.offer(root);
        while(!queue.isEmpty()){
            TreeNode ret = queue.peek();
            if(ret == null){
                break;
            }
            queue.poll();
            queue.offer(ret.leftTree);
            queue.offer(ret.rightTree);
        }
        //走到这，队列里要么都是null，要么除了null还有结点，后者说明不是完全二叉树
        while(!queue.isEmpty()){
            TreeNode ret = queue.poll();
            if(ret != null){
                return false;
            }
        }
        return true;
    }
}

6、二叉树题目（没代码的后面会给补上）

1、判断两棵树相不相等
2、判断其中一棵树是不是另一棵树的子树
3、翻转二叉树
4、判断是不是平衡二叉树
5、判断两棵二叉树是不是镜像对称
6、判断是不是轴对称二叉树
7、二叉树的层序遍历
8、二叉树的构建和遍历
9、给定一个二叉树, 找到该树中两个指定节点的最近公共祖先
10、二叉搜索树转换成排序双向链表
11、二叉树前序非递归遍历实现
12、二叉树中序非递归遍历实现
13、二叉树后序非递归遍历实现
14、根据一棵树的前序遍历与中序遍历构造二叉树
15、根据一棵树的中序遍历与后序遍历构造二叉树
16、二叉树创建字符串

（1）判断两棵树是否相同 链接

//时间复杂度：O(min(m,n))，其中 m和n 分别是两个二叉树的结点数
public boolean isSameTree(TreeNode p, TreeNode q) {
        //先判断根一样不，再判断左子树一样不，再判断右子树一样不，只有全一样(结构和值都一样)，才返回true
        //如果都是空树
        if(p == null && q == null){
            return true;
        }
        //如果一个是空树，一个不是
        if((p == null && q != null) || (p != null && q == null)){
            return false;
        }
        //走到这，则两个都不是空树
        //值不相等
        if(p.val != q.val){
            return false;
        }
        //走到这，既不是空树，根的值也相等
        return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
}

（2）判断其中一棵树是不是另一棵树的子树 链接 


    /**
     * 2、判断其中一棵树是不是另一棵树的子树
     * 时间复杂度：O(m*n)，其中 m和n 分别是两个二叉树的结点数
     */
    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
        //题目中已经给出了：两棵树都不是空树
        //如果一直没有匹配，root就会一直root.left，root会为空
        if(root == null || subRoot == null){
            return false;
        }
        //先判断subRoot是否和root相等，
        if(isSameTree(root,subRoot)) return true;
        //再判断subRoot是否是root的左子树的子树
        if(isSubtree(root.left,subRoot)) return true;
        //再判断subroot是否是root的右子树的子树
        if(isSubtree(root.right,subRoot)) return true;
        return false;
    }
   public boolean isSameTree(TreeNode p, TreeNode q) {
        //先判断根一样不，再判断左子树一样不，再判断右子树一样不，只有全一样(结构和值都一样)，才返回true
        //如果都是空树
        if(p == null && q == null){
            return true;
        }
        //如果一个是空树，一个不是
        if((p == null && q != null) || (p != null && q == null)){
            return false;
        }
        //走到这，则两个都不是空树
        //值不相等
        if(p.val != q.val){
            return false;
        }
        //走到这，既不是空树，根的值也相等
        return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
    }

（3）翻转二叉树 链接

public TreeNode invertTree(TreeNode root) {
        //先翻转根结点的左子树和右子树，再翻转左子树的左子树和右子树，再翻转右子树的左子树和右子树
        if(root == null){
            return null;
        }
        TreeNode tmp = root.left;
        root.left = root.right;
        root.right = tmp;
        invertTree(root.left);
        invertTree(root.right);
        return root;
}

（4）判断是不是平衡二叉树 链接

//判断是不是平衡二叉树，时间复杂度O(n)
    public boolean isBalanced(TreeNode root) {
        //平衡二叉树：每棵子树的高度差都要 <=1

        if(root == null){
            return true;
        }
        int ret = height(root);
        if(ret == -1){
            return false;
        }
        return true;
    }
    //求二叉树的高度，时间复杂度是O(n)
    //求根结点高度的时候，其实已经求了所有结点的高度，如果发现左树右树高度差大于1，说明已经不平衡了，就返回-1
    //否则就返回左树右树高度最大值+1
    //所以，我们需要在每次获得左树和右树高度的时候，都接收判断一下，如果发现接收到的是-1，说明已经出现了不平衡
    //如果一直没有接收到-1，说明这个二叉树的每棵子树都是平衡的，所以这棵二叉树是高度平衡的二叉树。
    //求二叉树的高度
    public int height(TreeNode root){
        if(root == null){
            return 0;
        }
        //求左子树的高度
        int leftH = height(root.left);
        if(leftH == -1){
            return -1;
        }
        //求右子树的高度
        int rightH = height(root.right);
        if(rightH == -1){
            return -1;
        }
        //如果左右子树的高度差 <= 1，返回左右子树高度的最大值+1
        //如果左右子树的高度差 > 1，返回-1，说明已经出现不平衡了
        if(Math.abs(leftH - rightH) <= 1){
            return Math.max(leftH,rightH) + 1;
        }else{
            return -1;
        }
    }

（5）判断两棵树是不是镜像对称

public boolean isMirrorSymmetry(TreeNode leftTree,TreeNode rightTree){
        //如果两个都是空树
        if(leftTree == null && rightTree == null){
            return true;
        }
        //如果一个是空树一个不是
        if((leftTree == null && rightTree != null) || (leftTree != null && rightTree == null)){
            return false;
        }
        //到这，两个都不是空树
        if(leftTree.val != rightTree.val){
            return false;
        }
        //到这，两个都不是空树，且根的值相同
        return isMirrorSymmetry(leftTree.left,rightTree.right) &&
                isMirrorSymmetry(leftTree.right,rightTree.left);
}

（6）判断是不是轴对称二叉树 链接

public boolean isSymmetric(TreeNode root) {
        
        if(root == null){
            return true;
        }
        //从第二层开始，比较左子树和右子树是否是镜像的
        return isMirrorSymmetry(root.left,root.right);
    }
    //先比较根是否是镜像的，再比较子树是否是镜像的
     public boolean isMirrorSymmetry(TreeNode leftTree,TreeNode rightTree){
        //如果两个都是空树
        if(leftTree == null && rightTree == null){
            return true;
        }
        //如果一个是空树一个不是
        if((leftTree == null && rightTree != null) || (leftTree != null && rightTree == null)){
            return false;
        }
        //到这，两个都不是空树
        if(leftTree.val != rightTree.val){
            return false;
        }
        //到这，两个都不是空树，且根的值相同
        return isMirrorSymmetry(leftTree.left,rightTree.right) &&
                isMirrorSymmetry(leftTree.right,rightTree.left);
    }

（7）二叉树的层序遍历 链接

//有返回值的层序遍历：用到队列比较方便
//难点在如何确定每一层，这里我们用到了队列中的size
//每一轮都要定义一个size
 public List<List<Integer>> levelOrder(TreeNode root) {
       List<List<Integer>> tmp = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        if(root == null){
            return tmp;
        }
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            List<Integer> list = new ArrayList<>();
            while(size > 0) {
                TreeNode ret = queue.poll();
                size--;
                list.add(ret.val);
                if (ret.left != null) {
                    queue.offer(ret.left);
                }
                if (ret.right != null) {
                    queue.offer(ret.right);
                }
            }
            tmp.add(list);
        }
        return tmp;
}

（8）二叉树的构建和遍历 链接

public class Main {
    static class TreeNode{
        public char val;
        public TreeNode leftTree;//存储左子树的引用
        public TreeNode rightTree;//存储右子树的引用
        public TreeNode(char val){
            this.val = val;
        }
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextLine()) { 
            String str = scanner.nextLine();//str里存的就是读入的字符串

           //首先遍历字符串，拿到字符串中的每个元素，
           //并创建结点，通过前序遍历构造一棵二叉树
           TreeNode root = createTree(str);
           //然后再中序遍历输出
           inOrder(root);
        }
    }
    //通过前序遍历构造二叉树
    public static int i = 0;
    public static TreeNode createTree(String str){
        TreeNode root = null;
        //通过i拿到字符串中的每个字符
        char ch = str.charAt(i);
        i++;
        if(ch == '#'){
            return null;
        }
        //把拿到的元素创建成结点
        root = new TreeNode(ch);
        root.leftTree = createTree(str);
        root.rightTree = createTree(str);
        return root;   
    }
    //中序遍历输出
    public static void inOrder(TreeNode root){
        if(root == null){
            return;
        }
        inOrder(root.leftTree);
        System.out.print(root.val+" ");
        inOrder(root.rightTree);
    }
}

（9）给定一个二叉树, 找到该树中两个指定节点的最近公共祖先  链接

 public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root == null){
            return null;
        }
        // p 和 q 其中有一个是root
        if(p == root || q == root){
            return root;
        }
        // p 和 q 分别在 root 的两侧
        // p 和 q 都在 root 的左侧 或 root 的右侧
        TreeNode ret1 = lowestCommonAncestor(root.left,p,q);
        TreeNode ret2 = lowestCommonAncestor(root.right,p,q);
        if(ret1 != null && ret2 != null){
            return root;
        }else if(ret1 != null){
            return ret1;
        }else if(ret2 != null){
            return ret2;
        }else{
            return null;
        }
}

（10）二叉搜索树转换成排序双向链表 链接

public TreeNode convert(TreeNode pRootOfTree) {
        //二叉搜索树：根左边的比根小，根右边的比根大
        //中序遍历二叉搜索树是有序的，是从小到大的
        //所以，转换成排序的双向链表，采用中序遍历的方法
        if(pRootOfTree == null){
            return null;
        }
        convertChild(pRootOfTree);
        TreeNode head = pRootOfTree;
        //链表的头就是二叉搜素树最左边的那个结点
        while(head.left != null){
            head = head.left;
        }
        return head;
    }
    public TreeNode prev = null;
    public void convertChild(TreeNode pRoot){
        if(pRoot == null){
            return;
        }
        convertChild(pRoot.left);

        if(prev != null){
            prev.right = pRoot;
        }
        pRoot.left = prev;
        prev = pRoot;
        convertChild(pRoot.right);
 }

（11）二叉树前序非递归遍历实现 链接

public TreeNode cur = null;
    public List<Integer> preorderTraversal(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        List<Integer> list = new ArrayList<>();
        //用到栈
        //前序遍历：根，左，右。往左走，一直入栈，只有这个节点没用了，才能出栈。
        if(root == null){
            return list;
        }
        cur = root;
        while(cur != null || !stack.empty()){
            while(cur != null){
                stack.push(cur);
                list.add(cur.val);
                cur = cur.left;
            }
            //cur 等于空，说明cur的左走完了，此时栈顶元素就是cur
            //根和左走完了，此时才能弹出栈顶元素（因为直到这时栈顶元素才没用了）
            cur = stack.pop();
            cur = cur.right;
        }
        return list;
 }

（12）二叉树中序非递归遍历实现 链接

（13）二叉树后序非递归遍历实现 链接

（14）根据一棵树的前序遍历与中序遍历构造二叉树 链接

（15）根据一棵树的中序遍历与后序遍历构造二叉树 链接

（16）二叉树创建字符串 链接

渡上舟
关注
  • 21
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
树和二叉树
12-18 828
树的特点： 1、树中至少有一个结点——根。 2、树中各子树是互不相交的集合。 树型结构（非线性结构），一对多的关系 根结点（无前驱）、叶子结点（无后继）、其它结点（一个直接前驱、但可能有多个后继） 结点、结点的度、叶子、分支结点、孩子、双亲、兄弟、树的度、结点的层次、深度、森林、有序树、无序树 （一种规定根结点的层数为0，另一种规定为1） 有向树：有确定的
树和二叉树对比
自己的选择，无论是否正确，请坚持下去，黎明就在下一刻。
09-08 3223
树和二叉树都有一个树字，从结构上来说，都是树状结构，但是它们之间的区别是什么呢？那就拿两者的特点来说一说把。 首先是 树 先看一下树的基本概念和它的一些术语： Root：根节点。 描述：树的顶部节点。 Child：子节点。 描述：离开根节点时直接连接到另一个节点的节点。 Leaf ：叶子节点。 描述：没有子节点的节点 Edge： 边。 描述：一个节点与另一个节点之间的连接。 Path：路径。 描述：连接节点和子节点的节...
【Java 数据结构】树和二叉树
热门推荐
书生-w的博客
04-17 1万+
树是一种非线性的数据结构，它是由n个(n>=0)个有限节点组成一个具有层次关系的集合。它的形状像一颗倒挂的树，根在上，叶在下。 特点： · 有一个特殊的结点称为根节点，根节点没有前驱结点 除根节点外，其余结点被分成M(M>0)个互不相交的集合T1,T2,.....,Tm，其中每一个集合又是一颗与树类似的字树。每棵子树的根节点有且只有一个前驱，可以没有或者多个后继 · 树是递归定义的 注意：在树形结构中，子树不能有交集，否则就不是树形结构
树和二叉树源码
11-08
在计算机科学领域，树和二叉树是两种重要的数据结构，它们在许多应用中发挥着核心作用，如文件系统、数据库索引、编译器设计等。本篇将深入探讨这些概念及其相关的算法。 首先，我们要理解“树”这一概念。树是一种...
python数据结构树和二叉树简介
01-20
一、树的定义 树形结构是一类重要的非线性结构。树形结构是结点之间有分支，并具有层次关系的结构。...它或者是空集，或者是由一个根和称为左、右子树的两个不相交的二叉树组成。特点：（1）二叉树是有序树，
树和二叉树课件
01-31
此外，满二叉树和完全二叉树有特殊的数组表示方法，可以节省空间并优化某些操作。 课件中还涉及到了二叉树的实现，包括创建、插入、删除等基本操作。例如，二叉搜索树（Binary Search Tree）是一种特殊的二叉树，...
java学习----递归
qq_56798493的博客
07-13 162
【代码】java学习----递归。
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
m0_73456341的博客
07-14 787
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 627
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
Spring Security 授权
persistence_PSH的博客
07-14 868
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 995
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
Java 线程池详解
qq_41591215的博客
07-13 940
线程池是一组已经初始化并等待执行任务的线程集合。通过使用线程池，我们可以避免频繁地创建和销毁线程，从而节省资源和减少系统开销。线程池的核心思想是通过复用线程来提高性能。
【JAVA】相关程序组件
qq_44077764的博客
07-15 141
【JAVA】相关程序组件
基于Java技术的校园台球厅人员与设备管理系统
heye0910032的博客
07-12 590
本文介绍了一个基于Java技术和SpringBoot框架开发的校园台球厅人员与设备管理系统。该系统利用MySQL数据库进行数据存储，实现了包括首页、个人中心、用户管理、会员账号管理、会员充值管理、球桌信息管理、会员预约管理、普通预约管理、留言反馈和系统管理等多功能集成。系统设计考虑了用户友好性和操作便捷性，旨在提高校园台球厅人员与设备管理的效率和质量。本文介绍了一个基于Java技术和SpringBoot框架开发的校园台球厅人员与设备管理系统。
Java 中有哪几种基本数据类型？请分别列出它们并简述每种数据类型的特点及其在内存中的占用空间？
最新发布
liangzai215的专栏
07-15 495
在Java的世界里，数据是构建应用程序的基石。为了高效地处理这些数据，Java设计了一系列基础数据类型，它们直接映射到计算机硬件上，因此在性能和内存使用上更为高效。我们常说的Java八大基本数据类型，涵盖了整数、浮点数、字符和布尔值，下面我将一一介绍它们的特点以及在内存中的占用空间，并通过简单的代码实例来加深理解。
深入剖析 Java 中 Spring Bean 的生命周期
weixin_42545951的博客
07-12 693
在 Java 开发中，Spring 框架是广泛使用的企业级应用开发框架。理解 Spring Bean 的生命周期对于开发者来说至关重要，这也是面试中经常会被问到的重要知识点。
树和二叉树的数据结构与算法描述
树和二叉树是数据结构课程的重要内容之一，本章节主要介绍树的类型定义、基本术语、树的存储结构、树的遍历、线索二叉树、树和森林的表示方法、树和森林的遍历、哈夫曼树与哈夫曼编码等知识点。 一、树的类型定义 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值