二叉树--前序遍历、中序遍历、后序遍历、层次遍历、查找、删除、更新--JAVA实现

最新推荐文章于 2024-10-19 00:00:00 发布
原创 最新推荐文章于 2024-10-19 00:00:00 发布 · 355 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#二叉树 #二叉树java实现 #前序遍历java实现
本文详细介绍了使用Java实现二叉树的各种操作，包括前序、中序、后序及层次遍历，查找、删除和更新节点的方法。通过具体代码示例，展示了如何构建二叉树并进行上述操作。

二叉树基础，请参考：https://blog.csdn.net/cinling123/article/details/103911110

本文重点，用JAVA实现--二叉树--前序遍历、中序遍历、后序遍历、层次遍历、查找、删除、更新。--经过测试

直接上代码：

import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;

class TreeNode{
	Integer value;
	TreeNode leftNode;
	TreeNode rightNode;
	
	public TreeNode(){}
	
	/**
	 * 初始化结点
	 */
	public TreeNode(int value){
		this.value=value;
		this.leftNode=null;
		this.rightNode=null;
	}
	
	/**
	 * 创建二叉树
	 */
	static TreeNode buildTree(int[] data){
		TreeNode node = new TreeNode();
		for (int i=0;i<data.length;i++) {
			insert(node, data[i]);
//			insert2(node, data[i]);
		}
		return node;
	}
	
	/**
	 * 以查找二叉树的规则插入，小的在左，大的在右--递归
	 */
	public static void insert(TreeNode node, int value){
		if (node.getValue() == null) {
			node.setValue(value);
		} else if (value < node.getValue()) {//建立左子树
			if (node.getLeftNode() == null) {//左子树节点为空
				node.setLeftNode(new TreeNode());
				insert(node.getLeftNode(), value);
			} else {
				insert(node.getLeftNode(), value);
			}
		} else if (value > node.getValue()) {//建立右子树
			if (node.getRightNode() == null) {//右子树节点为空
				node.setRightNode(new TreeNode());
				insert(node.getRightNode(), value);
			} else {
				insert(node.getRightNode(), value);
			}
		}
	}
	
	/**
	 * 以查找二叉树的规则插入，小的在左，大的在右
	 */
	private static void insert2(TreeNode node, int value){
		if (node.value == null) {//根节点
			node.value = value;
			return;
		}
		TreeNode currentNode = node;
		while(true){
			if (value < currentNode.value) {//建立左子树
				if (currentNode.leftNode == null) {//左子树节点为空
					currentNode.leftNode = new TreeNode(value);//建立左孩子节点
					return;
				} else {
					currentNode = currentNode.leftNode;
				}
			} else {//建立右子树
				if (currentNode.rightNode == null) {//右子树节点为空
					currentNode.rightNode = new TreeNode(value);//建立右孩子节点
					return;
				} else {
					currentNode = currentNode.rightNode;
				}
			}
		}
	}
	
	/**
	 * 前序遍历
	 * 前序遍历通俗的说就是从二叉树的根结点出发，当第一次到达结点时就输出结点数据，按照先向左再向右的方向访问
	 */
	static void preOrder(TreeNode node){
		if (node != null) {
			System.out.print(node.getValue() + " ");
			preOrder(node.getLeftNode());
			preOrder(node.getRightNode());
		}
	}
	
	/**
	 * 中序遍历
	 * 中序遍历就是从二叉树的根结点出发，当第二次到达结点时就输出结点数据，按照先向左再向右的方向访问
	 */
	static void inOrder(TreeNode node){
		if (node != null) {
			inOrder(node.getLeftNode());
			System.out.print(node.getValue() + " ");
			inOrder(node.getRightNode());
		}
	}
	
	/**
	 * 后序遍历
	 * 后序遍历就是从二叉树的根结点出发，当第三次到达结点时就输出结点数据，按照先向左再向右的方向访问
	 */
	static void afterOrder(TreeNode node){
		if (node != null) {
			afterOrder(node.getLeftNode());
			afterOrder(node.getRightNode());
			System.out.print(node.getValue() + " ");
		}
	}
	
	/**
	 * 层序遍历（队列实现）：其实就是从上到下，从左到右依次将每个数放入到队列中，然后按顺序依次打印就是想要的结果
	 *  1、首先将二叉树的根节点add到队列中，判断队列不为空，就输出队头的元素， 
	 *  2、判断节点如果有孩子，就将孩子add到队列中， 
	 *  3、遍历过的节点出队列， 
	 *  4、循环以上操作，直到Tree == NULL。
	 */
	static void floorOrder_queue(TreeNode node){
		Queue<TreeNode> q = new ConcurrentLinkedQueue<TreeNode>();
		if (null != node) {
			q.add(node);//根节点先入队列
		}
		while(q.isEmpty() == false){
			TreeNode currentNode = q.poll();//头元素出队列
			System.out.print(currentNode.getValue() + " ");
			if (currentNode.getLeftNode() != null) {//有左子树，左子树入队列
				q.add(currentNode.getLeftNode());
			}
			if (currentNode.getRightNode() != null) {//有右子树，右子树入队列
				q.add(currentNode.getRightNode());
			}
		}
	}
	
	/**
	 * 层序遍历（数据实现）：其实就是从上到下，从左到右依次将每个数放入到队列中，然后按顺序依次打印就是想要的结果
	 * 1、创建一个指针数组，保存二叉树结构体指针， 
	 * 2、保存二叉树根节点，再申请变量 in、out ，控制数组，在遍历过程中，始终能找到节点和该节点的前一个节点， 
	 * 3、循环以上过程。
	 */
	static void floorOrder_array(TreeNode node, int size){
		TreeNode[] array = new TreeNode[size];
		int in = 0;
		int out = 0;
		array[in++] = node;
		while (in > out) {
			TreeNode currentNode = array[out];
			if (currentNode != null) {
				System.out.print(currentNode.getValue() + " ");
				if (currentNode.getLeftNode() != null) {//有左子树，左子树入数组
					array[in++] = currentNode.getLeftNode();
				}
				if (currentNode.getRightNode() != null) {//有右子树，右子树加入数组
					array[in++] = currentNode.getRightNode();
				}
				out++;
			}
		}
	}
	
	/**
	 * 查找
	 */
	static TreeNode findNode(TreeNode node, int value){
		if (value == node.getValue()) {//值相等，找到，返回
			return node;
		} else if (value < node.getValue()) {//值比当前节点小，左子树查找
			if (null != node.getLeftNode()) {
				return findNode(node.getLeftNode(), value);
			} else {
				return null;
			}
		} else if (value > node.getValue()) {//值比当前节点大，右子树查找
			if (null != node.getRightNode()) {
				return findNode(node.getRightNode(), value);
			} else {
				return null;
			}
		}
		return null;
	}
	
	/**
	 * 删除节点
	 * 要求：删除的要求相对复杂，因为，删除之后，还是必须要保持二叉查找树的特性。
       实现思路：先找到要删除的节点，这时会有三种情况：
	    1、删除节点为（左或者右）叶子--此时直接将节点的父亲节点的（左或者右）节点置为空；
		2、删除节点只包含一个（左或者右）子树--此时，判断删除节点是父节点的左子树，还是右子树，用删除节点的唯一那一个“儿子”去替换自己；
		3、删除节点既有左子树又有右子树--此时，可以找到右子树中最小的节点，替换删除节点，再递归地删除了它（做法不唯一，同样也可以用左子树中最大的节点去替换删除节点）
	 */
	static void delete(TreeNode tree, int value) {
		// 查询到的节点的父节点
		TreeNode parent = null;
		// 查询到的节点
		TreeNode searchTree = tree;
		// 当节点不为空的时候开始循环
		while (searchTree != null) {
			// 如果节点的值等于查询值，跳出循环，之后的逻辑就是一个树查找的逻辑
			if (searchTree.getValue() == value) {
				break;
			} else if (searchTree.getValue() > value) {
				parent = searchTree;
				searchTree = searchTree.getLeftNode();
			} else if (searchTree.getValue() < value) {
				parent = searchTree;
				searchTree = searchTree.getRightNode();
			}
		}

		// 查询到的节点是父节点的左节点与否
		boolean parentLeftFlag = false;
		// 查询到的节点的父节点是否存在
		boolean hasParent = true;
		// 查询到的节点的左子树存在与否
		boolean leftFlag = false;
		// 查询到的节点的右子树存在与否
		boolean rightFlag = false;

		if (parent == null) {
			hasParent = false;
		} else if (parent.getRightNode() == searchTree) {
			parentLeftFlag = false;
		} else {
			parentLeftFlag = true;
		}

		if (searchTree == null) {
			return;
		}
		if (searchTree.getLeftNode() != null) {
			leftFlag = true;
		}
		if (searchTree.getRightNode() != null) {
			rightFlag = true;
		}

		if (!leftFlag && !rightFlag) {
			if (hasParent) {
				if (parentLeftFlag) {
					parent.setLeftNode(null);
				} else {
					parent.setRightNode(null);
				}
			} else {
				searchTree.setValue(null);
			}
		} else if (!leftFlag || !rightFlag) {
			if (hasParent) {
				if (parentLeftFlag) {
					if (leftFlag) {
						parent.setLeftNode(searchTree.getLeftNode());
					} else {
						parent.setLeftNode(searchTree.getRightNode());
					}
				} else {
					if (leftFlag) {
						parent.setRightNode(searchTree.getLeftNode());
					} else {
						parent.setRightNode(searchTree.getRightNode());
					}
				}
			} else {
				if (leftFlag) {
					searchTree.setValue(searchTree.getLeftNode().getValue());
					searchTree.setRightNode(searchTree.getLeftNode().getRightNode());
					searchTree.setLeftNode(searchTree.getLeftNode().getLeftNode());
				} else {
					searchTree.setValue(searchTree.getRightNode().getValue());
					searchTree.setLeftNode(searchTree.getRightNode().getLeftNode());
					searchTree.setRightNode(searchTree.getRightNode().getRightNode());
				}
			}
		} else if (leftFlag && rightFlag) {
			TreeNode minTree = searchTree.getRightNode();
			while (minTree.getLeftNode() != null) {
				minTree = minTree.getLeftNode();
			}
			Integer minTreeValue = minTree.getValue();
			delete(searchTree, minTreeValue);
			searchTree.setValue(minTreeValue);
		}
	}
	
	/**
	 * 先删除旧节点，再插入新的值
	 */
	static void update(TreeNode tree, int oldValue, int newValue){
		delete(tree, oldValue);
		insert( tree, newValue);
	}

	public Integer getValue() {
		return value;
	}

	public void setValue(Integer value) {
		this.value = value;
	}

	public TreeNode getLeftNode() {
		return leftNode;
	}

	public void setLeftNode(TreeNode leftNode) {
		this.leftNode = leftNode;
	}

	public TreeNode getRightNode() {
		return rightNode;
	}

	public void setRightNode(TreeNode rightNode) {
		this.rightNode = rightNode;
	}
}

/**
 * 二叉树
 */
public class TestTreeNode {
	public static void main(String[] args) {
		int[] data = {6,3,9,7,4,8,2,1,5};
		System.out.println("原始数组：");
		for (int i=0;i<data.length;i++) 
		System.out.print(data[i] + " ");
		TreeNode rootNode = TreeNode.buildTree(data);
		System.out.print("\n前序遍历：");
		TreeNode.preOrder(rootNode);
		System.out.print("\n中序遍历：");
		TreeNode.inOrder(rootNode);
		System.out.print("\n后序遍历：");
		TreeNode.afterOrder(rootNode);
		System.out.print("\n层序遍历--队列：");
		TreeNode.floorOrder_queue(rootNode);
		System.out.print("\n层序遍历--数组：");
		TreeNode.floorOrder_array(rootNode, data.length);
		System.out.print("\n二叉树查找--值为8的节点：");
		TreeNode node = TreeNode.findNode(rootNode, 8);
		System.out.print(node == null?"未找到":node.getValue());
		TreeNode.delete(rootNode, 3);//删除值为3的节点
		System.out.print("\n删除节点值为3后--中序遍历：");
		TreeNode.update(rootNode, 7, 10);//更新值为7的节点
		System.out.print("\n更新值为7的节点后---层序遍历：");
		TreeNode.floorOrder_queue(rootNode);
	}
}

创建树后的结构：

运行结果：

 

代码实现参考资料：

（二叉树的层序遍历（两种方法实现））：https://blog.csdn.net/m0_37925202/article/details/80796010
二叉树的建立：https://blog.csdn.net/zd454909951/article/details/78794263

Java实现二叉树（一）：二叉查找树的实现：https://blog.csdn.net/that_is_cool/article/details/80948929

详细图解二叉树中序遍历（非递归C++）LeetCode94
m0_55864612的博客
09-27 2868
详细图解二叉树中序遍历（非递归）二叉树中序递归含义LeetCode题目94详细图解源代码运行结果 二叉树中序递归含义 中序遍历首先遍历左子树，然后访问根结点，最后遍历右子树。若二叉树为空则结束返回，否则： （1）中序遍历左子树 （2）访问根结点 （3）中序遍历右子树 如图1所示二叉树，中序遍历结果：DBEAFC LeetCode题目94 给定一个二叉树的根节点 root ，返回它的 中序 遍历。 输入：root = [1,null,2,3] 输出：[1,3,2] 输入：root = [1,2] 输出：
二叉树遍历方法——前、中、后序遍历（图解）
热门推荐
在夜里行走的博客
11-04 17万+
二叉树的前、中、后序遍历的递归与非递归算法
二叉树的先序、中序、后序遍历超详解
代码是程序员的语言，博客是思想的桥梁，连接你我，共享智慧之光。
05-31 10万+
以上图为基础 ①前序遍历的方式是：首先访问根节点，然后访问左子树，最后访问右子树。 前序遍历序列：F C A D B E H G M ②中序遍历的方式是：首先访问左子树，接着访问根结点，最后访问右子树。 中序遍历序列：A C B D F H E M G ③后序遍历的方式是：首先访问左子树，接着访问右子树，最后访问根结点。 后序遍历序列：A B D C H M G E F ④相同的特点： 左子树总是在右子树的之前遍历。 遍历都可以用递归的方式来描述。 中序遍历的序列中任取一个结点，该结点的左子树右子树一定分.
详细图解二叉树四种遍历(前序中序后序层次遍历)
m0_68681879的博客
11-14 4万+
二叉树的四种遍历详细图解
java实现二叉树创建删除以及递归非递归遍历demo示例
hxf009的博客
04-17 283
java实现二叉树创建删除以及递归非递归遍历demo示例 基本概念 二叉树：每个节点最多有两颗子树，即左子树和右子树，次序不可以颠倒（即先有左才能有右） 满二叉树：除最后一层无任何子节点外，每一层上的所有节点都有两个子节点二叉树。即如果一个二叉树的层数为k，且节点总数是2^k-1，则它就是满二叉树。 平衡二叉树：它是一颗空树或者它的左右两个子树的高度差的绝对值不能超过1，并且左右两个子树都是一颗平...
二叉树(相关术语、创建、遍历、最大深度问题)梳理总结
总结分享
09-18 987
树是由n（n>=1）个有限结点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
Java数据结构之二叉树的基本操作
weixin_43553142的博客
09-23 490
二叉树的基本操作
数据结构之二叉搜索树—Java实现
weixin_34260991的博客
03-07 227
二叉查找树（Binary Search Tree，简称BST）是一棵二叉树，它的左子节点的值比父节点的值要小，右节点的值要比父节点的值大。它的高度决定了它的查找效率。 在理想的情况下，二叉查找树增删查改的时间复杂度为O(logN)（其中N为节点数），最坏的情况下为O(N)。当它的高度为logN+1时，我们就说二叉查找树是平衡的。 首先定义二叉树节点 class TreeNode { ...
二叉树（前中后序遍历，查找，删除）
最新发布
2301_80062351的博客
10-19 1507
二叉树的遍历 　 1. 前中后序遍历 　　 二叉树的前序遍历（根节点最先遍历）： 　　 中序遍历 　　 二叉树的后续遍历： 　　 小结： 　 2.二叉树的前中后续查找： 　　 2.1二叉树的前序查找： 　　 2.2二叉树的中序查找： 　　 2.2二叉树的后续查找: 　 3 二叉树节点删除操作： 　 完成删除结点的操作 　 思路 　 步骤:
【数据结构】二叉树先序、中序、后序及层次四种遍历（C语言版）
咖喱年糕的博客
02-13 2287
先序遍历结果为：A B D H I E J C F K G 动画演示： 中遍历结果为：H D I B E J A F K C G 动画展示：后序遍历中，根节点默认最后面后序遍历结果：H I D J E B K F G C A 动画展示： 层次遍历结果：A B C D E F G H I J K解释外圈跑的意思：这里的根，指的是每个分叉子树（左右子树的根节点）根节点，并不只是最开始头顶的根节点，需要灵活思考理解，建议画图理解！！
【数据结构】---树：中序遍历
qq_54185425的博客
01-13 1万+
中序遍历，是数据结构中树的遍历方式之一。特点：左、根、右。每次遍历时，先遍历左节点的数据，之后遍历本节点，最后遍历右节点，循环往复，直至树中数据遍历完成。二叉查找树进行中序遍历后，返回的序列是排好序的。数据结构方面的内容刚刚接触，讲解不够深刻，还望谅解。
图解二叉树遍历方法-前序遍历、中序遍历、后序遍历
天道酬勤
04-11 7750
前序遍历二叉树（Pre-order Traversal）的规则为：从根结点出发，先访问该结点，然后前序遍历该结点的左子树，再然后前序遍历该结点的右子树。 中序遍历二叉树（In-order Traversal）的规则为：从根结点出发，先中序遍历该结点的左子树，然后访问该结点，再然后中序遍历该结点的右子树。 后序遍历二叉树（Post-order Traversal）的规则为：从根结点出发，先后序遍历该结点的左子树，然后后序遍历该结点的右子树，再然后访问该结点。
二叉树（前序、中序、后序遍历图片步骤详解）
念念不忘，必有回响
06-08 6万+
首先我们有这么一颗二叉树： 前序遍历：根结点 —> 左子树 —> 右子树 这棵树的前序遍历为：ABDEGHCF 中序遍历：左子树—> 根结点 —> 右子树 这棵树的前序遍历为：DBGEHACF 后序遍历：左子树 —> 右子树 —> 根结点 这棵树的前序遍历为：DGHEBFCA 层次遍历：按层次遍历 这棵树的前序遍历为：ABCDEF...
二叉树的四种遍历方法(前序遍历、中序遍历、后序遍历、层序遍历)有图有真相！！！
Lotus_dong的博客
06-29 5996
文章目录二叉树的四种遍历方式前序遍历（Preorder Traversal）中序遍历（Inorder Traversal）后序遍历（Postorder Traversal）层序遍历（Level Order Traversal） 二叉树的四种遍历方式 相信大家能够看到二叉树的遍历就已经对二叉树本身有了足够的了解，这里就不进行过多的赘述了，我们直接进入正题。我们知道线性数据结构的遍历一般就是前序遍历和后序遍历，而二叉树的遍历常见的有三种：前序遍历、中序遍历、后序遍历（注意：前中后是针对根节点而言的），有时候也会
二叉树遍历（图解）
依步_的专栏
07-11 3万+
二叉树的顺序存储结构就是用一维数组存储二叉树中的节点，并且节点的存储位置，也就是数组的下标要能体现节点之间的逻辑关系。—–>一般只用于完全二叉树 链式存储—–>二叉链表 定义： lchild | data | rchild（两个指针域，一个数据域）typedef struct Node { ElemType data; struct Node *lchild
数据结构之二叉树的前序遍历、中序遍历、后序遍历、层序遍历
gongwq的博客
10-21 5万+
最近也是在准备笔试，由于没有系统的学过数据结构，所以每次在考到二叉树的遍历的时候都是直接跪，次数多了也就怒了，前些天也是准备论文没时间整这些，现在提交了，算是稍微轻松点了，所以花了半天的时间来学了下二叉树。现在记下来，以便后序查阅。 一、二叉树的遍历概念     1.  二叉树的遍历是指从根结点触发，按照某种次序依次访问二叉树中所有结点，使得每个结点被访问一次且仅被访问一次。 (1). 前(
二叉树的创建、销毁、前序遍历、中序遍历、后序遍历、等基本操作C语言实现
weixin_44132627的博客
05-15 2372
一、 简单概念 一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。 二叉树的特点： 1. 每个结点最多有两棵子树，即二叉树不存在度大于2的结点。 2. 二叉树的子树有左右之分，其子树的次序不能颠倒。 下图为几种树的节点的可能情况： 图1 二叉树的5种基本形态 主要的概念有二叉树的性质、二叉树的存储结构、二叉树的遍历，具体概念内...
二叉树的基本操作实现（建立、先序、中序、后序、层序）
nicec1的博客
10-28 1万+
[问题描述] 建立一棵二叉树，试编程实现二叉树的如下基本操作： 1. 按先序序列构造一棵二叉链表表示的二叉树T； 2. 对这棵二叉树进行遍历：先序、中序、后序以及层次遍历，分别输出结点的遍历序列；  [基本要求] 从键盘接受输入（先序），以二叉链表作为存储结构，建立二叉树（以先序来建立）， [测试数据] 如输入：ABC##DE#G##F###（其中#表示空格字符）则输出结果为： 先序...
二叉树实例学习（五）——更新节点及祖辈节点高度
weixin_30915275的博客
10-11 266
在第（四）节获取节点高度函数getHeight()函数的基础上，增添并测试更新节点高度函数和更新祖辈节点高度函数：updateHight（）、updateAboveHei（）。在上节中，每插入一个新节点，根结点以及新节点的其它祖辈节点的高度不增加，如今这已成为过去。在插入节点函数insertAsLC（）、insertAsRC（）函数中，分别添加updateAboveHei（），则每次插入新的节点，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值