二叉搜索树非递归实现-java版

二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树：
若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
它的左、右子树也分别为二叉排序树。

其实说白点就是一颗二叉树满足了左子节点小于根节点元素，右子节点大于根节点元素，这样的二叉树就是二叉搜索树，二叉搜索树实现符号表，具有插入、查找的高效性，对其优化可以生成平衡二叉树，红黑树等更高效的查找和插入数据结构，是一个优秀的基础算法。
看下其数据的结构
这是一个简单的二叉搜索树结构，满足了基本的需求

class Node{
    int key;
    int value;
    Node left,right;
//  int N;
    Node(int key,int value){

        this.key=key;
        this.value=value;

    }

}

看下树中方法涉及到插入、查找、删除基本操作

 class Tree{
    Node root; //储存根节点

    //查找指定key元素返回节点
    public Node find(int key){
        return null;
    }
    //插入元素
    public void insert(int key,int value){
    }
    //删除元素
    public void delete(int key){
    }
    //返回node下最小节点
    public Node min(Node node){     
    }
    //删除该节点下的最小节点
    public void deleteMin(Node node){ 
    }
    //删除该节点下最大节点
    public void deleteMax(Node node){
        }   
}

查找操作和二分查找类似，将key和节点的key比较，如果小于，那么就在Left Node节点查找,如果大于，则在Right Node节点查找，如果相等，直接返回Value。

    public Node find(int key){
//      查找也是从根元素出发,找不到返回null
        Node currentNode=root;
        while(currentNode!=null&¤tNode.key!=key){

            if(keyelse
            {
                currentNode=currentNode.right;
            }
        }


        return currentNode;
    }

插入过程非常简单，很类似与二叉树搜索树的查找过程。当需要插入一个新结点时，从根节点开始，迭代或者递归向下移动，直到遇到一个空的指针NIL，需要插入的值即被存储在该结点位置。

    public void insert(int key,int value){
        //如果根节点没有元素，此节点便为根节点
        if(root==null){
            root=new Node(key,value);
            return;
        }
        //比较左右节点元素，从root开始

        Node parentNode=root;//当前元素父元素
        Node currentNode=root;//当前元素

        while(currentNode!=null){ //一直遍历找到一个空元素为止

            parentNode=currentNode;
            if(key//如果key小于该元素值，往左找，相反则往右

                currentNode=currentNode.left;
            }else{

                currentNode=currentNode.right;
            }

        }

        if(key//插入元素
            System.out.println(parentNode.key+"的左边可以插入"+key);
             parentNode.left=new Node(key,value);
        }else{
            System.out.println(parentNode.key+"的右边可以插入"+key);
            parentNode.right=new Node(key,value);
        }


    }

返回该节点最小节点，就是一直遍历往左遍历直到找到其左子节点为空那么当前节点就是最小的。

    public Node min(Node node){ //返回node下最小节点
        //当前节点为空直接返回，不为空找到其左子节点为空为止
        Node currentNode=node;
        if(currentNode==null)
            return null;
        while(currentNode.left!=null){
            currentNode=currentNode.left;
        }
        return currentNode;

    }

删除元素操作在二叉树的操作中应该是比较复杂的。首先来看下比较简单的删除最大最小值得方法。

以删除最小值为例，我们首先找到最小值，及最左边左子树为空的节点，然后返回其右子树作为新的左子树。

public void deleteMin(Node node){ //删除该节点下的最小节点
        Node currentNode=node;
        Node parentNode=node;
        if(currentNode==null)
            return;
        //先定位到key，不用已经写好的find方法而自己写是因为find方法是从根开始的，有些地方的用到这个函数不用从根开始
        //一直往左深入，直到它的左子节点为null，然后将其右子节点替换掉该节点（如无右节点即为null）。
        while(currentNode.left!=null){

            parentNode=currentNode;
            currentNode=currentNode.left;
        }
        parentNode.left=currentNode.right; 
        currentNode.right=null;

    }

    public void deleteMax(Node node){
        //做法与min相似
        Node currentNode=node;
        Node parentNode=node;
        if(currentNode==null)
            return;

        while(currentNode.right!=null){
            parentNode=currentNode;
            currentNode=currentNode.right;
        }
        parentNode.right=currentNode.left; 
    currentNode.left=null;

    }

删除的一般情况，上述删除最大和最小只是两个特殊情况，有了上面做铺垫下面的就好理解点，首先我们需要找到待删除节点的左子树上的最大值节点，或者右子树上的最小值节点（T.Hibbard提出的一种解决方法），然后将该节点的参数值与待删除的节点参数值进行交换，最后删除该节点，这样需要删除的参数就从该二叉树中删除了。需要注意的是删除后的一些引用该置为null的一定要置为null好让其被回收。

    public void delete(int key){
        if(root==null) return;
        Node currentNode=root;
        Node parentNode=root;

        //定位到要删除的key 的父节点,以及当前元素
        while(currentNode!=null&¤tNode.key!=key){
            parentNode=currentNode;
            if(currentNode.key>key){
                currentNode=currentNode.left;
            }else{
                currentNode=currentNode.right;
            }

        }

        System.out.println("要删除的是："+currentNode.key);
        System.out.println("父亲是："+parentNode.key);
//       要替换删除元素的node
        Node exNode=min(currentNode.right);
        System.out.println("与其替换的是："+exNode.key);
        //找到其右节点中最小节点用以替换要删除的节点
        if(parentNode.key>key){
            parentNode.left=exNode;

        }else{
            parentNode.right=exNode;
        }
        deleteMin(currentNode.right); //删除原引用
        if(exNode!=null){
            //将新节点中的左右子节点更新为要删除元素的左右节点
            if(currentNode.left!=null&&exNode.key!=currentNode.left.key) //防止当子节点就是替代节点的时候引起死循环
            exNode.left=currentNode.left; 
            if(currentNode.right!=null&&exNode.key!=currentNode.right.key)
            exNode.right=currentNode.right;
        }
        currentNode.left=null;
        currentNode.right=null;


    }

中序遍历，其他遍历也差不多，不多讲

 public void inOrder(Node rootNode) { //中序遍历
                 if (rootNode != null) {
                     inOrder(rootNode.left);
                      System.out.println("key: " + rootNode.key + " " + "value: " + rootNode.value);
                     inOrder(rootNode.right);
                  }
              }

下面测试一下，这是测试代码

public static void main(String[] args) {
        // TODO Auto-generated method stub
         Tree tree = new Tree(); 
          tree.insert(6, 6);//插入操作,构造图一所示的二叉树 

         tree.insert(3, 3); 

        tree.insert(14, 14); 

         tree.insert(16, 16); 

         tree.insert(10, 10); 

         tree.insert(9, 9); 

        tree.insert(13, 13); 

         tree.insert(11, 11); 

        tree.insert(12, 12); 
        System.out.println("删除前遍历结果"); 

        tree.inOrder(tree.root);//中序遍历操作 

        System.out.println("删除节点10之后遍历结果"); 

         tree.delete(10);//删除操作 

          tree.inOrder(tree.root);

    }

依据代码 提示，可以自己手动轻松画出这棵二叉树，具体可自己实践。目前实现的这个版本不可插入重复元素，其实如果要插入重复元素，只需在插入操作中找到这个元素，更新即可。做下代码相应修改就好