二叉树遍历解析

二叉树中最常见的是二分搜索树，每个节点的值大于其左子树的所有节点的值，小于其右子树的所有节点的值。
下面分别介绍二分搜索树的三种遍历：
1、前序遍历
树根->左子树->右子树，图例如下：结果为（ABDGHCEIF）

2. 中序遍历
左子树->树根->右子树，图例如下：结果为（GDHBAEICF）

3. 后序遍历
左子树->右子树->树根，图例如下：结果为（GHDBIEFCA）

下面附上二分搜索树遍历及插入相关代码：

public class BST<E extends Comparable<E>> {
private class Node{
public E e;
public Node left,right;

public Node(E e){
this.e = e;
left = null;
right = null;
}
}

private Node root;
private int size;

public BST(){
root = null;
size = 0;
}

public int size(){
return size;
}

public boolean isEmpty(){
return size == 0;
}
//增加元素
public void add(E e){
add(root, e);
}

//向以node为根的二分搜索树中插入元素e,递归算法
private Node add(Node node, E e){
if(node == null){
size ++;
return new Node(e);
}
if(e.compareTo(node.e) < 0)
node.left = add(node.left, e);
else if(e.compareTo(node.e) > 0)
node.right = add(node.right, e);

return node;
}

//看二分搜索树中是否包含元素e
public boolean contains(E e){
return contains(root, e);
}

//看以node为根的二分搜索树是否包含元素e,递归算法
private boolean contains(Node node, E e){
if(node == null)
return false;
if(e.compareTo(node.e) == 0)
return true;
else if(e.compareTo(node.e) < 0 )
return contains(node.left, e);
else
return contains(node.right, e);
}

//**前序遍历**
public void preOrder(){
preOrder(root);
}
//**前序遍历**   以node为根的二分搜索树，递归算法
private void preOrder(Node node){
if (node != null){
System.out.println(node.e);
preOrder(node.left);
preOrder(node.right);
}
}

//**中序遍历**
public void inOrder(){
inOrder(root);
}

//**后序遍历**
public void postOrder(){
postOrder(root);
}

//中序遍历以node为根的二分搜索树，递归算法
private void inOrder(Node node){
if(node == null){
return;
}
inOrder(node.left);
System.out.println(node.e);
inOrder(node.right);
}

//后序遍历
private void postOrder(Node node){
if(node == null){
return;
}
postOrder(node.left);
postOrder(node.right);
System.out.println(node.e);
}
}