深圳幻海软件技术有限公司 欢迎您！
更多

二叉树（Java实现）

2023-03-31

this 节点 null
声明：本文部分文章取自于Java中关于二叉树详解_来学习的小张的博客-CSDN博客_java二叉树原理更多关于二叉树详情可以点击上面链接目录一：树形结构二：二叉树2.1二叉树的遍历：2.2二叉树的查找：2.3二叉树删除节点：（简单版）2.4顺序存储二叉树：2.5线索化二叉树：一：树形结构树是一种非线

声明：本文部分文章取自于

Java中关于二叉树详解_来学习的小张的博客-CSDN博客_java 二叉树原理

更多关于二叉树详情可以点击上面链接

目录

一：树形结构

二：二叉树

2.1 二叉树的遍历：

2.2 二叉树的查找：

2.3 二叉树删除节点：（简单版）

2.4 顺序存储二叉树：

2.5 线索化二叉树：

一：树形结构

树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：

  • 有一个特殊的节点，称为根节点，根节点没有前驱节点；
  • 除根节点外，其余节点被分成M(M > 0)个互不相交的集合T1、T2、......、Tm，其中每一个集合 Ti (1 <= i<= m) 又是一棵与树类似的子树。每棵子树的根节点有且只有一个前驱，可以有0个或多个后继；
  • 树是递归定义的。

  1. 节点的度：一个节点含有的子树的个数称为该节点的度； 如上图：A的度为6；
  2. 树的度：一棵树中，最大的节点的度称为树的度； 如上图：树的度为6；
  3. 叶子节点或终端节点：度为0的节点称为叶节点； 如上图：B、C、H、I…等节点为叶节点；
  4. 双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点； 如上图：A是B的父节点；
  5. 孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点； 如上图：B是A的孩子节点；
  6. 根结点：一棵树中，没有双亲结点的结点；如上图：A
  7. 节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；
  8. 树的高度或深度：树中节点的最大层次； 如上图：树的高度为4

以下概念仅做了解即可：

  1. 非终端节点或分支节点：度不为0的节点； 如上图：D、E、F、G...等节点为分支节点；
  2. 兄弟节点：具有相同父节点的节点互称为兄弟节点； 如上图：B、C是兄弟节点；
  3. 堂兄弟节点：双亲在同一层的节点互为堂兄弟；如上图：H、I互为兄弟节点；
  4. 节点的祖先：从根到该节点所经分支上的所有节点；如上图：A是所有节点的祖先；
  5. 子孙：以某节点为根的子树中任一节点都称为该节点的子孙。如上图：所有节点都是A的子孙；
  6. 森林：由m（m>=0）棵互不相交的树的集合称为森林。

二：二叉树

2.1 二叉树的遍历：

使用前序、中序、后续来遍历二叉树

  • 前序遍历：先输出父节点，再遍历左子树和右子树
  • 中序遍历：先遍历左子树，再输出父节点，再遍历右子树
  • 后序遍历：先遍历左子树，再遍历右子树，最后输出父节点

小结：看输出父节点的顺序，就确定是前序、中序还是后序。

分析二叉树的前序，中序，后序的遍历步骤：

1.创建一颗二叉树

2.前序遍历

  • 2.1先输出当前节点（初始的时候是root节点）
  • 2.2如果左子节点不为空，则递归继续前序遍历
  • 2.3如果右子节点不为空，则递归继续前序遍历

3.中序遍历

  • 3.1如果当前节点的左子节点不为空，则递归中序遍历
  • 3.2输出当前节点
  • 3.3如果当前的右子节点不为空，则递归中序遍历

4.后序遍历

  • 4.1如果当前节点的左子节点不为空，则递归后序遍历
  • 4.2如果当前节点的右子节点不为空，则递归后序遍历
  • 4.3输出当前节点

5.前、中、后序遍历代码实现：

  1. public class BinaryTreeDemo {
  2.     public static void main(String[] args) {
  3.       //先需要创建一颗二叉树
  4.       BinaryTree binaryTree=new BinaryTree();
  5.       //创建需要的结点
  6.         HeroNode root=new HeroNode(1,"宋江");
  7.         HeroNode node2=new HeroNode(2,"吴用");
  8.         HeroNode node3=new HeroNode(3,"卢俊义");
  9.         HeroNode node4=new HeroNode(4,"林冲");
  10.         HeroNode node5=new HeroNode(5,"武松");
  11.         HeroNode node6=new HeroNode(6,"鲁智深");
  12.         HeroNode node7=new HeroNode(7,"杨志");
  13.  
  14.         //说明，我们先手动创建该二叉树，后面我们学习递归的方式创建而常数
  15.         root.setLeft(node2);
  16.         root.setRight(node3);
  17.         node2.setLeft(node4);
  18.         node2.setRight(node5);
  19.         node3.setLeft(node6);
  20.         node3.setRight(node7);
  21.  
  22.         binaryTree.setRoot(root);
  23.  
  24.         //测试：
  25.         System.out.println("前序遍历");//1,2,4,5,3,6,7
  26.         binaryTree.preOrder();
  27.  
  28.         System.out.println("中序遍历");//4,2,5,1,6,3,7
  29.         binaryTree.infixOrder();
  30.         System.out.println("后序遍历");//4,5,2,6,7,3,1
  31.         binaryTree.postOrder();
  32.     }
  33. }
  34.  
  35. //定义二叉树
  36. class BinaryTree{
  37.     private HeroNode root;//根节点
  38.  
  39.     public void setRoot(HeroNode root){
  40.         this.root=root;
  41.     }
  42.     //前序遍历
  43.     public void preOrder(){
  44.         if(this.root!=null){
  45.             this.root.preOrder();
  46.         }else {
  47.             System.out.println("二叉树为空，无法遍历");
  48.         }
  49.     }
  50.     //后序遍历
  51.     public void infixOrder(){
  52.         if(this.root!=null){
  53.             this.root.infixOrder();
  54.         }else {
  55.             System.out.println("二叉树为空，无法遍历");
  56.         }
  57.     }
  58.     //后序遍历
  59.     public void postOrder(){
  60.         if(this.root!=null){
  61.             this.root.postOrder();
  62.         }else {
  63.             System.out.println("二叉树为空，无法遍历");
  64.         }
  65.     }
  66.  
  67. }
  68.  
  69. //先创建HeroNode结点
  70. class HeroNode{
  71.     private int no;
  72.     private String name;
  73.     private HeroNode left;//默认为null
  74.     private HeroNode right;//默认为null
  75.  
  76.     public HeroNode(int no, String name) {
  77.         this.no = no;
  78.         this.name = name;
  79.     }
  80.  
  81.     public int getNo() {
  82.         return no;
  83.     }
  84.  
  85.     public void setNo(int no) {
  86.         this.no = no;
  87.     }
  88.  
  89.     public String getName() {
  90.         return name;
  91.     }
  92.  
  93.     public void setName(String name) {
  94.         this.name = name;
  95.     }
  96.  
  97.     public HeroNode getLeft() {
  98.         return left;
  99.     }
  100.  
  101.     public void setLeft(HeroNode left) {
  102.         this.left = left;
  103.     }
  104.  
  105.     public HeroNode getRight() {
  106.         return right;
  107.     }
  108.  
  109.     public void setRight(HeroNode right) {
  110.         this.right = right;
  111.     }
  112.  
  113.     @Override
  114.     public String toString() {
  115.         return "HeroNode [no=" + no + ", name=" + name + "]";
  116.     }
  117.  
  118.     //编写前序遍历的方法
  119.     public void preOrder(){
  120.         System.out.println(this);//先输出父结点(谁调用这个方法，谁就是this)
  121.         //递归向左子树前序遍历
  122.         if(this.left!=null){
  123.             this.left.preOrder();
  124.         }
  125.         //递归向右子树前序遍历
  126.         if(this.right!=null){
  127.             this.right.preOrder();
  128.         }
  129.     }
  130.     //编写中序遍历的方法
  131.     public void infixOrder(){
  132.         //递归向左子树中序遍历
  133.         if(this.left!=null){
  134.             this.left.infixOrder();
  135.         }
  136.         //输出父结点
  137.         System.out.println(this);
  138.         //递归向右子树中序遍历
  139.         if(this.right!=null){
  140.             this.right.infixOrder();
  141.         }
  142.     }
  143.     //编写后序遍历的方法
  144.     public void postOrder(){
  145.         //递归向左子树后序遍历
  146.         if(this.left!=null){
  147.             this.left.postOrder();
  148.         }
  149.         //递归向右子树后序遍历
  150.         if(this.right!=null){
  151.             this.right.postOrder();
  152.         }
  153.         //输出父结点
  154.         System.out.println(this);
  155.     }
  156. }

2.2 二叉树的查找：

目的：使用前序、中序、后序的方式来查询指定的节点。

前序查找思路：

  • 先判断当前节点的no是否等于要查找的
  • 如果是相等的，则返回当前节点
  • 如果不相等，则判断当前节点的左子节点是否为空，如果不为空，则递归前序查找
  • 如果左递归前序查找，找到节点，则返回，否则继续判断，当前的节点的右子节点是否为空，如果不为空，则继续向右递归前序查找

中序查找思路：

  • 判断当前节点的左子节点是否为空，如果不为空，则递归中序查找
  • 如果找到，则返回，如果没有找到，就和当前节点比较，如果是则返回当前节点，否则继续进行右递归的中序查找
  • 如果右递归中序查找，找到就返回，否则为null

后序查找思路：

  • 判断当前节点的左子节点是否为空，如果不为空，则递归后序查找
  • 如果找到，就返回，如果没有找到，就判断当前节点的右子节点是否为空，如果不为空，则右递归进行后序查找，如果找到，就返回
  • 就和当前节点进行，如果找到则返回，否则返回null

查找指定节点的部分代码实现：

  1. //编写前序查找的方法
  2.     public HeroNode preSearch(int no){
  3.         //先判断当前节点是否符合
  4.         if(this.no==no){
  5.             return this;
  6.         }
  7.         HeroNode resNode=null;
  8.         //向左递归
  9.         if(this.left!=null){
  10.             resNode=this.left.preSearch(no);
  11.         }
  12.         //向右递归(判断左递归得到的节点是否为空，如果为空，则进行右递归)
  13.         if(resNode==null&&this.right!=null){
  14.             resNode=this.right.preSearch(no);
  15.         }
  16.         return resNode;//如果最终还是没有找到，则返回null
  17.     }
  18.  
  19.     //编写中序查找的方法
  20.     public HeroNode infixSearch(int no){
  21.        HeroNode resNode=null;
  22.        if(this.left!=null){
  23.            resNode=this.left.infixSearch(no);
  24.        }
  25.        if(this.no==no){
  26.            return this;
  27.        }
  28.        if(this.right!=null&&resNode==null){//左边没有找到，找右边
  29.            resNode=this.right.infixSearch(no);
  30.        }
  31.        return resNode;//不管有没有找到，都返回resNode
  32.     }
  33.     //编写后序查找的方法
  34.     public HeroNode postSearch(int no){
  35.         HeroNode resNode=null;
  36.         if(this.left!=null){
  37.             resNode=this.left.postSearch(no);
  38.         }
  39.         if(this.right!=null&&resNode==null){
  40.             resNode=this.right.postSearch(no);
  41.         }
  42.         if(this.no==no){
  43.             return this;
  44.         }
  45.         return resNode;
  46.     }

2.3 二叉树删除节点：（简单版）

规定：如果要删除的节点是叶子节点，则直接删除，如果是非叶子节点，则删除该子树。

思路：

首先先处理：

考虑如果树是空树root，如果只有一个root节点，则等价将二叉树置空。

如果不是，则进行下面步骤：

  1. 因为我们的二叉树是单向的，所以我们是判断当前节点的子节点是否需要删除节点，而不能去判断当前这个节点是不是需要删除节点。
  2. 如果当前节点的左子节点不为空，并且左子节点就是要删除节点，就将this.left=null;并且就返回（结束递归删除）
  3. 如果当前节点的右子节点不为空，并且右子节点就是要删除节点，就将this.right=null,并且就返回（结束递归删除）
  4. 如果第2和第3步没有删除节点，那么我们就需要向左子树进行递归删除。
  5. 如果第4步也没有删除节点，则应当向右子树进行递归删除。

节点删除的代码实现：

  1. //二叉树部分：删除节点
  2.     public void deleteNode(int no){
  3.         if(root!=null){
  4.             //如果只有一个root节点，这里立即判断root是不是要删除节点
  5.             if(root.getNo()==no){
  6.                 root=null;
  7.             }else {
  8.                 //递归删除
  9.                 root.deleteNode(no);
  10.             }
  11.         }else {
  12.             System.out.println("二叉树为空，删除失败");
  13.         }
  14.     }
  15. //链表部分：
  16. //递归删除节点
  17.     public void deleteNode(int no){
  18.         //判断当前节点的左子节点
  19.         if(this.left!=null&&this.left.no==no){
  20.             this.left=null;
  21.             return;
  22.         }
  23.         //判断当前节点的右子节点
  24.         if(this.right!=null&&this.right.no==no){
  25.             this.right=null;
  26.             return;
  27.         }
  28.         //左子树递归删除
  29.         if(this.left!=null){
  30.             this.left.deleteNode(no);
  31.         }
  32.         //右子树递归删除
  33.         if(this.right!=null){
  34.             this.right.deleteNode(no);
  35.         }
  36.  
  37.     }

2.4 顺序存储二叉树：

基本说明：从数据存储来啊看，数组存储方式和树的存储方式可以相互转化，即数组可以转换成树，也可以转换成数组。

 要求：

（1）图中的二叉树的节点，要求以数组的方式来存放arr【1,2,3,4,5,6,7】

（2）要求在遍历数组arr时，仍然可以以前序遍历、中序遍历和后序遍历的范围广是完成节点的遍历。

思路：

  • 顺序二叉树通常只考虑完全二叉树。
  • 数组下标为n的元素所对应的左子节点所在的下标为（2*n+1）；
  • 数组下标为n的元素所对应的右子节点所在的下标为（2*n+2）；
  • 数组下标为n的元素所对应的父节点为（n-1）/2；

提示：（可以自己对着上图验证一下）

顺序存储二叉树的代码实现：

  1. public class ArrayBinaryTreeDemo {
  2.     public static void main(String[] args) {
  3.         int[] arr={1,2,3,4,5,6,7};
  4.         ArrayBinaryTree arrayBinaryTree = new ArrayBinaryTree(arr);
  5.         arrayBinaryTree.preOrder(); //1,2,4,5,3,6,7
  6.     }
  7. }
  8. //编写一个ArrayBinaryTree，实现顺序存储二叉树遍历
  9. class ArrayBinaryTree{
  10.     private int[] arr;//存储数据节点的数组
  11.     public ArrayBinaryTree(int[] arr){
  12.         this.arr=arr;
  13.     }
  14.  
  15.     //编写一个方法，完成顺序存储二叉树的前序遍历
  16.  
  17.     //重载preOrder
  18.     public void preOrder(){
  19.         this.preOrder(0);
  20.     }
  21.     public void preOrder(int index){
  22.         //如果数组为空，或arr.length=0
  23.         if(arr==null || arr.length==0){
  24.             System.out.println("数组为空，不能按照二叉树的前序遍历");
  25.         }
  26.         //输出当前这个元素
  27.         System.out.println(arr[index]);
  28.         //向左递归遍历
  29.         if((index*2+1)<arr.length){
  30.             preOrder(2*index+1);
  31.         }
  32.         //向右递归遍历
  33.         if((index*2+2)<arr.length){
  34.             preOrder(2*index+2);
  35.         }
  36.     }
  37.  
  38. }

2.5 线索化二叉树：

 问题分析:

  • 当我们对上面的二叉树进行中序遍历时，数列为{8,3,10,1,6,14}；
  • 但是6,8,10,14这几个节点的左右指针，并没有完全的利用上
  • 如果我们希望充分利用各个节点的左右指针，让各个节点可以指向自己的前后节点，怎么办？
  • 解决方案：线索化二叉树

使用场景：

  • 线索化的实质就是将二叉链表中的空指针改为指向前驱节点或后继节点的线索；
  • 线索化的过程就是修改二叉链表中空指针的过程，可以按照前序、中序、后序的方式进行遍历，分别生成不同的线索二叉树；
  • 有了线索二叉树之后，我们再次遍历时，就相当于操作一个双向链表。
  • 使用场景：如果我们在使用二叉树过程中经常需要遍历二叉树或者查找节点的前驱节点和后继节点，可以考虑采用线索二叉树存储结构。

线索二叉树基本介绍：

  • n个节点的二叉链表中含有（n+1）【公式：2n-（n-1）=n+1】个空指针域。利用二叉链表中的空指针域，存放指向该节点在某种遍历次序下的钱去和后继节点的指针（这种附加的指针称为“线索”）。
  • 这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树（Thread BinartTree）。根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种。
  • 一个节点的前一个节点，称为前驱节点。
  • 一个节点的后一个节点，称为后继节点。

思路分析： 

 说明：当线索化二叉树后，Node节点的属性left和right，有如下情况：

（1）left指向的是左子树，也可能是指向的前驱节点，比如 1 节点left指向的左子树，而 10 节点的left指向的就是前驱节点。

（2）rigth指向的是右子树，也可能是指向后继节点，比如 1 节点right指向的是右子树，而 10 节点的right指向的是后继节点。

  1. public class ThreadedBinaryTreeDemo {
  2.     /*
  3.     中序线索化二叉树
  4.      */
  5.     public static void main(String[] args) {
  6.         HeroNode root=new HeroNode(1,"tom");
  7.         HeroNode node2=new HeroNode(3,"jack");
  8.         HeroNode node3=new HeroNode(6,"smith");
  9.         HeroNode node4=new HeroNode(8,"mary");
  10.         HeroNode node5=new HeroNode(10,"king");
  11.         HeroNode node6=new HeroNode(14,"dim");
  12.  
  13.         //二叉树，后面我们要递归创建，现在简单处理使用手动创建
  14.         root.setLeft(node2);
  15.         root.setRight(node3);
  16.         node2.setLeft(node4);
  17.         node2.setRight(node5);
  18.         node3.setLeft(node6);
  19.  
  20.         BinaryTree binaryTree = new BinaryTree();
  21.         binaryTree.setRoot(root);
  22.         binaryTree.threadedNodes();
  23.  
  24.         //测试：
  25.         HeroNode leftNode = node5.getLeft();
  26.         HeroNode rightNode = node5.getRight();
  27.  
  28.         System.out.println("10 节点的前驱节点："+leftNode);
  29.         System.out.println("10 节点的后继节点："+rightNode);
  30.  
  31.     }
  32. }
  33.  
  34. class BinaryTree{
  35.     private HeroNode root;//根节点
  36.  
  37.     //为了实现线索化，需要创建要给指向当前节点的前驱节点的指针
  38.     //在递归进行线索化时，pre总是保留前一个节点
  39.     private HeroNode pre=null;
  40.  
  41.     public void setRoot(HeroNode root){
  42.         this.root=root;
  43.     }
  44.  
  45.     //重载threadedNodes方法
  46.     public void threadedNodes(){
  47.         this.threadedNodes(root);
  48.     }
  49.  
  50.     //编写对二叉树进行中序线索化的方法
  51.  
  52.     /**
  53.      *
  54.      * @param node:就是当前需要线索化的节点
  55.      */
  56.     public void threadedNodes(HeroNode node){
  57.         //如果node==null，不能线索化
  58.         if(node==null){
  59.             return;
  60.         }
  61.         //（一）先线索化左子树
  62.         threadedNodes(node.getLeft());
  63.         //（二）线索化当前节点
  64.  
  65.         //处理当前节点的前驱节点
  66.         //以8节点来理解
  67.         //8节点的.left=null，8节点的.leftType=1
  68.         if(node.getLeft()==null){
  69.             //让当前节点的左指针指向前驱节点
  70.             node.setLeft(pre);
  71.             //修改当前节点的左指针的类型，指向前驱节点
  72.             node.setLeftType(1);
  73.         }
  74.  
  75.         //处理后继节点
  76.         if(pre!=null&&pre.getRight()==null){
  77.             //让前驱节点的右指针指向当前节点
  78.             pre.setRight(node);
  79.             //修改前驱节点的右指针类型
  80.             pre.setRightType(1);
  81.         }
  82.         //!!! 每处理一个节点后，让当前节点是下一个节点的前驱节点
  83.         pre=node;
  84.  
  85.         //（三）再线索化右子树
  86.         threadedNodes(node.getRight());
  87.     }
  88.  
  89.  
  90. }
  91.  
  92.  
  93. //先创建HeroNode结点
  94. class HeroNode{
  95.     private int no;
  96.     private String name;
  97.     private HeroNode left;//默认为null
  98.     private HeroNode right;//默认为null
  99.     //说明
  100.     //1.如果leftType==0表示指向的是左子树，1则表示指向前驱节点
  101.     //2.如果rightType==0表示指向是右子树，1则表示指向后继节点
  102.     private int leftType;
  103.     private int rightType;
  104.  
  105.     public HeroNode(int no, String name) {
  106.         this.no = no;
  107.         this.name = name;
  108.     }
  109.  
  110.     public int getLeftType() {
  111.         return leftType;
  112.     }
  113.  
  114.     public void setLeftType(int leftType) {
  115.         this.leftType = leftType;
  116.     }
  117.  
  118.     public int getRightType() {
  119.         return rightType;
  120.     }
  121.  
  122.     public void setRightType(int rightType) {
  123.         this.rightType = rightType;
  124.     }
  125.  
  126.     public int getNo() {
  127.         return no;
  128.     }
  129.  
  130.     public void setNo(int no) {
  131.         this.no = no;
  132.     }
  133.  
  134.     public String getName() {
  135.         return name;
  136.     }
  137.  
  138.     public void setName(String name) {
  139.         this.name = name;
  140.     }
  141.  
  142.     public HeroNode getLeft() {
  143.         return left;
  144.     }
  145.  
  146.     public void setLeft(HeroNode left) {
  147.         this.left = left;
  148.     }
  149.  
  150.     public HeroNode getRight() {
  151.         return right;
  152.     }
  153.  
  154.     public void setRight(HeroNode right) {
  155.         this.right = right;
  156.     }
  157.  
  158.     @Override
  159.     public String toString() {
  160.         return "HeroNode [no=" + no + ", name=" + name + "]";
  161.     }
  162. }

遍历线索化二叉树：

说明：对前面的中序线索化的二叉树，进行遍历

分析：因为线索化后，各个节点指向有变化，因此原来的遍历方式不能使用，这是需要使用新的方式遍历线索化二叉树，各个节点开头通过线型方式遍历，因此无需使用递归方式，这样也提高了遍历的效率。遍历的次序应当和中序遍历保持一致。

代码实现： 

  1. //遍历线索化二叉树
  2.     public void threadedList(){
  3.         //定义一个变量，存储当前遍历的节点，从root开始
  4.         HeroNode node=root;
  5.         while(node!=null){
  6.             //循环的找到leftType==1的节点，第一个找到就是8节点
  7.             //后面随着遍历而变化，因为当leftType==1是，说明该节点按照线索化处理后的有效节点
  8.             while(node.getRightType()==0){
  9.                 node=node.getLeft();
  10.             }
  11.  
  12.             //打印当前这个节点
  13.             System.out.println(node);
  14.             //如果当前节点的右指针指向的是后继节点，就一直输出
  15.             while (node.getRightType()==1){
  16.                 //获取到当前节点的后继节点
  17.                 node=node.getRight();
  18.                 System.out.println(node);
  19.             }
  20.             //替换这个遍历的节点
  21.             node=node.getRight();
  22.         }
  23.     }

文章知识点与官方知识档案匹配，可进一步学习相关知识
算法技能树首页概览42577 人正在系统学习中
【算法系列篇】滑动窗口
走进人工智能|深度学习 算法的创世纪