Java数据结构——二叉数的遍历

已于 2022-03-10 14:18:42 修改
阅读量1k 收藏
点赞数 1
分类专栏： Java数据结构 文章标签： java 二叉树
于 2021-12-31 13:23:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51184516/article/details/122254406
版权

文章目录

二叉树的遍历

1. 几种遍历方法

1.1 深度遍历：

  1. 先序遍历二叉树的操作定义为:
    若二叉树为空,则空操作;否则
    (1)访问根结点；
    (2)先序遍历左子树；
    (3)先序遍历右子树。
  2. 中序遍历二叉树的操作定义为:
    若三叉树为空,则空操作;否则
    (1)中序遍历左子树；
    (2)访问根结点；
    (3)中序遍历右子树。
  3. 后序遍历二叉树的操作定义为
    若二叉树为空,则空操作;否则
    (1)后序遍历左子树；
    (2)后序遍历右子树；
    (3)访问根结点。

1.2 广度遍历

  1. 层次遍历
    (1)严格的从左至右
    (2)从上到下

1.3 例子

在这里插入图片描述

  • 先序遍历：1 2 4 3 5
  • 中序遍历：4 2 1 3 5
  • 后序遍历：4 2 5 3 1
  • 层次遍历：1 2 3 4 5

2. 二叉树的遍历C语言实现

2.1 先序遍历

// 先序遍历
void PreorderTraversal(BiTree T) {
	if(T) {
		printf("%d ",T->data);
		PreorderTraversal(T->lchild);
	    PreorderTraversal(T->rchild);
	}
}

2.2 中序遍历

// 中序遍历
void InorderTraversal(BiTree T) {
	if(T) {
		InorderTraversal(T->lchild);
		printf("%d ",T->data);
	    InorderTraversal(T->rchild);
	}	
}

2.3 后序遍历

// 后序遍历
void PostorderTraversal(BiTree T) {
	if(T) {
		PostorderTraversal(T->lchild);
	    PostorderTraversal(T->rchild);
	    printf("%d ",T->data);
	}
}

2.4 层次遍历

  • 法一：
// 层次遍历
void LevelorderTraversal(BiTree T) {
	if(T) {
		// 不用队列，只能取数组了
		BiTree B[100];
		// 根节点第一个
		B[0] = T;
		// 巧妙之处 
		int first = 0;
		int after = 1;
		// 循环 
		while(first < after) {
			printf("%d ",B[first]->data);
			if(B[first]->lchild) {
				B[after] = B[first]->lchild;
				after++;
			} // of if for lchild
			if(B[first]->rchild) {
				B[after] = B[first]->rchild;
				after++;
			} // of if for rchild
			first++;			
		} // end while
	} // end if
} // end LevelorderTraversal
  • 法二：
//层次遍历
void LevelorderTraversal( BiTree T )
{
	BiTree a[100];
	int i = 0 ,j = 0;
	a[0] = T;
	while(T)
	{
		if(T->lchild!=NULL) a[++i] = T->lchild;
		if(T->rchild!=NULL) a[++i] = T->rchild;
		BiTree t = a[j];
		printf(" %d",t->data);
		if(i==j) break;
		j++;
		T = a[j];
	}
}

2.5 测试

2.5.1 源码
#include<stdio.h>
#include<malloc.h>

typedef int TElemType;

// 二叉树的二叉链表存储表示
typedef struct BiTNode {
	TElemType data;
	struct BiTNode *lchild, *rchild;
}BiTNode, *BiTree;
void CreateBiTree(BiTree &T) {
	// 
	T = (BiTree)malloc(sizeof(BiTNode));
	// 
	TElemType data;
	scanf("%d",&data);
	if(data == -1) T = NULL;
	if(T) {
		T->data = data;
		printf("输入%d节点的左子节点：\n",data);
		CreateBiTree(T->lchild);
		printf("输入%d节点的右子节点：\n",data);
		CreateBiTree(T->rchild);		 
	} // end if
} // end CreateBiTree

// 先序遍历
void PreorderTraversal(BiTree T) {
	if(T) {
		printf("%d ",T->data);
		PreorderTraversal(T->lchild);
	    PreorderTraversal(T->rchild);
	}
}
// 中序遍历
void InorderTraversal(BiTree T) {
	if(T) {
		InorderTraversal(T->lchild);
		printf("%d ",T->data);
	    InorderTraversal(T->rchild);
	}	
}
// 后序遍历
void PostorderTraversal(BiTree T) {
	if(T) {
		PostorderTraversal(T->lchild);
	    PostorderTraversal(T->rchild);
	    printf("%d ",T->data);
	}
}
// 层次遍历
void LevelorderTraversal(BiTree T) {
	if(T) {
		// 不用队列，只能取数组了
		BiTree B[100];
		// 根节点第一个
		B[0] = T;
		// 巧妙之处 
		int first = 0;
		int after = 1;
		// 循环 
		while(first < after) {
			printf("%d ",B[first]->data);
			if(B[first]->lchild) {
				B[after] = B[first]->lchild;
				after++;
			} // of if for lchild
			if(B[first]->rchild) {
				B[after] = B[first]->rchild;
				after++;
			} // of if for rchild
			first++;			
		} // end while
	} // end if
} // end LevelorderTraversal

int main(void) {
	printf("输入根节点：\n");
	BiTree T;
	CreateBiTree(T);
	printf("先序遍历：");
	PreorderTraversal(T); printf("\n");
	printf("中序遍历：");
	InorderTraversal(T); printf("\n");
	printf("后序遍历：");
	PostorderTraversal(T); printf("\n");
	printf("层次遍历：");
	LevelorderTraversal(T); printf("\n");
	return 0;
}
2.5.2 输出样例

在这里插入图片描述

3. 二叉树的遍历Java语言实现

3.1 先序遍历

	/**
	 * 先序遍历
	 */
	public void PreorderTraversal() {
		System.out.print(data + " ");
		if(lchild != null) {
			lchild.PreorderTraversal();
		}
		if(rchild != null) {
			rchild.PreorderTraversal();
		}
	}

3.2 中序遍历

	/**
	 * 中序遍历
	 */
	public void InorderTraversal() {
		if(lchild != null) {
			lchild.InorderTraversal();
		}
		System.out.print(data + " ");
		if(rchild != null) {
			rchild.InorderTraversal();
		}
	}

3.3 后序遍历

	/**
	 * 后序遍历
	 */
	public void PostorderTraversal() {
		if(lchild != null) {
			lchild.PostorderTraversal();
		}
		if(rchild != null) {
			rchild.PostorderTraversal();
		}
		System.out.print(data + " ");
	}

3.4 层次遍历

	/**
	 * 层次遍历
	 * @param T
	 */
	public static void LevelorderTraversal(BiTree T) {
		if(T != null) {
			// 不用队列，只能取数组了
			BiTree[] B = new BiTree[100];
			// 根节点第一个
			B[0] = T;
			// 巧妙之处 
			int first = 0;
			int after = 1;
			// 循环 
			while(first < after) {
				System.out.printf("%d ",B[first].data);
				if(B[first].lchild != null) {
					B[after] = B[first].lchild;
					after++;
				} // of lchild
				if(B[first].rchild != null) {
					B[after] = B[first].rchild;
					after++;
				} // of rchild
				first++;			
			} // end while
		} // end if
		
	} // end LevelorderTraversal

3.5 测试

3.5.1 源码
package datastructure.binarytree;

public class BinaryTree {

	/** 二叉树的数据域 */
	int data;

	/** 左孩子 */
	BinaryTree lchild;

	/** 右孩子 */
	BinaryTree rchild;

	/** 无参构造器 */
	BinaryTree() {
	}

	/**
	 * 构造一个根节点
	 * 
	 * @param elem
	 */
	BinaryTree(int elem) {
		data = elem;
		lchild = null;
		rchild = null;
	}

	/**
	 * 二叉树的存储
	 * 
	 * @return 二叉树
	 */
	public BinaryTree createBinaryTree() {

		// 创建根节点
		BinaryTree root = new BinaryTree(1);

		// 创建树枝，值域
		BinaryTree T_l = new BinaryTree(2);
		BinaryTree T_r = new BinaryTree(3);
		BinaryTree T_l_l = new BinaryTree(4);
		BinaryTree T_r_r = new BinaryTree(5);

		// 指针域
		root.lchild = T_l;
		root.rchild = T_r;
		T_l.lchild = T_l_l;
		T_r.lchild = T_r_r;

		return root;
	} // createBinaryTree

	/**
	 * 先序遍历
	 */
	public void preOrderTraverse() {
		System.out.print(data + " ");
		if (lchild != null) {
			lchild.preOrderTraverse();
		}
		if (rchild != null) {
			rchild.preOrderTraverse();
		}
	}

	/**
	 * 中序遍历
	 */
	public void inOrderTraverse() {
		if (lchild != null) {
			lchild.inOrderTraverse();
		}
		System.out.print(data + " ");
		if (rchild != null) {
			rchild.inOrderTraverse();
		}
	}

	/**
	 * 后序遍历
	 */
	public void postOrderTraverse() {
		if (lchild != null) {
			lchild.postOrderTraverse();
		}
		if (rchild != null) {
			rchild.postOrderTraverse();
		}
		System.out.print(data + " ");
	}

	/**
	 * 层次遍历
	 * 
	 * @param T
	 */
	public static void levelOrderTraverse(BinaryTree T) {
		if (T != null) {
			// 不用队列，只能取数组了
			BinaryTree[] B = new BinaryTree[100];
			// 根节点第一个
			B[0] = T;
			// 巧妙之处
			int first = 0;
			int after = 1;
			// 循环
			while (first < after) {
				System.out.printf("%d ", B[first].data);
				if (B[first].lchild != null) {
					B[after] = B[first].lchild;
					after++;
				}
				if (B[first].rchild != null) {
					B[after] = B[first].rchild;
					after++;
				}
				first++;
			}
		} // end if
	}

	public static void main(String[] args) {
		BinaryTree BT = new BinaryTree();
		BinaryTree binarytree = BT.createBinaryTree();

		System.out.print("先序遍历：");
		binarytree.preOrderTraverse();
		System.out.println();

		System.out.print("中序遍历：");
		binarytree.inOrderTraverse();
		System.out.println();

		System.out.print("后序遍历：");
		binarytree.postOrderTraverse();
		System.out.println();

		System.out.print("层次遍历：");
		levelOrderTraverse(binarytree);
		System.out.println();
	}

} // BinaryTree
3.5.2 输出样例

在这里插入图片描述

姜满月
关注
专栏目录
【数据结构】—二叉树遍历
四季轮换叶，一路招摇胜
05-01 1148
树是由n(n>=0)个结点所构成的有限集合。对于一颗非空树，其中有且仅有一个没有前驱的结点，这个结点就是【根节点】，其余结点有且仅有一个前驱，但可以有多个后继。今天讲解一下二叉树的三种遍历方法...
Java—数据结构之二叉搜索树
m0_68840064的博客
11-18 1159
在Java数据结构之二叉搜索树的学习中，我通过总结以及查阅资料，对以下问题有了更深一层的理解。什么是二叉搜索树，二叉搜索树有什么样的性质以及特点？二叉搜索树该如何进行查找，插入及删除？二叉搜索树的时间复杂度该如何计算？如果你在Java数据结构之二叉搜索树的学习中，也想对这些问题有一个更深的了解，请阅读这篇文章，或许会对你有所启发。二叉搜索树又叫二叉排序树，它或是一颗空树，或是具有以下性质的二叉树若它的左子树不为空，则左子树上的所有结点都小于根结点上的值。
用Java实现二叉树的深度优先、广度优先遍历
03-16
NULL 博文链接：https://redhacker.iteye.com/blog/413606
求二叉树的一条最长路径
心中的利剑：HTML5 Canvas游戏动画（JavaScript）
08-15 426
[code="java"]import java.util.*; public class BinaryTree { protected Node root; public BinaryTree(Node root) { this.root = root; } public No...
145. 二叉树的后序遍历
qq_43808588的博客
08-26 113
题目 给定一个二叉树，返回它的后序遍历。 代码 /** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int val, TreeN..
java有序二叉树的深度优先遍历和广度优先遍历
m566666的博客
01-02 1571
有序二叉树有两种遍历方法： 1、深度优先遍历 深度优先遍历又分为：1.先序遍历2.中序遍历3.后序遍历 如下代码为树的节点类： public class TreeNode { public TreeNode leftNode; public TreeNode rightNode; public Integer val; public TreeNode(Integer val) { this.val=val; } } 我们要通过下面的顺序对有序二叉树进行输出，通过递归是最好的方法。
Java二叉树-深度优先遍历
weixin_44772874的博客
10-03 391
深度优先遍历： 前序遍历： 根 + 左子树的前序遍历 + 右子树的前序遍历 public static void preOrderTraversal(Node root) { if (root == null) { return; } System.out.println(root); preOrderTraversal(root.left); ...
数据结构课程设计——树的遍历
09-13
"数据结构课程设计——树的遍历"这一主题聚焦于树这种非线性数据结构的一个核心操作：遍历。两江大学出版社可能提供了深入的教程或实践项目，让学生通过实际操作来理解和掌握树的遍历方法。 树是一种由节点（也称为...
Java数据结构复习：二叉树遍历详解
这篇笔记主要探讨了Java中的数据结构——二叉树及其遍历方法。二叉树是一种非线性数据结构，每个节点最多有两个子节点，通常分为左子节点和右子节点。在计算机科学中，二叉树广泛应用于搜索、排序和组织数据等方面。...
数据结构（十三）——二叉排序树
North_City_的博客
08-20 728
二叉排序树（BST）: (Binary Sort(Search) Tree), 对于二叉排序树的任何一个非叶子节点， 要求左子节点的值比当前节点的值小， 右子节点的值比当前节点的值大。 特别说明： 如果有相同的值， 可以将该节点放在左子节点或右子节点 比如针对数据 (7, 3, 10, 12, 5, 1, 9) ， 对应的二叉排序树为： 二叉排序树的建立与遍历 package binarysorttreee; public class BinarySortTreeDemo { public stat
Java实现二叉树深度优先遍历和广度优先遍历
小太阳啊凯的博客
12-17 328
话不多说，上代码 1.广度优先遍历 /** public class TreeNode { int val = 0; TreeNode left = null; TreeNode right = null; public TreeNode(int val) { this.val = val; } } */ public class S...
java使用栈结构实现二叉树的深度优先遍历
1号帅比的博客
06-05 1863
/** * 深度优先遍历 * 辅助数据结构：栈 * @param root */ public void depthOrderTraversal(TreeNode root) { if(root==null) { return ; } Stack&lt;TreeNode&gt; stack=new Stack&lt;TreeNode...
二叉树深度优先遍历和广度优先遍历（Java实现）
Dive Deep into The Knowledge
12-06 868
结点类 private static class TreeNode { private int value; TreeNode left, right; public TreeNode(int value) { this.value = value; } }   构建二叉树 ...
数据结构 | 二叉树遍历（Java）
xxzaa的博客
04-21 991
二叉树的节点定义
java手动构建二叉树并实现广度遍历、深度遍历（前序中序后序）
you do ,you win
04-21 2031
文章目录什么是二叉树属性节点TreeNode手动构建如下所示二叉树遍历广度遍历算法思想实现细节深度遍历先序遍历（根左右）算法思想实现细节中序遍历（左根右）算法思想实现细节后续遍历（左右根）算法思想实现细节 什么是二叉树 在计算机科学中，树是一种重要的非线性数据结构，直观的看，它是数据元素按分支关系组织起来的结构。二叉树是每个节点最多有两个子树的有序树。通常子树的根被称作“左子树”和“右子树”。二叉树常被用做二叉查找树和二叉堆或是二叉排序树。二叉树的每个节点至多只有两颗子树，二叉树有左右之分，次序不能颠倒。
java二叉树实现、遍历、求深度
nelly
03-09 194
import java.util.*;class node{int data;node lchild;node rchild;public node(int value){data=value;lchild=null;rchild=null;}}class BiTree{ArrayList nodeList;//nodelist即为树public BiTree(int[] a){//传入一个数组n
Java二叉树构建及深度优先遍历和广度优先遍历
Gahui~
08-14 2176
1.工程目录如下： 2.定义节点信息的类：TreeNode.java package binarytree; public class TreeNode{ public TreeNode() { // TODO Auto-generated constructor stub } int value; TreeNode left; TreeNode right; publ...
[java]二叉树构建、遍历、深度、平衡性
VictorLee
08-27 444
package tree;/** * 2017-3-15 * 剑指ｏffer-Ｐ５５ * @author victorlee * */ public class ConstructTree{ public Tree construct(int[] pre,int[] in){ if(pre.length ==0 || in.length == 0)
java二叉树前中后深度广度五种遍历方式记录
石头也有呆毛~~
07-27 334
看代码即可 /** * 前序遍历，递归实现 */ public void preOrder(TreeNode node){ if(node != null){ System.out.println(node.val); preOrder(node.left); preOrde...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

姜满月

鼓励，鼓励，更加努力

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

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

打赏作者

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

抵扣说明：

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

余额充值