概述
二叉树
是每个节点最多有两个子树的树结构。通常子树被称作左子树
和右子树
。
二叉树的遍历通常分为:前序遍历、中序遍历、后序遍历和层序遍历
。
前序遍历
前序递归遍历算法:访问根结点-->递归遍历根结点的左子树-->递归遍历根结点的右子树
中序遍历
中序递归遍历算法:递归遍历根结点的左子树-->访问根结点-->递归遍历根结点的右子树
后序遍历
后序递归遍历算法:递归遍历根结点的左子树-->递归遍历根结点的右子树-->访问根结点
二叉树节点
//二叉树节点
public class BinaryTreeNode {
private Object data;
private BinaryTreeNode left;
private BinaryTreeNode right;
public BinaryTreeNode() {
}
public BinaryTreeNode(Object data, BinaryTreeNode left, BinaryTreeNode right) {
this.data = data;
this.left = left;
this.right = right;
}
public Object getData() {
return data;
}
public void setData(Object data) {
this.data = data;
}
public BinaryTreeNode getLeft() {
return left;
}
public void setLeft(BinaryTreeNode left) {
this.left = left;
}
public BinaryTreeNode getRight() {
return right;
}
public void setRight(BinaryTreeNode right) {
this.right = right;
}
}
前序遍历
//前序遍历递归的方式
public void preOrder(BinaryTreeNode root) {
if (null != root) {
System.out.print(root.getData() + "\t");
preOrder(root.getLeft());
preOrder(root.getRight());
}
}
//前序遍历非递归的方式
public void preOrderNonRecursive(BinaryTreeNode root) {
Stack<BinaryTreeNode> stack = new Stack<BinaryTreeNode>();
while (true) {
while (root != null) {
System.out.print(root.getData() + "\t");
stack.push(root);
root = root.getLeft();
}
if (stack.isEmpty()) break;
root = stack.pop();
root = root.getRight();
}
}
中序遍历
//中序遍历采用递归的方式
public void inOrder(BinaryTreeNode root) {
if (null != root) {
inOrder(root.getLeft());
System.out.print(root.getData() + "\t");
inOrder(root.getRight());
}
}
//中序遍历采用非递归的方式
public void inOrderNonRecursive(BinaryTreeNode root) {
Stack<BinaryTreeNode> stack = new Stack<BinaryTreeNode>();
while (true) {
while (root != null) {
stack.push(root);
root = root.getLeft();
}
if (stack.isEmpty()) break;
root = stack.pop();
System.out.print(root.getData() + "\t");
root = root.getRight();
}
}
后序遍历
//后序遍历采用递归的方式
public void postOrder(BinaryTreeNode root) {
if (root != null) {
postOrder(root.getLeft());
postOrder(root.getRight());
System.out.print(root.getData() + "\t");
}
}
//后序遍历采用非递归的方式
public void postOrderNonRecursive(BinaryTreeNode root) {
Stack<BinaryTreeNode> stack = new Stack<BinaryTreeNode>();
while (true) {
if (root != null) {
stack.push(root);
root = root.getLeft();
} else {
if (stack.isEmpty()) return;
if (null == stack.lastElement().getRight()) {
root = stack.pop();
System.out.print(root.getData() + "\t");
while (root == stack.lastElement().getRight()) {
System.out.print(stack.lastElement().getData() + "\t");
root = stack.pop();
if (stack.isEmpty()) {
break;
}
}
}
if (!stack.isEmpty())
root = stack.lastElement().getRight();
else
root = null;
}
}
}
层序遍历
//层序遍历
public void levelOrder(BinaryTreeNode root) {
BinaryTreeNode temp;
Queue<BinaryTreeNode> queue = new LinkedList<BinaryTreeNode>();
queue.offer(root);
while (!queue.isEmpty()) {
temp = queue.poll();
System.out.print(temp.getData() + "\t");
if (null != temp.getLeft())
queue.offer(temp.getLeft());
if (null != temp.getRight()) {
queue.offer(temp.getRight());
}
}
}
模拟二叉树实现
public static void main(String[] args) {
//模拟生成上图的二叉树
BinaryTreeNode nodeF = new BinaryTreeNode("F", null, null);
BinaryTreeNode nodeE = new BinaryTreeNode("E", null, nodeF);
BinaryTreeNode nodeD = new BinaryTreeNode("D", null, null);
BinaryTreeNode nodeC = new BinaryTreeNode("C", null, null);
BinaryTreeNode nodeB = new BinaryTreeNode("B", nodeC, nodeD);
BinaryTreeNode nodeA = new BinaryTreeNode("A", nodeB, nodeE);
BinaryTree tree = new BinaryTree();
//采用递归的方式进行前序遍历
System.out.println("-----前序遍历------");
tree.preOrder(nodeA);
System.out.println();
//采用非递归的方式进行前序遍历
tree.preOrderNonRecursive(nodeA);
System.out.println();
//采用递归的方式进行遍历
System.out.println("-----中序遍历------");
tree.inOrder(nodeA);
System.out.println();
//采用非递归的方式遍历
tree.inOrderNonRecursive(nodeA);
System.out.println();
//采用递归的方式进行遍历
System.out.println("-----后序遍历------");
tree.postOrder(nodeA);
System.out.println();
//采用非递归的方式遍历
tree.postOrderNonRecursive(nodeA);
System.out.println();
//采用递归的方式进行遍历
System.out.println("-----层序遍历------");
tree.levelOrder(nodeA);
System.out.println();
}
输出如下:
-----前序遍历------
A B C D E F
A B C D E F
-----中序遍历------
C B D A E F
C B D A E F
-----后序遍历------
C D B F E A
C D B F E A
-----层序遍历------
A B E C D F