树的遍历

最新推荐文章于 2024-04-23 13:01:43 发布
最新推荐文章于 2024-04-23 13:01:43 发布
阅读量244 收藏 2
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42079455/article/details/89103878
版权

1、树的遍历方式
二叉树的定义是递归的，一棵非空的二叉树是由根节点、左子树、右子树3个基本部分组成的，因此遍历一棵非空的二叉树的问题可分解为3个子问题：访问根节点、遍历左子树和遍历右子树。
遍历分为3种：
在这里插入图片描述
遍历结果：
（1）前序遍历二叉树: A B D E H J K M C F G
（2）中序遍历二叉树: D B H E K J M A F C G
（3）后续遍历二叉树: D H K M J E B F G C A
2、树的递归遍历
2.1、先序遍历
思路：若二叉树为空树，则空操作；否则，（1）访问根结点（或输出当前节点的值）；（2）先序遍历左子树；（3）先序遍历右子树。
代码：

// 递归先序遍历
	public static void preOrder(Node node) {
		if (node != null) {
			System.out.print(node.getData() + " ");
			preOrder(node.left);
			preOrder(node.right);
		}
	}

2.2、中序遍历
思路：若二叉树为空树，则空操作；否则，（1）先序遍历左子树；（2）访问根结点（或输出当前节点的值）；（3）先序遍历右子树。
代码：

	// 递归中序遍历
	public static void inOrder(Node node) {
		if (node!= null) {
			inOrder(node.getLeft());
			System.out.print(node.getData() + " ");
			inOrder(node.getRight());
		}
	}

2.3、后序遍历
思路：若二叉树为空树，则空操作；否则，（1）先序遍历左子树；（2）先序遍历右子树；（3）访问根结点（或输出当前节点的值）；
代码：

	// 递归后序遍历
	public static void postOrder(Node node) {
		if (node != null) {
			postOrder(node.left);
			postOrder(node.right);
			System.out.print(node.getData() + " ");
		}
	}

3、树的非递归遍历
3.1、先序遍历非递归算法
思路：
1.若根结点不为空，则将根节点放入栈

2.取出根结点，输出其值

3.若右儿子非空，将右儿子放入栈之后，若左儿子非空再将左儿子放入栈

4.若栈不为空，则获取栈顶的结点，输出该结点的值

5.若右儿子非空，将右儿子放入栈之后，若左儿子非空再将左儿子放入栈

6.步骤4和5不断重复，直到结束条件:栈空，也就是树遍历完成;

注意：因为栈是先进后出的，所以我们要先把右儿子放入栈之后，在放入左儿子，这样就保证了，先遍历左子树，在遍历有子树
代码：

// 非递归先序遍历
	public static void preOrder2(Node root) {
		Stack<Node> s = new Stack<Node>();
		if (root != null)
			s.push(root);
		// 因为栈是先进后出的，所以先放右儿子在放左儿子
		while (!s.isEmpty()) {
			root = s.pop();
			System.out.print(root.getData() + " ");
			// 将右儿子放入栈
			if (root.right != null) {
				s.push(root.right);
			}
			// 将左儿子放入栈
			if (root.left != null) {
				s.push(root.left);
			}
		}
	}

3.2、中序遍历非递归算法
代码：

// 非递归中序遍历
	public static void inOrder2(Node root) {
		Stack<Node> s = new Stack<Node>();
		Node curNode = root;
		while (curNode != null || s.size() > 0) {
			while (curNode != null) {
				s.push(curNode);
				curNode = curNode.left;
			}
			if (s.size() > 0) {
				curNode = s.pop();
				System.out.print(curNode.getData() + " ");
				curNode = curNode.right;
			}
		}
	}

3.3、后序遍历非递归算法
代码：

// 非递归后序遍历
	public static void postOrder2(Node root) {
		Stack<Node> s = new Stack<Node>();
		Node curNode = root;
		Node preNode = root;
		while (curNode != null || s.size() > 0) {
			while (curNode != null) {
				s.push(curNode);
				curNode = curNode.left;
			}
			if (s.size() > 0) {
				Node tmpNode = s.peek().right;
				if (tmpNode == null || tmpNode == preNode) {
					curNode = s.pop();
					System.out.print(curNode.getData() + " ");
					preNode = curNode;
					curNode = null;
				} else {
					curNode = tmpNode;
				}
			}
		}
	}

4、二叉树的构造代码
二叉树的构造在我以前的博客里有的，有兴趣的可以看看，附上链接：
树的构造相关知识链接
下面是我写的一个关于树的遍历的一个完整代码，欢迎各位大佬指出错误！

package com.wd.digui;

import java.util.Stack;

public class Wd_27 {

	public static void main(String[] args) throws Exception {
		// 构造一颗二叉树
		binaryTree root = new binaryTree('A');
		Node node2 = root.add(root.getRoot(), 'B', true);
		root.add(node2, 'D', true);
		Node node3 = root.add(node2, 'E', false);
		root.add(node3, 'H', true);
		Node node4 = root.add(node3, 'J', false);
		root.add(node4, 'K', true);
		root.add(node4, 'M', false);
		Node node5 = root.add(root.getRoot(), 'C', false);
		root.add(node5, 'F', true);
		root.add(node5, 'G', false);

		System.out.print("前序递归遍历：");
		preOrder(root.getRoot());
		System.out.println();

		System.out.print("中序递归遍历：");
		inOrder(root.getRoot());
		System.out.println();

		System.out.print("后序递归遍历：");
		postOrder(root.getRoot());
		System.out.println();

		System.out.print("前序非递归遍历：");
		preOrder2(root.getRoot());
		System.out.println();

		System.out.print("中序非递归遍历：");
		inOrder2(root.getRoot());
		System.out.println();

		System.out.print("后序非递归遍历：");
		postOrder2(root.getRoot());
	}

	// 递归先序遍历
	public static void preOrder(Node node) {
		if (node != null) {
			System.out.print(node.getData() + " ");
			preOrder(node.left);
			preOrder(node.right);
		}
	}

	// 递归中序遍历
	public static void inOrder(Node node) {
		if (node!= null) {
			inOrder(node.getLeft());
			System.out.print(node.getData() + " ");
			inOrder(node.getRight());
		}
	}

	// 递归后序遍历
	public static void postOrder(Node node) {
		if (node != null) {
			postOrder(node.left);
			postOrder(node.right);
			System.out.print(node.getData() + " ");
		}
	}

	// 非递归先序遍历
	public static void preOrder2(Node root) {
		Stack<Node> s = new Stack<Node>();
		if (root != null)
			s.push(root);
		// 因为栈是先进后出的，所以先放右儿子在放左儿子
		while (!s.isEmpty()) {
			root = s.pop();
			System.out.print(root.getData() + " ");
			// 将右儿子放入栈
			if (root.right != null) {
				s.push(root.right);
			}
			// 将左儿子放入栈
			if (root.left != null) {
				s.push(root.left);
			}
		}
	}

	// 非递归中序遍历
	public static void inOrder2(Node root) {
		Stack<Node> s = new Stack<Node>();
		Node curNode = root;
		while (curNode != null || s.size() > 0) {
			while (curNode != null) {
				s.push(curNode);
				curNode = curNode.left;
			}
			if (s.size() > 0) {
				curNode = s.pop();
				System.out.print(curNode.getData() + " ");
				curNode = curNode.right;
			}
		}
	}

	// 非递归后序遍历
	public static void postOrder2(Node root) {
		Stack<Node> s = new Stack<Node>();
		Node curNode = root;
		Node preNode = root;
		while (curNode != null || s.size() > 0) {
			while (curNode != null) {
				s.push(curNode);
				curNode = curNode.left;
			}
			if (s.size() > 0) {
				Node tmpNode = s.peek().right;
				if (tmpNode == null || tmpNode == preNode) {
					curNode = s.pop();
					System.out.print(curNode.getData() + " ");
					preNode = curNode;
					curNode = null;
				} else {
					curNode = tmpNode;
				}
			}
		}
	}
}

// 二叉树类
class binaryTree {
	// root表示根结点
	private Node root;

	public binaryTree(Object data) {
		root = new Node(data);
	}

	// 为指定的结点添加子节点
	public Node add(Node parent, Object data, boolean isLeft) throws Exception {
		if (parent == null || parent.data == null) {
			throw new Exception("结点为空不能添加子结点！");
		}
		Node node = null;
		if (isLeft) {
			if (parent.left != null) {
				throw new Exception("左结点不为空不能添加结点！");
			} else {
				node = new Node(data);
				parent.left = node;
			}
		} else {
			if (parent.right != null) {
				throw new Exception("右结点不为空不能添加结点！");
			} else {
				node = new Node(data);
				parent.right = node;
			}
		}
		return node;
	}

	// 判断树是否为空
	public boolean isEmpty() {
		return root.data == null;
	}

	// 获取根节点
	public Node getRoot() {
		if (isEmpty()) {
			throw new RuntimeException("树为空，不能获取根节点");
		}
		return root;

	}
}

// 树节点类
class Node {
	Object data;// 数据域
	Node left;// 左儿子
	Node right;// 右儿子

	public Node() {

	}

	public Node(Object data) {
		super();
		this.data = data;
		this.left = null;
		this.right = null;
	}

	public Node(Object data, Node left, Node right) {
		super();
		this.data = data;
		this.left = left;
		this.right = right;
	}

	public Object getData() {
		return data;
	}

	public void setData(Object data) {
		this.data = data;
	}

	public Node getLeft() {
		return left;
	}

	public void setLeft(Node left) {
		this.left = left;
	}

	public Node getRight() {
		return right;
	}

	public void setRight(Node right) {
		this.right = right;
	}

}

运行结果：在这里插入图片描述
跟详细的参考：
树的遍历

奔跑的蜗牛@1997
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
三叉树多叉树遍历
04-21
三叉树多叉树遍历 c# 2.0
树及其遍历
世界仙境与冷酷尽头's Blog
07-29 211
DSA树
MySQL索引结构（1）：搞懂二叉树（遍历方式）
祝我飞黄腾达
05-17 1770
二叉树的由来 在 jdk1.8 之前，HashMap 的数据结构由「数组+链表」组成，数组是 HashMap 的主体，链表是为了解决 Hash 冲突引入的，正常的数据存放是直接存在数组中，但如果发生 Hash 冲突就会以链表的形式进行存储，而在 jdk1.8之后，当链表的长度超过 8 之后，将会转换成红黑树存储。 清楚HashMap八股文的小伙伴应该知道，为何随着版本的迭代会引入不同的数据结构呢？ 数组 > 链表 > 树 ✧ 数组 优点 缺点 简单易用，随机访问性强
数据结构 12-树的遍历
一分耕耘一分收获
06-09 253
定义：按照一定次序访问树中所有节点，并 且每个节点仅被访问一次的过程。请注意，现在还没有说到树的物理存储结构，所说的遍历都是逻辑结构上的遍历。 遍历是最基本的运算，是树中所有其他运算的基础。 树的分类方式可以分为两种，一种是深度遍历方式 DFS，一种是广度遍历方式 BFS（层次遍历方式）。 深度遍历是一种使用固定规则，从根节点出发以遍历每条子树从而遍历完整棵树的方式。 前面说了树是可以递归的，当从根出发时候，就会形成对子树的递归。 而层次遍历方式更好理
三、高级数据结构和算法：树的遍历
小脑斧的博客
06-16 1260
树的遍历（递归和迭代）
树的遍历（四种全）｜C++
热门推荐
taoxing
02-15 2万+
一.树的遍历 树的遍历也叫树的搜索，是指按照某种规则对树的节点进行一遍不重复的访问。按照不同的方式可以分为树的前序遍历、中序遍历、后序遍历和层序遍历。 二.前序遍历 1）树的前序遍历指的是对树按照根、左、右的规律进行访问。 遍历结果为：F, B, A, D, C, E, G, I, H 2）递归代码实现（对于前序、中序、后序遍历的递归实现非常的相似，只是改变输出数组语句的位置） //存储遍历结果的数组 vector<int> v; //前序遍历函数 vector<int
数据结构——树的遍历
K.Sun
11-26 5066
原文地址：Tree Traversals 不像线性数据结构（数组，列表，队列，堆栈等），它们在逻辑上只有一种遍历方式，树可以有不同的遍历方式。下面就是遍历树的一般所用的方法： 深度优先遍历： 1）中序遍历（Left, Root, Right）：4 2 5 1 3 2）先序遍历（Root, Left, Right）：1 2 4 5 3 3）后序遍历（Left, Right, Root）
树的四种遍历方式
小叮当不懒的博客
09-28 4766
目录树的四种遍历方式先序遍历中序遍历后序遍历层序遍历 不积跬步，无以至千里；不积小流，无以成江海。要沉下心来，诗和远方的路费真的很贵！ 树的四种遍历方式 树的遍历方式一般来说有四种： 先序遍历 中序遍历 后序遍历 层序遍历 只有层序遍历是属于广度优先搜索，剩下三个都是深度优先搜索的。 先序遍历 以最简单的二叉树进行遍历测试，可能在树的构建上很粗糙，主要表达遍历树的思想。 树的结构类 package com.hnu; //数据结构树，封装 public class TreeNode { //结
遍历目录树 遍历目录树 遍历目录树 遍历目录树
02-17
遍历目录树 遍历目录树 遍历目录树 遍历目录树
deepdash:eachDeep，filterDeep，findDeep，someDeep，omitDeep，pickDeep，keysDeep等。以UnderscoreLodash方式编写的树遍历库
04-29
以Underscore / Lodash方式编写的树遍历库。 独立或作为Lodash mixin扩展 安装 在浏览器中 在Lodash之后加载，然后将lodash实例传递给deepdash函数： < script src =" ...
多叉树 遍历
05-25
NULL 博文链接：https://zw7534313.iteye.com/blog/473446
string模拟实现
最新发布
m0_73969414的博客
04-23 781
c++中string的模拟实现，面试必会知识点
【1524】java投票管理系统Myeclipse开发mysql数据库web结构java编程计算机网页项目
qq_251836457的博客
04-18 777
2、开发环境为TOMCAT7.0,Myeclipse8.5开发，数据库为Mysql5.0，使用java语言开发。(5)投票选项管理：对投票选项信息进行添加、删除、修改和查看。(6)投票记录管理：对投票记录信息进行添加、删除、修改和查看。(1)管理员管理：对管理员信息进行添加、删除、修改和查看。(2)用户管理：对用户信息进行添加、删除、修改和查看。(3)公告管理：对公告信息进行添加、删除、修改和查看。(4)投票管理：对投票信息进行添加、删除、修改和查看。4）投票浏览查看、查看投票、投票记录。
javaweb-SpringBoot基础
kussm_的博客
04-20 1053
Spring的官网(Spring的简介：Spring makes Java simple。Spring Boot 可以帮助我们非常快速的构建应用程序、简化开发、提高效率。创建一个子包controller。
2.8 构建gradle环境
蚊者逆袭的博客
04-18 2227
Gradle是一种现代化的构建工具，用于自动化地构建、测试和部署软件项目。它是一种基于JVM（Java虚拟机）的构建工具，最初是为了解决Apache Ant和Apache Maven等传统构建工具的一些限制而开发的。
Web前端 Javascript笔记5
cycyzh的博客
04-18 952
script>'console.log("哈哈哈佳人们好困")'}, 3000)​let t1 = setTimeout('console.log("你们看到这句话的时候我早已身价百万！！")', 4000)​</script>3秒，四秒后出来的东西，出现前会返回计时器编号。
树遍历的递归Python代码
03-25
以下是树遍历的递归Python代码： ```python class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right def in_order_traversal(root): if root: in_order_traversal(root.left) print(root.val) in_order_traversal(root.right) root = TreeNode(1, TreeNode(2), TreeNode(3)) in_order_traversal(root) ``` 这段代码可以进行中序遍历的递归实现，输出节点的 value 值。 请注意，这段代码只是示例，可能存在语法错误，仅供参考。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值