java 二叉搜索树（搜索、添加、遍历）

http://marcospring.iteye.com/blog/1622408

栈、队列、链表都有他们各自的好处，同样的也有弊端的存在。
     如果我想要一个有序的数组和链表这个当然很好实现。现在我要在这几个数据结构中查找一个值。先说数组，因为是有序的通过二分查找很快的就可以找到。查找的效率还是很高的，但如果要是插入呢，为了保证有序，我要先找到插入位置，然后再将比插入数字大的数字依次向后移动；这时的第一反应就是链表！他打插入速度很快，只要改变指针的指向就可以了。但是链表大查找要从头开始找啊。只有知道了前一个元素的地址才能知道下一个地址。所以链表查找起来又费劲了。这时候就有人引进了树。
    树也分很多种，只说特殊的二叉树中的二叉搜索树。
    二叉搜索树定义：一个节点的左子节点的关键自值小于这个节点，右子节点的关键字值大于或等于这个父节点。
    二叉搜索树插入的时候可以直接改变左树右树的指针指向，查找的时候可以根据排序二叉树的特点。
    这就是一个二叉搜索树

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

Java代码  

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

代码不多，描述了一个节点的内容。关于二叉搜索树的描述主要从查询节点、添加节点、遍历、最大值、最小值、删除节点来描述。这里不包括存在相等节点的情况。
查询节点:这个比较简单，根据二叉树的定义查询就可以了。看图写代码最方便，

再看代码

Java代码  

1. public TreeNode search(int Key) {  
2.         TreeNode node = root;  
3.         // 首先定义一个节点让其指向根，在下面的循环中  
4.         // 只要节点值不等于要查找的节点值就进入循环如果没有找到则返回null  
5.         while (node.keyValue != Key) {  
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 node;  
16.     }  

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

再看代码

Java代码  

1. public void insert(int Key) {  
2.         TreeNode node = new TreeNode(Key);  
3.         // 添加节点之前首先要找到要添加的位置，这样就要记住要添加节点的父节点  
4.         // 让父节点的左右指向要添加的节点  
5.         if (root == null) { // 如果根结点为空，则根节点指向新节点  
6.             root = node;  
7.         } else {  
8.             TreeNode currentNode = root;// 定义当前节点并指向根节点  
9.             TreeNode parentNode;  
10.             while (true) { // 寻找节点添加的位置  
11.                 parentNode = currentNode;  
12.                 if (Key < currentNode.keyValue) {  
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.     }  

遍历树：遍历分为中序遍历（最常用，也最有用），前序遍历，后续遍历。
这里就发一个中序遍历的图，理解了这个前序和后续都很好理解。

再看代码

Java代码  

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

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

Java代码  

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

关于删除节点单独发一篇，因为实在太麻烦了。。。