java数据结构之二叉树的遍历

最新推荐文章于 2024-03-10 21:38:04 发布
最新推荐文章于 2024-03-10 21:38:04 发布
阅读量628 收藏 7
点赞数 6
分类专栏： 数据结构 文章标签： 数据结构 二叉树 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43478315/article/details/103541308
版权

文中内容来源于《数据结构 --Java语言描述》（第二版） 刘小晶 杜选 主编
此系列文章作为学校实验记录，若文中内容有误，请大家指出，谢谢

实验目的

1、掌握二叉树的特点及其存储方式；
2、掌握二叉树的创建；
3、掌握二叉树先序、中序、后序遍历的基本方法及应用；

实验内容

1、用先序方法建立一棵二叉树；
2、实现先序、中序和后序遍历二叉树的操作；
3、实现统计二叉树叶子结点个数和计算二叉树深度的操作；

实验步骤

1、二叉链表节点类的定义；
2、二叉树类的定义；
3、建立下图所示的二叉树 abd###ce##f##
在这里插入图片描述
以字符串的形式“根左右”定义一棵二叉树时，写出创建二叉树的操作：
4、编程实现以上二叉树的先序、中序和后序遍历操作，输出遍历序列；
5、完成统计以上二叉树中叶子结点的个数或计算以上二叉树的深度；

源代码

//BiTreeNode.java
package ch5;
public class BiTreeNode {
	public Object data;
	public BiTreeNode lchild;
	public BiTreeNode 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;
	}
}

//BiTree.java
package ch5;
import ch3.LinkQuene;
import ch3.LinkStack;
public class BiTree {
	private BiTreeNode root;
	
	public BiTree() {
		this.root = null;
	}
	
	public BiTree(BiTreeNode root) {
		this.root = 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 BiTree(String preOrder,String inOrder,int preIndex,int inIndex,int count) {
		if(count>0) {
			char r = preOrder.charAt(preIndex);
			int i = 0;
			for(;i<count;i++) {
				if(r == inOrder.charAt(i + inIndex)) {
					break;
				}
			}
			root = new BiTreeNode(r);
			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;
		}
	}
	
	public boolean isEmpty() {
		return root == null;
	}
	
	public void makeEmpty() {
		root =null;
		System.out.println("二叉树已置空");
	}
	
	public BiTreeNode getRoot() {
		return root;
	}
	
	public void preRootTraverse(BiTreeNode T) {
		if(T != null) {
			System.out.print(T.data);
			preRootTraverse(T.lchild);
			preRootTraverse(T.rchild);
		}
	}
	
	public void inRootTraverse(BiTreeNode T) {
		if(T != null) {
			inRootTraverse(T.lchild);
			System.out.print(T.data);
			inRootTraverse(T.rchild);
		}
	}
	
	public void postRootTraverse(BiTreeNode T) {
		if(T != null) {
			postRootTraverse(T.lchild);
			postRootTraverse(T.rchild);
			System.out.print(T.data);
		}
	}
	
	//判断二叉树是否相等
	public boolean isEqual(BiTreeNode T1,BiTreeNode T2) {
		if(T1 == null&&T2 ==null) {
			return true;
		}
		if(T1 != null&&T2 != null) {
			if(T1.data.equals(T2.data)) {
				if(isEqual(T1.lchild,T2.lchild)) {
					if(isEqual(T1.rchild,T2.rchild)) {
						return true;
					}
				}
			}
		}
		return false;
	}
	
	//求二叉树的深度
	public int getDepth(BiTreeNode T) {
		if(T != null) {
			int lDepth = getDepth(T.lchild);
			int rDepth = getDepth(T.rchild);
			return 1 + (lDepth>rDepth ? lDepth : rDepth);
		}
		return 0;
	}
	//计算二叉树中节点的个数
	public int countNode(BiTreeNode T) {
		int count = 0;
		if(T != null) {
			++count;
			count += countNode(T.lchild);
			count += countNode(T.rchild);
		}
		return count;
	}
	//统计叶子节点
	public int countLNode(BiTreeNode T) {
		int count = 0;
		if(T != null) {
			if(T.lchild == null&&T.rchild == null) {
				++count;
			} else {
				count += countLNode(T.lchild);
				count += countLNode(T.rchild);
			}
		}
		return count;
	}
	//查找值为x的节点
	public BiTreeNode searchNode(BiTreeNode T,Object x) {
		if(T != null) {
			if(T.data.equals(x)) {
				return T;
			} else {
				BiTreeNode lresult = searchNode(T.lchild,x);
				return lresult != null ? lresult : searchNode(T.rchild,x);
			}
		}
		return null;
	}
	//交换左右子树
	public void ExchangeLR(BiTreeNode node) {
        if(node == null)
            return ;
        else{
            BiTreeNode temp = node.lchild;
            node.lchild = node.rchild;
            node.rchild = temp;
        }
        ExchangeLR(node.lchild);
        ExchangeLR(node.rchild);
    }
	public void tip() {
		System.out.println("请输入以下数字执行您想要进行的操作：");
		System.out.println("1：   判断二叉树是否为空");
		System.out.println("2：   置空二叉树");
		System.out.println("3：   获取该树的根节点");
		System.out.println("4：   先根遍历");
		System.out.println("5：   中根遍历");
		System.out.println("6：   后根遍历");
		System.out.println("7：   求二叉树深度");
		System.out.println("8：   求二叉树节点个数");
		System.out.println("9：   求二叉树叶子结点个数");
		System.out.println("10： 交换左右子树");
		System.out.println("11： 退出本次操作");
	}
}

//BiTreeTest.java
package ch5;
import java.util.Scanner;
public class BiTreeTest {
	public static void main(String[] args) {
		System.out.println("开始创建二叉树，请输入一个以“根左右”形式的字符串：");
		Scanner input = new Scanner(System.in);
//		"abd###ce##f##"
		String str = input.nextLine();
		BiTree T = new BiTree(str);
//		Object aim;
		int flag;
		String judjement;
		while(true) {
			T.tip();
			int choice = input.nextInt();
			
			switch(choice) {
				case 1://判断二叉树是否为空
					System.out.println(T.isEmpty());
					break;
				case 2://置空二叉树
					T.makeEmpty();
					break;
				case 3://获取该树的根节点
					System.out.println(T.getRoot());
					break;
				case 4://先根遍历
					T.preRootTraverse(T.getRoot());
					break;
				case 5://中根遍历
					T.inRootTraverse(T.getRoot());
					break;
				case 6://后根遍历
					T.postRootTraverse(T.getRoot());
					break;
				case 7://求二叉树深度
					System.out.println(T.getDepth(T.getRoot()));
					break;
				case 8://求二叉树节点个数
					System.out.println(T.countNode(T.getRoot()));
					break;
				case 9://求二叉树叶子结点个数
					System.out.println(T.countLNode(T.getRoot()));
					break;
				case 10://交换左右子树
					T.ExchangeLR(T.getRoot());
					System.out.println("交换成功");
					break;
				case 11://退出本次操作
					break;
				default :
					System.out.println("输入格式有误，请重新输入");
					break;
			}
			flag = 1;
			while(flag>0) {
				System.out.println();
				System.out.println("是否要结束本条链表的操作?y/n");
				judjement = input.next();
				if(judjement.equals("y"))
					break;
				else if(judjement.equals("n"))
					flag = -1;
				else
					System.out.println("输入有误");
			}
			if(flag == 1) {
				break;
			}
		}
		input.close();
		System.out.println("程序结束");
	}
}

运行结果

（运行代码有些冗长…）

开始创建二叉树，请输入一个以“根左右”形式的字符串：
abd###ce##f##
请输入以下数字执行您想要进行的操作：
1：   判断二叉树是否为空
2：   置空二叉树
3：   获取该树的根节点
4：   先根遍历
5：   中根遍历
6：   后根遍历
7：   求二叉树深度
8：   求二叉树节点个数
9：   求二叉树叶子结点个数
10： 交换左右子树
11： 退出本次操作
4
abdcef
是否要结束本条链表的操作?y/n
n
请输入以下数字执行您想要进行的操作：
1：   判断二叉树是否为空
2：   置空二叉树
3：   获取该树的根节点
4：   先根遍历
5：   中根遍历
6：   后根遍历
7：   求二叉树深度
8：   求二叉树节点个数
9：   求二叉树叶子结点个数
10： 交换左右子树
11： 退出本次操作
5
dbaecf
是否要结束本条链表的操作?y/n
n
请输入以下数字执行您想要进行的操作：
1：   判断二叉树是否为空
2：   置空二叉树
3：   获取该树的根节点
4：   先根遍历
5：   中根遍历
6：   后根遍历
7：   求二叉树深度
8：   求二叉树节点个数
9：   求二叉树叶子结点个数
10： 交换左右子树
11： 退出本次操作
6
dbefca
是否要结束本条链表的操作?y/n
n
请输入以下数字执行您想要进行的操作：
1：   判断二叉树是否为空
2：   置空二叉树
3：   获取该树的根节点
4：   先根遍历
5：   中根遍历
6：   后根遍历
7：   求二叉树深度
8：   求二叉树节点个数
9：   求二叉树叶子结点个数
10： 交换左右子树
11： 退出本次操作
9
3

是否要结束本条链表的操作?y/n
n
请输入以下数字执行您想要进行的操作：
1：   判断二叉树是否为空
2：   置空二叉树
3：   获取该树的根节点
4：   先根遍历
5：   中根遍历
6：   后根遍历
7：   求二叉树深度
8：   求二叉树节点个数
9：   求二叉树叶子结点个数
10： 交换左右子树
11： 退出本次操作
7
3

是否要结束本条链表的操作?y/n
y
程序结束
sticker_start_tag
关注
  • 6
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
二叉树的基本操作
05-31
先序遍历输入(以#结束):AB#CD##E##F#GH### 中序遍历输出:BDCEAFHG 先序遍历输出:ABCDEFGH 后序遍历输出:DECBHGFA 层序遍历输出:ABFCGDEH 树的深度:4 结点的个数:8 叶结点的个数:3
线索二叉树
dying 搁浅
10-25 484
对于具有n个结点的二叉树(如下图): abdgcef;(n=7)在2n个指针域中：abd#g###ce##f##(#=8;*child=6)而线索二叉树意在利用这些空指针存放结点在某种遍历序列下的前驱和后继信息。规则为：对于任意结点，若其左指针域为空，则用其存放前驱线索，若右为空则存放后继线索。中序线索化链表伪代码： 建立二叉链表，将每个结点的左右标志设为0； 遍历二叉链表，建立线索 #pr
Java“树结构TreeNode”用法详解，二叉树用法实现代码！！！
wwwwwmmn的博客
03-10 2322
本篇文章详细整理了TreeNode的用法，二叉树四种遍历的详细实现代码，构造二叉树，查找父节点等……
数据结构③：二叉树的操作
学徒
11-19 850
（1）输入完全二叉树的先序序列，用#代表虚结点（空指针），如ABD###CE##F##，建立二叉树的二叉链表。 （2）写出对用二叉链表存储的二叉树进行先序、中序和后序遍历的递归和非递归算法。（3）写出对用二叉链表存储的二叉树进行层次遍历算法。 （4）求二叉树的所有叶子及结点总数。 （5）求二叉树的深度。 代码： #include<stdio.h> #include<stdlib....
树、二叉树的基本操作（数据结构)
m0_57124079的博客
04-25 1783
树递归与非递归遍历、总结点数以及叶子节点数、哈夫曼树、双亲法
数据结构-树课后题-编写非递归算法，求二叉树中叶子结点的个数
h420405961的博客
10-17 2810
以先序遍历为例创建二叉树以及求叶子节点的个数 测试：ABD#G###CE##F## //编写非递归算法，求二叉树中叶子结点的个数 #include<stdio.h> #include<stdlib.h> #define MaxSize 1000 typedef struct BiTNode { char data; struct BiTNode* lchild; struct BiTNode* rchild; }BiTNode,*BiTree..
数据结构-二叉树（Java实现）
11-27
1、假设二叉树的结点值是字符，根据输入的一颗二叉树的标明了空子树的完整先根遍历序列，建立一棵以二叉链表表示的二叉树。 2、对二叉树进行先根、中根和后根遍历操作，并输出遍历序列，同时观察输出序列是否与逻辑...
java实现二叉树遍历算法（源代码）
最新发布
04-30
本文介绍了使用Java语言实现二叉树前序、中序和后序遍历的基本算法。首先，定义了一个简单的TreeNode类来表示二叉树的节点，包括节点...这些遍历算法是二叉树操作的基础，对于理解树形数据结构和算法设计具有重要意义。
图解红黑树及Java进行红黑二叉树遍历的方法
09-02
红黑树问题是各大计算机考研命题以及面试算法题目中的热门,接下来我们为大家图解红黑树及Java进行红黑二叉树遍历的方法,需要的朋友可以参考下
【java 数据结构】还不会二叉树？一篇搞定二叉树
12-21
二叉树是我们常见的数据结构之一，在学习二叉树之前我们需要知道什么是树，什么是二叉树，本篇主要讲述了二叉树，以及二叉树的遍历。 你能get到的知识点？ 1、树的介绍 2、二叉树的介绍 3、二叉树遍历的四种方法 4、...
java 二叉树遍历
11-14
使用java语言，对数据结构中的二叉树进行遍历，包含算法逻辑。
数据结构-二叉树-课后习题-编写一个递归算法，利用叶结点中空的指针域，将空结点自左向右连接成一个链表
h420405961的博客
10-22 515
思路： 将二叉树的叶子结点转换成单链表，并返回最左叶子结点的地址（链头）） 即可用先序遍历 找到结点并且将其连接连接成链表就可以了 此处先序遍历建立的二叉树为下如所示：（ABD#G###CE##F##） //---编写一个递归算法，利用叶结点中空的指针域，将空结点自左向右连接成一个链表---// //二叉链表 存储表示 #include<stdio.h> #include<stdlib.h> typedef struct BiTNode { c...
用递归和栈实现二叉树遍历（先序、中序、后序、层次）
CXR_XC的博客
11-05 2597
使用递归和栈两种方式实现二叉树的先序遍历、中序遍历、后序遍历。另外，利用队列来实现层次遍历。
二叉树非递归后序遍历的实现
hellokikiqiqi的博客
11-08 673
二叉树的非递归遍历有三种方法：先序、中序、后序，其中先序和中序非递归遍历思路基本相同，有疑问者可参考书籍或其他博客，这里讲一下重点讲一下非递归后序遍历。 其实，动笔写一下三种遍历，我们很容易就可以发现一点。假如二叉树ABD#G###CE##FH### ，则先序（根左右）：ABDGCEFH 后序（左右根）：GDBEHFCA 两者看似没多大关系，但通过图，我们可以发现后序为反向的先序，即先遍历右子树再遍历左子树，我们便可通过这个思路来完成后序遍历的实现。 想想看栈的存储方式，所以我们需要另外一...
用java实现二叉树的中序遍历（递归和迭代）
m0_57248752的博客
03-29 688
用java实现二叉树的中序遍历（递归和迭代）（有图解）
二叉树的基本操作（共21个）
CXR_XC的博客
11-04 9039
简单介绍二叉树，并给出二叉树的21种基本操作
前序遍历、中序遍历、后序遍历层序遍历详解附代码（数据结构C语言）
热门推荐
kim的博客
05-10 1万+
由于二叉树是递归定义的，显然，可以把二叉树遍历操作设计成递归算法。 从二叉树的定义可知，一棵二叉树由三部分组成:根结点，左子树和右子树。若规定D、L、R分别代表“访问根结点”、“遍历根结点的左子树”和“遍历根结点的右子树”，则共有6种组合:LDR、DLR、LRD、RDL、DRL和RLD,由于先遍历左子树和先遍历右子树在算法设计上没有本质区别，因此我们只讨论6种组合的前三种:DLR、LDR和LRD,根据遍历方法对访问根结点处理的位置不同，称这三种遍历方法分别为前序遍历(DLR)、中序遍历(L...
数据结构之二叉树的构建与遍历
zhqi9277的博客
04-26 556
按照已知二叉树，从键盘读入节点字符，建立二叉树（例如：ABD#G###CE##FH###）；分别采用先序、中序、后序、按层遍历该二叉树，分别输出遍历结果。提示：以下是本篇文章正文内容，下面案例可供参考采用递归的复杂度分析：时间复杂度为O(n)，其中n为二叉树的节点数。空间复杂度为O(h)，其中h为二叉树的高度，因为该算法使用了递归，每次递归会消耗一定的系统栈空间。未采用递归的复杂度分析：使用了栈来模拟递归过程，时间复杂度为O(n)，其中n为二叉树的节点数。
Java二叉查找树遍历（前序遍历，中序遍历，后序遍历）
timewilltell12的博客
03-30 2373
针对树这一数据结构的遍历问题主要有四种，前序遍历、中序遍历、后序遍历、层序遍历，我们主要说明一下二叉树前序、中序、后序的递归方式代码模板。 基本思想 前序遍历：根结点 —> 左子树 —> 右子树 中序遍历：左子树—> 根结点 —> 右子树 后序遍历：左子树 —> 右子树 —> 根结点 前序遍历 //前序遍历 //获取整个树中所有的键 public Queue<Key> preErgodic(){ Queue&l
java数据结构二叉树
01-05
二叉树是一种常见的数据结构，它由节点组成，每个节点最多有两个子节点：左子节点和右子节点。以下是一个简单的Java实现二叉树的例子： ```java // 定义二叉树节点类 class TreeNode { int val; TreeNode left; TreeNode right; public TreeNode(int val) { this.val = val; this.left = null; this.right = null; } } // 构建二叉树 public class BinaryTree { TreeNode root; public BinaryTree(int val) { this.root = new TreeNode(val); } // 插入节点 public void insert(int val) { TreeNode newNode = new TreeNode(val); if (root == null) { root = newNode; } else { TreeNode current = root; TreeNode parent; while (true) { parent = current; if (val < current.val) { current = current.left; if (current == null) { parent.left = newNode; return; } } else { current = current.right; if (current == null) { parent.right = newNode; return; } } } } } // 先序遍历 public void preOrderTraversal(TreeNode node) { if (node != null) { System.out.print(node.val + " "); preOrderTraversal(node.left); preOrderTraversal(node.right); } } // 中序遍历 public void inOrderTraversal(TreeNode node) { if (node != null) { inOrderTraversal(node.left); System.out.print(node.val + " "); inOrderTraversal(node.right); } } // 后序遍历 public void postOrderTraversal(TreeNode node) { if (node != null) { postOrderTraversal(node.left); postOrderTraversal(node.right); System.out.print(node.val + " "); } } } // 创建二叉树并进行遍历 public class Main { public static void main(String[] args) { BinaryTree binaryTree = new BinaryTree(5); binaryTree.insert(3); binaryTree.insert(7); binaryTree.insert(2); binaryTree.insert(4); binaryTree.insert(6); binaryTree.insert(8); System.out.println("先序遍历结果："); binaryTree.preOrderTraversal(binaryTree.root); System.out.println(); System.out.println("中序遍历结果："); binaryTree.inOrderTraversal(binaryTree.root); System.out.println(); System.out.println("后序遍历结果："); binaryTree.postOrderTraversal(binaryTree.root); System.out.println(); } } ``` 这个例子展示了如何构建一个二叉树，并对其进行先序、中序和后序遍历。你可以根据需要修改节点的值和插入顺序来构建不同的二叉树。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值