二叉树的遍历,可以使用递归方式解决,非常简单,只要考虑怎么解决 A B C的遍历就好了
前序遍历 : A B C
中序遍历 : B A C
后序遍历 : B C A
下面我们进入实战:
如图:
前序遍历 : A | B | D | E | C | F | G |
中序遍历 : D | B | E | A | F | C | G |
后序遍历 : D | E | B | F | G | C | A |
直接上代码
/**
* 二叉树的遍历(前序 、中序、后序)
*/
public class BinaryTreeTraversing {
/**
* 构建二叉树
*
* @return
*/
private static BinTree buildBinTree() {
BinTree A = new BinTree("A");
BinTree B = new BinTree("B");
BinTree C = new BinTree("C");
BinTree D = new BinTree("D");
BinTree E = new BinTree("E");
BinTree F = new BinTree("F");
BinTree G = new BinTree("G");
A.leftTree = B;
A.rightTree = C;
B.leftTree = D;
B.rightTree = E;
C.leftTree = F;
C.rightTree = G;
return A;
}
public static void main(String[] args) {
BinTree binTree = buildBinTree();
System.out.print("\n前序遍历 : ");
preOrder(binTree);
System.out.print("\n中序遍历 : ");
inOrder(binTree);
System.out.print("\n后序遍历 : ");
postOrder(binTree);
}
/**
* 前序遍历 : A | B | D | E | C | F | G |
* @param binTree
*/
private static void preOrder(BinTree binTree) {
System.out.print(binTree.data + " | ");
if (binTree.leftTree != null) {
preOrder(binTree.leftTree);
}
if (binTree.rightTree != null) {
preOrder(binTree.rightTree);
}
}
/**
* 中序遍历 : D | B | E | A | F | C | G |
* @param binTree
*/
private static void inOrder(BinTree binTree) {
if (binTree.leftTree != null) {
inOrder(binTree.leftTree);
}
System.out.print(binTree.data + " | ");
if (binTree.rightTree != null) {
inOrder(binTree.rightTree);
}
}
/**
* 后序遍历 : D | E | B | F | G | C | A |
* @param binTree
*/
private static void postOrder(BinTree binTree) {
if (binTree.leftTree != null) {
postOrder(binTree.leftTree);
}
if (binTree.rightTree != null) {
postOrder(binTree.rightTree);
}
System.out.print(binTree.data + " | ");
}
/**
* tree 对象
*/
static class BinTree {
private String data;
private BinTree leftTree;
private BinTree rightTree;
public BinTree(String data) {
this.data = data;
}
public BinTree getLeftTree() {
return leftTree;
}
public void setLeftTree(BinTree leftTree) {
this.leftTree = leftTree;
}
public BinTree getRightTree() {
return rightTree;
}
public void setRightTree(BinTree rightTree) {
this.rightTree = rightTree;
}
}
}
/**
* 层序遍历:借助队列
* @param root
* @return
*/
public static List<List<String>> levelOrder(BinTree root) {
List<List<String>> result = new ArrayList<List<String>>();
Deque<BinTree> queue = new ArrayDeque<BinTree>();
queue.offer(root);
while (!queue.isEmpty()) {
int size = queue.size();
List<String> element = new ArrayList<String>();
for (int i = 0; i < size; i++) {
BinTree binTree = queue.poll();
element.add(binTree.data);
if (binTree.leftTree != null) {
queue.add(binTree.leftTree);
}
if (binTree.rightTree != null) {
queue.add(binTree.rightTree);
}
}
result.add(element);
}
return result;
}