二叉树遍历
二叉树是一种很重要的数据结构, 二叉树的遍历又是二叉树的重要算法
- 递归方法, 利用递归, 二叉树的前、中、后序遍历大致都是几行代码就可以实现。但是递归算法虽然方便了我们思考,却增大了机器跑代码的负担。
void preorder(BinTree<T> tr) { // 前序遍历
if(tr == null) return;
visit(tr.data); // 改变visit位置即可
preorder(tr.lChild);
preorder(tr.rChild);
}
递归算法看起来很优雅,但涉及多层次函数调用,编译器支持尾递归优化则还好,如果不支持尾递归,那么·这种算法的时间复杂度O(n)的常数项还是挺大的。
- 递归算法的实现基础是栈内存的使用,如果我们人为的结合栈数据结构,则可以实现迭代算法
- 前序遍历
- 中序遍历
- 后序遍历
- 层序遍历
Java算法实现
package com.codevs.learn;
import java.util.*;
import java.util.function.Consumer;
/**
* 二叉树遍历方法, 非递归
* 前序遍历, 中序遍历可以从遍历顺序上考虑, 结合栈的特性
* 后序遍历的实现稍微复杂一点, 除了遍历顺序, 还要考虑节点的重复遍历
*/
public class BinTree<T> { // 简单结构
BinTree<T> lChild;
BinTree<T> rChild;
T data;
/**
* 考虑前序遍历的特点: 先从左分支依次访问所有节点, 然后逆序依次访问右子树(可循环部分), 而逆序符合栈的特点
*/
public static <T> void preorder(BinTree<T> tr, Consumer<T> c) {
Deque<BinTree<T>> stack = new LinkedList<>();
while(true) {
while(tr != null) { // 沿左分支依次遍历, 将右子节点入栈
c.accept(tr.data);
if(tr.rChild != null) { // Deque不允许null数据, 否则这里也可以直接入栈
stack.push(tr.rChild);
}
tr = tr.lChild;
}
if(stack.isEmpty()) { // 栈空表示遍历完成
break;
}
tr = stack.pop(); // 左分支遍历完,对栈顶右子树做相同遍历
}
}
/**
* 考虑中序遍历: 先找左节点, 即也要沿左分支找底层节点, 然后逆序访问(左 根 右)
*/
public static <T> void midorder(BinTree<T> tr, Consumer<T> c) {
Deque<BinTree<T>> stack = new LinkedList<>();
while(true) {
while(tr != null) { // 沿左分支找底层左节点
stack.push(tr);
tr = tr.lChild;
} // 此处栈顶即下一个要处理的节点(左 根 右)
if(stack.isEmpty()) { // 栈空表示遍历完成
break;
}
tr = stack.pop(); // 左子树遍历完成
c.accept(tr.data);
tr = tr.rChild; // 遍历右子树
}
}
/**
* 后序遍历复杂一些, 因为找到左分支的底层节点后, 还要考虑其右子树是否存在的情况
* 可以考虑: 访问到一个左节点时, 不能直接处理, 需要先遍历其右子树(无论存不存在), 从右子树返回后才可以直接处理
* 所以, 每个节点首次访问时不能处理, 需要在二次访问时才被真正处理
*/
public static <T> void suforder(BinTree<T> tr, Consumer<T> c) {
Deque<BinTree<T>> stack = new LinkedList<>();
Map<BinTree<T>, Boolean> flag = new HashMap<>(); // 这里使用Map为例记录节点访问标志
while(true) {
while(tr != null) { // 同理,左分支入栈
stack.push(tr);
tr = tr.lChild;
} // 此时如果栈不为空, 则栈顶元素被记一次访问
if(stack.isEmpty()) { // 栈空表示遍历完成
break;
}
tr = stack.peek(); // 获取当前栈顶元素
while(flag.get(tr) == Boolean.TRUE) { // 如果该元素已经是二次访问, 则处理
flag.remove(tr); // 清除其标志
stack.pop(); // 该元素出栈
c.accept(tr.data); // 访问内容
if(stack.isEmpty()) { // 判空
return;
}
tr = stack.peek(); // 继续获取栈顶元素处理, 此时也是记一次访问
}
flag.put(tr, Boolean.TRUE); // 标记栈顶元素, 表示下次再访问(即从右子树返回)直接处理
tr = tr.rChild; // 遍历其右子树
}
}
/**
* 层序遍历, 借助队列可以很容易实现
*/
public static <T> void flrorder(BinTree<T> tr, Consumer<T> c) {
Queue<BinTree<T>> queue = new LinkedList<>();
if(tr != null) {
queue.add(tr);
}
while(!queue.isEmpty()) {
tr = queue.poll();
c.accept(tr.data);
if(tr.lChild != null) {
queue.add(tr.lChild);
}
if(tr.rChild != null) {
queue.add(tr.rChild);
}
}
}
/**
* 简单测试
*/
BinTree(BinTree<T> l, BinTree<T> r, T d) {
this.lChild = l;
this.rChild = r;
this.data = d;
}
public static void main(String[] args) {
// 先随便乱写一个二叉树, 用于遍历测试
BinTree<String> btree = new BinTree<>(
new BinTree<>(new BinTree<>(null, null, "D"),
new BinTree<>(null, new BinTree<>(null, null, "G"), "E"), "B"),
new BinTree<>(null, new BinTree<>(
new BinTree<>(new BinTree<>(null, null, "J"), null, "H"),
new BinTree<>(new BinTree<>(null, null, "K"), null, "I"), "F"), "C"), "A");
BinTree.preorder(btree, d -> System.out.print(d));
System.out.println("\t----先序遍历");
BinTree.midorder(btree, d -> System.out.print(d));
System.out.println("\t----中序遍历");
BinTree.suforder(btree, d -> System.out.print(d));
System.out.println("\t----后序遍历");
BinTree.flrorder(btree, d -> System.out.print(d));
System.out.println("\t----层序遍历");
}
}
输出结果:
ABDEGCFHJIK ----先序遍历
DBEGACJHFKI ----中序遍历
DGEBJHKIFCA ----后序遍历
ABCDEFGHIJK ----层序遍历
非递归算法实现之后,虽然时间复杂度也是O(n),但常系数的减小对于大量数据来说,时间和空间效率的提升还是很可观的