目录
一、遍历二叉树
1、介绍
在计算机程序中,遍历本身是一个线性操作。所以遍历一个拥有线性结构的如:数组、链表,是一件很简单的事情。而二叉树是非线性数据机构,遍历时需要将非线性关联的节点转换成一个线性的结构,进行遍历。不同的方式可以遍历出不同的顺序。
2、遍历的种类
从节点位置关系:
- 前序遍历
- 中序遍历
- 后序遍历
- 层序遍历
从宏观角度来看分为两类:
- 深度优先遍历(前序、中序、后序)
- 广度优先遍历(层序遍历)
二、深度优先遍历(递归)
深度优先遍历不仅仅适用于二叉树,在树、图等一些复杂数据结构常常被用到。所谓深度优先,顾名思义,纵向遍历。
1、前序遍历
如图所示,一颗深度为3、6节点的二叉树。前序遍历优先级为由上到下,右根节点靠左遍历。
模拟前序遍历结果
- 输出根节点1 。
- 获取此节点的左孩子节点,输出节点2 。
- 再次获取左孩子节点,输出节点4。
- 节点4没有左孩子节点,也没有右孩子节点,那么回到节点2,输出2节点的右孩子节点5。
- 节点5没有左孩子节点也没右右孩子节点,那么回到节点1,输出1的右孩子节点3。
- 先看节点3有没有左孩子节点,没有则输出右孩子节点6。
- 结束遍历
2、中序遍历
还是此图作为案例,中序遍历的输出顺序是:左子树->根节点->右子树。
模拟中序遍历
- 首先访问跟节点的左孩子节点,如果左孩子节点还有左孩子,那么继续向下访问,直到不在有左孩子,则输出此节点。如图,输出节点4。
- 接着输出节点2。
- 再输出节点2的右孩子节点5。
- 根节点的左子树遍历完毕,接着输出跟节点1。
- 按照顺序,左子树和根节点都输出完毕,此时遍历右子树,按照从左到右依次输出3、6节点。
- 遍历完毕。
3、后序遍历
后序遍历,意思是从树的后方开始遍历。即从树的下方遍历。顺序:从下往上,深度优先,左子树优先,右子树其次,根节点最后。
模拟后序遍历
- 从下往上,从左子树开始,首先输出最靠右的叶子节点4。
- 其次输出节点4的同级节点5。
- 接着输出两者父节点2。
- 左子树遍历完毕,发现到了根节点,再从根节点找到右孩子,找右孩子的左孩子和右孩子,发现没有左孩子,输出右孩子节点6。
- 最后依次输出节点3、1。
4、代码实现
节点
/**
* @author chengyanqi
* @date 2020/8/6 22:44
*/
public class TreeNode {
int data;//数据
TreeNode leftChild;//左孩子
TreeNode rightChild;//右孩子
//构造方法
public TreeNode(int data) {
this.data = data;
}
}
工具类:前序、中序、后序遍历
/**
* @author chengyanqi
* @date 2020/8/6 22:45
*/
public class TreeNodeUtil {
/**
* 构建二叉树
* @param inputList 输入的队列
* @return 返回构建的node
*/
public static TreeNode createBinaryTree(LinkedList<Integer> inputList) {
TreeNode node = null;
if (null == inputList || inputList.isEmpty()) {
return null;
}
Integer data = inputList.removeFirst();
if (data != null) {
node = new TreeNode(data);
node.leftChild = createBinaryTree(inputList);
node.rightChild = createBinaryTree(inputList);
}
return node;
}
//前序遍历(由上到下)
public static void preOrderTraveral(TreeNode node) {
if (node == null) {
return;
}
System.out.println(node.data);
preOrderTraveral(node.leftChild);
preOrderTraveral(node.rightChild);
}
//中序遍历(由左到右)
public static void inOrderTraveral(TreeNode node) {
if (node == null) {
return;
}
inOrderTraveral(node.leftChild);
System.out.println(node.data);
inOrderTraveral(node.rightChild);
}
//后序遍历
public static void postOrderTraveral(TreeNode node) {
if (node == null) {
return;
}
postOrderTraveral(node.leftChild);
postOrderTraveral(node.rightChild);
System.out.println(node.data);
}
}
测试
/**
* @author chengyanqi
* @date 2020/8/6 22:54
*/
public class TreeNodeTest {
public static void main(String[] args) {
Integer[] integers = new Integer[]{3, 2, 5, null, null, 10, null, null, 8, null, 4};
List<Integer> integerList = Arrays.asList(integers);
LinkedList<Integer> linkedList = new LinkedList<>(integerList);
TreeNode binaryTree = TreeNodeUtil.createBinaryTree(linkedList);
System.out.println("前序遍历");
TreeNodeUtil.preOrderTraveral(binaryTree);
System.out.println("中序遍历");
TreeNodeUtil.inOrderTraveral(binaryTree);
System.out.println("后序遍历");
TreeNodeUtil.postOrderTraveral(binaryTree);
}
}
输出结果如下
前序遍历
3
2
5
10
8
4
中序遍历
5
2
10
3
8
4
后序遍历
5
10
2
4
8
3
构建二叉树如图
三、深度优先遍历(栈)
绝大多数可以用递归解决的问题,都可以用另一种数据结构栈来解决。
1、非递归前序遍历理论
以前序遍历为例,用栈来做深度优先遍历主要思想是以下几个步骤
- 以上图为例,首先遍历根节点1,放入栈中。
- 遍历根节点1的左孩子节点2,放入栈中
- 遍历节点2的左孩子节点4,放入栈中。
- 此时,发现节点4既没有左孩子,也没有右孩子,我们需要回溯到上一个节点2。我们可以将节点4出栈,就可以访问到2节点。再拿到2的右孩子5节点。此时2节点已经没有利用价值了,所以将2节点弹栈,将5节点入栈。
- 节点5既没有左孩子也没有右孩子,直接将5弹栈。此时只剩下节点1。找到节点1的右节点3,找到后,节点1也没有利用价值了,直接弹栈。由3节点入栈。
- 根据3节点找左孩子,没有找到。再找右孩子节点6。此时3节点没有利用价值,进行弹栈。再将节点6入栈。此时栈内只有节点6
- 节点6既没有左孩子也没有右孩子,直接进行出栈。此时栈为空,遍历结束。
以上步骤如下图表示
2、非递归前序遍历代码
/**
* 前序遍历(非递归)
*/
public static void preOrderTraveralWithStack(TreeNode root) {
Stack<TreeNode> stack = new Stack<>();
TreeNode treeNode = root;
while (treeNode != null || !stack.empty()) {
//访问节点的左孩子节点,进行入栈
while (treeNode != null) {
System.out.println(treeNode.data);
stack.push(treeNode);
treeNode = treeNode.leftChild;
}
//如果没有左孩子节点,则进行弹栈处理,访问节点的右孩子节点
if (!stack.empty()) {
treeNode = stack.pop();//弹栈
treeNode = treeNode.rightChild;
}
}
}
public static void main(String[] args) {
Integer[] integers = new Integer[]{3, 2, 5, null, null, 10, null, null, 8, null, 4};
List<Integer> integerList = Arrays.asList(integers);
LinkedList<Integer> linkedList = new LinkedList<>(integerList);
TreeNode binaryTree = TreeNodeUtil.createBinaryTree(linkedList);
TreeNodeUtil.preOrderTraveralWithStack(binaryTree);
输出:
3
2
5
10
8
4
四、广度优先遍历
如果说深度优先遍历是一个方向走到底,那么广度优先遍历就是每个方向走一步,再每个方向走两步…一直到走完。
1、层序遍历理论
顾名思义,一层一层进行遍历。遍历输出步骤如图:
广度优先遍历使用队列来实现。
文字解析
- 根节点1进入队列。
- 根节点1出队,并得到节点1的左孩子节点2和右孩子节点3.并且让2、3入队。
- 节点2出队,得到节点2的左孩子节点4和右孩子节点5,并依次4、5进行入队。
- 节点3出队,得到节点3的右孩子节点6。并让节点6入队。
- 此时队列内依次包含4、5、6三个节点,节点4没有孩子节点,所以没有新的节点加入。
- 节点5、6同理,没有孩子节点,直接进行输出。
图片解析
2、层序遍历代码
/**
* 二叉树层序遍历
* @param root 二叉树根节点
*/
public static void levelOrderTraversal(TreeNode root) {
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);//入队
while (!queue.isEmpty()) {
TreeNode pollNode = queue.poll();//出队
System.out.println(pollNode.data);
//如果有左孩子,则进行入队
if (pollNode.leftChild != null) {
queue.offer(pollNode.leftChild);
}
//如果有右孩子,则进行入队
if (pollNode.rightChild != null) {
queue.offer(pollNode.rightChild);
}
}
}
public static void main(String[] args) {
Integer[] integers = new Integer[]{3, 2, 5, null, null, 10, null, null, 8, null, 4};
List<Integer> integerList = Arrays.asList(integers);
LinkedList<Integer> linkedList = new LinkedList<>(integerList);
TreeNode binaryTree = TreeNodeUtil.createBinaryTree(linkedList);
TreeNodeUtil.levelOrderTraversal(binaryTree);
}
输出结果
3
2
8
5
10
4
五、小结
二叉树用递归方式来实现前序、中序、后续遍历,是最为自然的方式,因此代码也很简洁。
这三种遍历方式的区别,仅仅是输出的执行位置不同
- 前序遍历的输出在前
- 中序遍历的输出在中间
- 后续遍历的输出在最后