Java-树

最新推荐文章于 2024-10-13 22:37:06 发布
最新推荐文章于 2024-10-13 22:37:06 发布
阅读量1.2k 收藏 21
点赞数 37
文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80873677/article/details/141949974
版权

一，树

1.1 概念

树是一种 非线性 的数据结构，它是由 n （ n>=0 ）个有限结点组成一个具有层次关系的集合。 把它叫做树是因为它看 起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的 。
它具有以下的特点：
  • 有一个特殊的结点，称为根结点，根结点没有前驱结点
  • 除根结点外，其余结点被分成M(M > 0)个互不相交的集合T1、T2、......、Tm，其中每一个集合Ti (1 <= i <= m) 又是一棵与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继
  • 树是递归定义的。

树中常用的一些概念：

结点的度 ：一个结点含有子树的个数称为该结点的度；
树的度 ：一棵树中，所有结点度的最大值称为树的度；
叶子结点或终端结点 ：度为 0 的结点称为叶结点；
双亲结点或父结点 ：若一个结点含有子结点，则这个结点称为其子结点的父结点；
孩子结点或子结点 ：一个结点含有的子树的根结点称为该结点的子结点；
根结点 ：一棵树中，没有双亲结点的结点；
结点的层次 ：从根开始定义起，根为第 1 层，根的子结点为第 2 层，以此类推
树的高度或深度 ：树中结点的最大层次；
非终端结点或分支结点 ：度不为 0 的结点；
兄弟结点 ：具有相同父结点的结点互称为兄弟结点； 
堂兄弟结点 ：双亲在同一层的结点互为堂兄弟；
结点的祖先 ：从根到该结点所经分支上的所有结点；
子孙 ：以某结点为根的子树中任一结点都称为该结点的子孙。
森林 ：由 m （ m>=0 ）棵互不相交的树组成的集合称为森林
1.3 树的表示形式（了解）
树结构相对线性表就比较复杂了，要存储表示起来就比较麻烦了，实际中树有很多种表示方式，如： 双亲表示法 ， 孩子表示法 、 孩子双亲表示法 、 孩子兄弟表示法 等等。我们这里就简单的了解其中最常用的 孩子兄弟表示法 。

一、双亲表示法

 

  1. 定义与原理：

    • 用一组连续空间存储树的所有节点，同时在每个节点中，附设一个指示器指示其双亲节点在数组中的位置。
    • 也就是说，每个节点除了存储自身的数据信息外，还存储一个指向其双亲节点的指针（在这种情况下，用数组下标来表示指针）

二、孩子表示法

 

  1. 定义与原理：

    • 把每个节点的孩子节点排列成一个单链表，称为孩子链表。n 个节点有 n 个孩子链表，如果是叶子节点，则此单链表为空。然后，n 个头指针又组成一个线性表，采用顺序存储结构，存放进一个一维数组中。
    • 这种存储方式便于查找某个节点的孩子节点。

三、孩子双亲表示法

 

  1. 定义与原理：

    • 结合了双亲表示法和孩子表示法的特点，既存储每个节点的孩子链表，又存储每个节点的双亲位置。

四、孩子兄弟表示法

 

  1. 定义与原理：

    • 又称二叉树表示法，以二叉链表作为树的存储结构。链表中每个节点设两个指针域，分别指向该节点的第一个孩子节点和下一个兄弟节点。
    • 这种表示法使得任意一棵树都能转换为二叉树进行处理，方便实现各种树的操作。

 

二. 二叉树（重点）

2.1 概念

一棵二叉树是结点的一个有限集合，该集合：
1. 或者为空
2. 或者是由 一 个根节 点加上两棵别称为 左子树 和 右子树 的二叉树组成。

2.2 两种特殊的二叉树 

1. 满二叉树 : 一棵二叉树，如果 每层的结点数都达到最大值，则这棵二叉树就是满二叉树 。也就是说， 如果一棵 二叉树的层数为 K ，且结点总数是 ，则它就是满二叉树 。
2. 完全二叉树 : 完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为 K 的，有 n个结点的二叉树，当且仅当其每一个结点都与深度为K 的满二叉树中编号从 0 至 n-1 的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树

 2.3 二叉树的性质

1. 若规定 根结点的层数为 1 ，则一棵 非空二叉树的第 i 层上最多有2^(i-1)
(i>0) 个结点
2. 若规定只有 根结点的二叉树的深度为 1 ，则 深度为 K 的二叉树的最大结点数是(2^k) - 1
(k>=0)
3. 对任何一棵二叉树 , 如果其 叶结点个数为 n0, 度为 2 的非叶结点个数为 n2, 则有 n0 ＝ n2 ＋ 1
4. 具有 n 个结点的完全二叉树的深度 k 为 log 2(n+1) 上取整
5. 对于具有 n 个结点的完全二叉树 ，如果按照 从上至下从左至右的顺序对所有节点从 0 开始编号 ，则对于 序号为 i 的结点有 ：
  1. 若i>0，双亲序号：(i-1)/2；i=0，i为根结点编号，无双亲结点
  2. 若2i+1<n，左孩子序号：2i+1，否则无左孩子
  3. 若2i+2<n，右孩子序号：2i+2，否则无右孩子
二叉树的建立： 
class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int val) {
        this.val = val;
    }
}
   public void insert(int value) {
       root = insertRec(root, value);
   }

   private TreeNode insertRec(TreeNode root, int value) {
       if (root == null) {
           return new TreeNode(value);
       }

       if (value < root.val) {
           root.left = insertRec(root.left, value);
       } else if (value > root.val) {
           root.right = insertRec(root.right, value);
       }

       return root;
   }

2.4 二叉树的遍历：

//前序递归实现：

   public void preorderTraversalRec(TreeNode root) {
       if (root == null) {
           return;
       }
       System.out.print(root.val + " ");
       preorderTraversalRec(root.left);
       preorderTraversalRec(root.right);
   }
//前序非递归实现：
   public void preorderTraversal(TreeNode root) {
       if (root == null) {
           return;
       }
       Stack<TreeNode> stack = new Stack<>();
       stack.push(root);
       while (!stack.isEmpty()) {
           TreeNode node = stack.pop();
           System.out.print(node.val + " ");
           if (node.right!= null) {
               stack.push(node.right);
           }
           if (node.left!= null) {
               stack.push(node.left);
           }
       }
   }
//中序递归实现：
   public void inorderTraversalRec(TreeNode root) {
       if (root == null) {
           return;
       }
       inorderTraversalRec(root.left);
       System.out.print(root.val + " ");
       inorderTraversalRec(root.right);
   }
//中序非递归实现：

   public void inorderTraversal(TreeNode root) {
       if (root == null) {
           return;
       }
       Stack<TreeNode> stack = new Stack<>();
       TreeNode current = root;
       while (current!= null ||!stack.isEmpty()) {
           while (current!= null) {
               stack.push(current);
               current = current.left;
           }
           current = stack.pop();
           System.out.print(current.val + " ");
           current = current.right;
       }
   }

//后序递归实现：
   public void postorderTraversalRec(TreeNode root) {
       if (root == null) {
           return;
       }
       postorderTraversalRec(root.left);
       postorderTraversalRec(root.right);
       System.out.print(root.val + " ");
   }
//后序非递归实现：

   public void postorderTraversal(TreeNode root) {
       if (root == null) {
           return;
       }
       Stack<TreeNode> stack = new Stack<>();
       TreeNode prev = null;
       TreeNode current = root;
       while (current!= null ||!stack.isEmpty()) {
           while (current!= null) {
               stack.push(current);
               current = current.left;
           }
           current = stack.peek();
           if (current.right == null || current.right == prev) {
               System.out.print(current.val + " ");
               stack.pop();
               prev = current;
               current = null;
           } else {
               current = current.right;
           }
       }
   }

以下是总代码：

import java.util.Stack;
import java.util.LinkedList;
import java.util.Queue;

class TreeNode {
    char val;
    TreeNode left;
    TreeNode right;

    TreeNode(char val) {
        this.val = val;
    }
}
public class MyTree {
        // 获取树中节点的个数
        public int size(TreeNode root) {
            if (root == null) {
                return 0;
            }
            return 1 + size(root.left) + size(root.right);
        }

        // 获取叶子节点的个数
        public int getLeafTreeNodeCount(TreeNode root) {
            if (root == null) {
                return 0;
            }
            if (root.left == null && root.right == null) {
                return 1;
            }
            return getLeafTreeNodeCount(root.left) + getLeafTreeNodeCount(root.right);
        }

        // 获取第 K 层节点的个数
        public int getKLevelTreeNodeCount(TreeNode root, int k) {
            if (root == null || k < 1) {
                return 0;
            }
            if (k == 1) {
                return 1;
            }
            return getKLevelTreeNodeCount(root.left, k - 1) + getKLevelTreeNodeCount(root.right, k - 1);
        }

        // 获取二叉树的高度
        public int getHeight(TreeNode root) {
            if (root == null) {
                return 0;
            }
            int leftHeight = getHeight(root.left);
            int rightHeight = getHeight(root.right);
            return Math.max(leftHeight, rightHeight) + 1;
        }

        // 检测值为 value 的元素是否存在
        public TreeNode find(TreeNode root, char val) {
            if (root == null) {
                return null;
            }
            if (root.val == val) {
                return root;
            }
            TreeNode leftResult = find(root.left, val);
            if (leftResult != null) {
                return leftResult;
            }
            return find(root.right, val);
        }

        // 层序遍历
        public void levelOrder(TreeNode root) {
            if (root == null) {
                return;
            }
            Queue<TreeNode> queue = new LinkedList<>();
            queue.add(root);
            while (!queue.isEmpty()) {
                TreeNode node = queue.poll();
                System.out.print(node.val + " ");
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
            }
        }

        // 判断一棵树是不是完全二叉树
        public boolean isCompleteTree(TreeNode root) {
            if (root == null) {
                return true;
            }
            Queue<TreeNode> queue = new LinkedList<>();
            queue.add(root);
            boolean flag = false;
            while (!queue.isEmpty()) {
                TreeNode node = queue.poll();
                if (node.left != null) {
                    if (flag) {
                        return false;
                    }
                    queue.add(node.left);
                } else {
                    flag = true;
                }
                if (node.right != null) {
                    if (flag) {
                        return false;
                    }
                    queue.add(node.right);
                } else {
                    flag = true;
                }
            }
            return true;
        }

        // 前序递归实现
        public void preorderTraversalRec(TreeNode root) {
            if (root == null) {
                return;
            }
            System.out.print(root.val + " ");
            preorderTraversalRec(root.left);
            preorderTraversalRec(root.right);
        }

        // 前序非递归实现
        public void preorderTraversal(TreeNode root) {
            if (root == null) {
                return;
            }
            Stack<TreeNode> stack = new Stack<>();
            stack.push(root);
            while (!stack.isEmpty()) {
                TreeNode node = stack.pop();
                System.out.print(node.val + " ");
                if (node.right != null) {
                    stack.push(node.right);
                }
                if (node.left != null) {
                    stack.push(node.left);
                }
            }
        }

        // 中序递归实现
        public void inorderTraversalRec(TreeNode root) {
            if (root == null) {
                return;
            }
            inorderTraversalRec(root.left);
            System.out.print(root.val + " ");
            inorderTraversalRec(root.right);
        }

        // 中序非递归实现
        public void inorderTraversal(TreeNode root) {
            if (root == null) {
                return;
            }
            Stack<TreeNode> stack = new Stack<>();
            TreeNode current = root;
            while (current != null || !stack.isEmpty()) {
                while (current != null) {
                    stack.push(current);
                    current = current.left;
                }
                current = stack.pop();
                System.out.print(current.val + " ");
                current = current.right;
            }
        }

        // 后序递归实现
        public void postorderTraversalRec(TreeNode root) {
            if (root == null) {
                return;
            }
            postorderTraversalRec(root.left);
            postorderTraversalRec(root.right);
            System.out.print(root.val + " ");
        }

        // 后序非递归实现
        public void postorderTraversal(TreeNode root) {
            if (root == null) {
                return;
            }
            Stack<TreeNode> stack = new Stack<>();
            TreeNode prev = null;
            TreeNode current = root;
            while (current != null || !stack.isEmpty()) {
                while (current != null) {
                    stack.push(current);
                    current = current.left;
                }
                current = stack.peek();
                if (current.right == null || current.right == prev) {
                    System.out.print(current.val + " ");
                    stack.pop();
                    prev = current;
                    current = null;
                } else {
                    current = current.right;
                }
            }
        }
    }

public class Test233 {
    public static void main(String[] args) {
        MyTree tree = new MyTree();
        TreeNode root = new TreeNode('A');
        root.left = new TreeNode('B');
        root.right = new TreeNode('C');
        root.left.left = new TreeNode('D');
        root.left.right = new TreeNode('E');

        System.out.println("前序遍历：");
        tree.preorderTraversalRec(root);
        System.out.println();

        System.out.println("中序遍历：");
        tree.inorderTraversal(root);
        System.out.println();

        System.out.println("后序遍历：");
        tree.postorderTraversal(root);
        System.out.println();

        TreeNode found = tree.find(root, 'A');
        if (found!= null) {
            System.out.println("找到了值为 A的节点");
        } else {
            System.out.println("未找到值为 A 的节点");
        }

        int treeHeight = tree.getHeight(root);
        System.out.println("树的高度为：" + treeHeight);
    }
}

爪哇爪巴
关注
java-根据过滤条件显示树形结构
04-17
在Java编程中，构建和显示树形结构是一种常见的任务，特别是在数据表示、文件系统操作或者组织复杂的对象层次结构时。本篇文章将详细讲解如何在Java中根据过滤条件来实现这一功能，同时也会提及所需的jar包。 首先...
tree-sitter-java:树保姆的Java语法
04-17
《树保姆Java语法解析——深度探索tree-sitter-java》 在编程世界中，解析器扮演着至关重要的角色，它们能够将源代码转化为机器可以理解的形式。对于Java开发者来说，理解和利用有效的解析工具能够极大地提高代码...
Java-用Java来实现最小生成树算法
07-01
Java-用Java来实现最小生成树算法.html Java-用Java来实现最小生成树算法.html Java-用Java来实现最小生成树算法.html Java-用Java来实现最小生成树算法.html Java-用Java来实现最小生成树算法.html
B.rar_B-树索引_B树_b tree_b tree java_java B-Tree
09-19
标题中的"B.rar_B-树索引_B树_b tree_b tree java_java B-Tree"表明这是一个关于B-树实现的压缩文件，其中包含了用Java语言编写的B-树索引代码，并且含有详细的注释。这为学习和理解B-树提供了实践示例。 首先，...
Java-Red-Black-Tree:Java中通用红黑树的实现
06-11
在Java中，红黑树的实现位于`java.util.TreeMap`和`java.util.TreeSet`的源码中，具体可以查看`java.util.TreeMap$Node`类，这个类代表了红黑树的节点，包含了颜色属性、键、值和子节点等信息。通过分析源码，我们...
java-05 数据结构-队列-LinkedBlockingQueue 和 ConcurrentLinkedQueue的区别
wyh106115的博客
10-09 677
在Java多线程应用中，队列的使用率很高，多数生产消费模型的首选数据结构就是队列(先进先出)。Java提供的线程安全的Queue可以分为阻塞队列和非阻塞队列，其中阻塞队列的典型例子是BlockingQueue，非阻塞队列的典型例子是ConcurrentLinkedQueue，在实际应用中要根据实际需要选用阻塞队列或者非阻塞队列。
数据结构和算法简介
知其然 知其所以然
10-07 875
所谓算法，其实就是定义良好的计算过程，取一个或一组的值为输入，并产生出一个或一组值作为输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。一个算法所花费的时间与其中语句的执行次数成正比，但是算法中的语句往往比较多，所以，我们选择算法中的基本操作的执行次数，为算法的时间复杂度。空间复杂度也是一个数学表达式，是对一个算法在运行过程中临时额外占用存储空间大小的度量。我们可以这样理解，解决同一个问题，可能有不同的算法， 但是不同的算法都不能避免解决该问题本身所需要的存储空间。
数据结构：红黑树
2303_78940834的博客
10-13 1052
前面我们介绍了AVL树来解决搜索二叉树不平衡的问题，今天我们带来一种新的解决方案，同时，这种解决方案在实践中比AVL树更常用，这种数据结构就是红黑树。
数据结构之链表
最新发布
2301_79562326的博客
10-13 528
使用“快慢指针”方法，快指针一次走两步，慢指针一次走一步。如果链表有环，快慢指针会在某一点相遇。：要求将单向链表反转，使得原来的头节点变为尾节点，尾节点变为头节点。遍历链表就是从头节点开始，依次访问每个节点，直到。（对于单向链表）或循环到头节点（对于循环链表）。：将两个已经排序的链表合并为一个新的有序链表。// 删除头节点示例。
数据结构——排序（归并排序）
2302_80919983的博客
10-10 911
归并排序（Merge Sort）是一种基于分治策略的高效排序算法。它的核心思想是将一个数组分成两个或多个子数组，对每个子数组进行排序，然后将排序好的子数组合并成一个最终的有序数组。1.1.对于一个给定的数组，归并排序会不断地将其分成更小的子数组。通常是将数组从中间位置分成两个子数组，这个过程是递归进行的。例如，对于数组[4, 7, 2, 6, 3, 8]，首先会被分为[4, 7, 2]和[6, 3, 8]两个子数组。
NR PDSCH资源分配与DM-RS和PT-RS参考信号
WHS-_-2022的博客
10-13 646
本文的写作目的是为了汉化MATLAB关于 NR PDSCH 资源分配的，帮助大家更快的掌握PDSCH中资源的分配问题。来张时频资源图镇楼。
手撕数据结构 —— 单链表（C语言讲解）
知其然 知其所以然
10-10 1235
链表是一种利用不连续的内存空间存储数据元素的数据结构，并且元素之间可以不按顺序进行存储。正是因为链表不按顺序存储，要想找到下一个数据就需要记录下一个数据的地址，因此，链表中的数据是包含在一个结构体中，我们通常称这个结构体变量为结点。最后一个结点没有下一个结点，就指向空。链表的特点是按需申请和释放。链表逻辑示意图如下：我们申请结点的时候，一般是使用动态内存管理的函数申请内存空间（malloc、realloc），这些函数是从堆上申请空间的。
《重生到现代之从零开始的数据结构生活》—— 顺序表1
yttandb的博客
10-10 857
顺序表
数据结构(7.4_2)——B树的插入删除
m0_65240792的博客
10-07 320
借后继结点：借前驱结点： 结点合并：
2024/10/9 数据结构打卡
m0_63504902的博客
10-10 259
1 利用快速排序算法，将元素从小到大进行排序，由题意可知，将a1划分成数组下标0，n-1/2（闭区间）和（n-1/2，n)开区间，满足了题意。时间复杂度 nlogn 空间复杂度o1。
81.【C语言】数据结构之空间复杂度
2401_85828611的博客
10-13 326
对一个算法在运行过程中临时占用存储空间大小的量度,不是程序占用了多少bytes的空间,通常用多少个变量来衡量,也使用大O渐进表示法(有关大O渐进表示法见80.【C语言】数据结构之时间复杂度原因:函数运行时所需要的栈空间(存储参数,局部变量,一些寄存器信息等)在编译期间已经确定好了,因此空间复杂度主要通过函数在运行时候显式申请的额外空间来确定(一定要理解额外的含义)
数据结构——遍历二叉树
weixin_74209413的博客
10-07 1176
遍历定义-- 顺着某一条搜索路径巡访二叉树中的结点，使得每个结点均被访问一次，而且仅被访问一次(又称周游)。“访问”的含义很广，可以是对结点作各种处理，如：输出结点的信息、修改结点的数据值等，但要求这种访问不破坏原来的数据结构。遍历目的-- 得到树中所有结点的一个线性排列。遍历用途--它是树结构插入、删除、修改、查找和排序运算的前提，是二又树一切运算的基础和核心。遍历方法依次遍历二叉树的三个组成部分，便是遍历了整个二叉树。
数据结构【C语言】[
qq_53682472的博客
10-10 1058
数据结构？实现一些项目，需要在内存中将数据存储起来。例如：通讯录中，每个人的信息存储起来。可以用数组；链表；树...，用来干嘛算法？用一系列的计算步骤，将输入数据转换为输出结果。排序、查找、去重...推荐算法（抖音）二叉树特点：度为2的树。
数据结构 ——— 单链表oj题：相交链表（链表的共节点）
weixin_55341642的博客
10-07 369
两个单链表的头节点 headA 和 headB ，请找出并返回两个单链表相交的起始节点，如果两个链表不存在相交节点，则返回 NULL
JAVA编程实现L-System分形树绘制
"这篇文章介绍如何使用Java实现L-System（Lindenmayer系统）来绘制树形结构。L-System是一种形式化的重写系统，常用于模拟植物生长和创建自相似的分形图像。程序包括一个主函数和两个类，主函数定义绘图规则和操作，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值