数据结构 — 二叉树（创建、遍历）java实现

最新推荐文章于 2022-11-03 14:22:46 发布
最新推荐文章于 2022-11-03 14:22:46 发布
阅读量1.1k 收藏 1
点赞数 1
分类专栏： 数据结构 & 算法 文章标签： 数据结构 java 二叉树 遍历 创建
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/peerslee/article/details/50081717
版权

1、链表的节点

package package1;

public class Node {
	//数据域
	public Object data;
	//引用域（指针域）
	public Node next;
	//无参构造器
	public Node() {
		this(null,null);
	}
	//一个参数的构造器
	public Node(Object data) {
		this(data,null);
	}
	//两个参数
	public Node(Object data,Node next) {
		this.data = data;
		this.next = next;
	}
}
</span>

2、队列接口

package package1;

public interface IQueue {
	public void clear();
	public boolean isEmpty();
	public int length();
	public Object peek();
	public void offer(Object x) throws Exception;
	public Object poll();
}
</span>

3、栈接口 

package package1;

public interface IStack {
	public void clear();
	public boolean isEmpty();
	public int length();
	public Object peek();
	public void push(Object x) throws Exception;
	public Object pop();
}
</span>

4、链队列 

package package1;

public class LinkQueue implements IQueue{

	private Node front;
	private Node rear;
	
	public LinkQueue() {
		front = rear = null;
	}
	public void clear() {
		front = rear = null;
	}

	public boolean isEmpty() {
		return front == null;
	}

	public int length() {
		Node n = front;
		int length = 0;
		while(n != null) {
			n = n.next;
			length++;
		}
		return length;
	}

	public Object peek() {
		if(front != null) {
			return front.data;
		}else {
			return null;
		}
	}

	public void offer(Object x) {
		Node n = new Node(x);
		if(front != null) {
			rear.next = n;
			rear = n;
		}else {
			front = rear = n;
		}
	}

	public Object poll() {
		if(front != null) {
			Node n = front;
			front = front.next;
			if(n == rear) {
				rear = null;
			}
			return n.data;
		}else {
			return null;
		}
	}

}
</span>

4、链栈 
package package1;

public class LinkStack implements IStack{
	//栈顶元素
	private Node top;
	//将栈置空
	public void clear() {
		top = null;
	}
	//判断栈是否为空
	public boolean isEmpty() {
		return top == null;
	}
	//求链栈的长度
	public int length() {
		Node n = top;
		int length = 0;
		while(n != null) {
			n = n.next;
			length++;
		}
		return length;
	}
	//取栈顶元素，并返回其值
	public Object peek() {
		if(!isEmpty())
			return top.data;
		else 
			return null;
	}
	//入栈
	public void push(Object x) {
		Node n = new Node(x);
		n.next = top;
		top = n;
	}
	
	//出栈
	public Object pop() {
		//this为隐式参数
		if(this.isEmpty()) {
			return null;
		}else {
			Node n = top;
			top = top.next;
			return n.data;
		}
	}
	//整个栈的遍历
	public void display() {
		Node n = top;
		while(n != null) {
			System.out.print(n.data.toString() + " ");
			n = n.next;
		}
	}
}
</span>
5、二叉树节点 

package package1;

public class BiTreeNode {

	//域
	public Object data;
	public BiTreeNode lchild,rchild;
	
	//构造空节点
	public BiTreeNode() {
		this(null);
	}
	
	//构造左右孩子域为空的二叉树
	public BiTreeNode(Object data) {
		this(data, null, null);
	}
	
	//构造左右孩子和数据域都不为空的二叉树
	public BiTreeNode(Object data, BiTreeNode lchild, BiTreeNode rchild) {
		this.data = data;
		this.lchild = lchild;
		this.rchild = rchild;
	}
}
</span>
6、二叉树（包含二叉树的基本操作） 

package package1;

public class BiTree {
	//域
	private BiTreeNode root;
	
	//构造空树
	public BiTree() {
		this.root = null;
	}
	//构造二叉树
	public BiTree(BiTreeNode root) {
		this.root = root;
	}
	
	/*根据先根遍历和中根遍历创建一颗二叉树
	 * preOrder 先根遍历序列
	 * inOrder 中根遍历序列
	 * preIndex 先根遍历序列在preOrder中的开始位置
	 * inIndex 中根遍历序列在inOrder中的开始位置
	 * count 节点的总数
	 */
	public BiTree(String preOrder, String inOrder, int preIndex, int inIndex, int count) {
		/*
		 * 算法描述：
		 * 1.先根和中根非空
		 * 2.取先根遍历序列中第一个节点作为根节点
		 * 3.找到根节点在中序中的位置
		 * 4.创建根节点、左子树、右子树
		 */
		if(count > 0){
			char r = preOrder.charAt(preIndex);
			int i = 0;
			for(; i < count; i++){
				if(r == inOrder.charAt(inIndex + i))
					break;
			}
			root = new BiTreeNode(r);
		    /*
		     * 先序：root：lchild：rchild
		     * 中序：lchild：root：rchild
		     */
			root.lchild = new BiTree(preOrder, inOrder, preIndex+1, inIndex, i).root;
			root.rchild = new BiTree(preOrder, inOrder, preIndex+i+1, inIndex+i+1, count-i-1).root;
			
		}
	}
	
	//标明空子树的 先根遍历序列创建一棵二叉树
	private static int index = 0;
	public BiTree(String preStr){
		char c = preStr.charAt(index++);
		if(c != '#') {
			root = new BiTreeNode(c);
			root.lchild = new BiTree(preStr).root;
			root.rchild = new BiTree(preStr).root;
		} else {
			root = null;
		}
		
	}
	
	//递归先根遍历
	public void preRootTraverse(BiTreeNode T) {
		if(T != null){
			System.out.print(T.data);
			preRootTraverse(T.lchild);
			preRootTraverse(T.rchild);
		}
	}
	
	/*
	 * 非递归先根遍历
	 * 1.第一层循环：栈是否为空
	 * 2.不断的访问左子树，右子树入栈，一会返回（出栈）
	 * 3.重点：直接访问
	 */
	public void preRootTraverse() {
		BiTreeNode T = root;
		if(T != null) {
			//将root入栈之后就是不断的入栈出栈
			LinkStack S = new LinkStack();
			S.push(T);
			//入栈出栈的过程
			while(!S.isEmpty()) {
				T = (BiTreeNode)S.pop();
				System.out.print(T.data);
				while(T != null) {
					if(T.lchild != null) {
						System.out.print(T.lchild.data);
					}
					if(T.rchild != null) {
						S.push(T.rchild);
					}
					T = T.lchild;//一直向下
				}
			}
		}
	}
	
	//递归中根遍历
	public void inRootTraverse(BiTreeNode T) {
		if(T != null){
			inRootTraverse(T.lchild);
			System.out.print(T.data);
			inRootTraverse(T.rchild);
		}
	}
	
	/*
	 * 非递归中根遍历
	 * 1.第一层循环同先根
	 * 2.左孩子不断入栈，然后到底之后出栈时访问输出，之后右孩子入栈
	 * 3.重点：没有左子树，出栈，访问
	 */
	public void inRootTraverse() {
		BiTreeNode T = root;
		if(T != null) {
			LinkStack S = new LinkStack();
			S.push(T);
			while(!S.isEmpty()) {
				while(S.peek() != null) {
					S.push(((BiTreeNode)S.peek()).lchild);
				}
				//空节点出栈
				S.pop();
				if(!S.isEmpty()) {
					T = (BiTreeNode)S.pop();
					System.out.print(T.data);
					S.push(T.rchild);
			}
			
			}
		}
	}
	
	//递归后根遍历
	public void postRootTraverse(BiTreeNode T) {
		if(T != null){
			postRootTraverse(T.lchild);
			postRootTraverse(T.rchild);
			System.out.print(T.data);
		}
	}
	
	/*
	 * 非递归后根遍历
	 * 1.第一层同上两个
	 * 2.不断将左子树入栈，到底，出栈，如果出栈节点为叶子节点，访问
	 * 3.重点：没有左子树 和 右子树 （已经被访问了）
	 */
	public void postRootTraverse() {
		BiTreeNode T = root;
		if(T != null) {
			LinkStack S = new LinkStack();
			S.push(T);
			Boolean flag;
			BiTreeNode p = null;
			while(!S.isEmpty()) {
				while(S.peek() != null) {
					S.push(((BiTreeNode)S.peek()).lchild);
				}
				S.pop();
				while(!S.isEmpty()) {
					T = (BiTreeNode)S.peek();//取栈顶元素
					if(T.rchild == null || T.rchild == p) {
						System.out.print(T.data);
						S.pop();
						p = T;
						flag = true;
					} else {
						S.push(T.rchild);
						flag = false;
					}
					if(!flag) {
						break;
					}
				}
			}
		}
	}
	
	//层次遍历（自左向右）
	//http://blog.csdn.net/peerslee/article/details/49473831
	public void levelTraverse() {
		
		BiTreeNode T = root;
		if(T != null) {
			LinkQueue L = new LinkQueue();
			L.offer(T);
			
			while(!L.isEmpty()) {
				T = (BiTreeNode)L.poll();
				
				System.out.print(T.data);
				if(T.lchild != null) {
					L.offer(T.lchild);
				}
				if(T.rchild != null) {
					L.offer(T.rchild);
				}
			}
		}
	}
	
	public BiTreeNode getRoot() {
		return root;
	}
	
	public void setRoot(BiTreeNode root) {
		this.root = root;
	}
}


7、测试程序 

package package1;

public class t1 {

	public static void main(String[] args) {
		String preOrder = "ABDEGCFH";
		String inOrder = "DBGEAFHC";
		
		BiTree T = new BiTree(preOrder,inOrder,0,0,preOrder.length());
		System.out.println("先根遍历(递归）");
		T.preRootTraverse(T.getRoot());
		System.out.println();
		System.out.println("先根遍历(非递归）");
		T.preRootTraverse();
		System.out.println();
		System.out.println("中根遍历（递归）");
		T.inRootTraverse(T.getRoot());
		System.out.println();
		System.out.println("中根遍历（非递归）");
		T.inRootTraverse();
		System.out.println();
		System.out.println("后根遍历（递归）");
		T.postRootTraverse(T.getRoot());
		System.out.println();
		System.out.println("后根遍历（非递归）");
		T.postRootTraverse();
		
		System.out.println();
		System.out.println("层次遍历");
		T.levelTraverse();
	}

}
</span>


8、测试结果







PeersLee
关注
专栏目录
【数据结构】—二叉树遍历
四季轮换叶，一路招摇胜
05-01 1123
树是由n(n>=0)个结点所构成的有限集合。对于一颗非空树，其中有且仅有一个没有前驱的结点，这个结点就是【根节点】，其余结点有且仅有一个前驱，但可以有多个后继。今天讲解一下二叉树的三种遍历方法...
Java数据结构之二叉树的建立
weixin_44270248的博客
05-16 671
基本概念 二叉树的遍历可使非线性结构的树转换成线性序列。先序遍历序列和后序遍历序列反应父结点和孩子结点间的层次关系，中序遍历序列反应兄弟节点间的左右次序关系。因为二叉树是具有层次关系的结点构成的非线性结构，并且每个结点的孩子结点具有左右次序，所以已知一种遍历序列无法确定唯一的二叉树，只有同时知道中序和先序遍历序列，或同时知道中序和后续遍历序列，才能确定结点的层次关系和结点的左右次序，才能确定唯一的...
数据结构 Java数据结构 --- 二叉树
wwzzzzzzzzzzzzz的博客
12-11 5163
二叉树 1. 树形结构 1.1 概念 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点： 有一个特殊的节点，称为根节点，根节点没有前驱节点 除根节点外，其余节点被分成M(M > 0)个互不相交的集合T1、T2、…Tm，其中每一个集合 Ti (1 <= i<= m) 又是一棵与树类似的子树。每棵子树的根节点有且只有一个前驱，可以有0个或多个后继 树是递归定义的。
Java数据结构实现二叉树
cccccccmmm的博客
08-10 1345
第一步：判断新结点中的元素是否小于当前结点对象，如果小于那么新结点则放到当前结点的左边，那放到左边我们又要判断了，如果当前结点有左子树了那我们又得判断新结点的元素是否小于当前结点的左子树，如果小于又放到当前结点的左子树的左子树上，反之则放到当前结点的左子树的右子树上，如果当前结点的左子树的左子树上又有结点，然后又要判断......我们就用节点Node来表示，那么节点类的实现我们刚刚看过二叉树的图了，二叉树节点的元素分为：左子树、元素、右子树，所以我们需要有三个成员变量，分别存放左子树、元素以及右子树。...
数据结构（二叉树）——Java实现
最新发布
m0_56911284的博客
11-03 2829
认识二叉树，并用Java实现其一系列的操作。
数据结构-二叉树 JAVA语言实现
10-16
使用教程：http://blog.csdn.net/z740852294/article/details/78250911
数据结构 | 二叉树遍历（Java）
xxzaa的博客
04-21 968
二叉树的节点定义
5种方法完成二叉树后序遍历(Java实现)
Dream_Owner的博客
12-27 1090
5种方法完成二叉树后序遍历[1] 代码最少-----递归[2] 非递归之----先序遍历的逆序[3] 非递归之----双栈法(添加一个Flag栈)[4] 非递归之----记录末次输出[5] 非递归之----记录末次输出的另一种方法[6] 总结 [1] 代码最少-----递归 递归的思想非常简单,宏观上来讲,就是"先访问做孩子,再访问右孩子,最后访问自己";限定好递归结束条件即可. publ...
Java二叉树的遍历思想及核心代码实现
08-26
Java二叉树的遍历思想及核心代码实现 Java二叉树的遍历思想及核心代码实现是计算机科学中的一种重要概念，它是指对二叉树进行遍历的思想和实现方法。二叉树是一种特殊的树形结构，它的每个结点最多有两个孩子结点，...
数据结构课程设计二叉树的遍历.pdf
09-30
数据结构课程设计二叉树的遍历 本文主要介绍了二叉树的遍历方式和应用，旨在帮助读者更好地理解二叉树的结构和运作机理。二叉树是一种非线性结构，广泛应用于操作系统的文件构成、人工智能和算法分析的模型表示、...
由先根次序和中跟次序建立二叉树，以及遍历的递归、非递归算法
04-18
由先根次序和中跟次序建立二叉树，以及各种遍历的递归、非递归算法
二叉树替换子树
05-15
以标明空子树的先根序列构造二叉树替换二叉树的子树，
二叉树详解-Java实现二叉树数据结构
♾️
08-26 1756
树的由来 我们知道对于有序数组，查找很快，并介绍可以通过二分法查找，但是 想要在有序数组中插入一个数据项，就必须先找到插入数据项的位置，然后将所有插入位置后面的数据 项全部向后移动一位，来给新数据腾出空间，平均来讲要移动N/2次，这是很费时的。同理，删除数据 也是。 然后我们介绍了另外一种数据结构——链表，链表的插入和删除很快，我们只需要改变一些引用值 就行了，但是查找数据却很慢了，因为不管我们查找什么数据，都需要从链表的第一个数据项开始，遍 历到找到所需数据项为止，这个查找也是平均需要比较N/2次。 那么
Java数据结构之二叉树
fear_wolf的博客
10-25 2856
二叉树的创建很简单，但是难就难在操作上，我们为了简便，先自己手动创建一个简陋的二叉树的结构，着重介绍二叉树的操作，先创建一棵二叉树。我们有前面的概念可以看出，二叉树定义是递归式的，因此后序基本操作中基本都是按照递归实现的。完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是从满二叉树中引出来的，对于。的数据结构，它是由n（n >= 0）个有限节点组成的一个具有层次关系的集合，遍历是二叉树上最重要的操作之一，是二叉树进行其他运算的基础。称之为完全二叉树，由此可知，满二叉树是一种特殊的完全二叉树。
从零单刷数据结构（Java描述）（二十一）——二叉树的创建
waS_TransvolnoS的博客
06-14 190
想创建一棵二叉树，首先要创建一棵带根结点的树，定义左右结点和结点的权。 //定义一棵二叉树 class BinaryTree{ TreeNode root; //设置根结点 public void setRoot(TreeNode root){ this.root=root; } //获取根结点 public Tree...
java数据结构创建一个树_【数据结构】-java实现-先序创建普通二叉树（即递归创建一棵普通二叉树）...
weixin_42351189的博客
02-26 242
怎么按照要求创建一棵二叉树怎么创建下图的二叉树？ 我写过完全二叉树的创建【数据结构】-java 完全二叉树的创建以及递归遍历算法实现参考完全二叉树的结点的创建。对于这种普通的二叉树我们也可以用递归的方式去创建。先上代码，朋友们应该就明白个大概了，文本末附总结树节点的创建//全部是私有属性，这里用set、get方法返回所需要的属性。public class BTNode {//定义一个二叉树的结点p...
Java数据结构之树结构-二叉树（创建和遍历）
jiu_yu的博客
08-10 410
二叉树即每个节点子节点最多为2的树结构。 （满二叉树） （完全二叉树） 先序遍历，后续遍历，中序遍历道理是一样的，只不过顺序不同. 这里以中序遍历为例，以下是遍历的顺序，思想就是先找中间节点，再找左节点，再找右节点。但是因为每个节点都有其对应的左子树与右子树。所以找完中间节点之后应该是对其左子树应用中序遍历，再对其右子树进行中序遍历。这个思想在Java代码中体现为递归思想。 源代码 package binaryTree; /** * 树结构-二叉树（创建和遍历） * @author cx998
java：数据结构（四）二叉查找树以及树的三种遍历
weixin_30885111的博客
05-02 78
@TOC 二叉树模型 二叉树是树的一种应用，一个节点可以有两个孩子：左孩子，右孩子，并且除了根节点以外每个节点都有一个父节点。当然这种简单的二叉树不能解决让树保持平衡状态，例如你一直往树的左边添加元素，就会导致查找效率的减慢。，如何解决这个问题，下一篇文章再说。 二叉树的实现 二叉树的实现类 import java.util.LinkedList; /** * 二叉查找树 * @para...
java实现二叉树创建和遍历
03-08 1488
今天晚上我学习了java语言的二叉树创建和遍历算法。 实现的机制和上一节课差不多。 代码如下： package 二叉树链表; public class Node { private int value; private Node leftChild; private Node rightChild; public Node(int value) { super();
Java实现数据结构：二叉树操作与遍历
"实习题目涉及Java编程实现数据结构中的二叉树操作，包括前序、中序、后序遍历，计算叶子数、树高，以及左右子树交换后的遍历序列。选做题目包括非递归后序遍历、中序线索树的非递归遍历，以及根据前序和中序遍历...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

PeersLee

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值