Java二叉树基础

最新推荐文章于 2024-07-30 09:08:14 发布
最新推荐文章于 2024-07-30 09:08:14 发布
阅读量208 收藏 1
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42011443/article/details/111721246
版权

在前篇文章Java集合框架中我们介绍了排序二叉树、平衡二叉树以及红黑树的概念以及常见的增删操作步骤，这次就学习一下二叉树中常见的一些遍历、翻转等算法，之后刷题时如果遇见相关的题型再做补充。

创建

这里以排序二叉树为例：

public class test {
	
	public static void main(String[] args) {
	      int[] arr = {5,3,2,0,4,7,1,9,8};
	      BinarySortTree  binarySortTree = new BinarySortTree();
	      for(int i=0;i<arr.length;i++) {
	    	  binarySortTree.add(new Node(arr[i]));
	      }
	}
}

class BinarySortTree{
	 private Node root;
	 public void add(Node node) {
		 if(root == null) {
			 root =node;
		 }else {
			 root.add(node);
		 }
	 }
}

class Node{
	int value;
	Node leftNode;
	Node rightNode;
	
	public Node(int value) {
		this.value = value;
	}
	
	public void add(Node node) {
		if(node == null) {
			return;
		}
		
		if(node.value < this.value) {
			if(this.leftNode == null) {
				this.leftNode = node;
			}else {
				this.leftNode.add(node);
			}
		}else {
			if(this.rightNode == null) {
				this.rightNode = node;
			}else {
				this.rightNode.add(node);
			}
		}
	}
}

核心思想就是判断当前插入节点的值，与根节点比较，如果小于根节点，就递归插入左子树，如果大于根节点，就递归插入右子树。

遍历

首先看深度优先遍历的前/中/后序遍历(递归和非递归)以及层序遍历方法：

先序遍历: 根->左->右
中序遍历: 左->根->右
后序遍历: 左->右->根

public class test {
	public static void main(String[] args) {
	      int[] arr = {5,3,2,0,4,7,1,9,8};
	      BinarySortTree  binarySortTree = new BinarySortTree();
	      for(int i=0;i<arr.length;i++) {
	    	  binarySortTree.add(new Node(arr[i]));
	      }
	      binarySortTree.preTraverse();
	}

}

class BinarySortTree{
	 private Node root;
	 public void add(Node node) {
		 if(root == null) {
			 root =node;
		 }else {
			 root.add(node);
		 }
	 }
	 
	 public void preTraverse() {
		 if(root !=null) {
			 root.preTraverse();
		 }
	 }
}
class Node{
	int value;
	Node leftNode;
	Node rightNode;
	
	public Node(int value) {
		this.value = value;
	}
	
	public void add(Node node) {
		if(node == null) {
			return;
		}
		
		if(node.value < this.value) {
			if(this.leftNode == null) {
				this.leftNode = node;
			}else {
				this.leftNode.add(node);
			}
		}else {
			if(this.rightNode == null) {
				this.rightNode = node;
			}else {
				this.rightNode.add(node);
			}
		}
	}
	
	 public void preTraverse() {
		  //System.out.print(this.value+" ");//前序
		  if(this.leftNode!=null) {
			  this.leftNode.preTraverse();
		  }
		  System.out.print(this.value+" ");//中序
		  if(this.rightNode!=null) {
			  this.rightNode.preTraverse();
		  }
		  //System.out.print(this.value+" ");//后序
	 }
}

这里以中序为例，先访问左子树，再根，再右子树，那么输出的序列应为有序序列，运行结果如下：
在这里插入图片描述
非递归方法：

//先序遍历
public static void preOrder2() {
     if(root == null) return;
     Stack<Node> q = new Stack<Node>();
     q.add(root);
     while(!q.isEmpty()){
          Node temp = q.pop();
          System.out.print(temp.value +" ");
          if(temp.rightNode!=null) q.add(temp.rightNode);
          if(temp.leftNode!=null) q.add(temp.leftNode);
     }
}

//中序遍历
 public void midTraverse() {
		if(root == null) return;
		Stack<Node> stack = new Stack<>();
		while(root!=null || !stack.isEmpty()) {
			while (root!=null) {
			    stack.push(root);
			    root = root.leftNode;
			}
			if(!stack.isEmpty()) {
				root = stack.pop();
				System.out.print(root.value+" ");
				root = root.rightNode;
			}
		}
}

//后序遍历
 public void posTraverse() {
		 List<Integer> list = new ArrayList<>();
		 if(root == null) return;
	     Stack<Node> q = new Stack<Node>();
	     q.add(root);
	     while(!q.isEmpty()){
	          Node temp = q.pop();
	          list.add(temp.value);
	          if(temp.leftNode!=null) q.add(temp.leftNode);
	          if(temp.rightNode!=null) q.add(temp.rightNode);
	     }
	     for(int i=list.size()-1;i>=0;i--) {
	    	 System.out.print(list.get(i)+" ");
	     }
}

接着看层序遍历(BFS广度优先)：

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class test {
	
	public static void main(String[] args) {
	      int[] arr = {5,3,2,0,4,7,1,9,8};
	      BinarySortTree  binarySortTree = new BinarySortTree();
	      for(int i=0;i<arr.length;i++) {
	    	  binarySortTree.add(new Node(arr[i]));
	      }
	      binarySortTree.traver_bfs();
	}

}

class BinarySortTree{
	 private Node root;
	 public void add(Node node) {
		 if(root == null) {
			 root = node;
		 }else {
			 root.add(node);
		 }
	 }
	 
	 public void traver_bfs() {
		 if(root!=null) {
			 bfs(root);
		 }	
	 }
	 
	 public void bfs(Node root) {
		 if (root == null) 
			 return;
		 LinkedList<Node> list = new LinkedList<Node>(); 
		 list.add(root);
		 Node currentNode;
		 while(!list.isEmpty()) {
			 currentNode = list.poll();
			 System.out.print(currentNode.value+" ");
			 if(currentNode.leftNode!=null){
				 list.add(currentNode.leftNode);
			 }
			 if(currentNode.rightNode!=null) {
				 list.add(currentNode.rightNode);
			 }
		 }
		
	} 
}
class Node{
	int value;
	Node leftNode;
	Node rightNode;
	
	public Node(int value) {
		this.value = value;
	}
	
	public void add(Node node) {
		if(node == null) {
			return;
		}
		
		if(node.value < this.value) {
			if(this.leftNode == null) {
				this.leftNode = node;
			}else {
				this.leftNode.add(node);
			}
		}else {
			if(this.rightNode == null) {
				this.rightNode = node;
			}else {
				this.rightNode.add(node);
			}
		}
	}
	
}

运行结果如下：
在这里插入图片描述

左右翻转

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

public class test {
	
	public static void main(String[] args) {
	      int[] arr = {5,3,2,0,4,7,1,9,8};
	      BinarySortTree  binarySortTree = new BinarySortTree();
	      for(int i=0;i<arr.length;i++) {
	    	  binarySortTree.add(new Node(arr[i]));
	      }
	      binarySortTree.invert_tree();
	      binarySortTree.traver_bfs();
	}

}

class BinarySortTree{
	 private Node root;
	 public void add(Node node) {
		 if(root == null) {
			 root = node;
		 }else {
			 root.add(node);
		 }
	 }
	 
	 public void invert_tree() {
		 invert(root);
	 }
	 
	 public void invert(Node root) {
		 if(root == null) return;
		 Node temp = root.leftNode;
		 root.leftNode = root.rightNode;
		 root.rightNode = temp;
		 invert(root.leftNode);
		 invert(root.rightNode);
	} 
	public void traver_bfs() {
		 if(root!=null) {
			 bfs(root);
		 }	
	}
	 
	public void bfs(Node root) {
		 if (root == null) 
			 return;
		 LinkedList<Node> list = new LinkedList<Node>(); 
		 list.add(root);
		 Node currentNode;
		 while(!list.isEmpty()) {
			 currentNode = list.poll();
			 System.out.print(currentNode.value+" ");
			 if(currentNode.leftNode!=null){
				 list.add(currentNode.leftNode);
			 }
			 if(currentNode.rightNode!=null) {
				 list.add(currentNode.rightNode);
			 }
		}
		
	} 
}
class Node{
	int value;
	Node leftNode;
	Node rightNode;
	
	public Node(int value) {
		this.value = value;
	}
	
	public void add(Node node) {
		if(node == null) {
			return;
		}
		
		if(node.value < this.value) {
			if(this.leftNode == null) {
				this.leftNode = node;
			}else {
				this.leftNode.add(node);
			}
		}else {
			if(this.rightNode == null) {
				this.rightNode = node;
			}else {
				this.rightNode.add(node);
			}
		}
	}
	
}

运行结果如下：
在这里插入图片描述

查找最大值

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

public class test {
	
	public static void main(String[] args) {
	      int[] arr = {7,3,10,12,5,1,9,8,7};
	      BinarySortTree  binarySortTree = new BinarySortTree();
	      for(int i=0;i<arr.length;i++) {
	    	  binarySortTree.add(new Node(arr[i]));
	      }
	      binarySortTree.q_maxValue1();
	      binarySortTree.q_maxValue2();
	}
}

class BinarySortTree{
	 private Node root;
	 public void add(Node node) {
		 if(root == null) {
			 root = node;
		 }else {
			 root.add(node);
		 }
	 }
	 public void q_maxValue1() {
		 int maxValue = maxValue1(root);
		 //System.out.println(maxValue);
	 }
	 public int maxValue1(Node root) {
		 if (root == null) return 0;
		 int right = maxValue1(root.rightNode);
		 return Math.max(root.value, right);
	 }
	 
	 public void q_maxValue2() {
		 int maxValue = maxValue2(root);
		 System.out.println(maxValue);
	 }
	 
	 public int maxValue2(Node root) {
		 if (root == null) {
			 return Integer.MIN_VALUE;
		 }else {
			 int left = maxValue2(root.leftNode);
		     int right = maxValue2(root.rightNode);
		     return Math.max(Math.max(left, right), root.value);
		}
	 }
}
class Node{
	int value;
	Node leftNode;
	Node rightNode;
	
	public Node(int value) {
		this.value = value;
	}
	
	public void add(Node node) {
		if(node == null) {
			return;
		}
		
		if(node.value < this.value) {
			if(this.leftNode == null) {
				this.leftNode = node;
			}else {
				this.leftNode.add(node);
			}
		}else {
			if(this.rightNode == null) {
				this.rightNode = node;
			}else {
				this.rightNode.add(node);
			}
		}
	}	
}

运行结果如下：
在这里插入图片描述

最大深度

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

public class test {
	
	public static void main(String[] args) {
	      int[] arr = {7,3,10,12,5,1,9,8,7};
	      BinarySortTree  binarySortTree = new BinarySortTree();
	      for(int i=0;i<arr.length;i++) {
	    	  binarySortTree.add(new Node(arr[i]));
	      }
	      binarySortTree.q_maxDepth();
	}

}

class BinarySortTree{
	 private Node root;
	 public void add(Node node) {
		 if(root == null) {
			 root = node;
		 }else {
			 root.add(node);
		 }
	 }
	 public void q_maxDepth() {
		 int maxdepth = maxDepth(root);
		 System.out.println(maxdepth);
	 }
	 public int maxDepth(Node root) {
		    if (root == null) return 0;
		    int left = maxDepth(root.leftNode);
		    int right = maxDepth(root.rightNode);
		    return Math.max(left, right) + 1;
	 }
	 
	
}
class Node{
	int value;
	Node leftNode;
	Node rightNode;
	
	public Node(int value) {
		this.value = value;
	}
	
	public void add(Node node) {
		if(node == null) {
			return;
		}
		
		if(node.value < this.value) {
			if(this.leftNode == null) {
				this.leftNode = node;
			}else {
				this.leftNode.add(node);
			}
		}else {
			if(this.rightNode == null) {
				this.rightNode = node;
			}else {
				this.rightNode.add(node);
			}
		}
	}
	
}

运行结果：
在这里插入图片描述

最小深度

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

public class test {
	
	public static void main(String[] args) {
	      int[] arr = {7,3,10,12,5,1,9,8,7};
	      BinarySortTree  binarySortTree = new BinarySortTree();
	      for(int i=0;i<arr.length;i++) {
	    	  binarySortTree.add(new Node(arr[i]));
	      }
	      binarySortTree.q_minDepth();
	}

}

class BinarySortTree{
	 private Node root;
	 public void add(Node node) {
		 if(root == null) {
			 root = node;
		 }else {
			 root.add(node);
		 }
	 }
	 public void q_minDepth() {
		 int mindepth = minDepth(root);
		 System.out.println(mindepth);
	 }
	 public int minDepth(Node root) {
		    if (root == null) return 0;
		    int left = minDepth(root.leftNode);
		    int right = minDepth(root.rightNode);
		    if (left == 0) {
		        return right + 1;
		    } else if (right == 0) {
		        return left + 1;
		    } else {
		        return Math.min(left, right) + 1;
		    }
	 }
	 
	
}
class Node{
	int value;
	Node leftNode;
	Node rightNode;
	
	public Node(int value) {
		this.value = value;
	}
	
	public void add(Node node) {
		if(node == null) {
			return;
		}
		
		if(node.value < this.value) {
			if(this.leftNode == null) {
				this.leftNode = node;
			}else {
				this.leftNode.add(node);
			}
		}else {
			if(this.rightNode == null) {
				this.rightNode = node;
			}else {
				this.rightNode.add(node);
			}
		}
	}
	
}

运行结果：
在这里插入图片描述

平衡二叉树判断

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

public class test {	
	public static void main(String[] args) {
	      int[] arr = {50,25,75,37};
	      BinarySortTree  binarySortTree = new BinarySortTree();
	      for(int i=0;i<arr.length;i++) {
	    	  binarySortTree.add(new Node(arr[i]));
	      }
	      binarySortTree.judgeBalance();
	}
}

class BinarySortTree{
	 private Node root;
	 Boolean isBalance = true; 
	 public void add(Node node) {
		 if(root == null) {
			 root = node;
		 }else {
			 root.add(node);
		 }
	 }
	public void judgeBalance() {
		judgeTree(root);
		System.out.print(isBalance);
	}
	public int judgeTree(Node node) {
		if(node == null || isBalance == false) {
			return 0;
		}
		int judgeLeft = judgeTree(node.leftNode);
		int judgeRight = judgeTree(node.rightNode);
		if(Math.abs(judgeLeft - judgeRight) > 1) {
			isBalance = false;
		}
		return Math.max(judgeLeft, judgeRight)+1;
	}	
}
class Node{
	int value;
	Node leftNode;
	Node rightNode;
	
	public Node(int value) {
		this.value = value;
	}
	
	public void add(Node node) {
		if(node == null) {
			return;
		}
		
		if(node.value < this.value) {
			if(this.leftNode == null) {
				this.leftNode = node;
			}else {
				this.leftNode.add(node);
			}
		}else {
			if(this.rightNode == null) {
				this.rightNode = node;
			}else {
				this.rightNode.add(node);
			}
		}
	}
	
}

排序二叉树判断

这里采用中序遍历，如果前节点不小于当前节点的值，则不符合排序二叉树的条件：

public class test {
	public static void main(String[] args) {
	      int[] arr = {5,3,2,0,4,7,1,9,8};
	      BinarySortTree  binarySortTree = new BinarySortTree();
	      for(int i=0;i<arr.length;i++) {
	    	  binarySortTree.add(new Node(arr[i]));
	      }
	      binarySortTree.midTraverse();
	}

}

class BinarySortTree{
	 private Node root;
	 Boolean isBinarySortTree = true;
	 Node preNode = null;
	 public void add(Node node) {
		 if(root == null) {
			 root =node;
		 }else {
			 root.add(node);
		 }
	 }
	 
	 public void midTraverse() {
		 midTraverse(root);
		 System.out.print(isBinarySortTree);
	 }
	 
	 public void midTraverse(Node root) {
		 if (root != null) {
			 midTraverse(root.leftNode);
		     if(preNode != null && preNode.value>=root.value) isBinarySortTree = false;
		     preNode = root;
		     midTraverse(root.rightNode);
		 }
	 }
}
class Node{
	int value;
	Node leftNode;
	Node rightNode;
	
	public Node(int value) {
		this.value = value;
	}
	
	public void add(Node node) {
		if(node == null) {
			return;
		}
		
		if(node.value < this.value) {
			if(this.leftNode == null) {
				this.leftNode = node;
			}else {
				this.leftNode.add(node);
			}
		}else {
			if(this.rightNode == null) {
				this.rightNode = node;
			}else {
				this.rightNode.add(node);
			}
		}
	}
}

这里由于建树的时候就是建立的排序二叉树，因此输出为true:
在这里插入图片描述

排序二叉树中第K小的元素

在这里插入图片描述
这里其实也可以用中序遍历的方法，为什么中序遍历最后事有序的呢？可以参考上图，如果将每个节点的值投影到坐标轴上，最终得到的就是一个有序序列，而中序遍历的遍历顺序和这种投影所形成的顺序是相通的。

iriris
关注
专栏目录
java二叉树
04-24
以下是对"java二叉树"这个主题的详细解析。 首先，我们要理解二叉树的基本操作： 1. 插入节点：在二叉树中插入新节点时，需要遵循二叉树的规则，即新节点只能作为现有节点的左孩子或右孩子。插入操作取决于比较新...
【Java】二叉树
qq_61635026的博客
07-08 2752
二叉树（Binary Tree）是一种常见的树形结构，它由节点（Node）和节点之间的关系构成。每个节点最多有两个子节点，分别称为左子节点和右子节点。二叉树中的每个节点可以为空（null）。
二叉树（Java实现）
热门推荐
JiaXingNashishua的博客
05-22 1万+
声明：本文部分文章取自于 Java中关于二叉树详解_来学习的小张的博客-CSDN博客_java 二叉树原理 更多关于二叉树详情可以点击上面链接 一：树形结构 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点： 有一个特殊的节点，称为根节点，根节点没有前驱节点； 除根节点外，其余节点被分成M(M > 0)个互不相交的集合T1、T2、......、Tm，其中每一个
java数据结构：二叉树
最新发布
qq_74667605的博客
07-30 293
1.子树不能相交2.除了根节点，每个节点有且仅有一个父节点3.一颗N个节点的树有N-1条边。
数据结构（二叉树）——Java实现
m0_56911284的博客
11-03 2838
认识二叉树，并用Java实现其一系列的操作。
Java语言----二叉树
tq02的博客
05-28 2932
二叉树详细讲解，以及Java实现代码
Java二叉树算法实例.zip_java 二叉树_二叉树
09-22
这个名为"Java二叉树算法实例.zip"的压缩包显然是一个针对初学者的教程，旨在帮助他们理解并掌握二叉树的基本概念和常见算法。 首先，二叉树是由节点构成的数据结构，每个节点包含两个子节点，分别称为左子节点和右...
Bitreesearch.rar_java二叉树实验
09-22
在这个“Bitreesearch.rar_java二叉树实验”中，我们主要探讨的是如何利用Java语言来实现二叉排序树（Binary Search Tree, BST），以及如何进行中序遍历来展示树中的数据。这个实验将帮助我们深入理解二叉树的性质和...
java 二叉树详解 + 实现代码
12-21
二叉树是一种特殊的树结构，其中每...理解和掌握二叉树的结构及其遍历方式对于学习数据结构和算法至关重要，它们是解决复杂问题的基础工具。通过实例化节点类、构建树结构以及遍历节点，我们可以有效地处理和操作数据。
java基础面试题重建二叉树
05-12
java基础面试题重建二叉树提取方式是百度网盘分享地址
二叉树（Java版）
WYSCODER的博客
08-04 2992
二叉树，看这一篇就够了~~~
Java二叉树
m0_64318128的博客
10-16 1860
二叉树的概念、性质、以及二叉树的基本操作
Java数据结构————二叉树
爱敲代码的三毛的博客
08-20 1186
文章目录一、树型结构（了解）1.概念2. 树与非树3. 树的一些重要的概念4. 树的表示形式（了解）5. 树的一些应用二、二叉树1.二叉树的概念2.二叉树的基本形态3.两种特殊的二叉树4. 二叉树的性质5. 二叉树的存储三、二叉树的基本操作1.二叉树的遍历2.前序遍历3. 中序遍历4. 后序遍历5. 求结点个数6.求叶子结点个数7. 求第 k 层结点个数8.获取二叉树的高度9. 查找 val 所在结点10. 层序遍历11. 判断一棵树是不是完全二叉树完！ 要想了解二叉树先要知道什么是树 一、树型结构（..
Java数据结构之二叉树
qq_64580912的博客
11-09 1861
1) n个结点的二叉链表中含有n+1【公式2n-(n-1)=n+1】个空指针域。利用二叉链表中的空指针域，存放指向该结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为"线索")2)这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种3)一个结点的前一个结点，称为前驱结点4)一个结点的后一个结点，称为后继结点。
[JAVA数据结构] 二叉树 - 详解
weixin_55250388的博客
02-01 1347
对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从0至n-1的结点一一对应时称之为完全二叉树。二叉树的顺序存储，通过学习你会发现，其实二叉树并不适合用数组存储，因为并不是每个二叉树都是完全二叉树，普通二叉树使用顺序表存储或多或少会存在空间浪费的现象。1. 某二叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该二叉树中的叶子结点数为（ B）结点的层次：从根开始定义起，根为第1层，根的子结点为第2层，以此类推,, 上图为4层。Node right;
二叉树详解（Java）
weixin_45969711的博客
11-14 1422
也就是说，如果一个二叉树的层数为K，且结点总数是(2^k) -1 ，则它就是满二叉树。先访问左子节点，左子节点不为空就递归中序遍历，再访问根节点，然后再访问右子节点，右子节点不为空就递归中序遍历。先访问左子节点，左子节点不为空就递归后序遍历，再访问右子节点，右子节点不为空就递归后序遍历，然后再访问根节点。先访问根节点，再访问左节点，左节点不为空就递归前序遍历，再访问右节点，右节点不为空就递归前序遍历。若规定根节点的层数为1，具有n个结点的满二叉树的深度，h=Log2(n+1)
[数据结构]二叉树(JAVA)
weixin_53106294的博客
11-01 865
二叉树的基本概念及简单模拟实现
Java——二叉树
申俏雅的博客
03-12 909
度为0的节点产生0条边，度为1的节点有n1个 产生n1条边，度为2的节点有n2个 产生2*n2条边，二叉树有N个节点，一棵二叉树，有n0（度为0的节点）,n1（度为1的节点）,n2（度为2）有。3.二叉树不存在度大于2的节点，二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树。：以某节点为根的子树中任一节点都称为该节点的子孙。：若一个节点含有子节点，则这个节点称为其子节点的父节点；2.在具有2n个节点的完全二叉树中，叶子节点的个数是 （n ）个。：一个节点含有的子树的根节点称为该节点的子节点；
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值