排序二叉树简单源码实现

排序二叉树简单源码实现

标签（空格分隔）： java tree

---

排序二叉树，具有中序排序永远都是排好序的特征，用来排序是再好不过了。排序二叉树左子树大于更节点 小于右子树

public class SearchTree<K extends Comparable,V> {

    private Node<K,V> root;
    /**
    整个的数据结构就是如下，K用来做比较 v标识存放的值
    
    */
    private static class Node<K,V>{
        V v;
        K k;
        Node<K,V> left,right;
        int N;
        public Node(K key,V vale){
            this.k = key;
            this.v = vale;
        }
    }
    //存放size值 size(root)=size(right)+size(left)+1
    private  int size(Node x){
        if(x==null){
            return 0;
        }else{
            return  x.N;
        }
    }
    /*
        排序二叉树基本特征 是左子树小于根节点 小于右子树 
    */
    private Node put(Node node,K k,V v){
        if (node==null){
            return new Node(k,v);
        }else{
            int i = k.compareTo(node.k);
            if(i==0){
                node.v = v;
            }else if(i>0){
                node.right = put(node.right,k,v);
            }else{
                node.left = put(node.left,k,v);
            }
        }
        recalculateSize(node);//树的节点数量 就需要重新赋值计数 变量N
        return node;
    }
    public void  put(K k,V v){
        root = put(root,k,v);
    }
    protected void recalculateSize(Node x) {
        x.N = size(x.left) + size(x.right) + 1;
    }

    public void forEache(){
      forEacheBefore(root);
        System.out.println("---------------------");
      forEacheMiddle(root);
        System.out.println("-----------------------");
      forEacheAfter(root);
    }
    private void forEacheBefore(Node node){
        if(node==null){
            return;
        }else{
            System.out.println(node.k+"------"+node.v);
            forEacheBefore(node.left);
            forEacheBefore(node.right);
        }
    }
    private void forEacheMiddle(Node node){
        if(node==null){
            return;
        }else{
            forEacheMiddle(node.left);
            System.out.println(node.k+"------"+node.v);
            forEacheMiddle(node.right);
        }
    }
    private void forEacheAfter(Node node){
        if(node==null){
            return;
        }else{
            forEacheAfter(node.left);
            forEacheAfter(node.right);
            System.out.println(node.k+"------"+node.v);
        }
    }
    public void deleteMin(){
        root = deleteMin(root);
    }
    //删除最小的时候是 如果一个节点没有左子树 那么他就是最小的，删除就是把 当前的节点的索引赋值到他的右子树上
    public Node deleteMin(Node node){
        if(node.left==null){
            return node.right;
        }
        node.left = deleteMin(node.left);
        recalculateSize(node);
        return node;
    }
    public K maxKey(){
        return (K) maxKey(root).k;
    }
    private Node maxKey(Node node){
        if(node==null){
            return null;
        }else{
            if(node.right==null){
                return node;
            }else{
                return maxKey(node.right);
            }
        }
    }
    //
     public V get(K k){
        Node node = get(root, k);
        if(null!=node){
           return (V) node.v;
       }else {
           return null;
       }
    }
    private Node get(Node node ,K k){
        if(node==null){
            return null;
        }else{
            int to = node.k.compareTo(k);
            if(to==0){//相等就直接返回了
                return node;
            }else if(to<0){//node k小于K 标识 k大了 就只能在右边查找了
                return get(node.right,k);
            }else{
                return get(node.left,k);
            }
        }
    }
    
}

java8 中HashMap如果数量到了一定程度链表会使用 红黑树来存储，红黑树是一种特殊的查找二叉树，学习这个也是为了进一步学习红黑树 然后读懂hashMap源码