栈、队列、链表都有他们各自的好处，同样的也有弊端的存在。

     如果我想要一个有序的数组和链表这个当然很好实现。现在我要在这几个数据结构中查找一个值。先说数组，因为是有序的通过二分查找很快的就可以找到。查找的效率还是很高的，但如果要是插入呢，为了保证有序，我要先找到插入位置，然后再将比插入数字大的数字依次向后移动；这时的第一反应就是链表！他打插入速度很快，只要改变指针的指向就可以了。但是链表大查找要从头开始找啊。只有知道了前一个元素的地址才能知道下一个地址。所以链表查找起来又费劲了。这时候就有人引进了树。

    树也分很多种，只说特殊的二叉树中的二叉搜索树。

    二叉搜索树定义：一个节点的左子节点的关键自值小于这个节点，右子节点的关键字值大于或等于这个父节点。

    二叉搜索树插入的时候可以直接改变左树右树的指针指向，查找的时候可以根据排序二叉树的特点。

    这就是一个二叉搜索树

    现在开始用代码来描述这棵树。先看节点类    

1. package
2. /** 
3.  * @author 作者 MarcoSpring 
4.  * @version 创建时间：2012-8-3 上午10:13:13 
5.  * 树节点类 
6.  */
7. public class
8. public int keyValue;    //关键字值
9. public TreeNode leftNode;//左节点
10. public TreeNode rightNode;//右节点
11.       
12. public
13. public TreeNode(int
14. this.keyValue = Key;  
15.     }  
16. }

代码不多，描述了一个节点的内容。关于二叉搜索树的描述主要从查询节点、添加节点、遍历、最大值、最小值、删除节点来描述。这里不包括存在相等节点的情况。

查询节点:这个比较简单，根据二叉树的定义查询就可以了。看图写代码最方便，

再看代码 

1. public TreeNode search(int
2.         TreeNode node = root;  
3. // 首先定义一个节点让其指向根，在下面的循环中
4. // 只要节点值不等于要查找的节点值就进入循环如果没有找到则返回null
5. while
6. if (Key < node.keyValue) { // 如果要查找的值小于节点值则指向左节点
7.                 node = node.leftNode;  
8. else { // 否则指向右节点
9.                 node = node.rightNode;  
10.             }  
11. if (node == null) { // 如果节点为空了则返回null
12. return null;  
13.             }  
14.         }  
15. return
16.     }

添加节点，添加节点的过程是现搜索再添加。先看图

再看代码 

    1. public void insert(int
2. new
3. // 添加节点之前首先要找到要添加的位置，这样就要记住要添加节点的父节点
4. // 让父节点的左右指向要添加的节点
5. if (root == null) { // 如果根结点为空，则根节点指向新节点
6.             root = node;  
7. else
8. // 定义当前节点并指向根节点
9.             TreeNode parentNode;  
10. while (true) { // 寻找节点添加的位置
11.                 parentNode = currentNode;  
12. if
13.                     currentNode = currentNode.leftNode;  
14. if (currentNode == null) { // 当找到空节点的时候，父节点的左节点指向新节点
15.                         parentNode.leftNode = node;  
16. return;  
17.                     }  
18. else
19.                     currentNode = currentNode.rightNode;  
20. if (currentNode == null) { // 当找到空节点的时候，父节点的右节点指向新节点
21.                         parentNode.rightNode = node;  
22. return;  
23.                     }  
24.                 }  
25.             }  
26.         }  
27.     }

    遍历树：遍历分为中序遍历（最常用，也最有用），前序遍历，后续遍历。

    这里就发一个中序遍历的图，理解了这个前序和后续都很好理解。

    再看代码 

      1. public void
2. if (node != null) {  
3.             display(node.leftNode);  
4. ",");  
5.             display(node.rightNode);  
6.         }  
7.     }

      最大值、最小值：这个就不用说了，最大值一直往右走，最小值一直往左走。

      直接上代码： 

      public int
1.     TreeNode node = root;  
2. null;  
3. while (node != null) {  
4.         parent = node;  
5.         node = node.rightNode;  
6.     }  
7. return
8. }  
9.   
10.   
11. public int
12.     TreeNode node = root;  
13. null;  
14. while (node != null) {  
15.         parent = node;  
16.         node = node.leftNode;  
17.     }  
18. return
19. }