树型结构是一种非常重要的非线性数据结构,在计算机领域应用广泛,本文以二叉树为例,详细介绍二叉树的构建及遍历方式,其中包含递归实现的先序遍历、中序遍历及后续遍历,以及非递归实现的深度优先遍历、广度优先遍历。
以下是Java代码实现:
package me.geed.algorithms;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;
public class BinaryTree {
/**二叉树根节点*/
private Node rootNode;
/**
* 由整数数组构造二叉树
* @param array
*/
public BinaryTree(int[] array) {
rootNode = createBinaryTreeNode(array, 0);
}
public class Node {
private int value;
private Node leftChild;
private Node rightChild;
public Node(int value) {
this.value = value;
}
}
/**
* 先序遍历二叉树--递归方式
* @param node
*/
public void preOrderTraverse(Node node) {
if (node != null) {
System.out.print(node.value + " ");
preOrderTraverse(node.leftChild);
preOrderTraverse(node.rightChild);
}
}
/**
* 中序遍历二叉树--递归方式
* @param node
*/
public void midOrderTraverse(Node node) {
if (node != null) {
midOrderTraverse(node.leftChild);
System.out.print(node.value + " ");
midOrderTraverse(node.rightChild);
}
}
/**
* 后序遍历二叉树--递归方式
* @param node
*/
public void postOrderTraverse(Node node) {
if (node != null) {
postOrderTraverse(node.leftChild);
postOrderTraverse(node.rightChild);
System.out.print(node.value + " ");
}
}
/**
* 深度优先遍历(跟先序遍历是一样的)--非递归实现
* 借助栈先进后出的特点,示例仅演示原理,如果追求效率可以使用ArrayDeque
*/
public void depthOrderTraverse(){
if (rootNode == null) {
return;
}
Stack<Node> stack = new Stack<Node>();
stack.push(rootNode);
while (!stack.isEmpty()) {
Node node = stack.pop();
System.out.print(node.value + " ");
if (node.rightChild != null) {
stack.push(node.rightChild);
}
if (node.leftChild != null) {
stack.push(node.leftChild);
}
}
}
/**
* 广度优先遍历(跟层序遍历是一样的)--非递归实现
* 借助链表尾部进、头部出的特点,如追求效率可使用ArrayDeque
*/
public void levelOrderTraverse() {
if (rootNode == null) {
return;
}
Queue<Node> queue = new LinkedList<Node>();
queue.add(rootNode);
while (!queue.isEmpty()) {
Node node = queue.remove();
System.out.print(node.value + " ");
if (node.leftChild != null) {
queue.add(node.leftChild);
}
if (node.rightChild != null) {
queue.add(node.rightChild);
}
}
}
/**
* 创建二叉树的节点
* @param array
* @param index
* @return
*/
public Node createBinaryTreeNode(int[] array, int index) {
if (index < array.length) {
int value = array[index];
if (value != 0) {
Node node = new Node(value);
node.leftChild = createBinaryTreeNode(array, index * 2 + 1);
node.rightChild = createBinaryTreeNode(array, index * 2 + 2);
return node;
}
}
return null;
}
/**
* 入口函數
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] array = {1, 3, 6, 8, 12, 7, 29, 47, 35, 0, 99, 0, 0, 68, 0};
BinaryTree bTree = new BinaryTree(array);
/**
* 由以上数组生成的二叉树结构如下,0表示空节点
*
* 1
* / \
* 3 6
* / \ / \
* 8 12 7 29
* / \ \ /
* 47 35 99 68
*/
System.out.println("先序遍历二叉树");
bTree.preOrderTraverse(bTree.rootNode);
System.out.println("\n中序遍历二叉树");
bTree.midOrderTraverse(bTree.rootNode);
System.out.println("\n后序遍历二叉树");
bTree.postOrderTraverse(bTree.rootNode);
System.out.println("\n深度优先遍历二叉树");
bTree.depthOrderTraverse();
System.out.println("\n广度优先遍历二叉树");
bTree.levelOrderTraverse();
}
}
以上代码中的注释已经描述的比较清楚,程序运行结果如下:
先序遍历二叉树
1 3 8 47 35 12 99 6 7 29 68
中序遍历二叉树
47 8 35 3 12 99 1 7 6 68 29
后序遍历二叉树
47 35 8 99 12 3 7 68 29 6 1
深度优先遍历二叉树
1 3 8 47 35 12 99 6 7 29 68
广度优先遍历二叉树
1 3 6 8 12 7 29 47 35 99 68