Tree--二叉树BinarySearchTree

时间 2019-12-06

原文原文链接

　　BinarySearchTreeMap的实现java

 1 public interface Map<K extends Comparable<K>, V> {
 2     void put(K k, V v);
 3     
 4     V get(K k);
 5     
 6     void delete(K k);
 7     
 8     boolean contains(K k);
 9     
10     boolean isEmpty();
11     
12     int size();
13     
14     int size(K lo, K hi);
15     
16     K min();
17     
18     K max();
19     
20     K floor(K k);
21     
22     K ceiling(K k);
23     
24     // the number of keys less than key
25     int rank(K k);
26     
27     K select(int k);
28     
29     void deleteMin();
30     
31     void deleteMax();
32     
33     // keys in [lo , hi] in sorted order
34     Iterable<K> keys(K lo, K hi);
35     
36     Iterable<K> keys();
37 }

Map　Interface

　　二叉树的定义node

　　在计算机科学中，二叉树是每一个节点最多有两个子树的树结构。一般子树被称做“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。二叉树的左子节点 < 父节点　< 右子节点git

　　这是typical的二叉树的样子, null 表明子节点为空，从这张图能够看出，左子节点 9 小于父节点 10 小于右子节点　github

1     private class Node<K, V> {
2         private K k;
3         private V v;
4         private Node<K, V> left;
5         private Node<K, V> right;
6         private int size;
7         Node(K k, V v) { this.k = k; this.v = v; }
8         Node(K k, V v, int size) { this.k = k; this.v = v; this.size = size;}
9     }

Node(节点)对象

　　 二叉树的插入操做app

　假设咱们依次插入 10 ， 9， 15， 5 , 7 这5个元素到二叉树中。see what will happen 这是个动态图less

 1     @Override
 2     public void put(K k, V v) {
 3         root = put(root, k, v);　//root 是根节点
 4     }
 5     
 6     private Node<K, V> put(Node<K, V> node, K k, V v) {
 7         if (node == null) return new Node<>(k, v, 1);
 8         int cmp = node.k.compareTo(k);
 9         if (cmp > 0) { //node的k大一点 放到左边的数中
10             node.left = put(node.left, k, v);
11         } else if (cmp < 0) { //node的k小一点 放到右边的数中
12             node.right = put(node.right, k, v);
13         } else node.v = v;
14         
15         node.size = size(node.left) + size(node.right) + 1;
16         return node;
17     }

put operation (插入)

　　二叉树的get 方法ide

　　get方法简单来讲就是要找到那个key相同的对象。好比咱们要在「10 ， 9， 15， 5 , 7 」上图所示中找到　７this

 1  @Override  2     public V get(K k) {  3         return get(root, k);  4  }  5     
 6     private V get(Node<K, V> node, K k) {  7         
 8         if (node == null) return null; //not find
 9         else if (node.k.compareTo(k) > 0) { //node的k大一点 放到左边的数中
10             return get(node.left, k); 11         } else if (node.k.compareTo(k) < 0) { //node的k小一点 放到右边的数中
12             return get(node.right, k); 13         } else {                      //equal
14             return node.v; 15  } 16         
17     }

get operation

　　二叉树的删除操做spa

　　其实想象一下，当你删除一个node的时候，你须要找一个替代node来代替这个node。3d

　　这里又分3种状况。首先假设你有以下的树结构

　　１．第一种状况是这个删除的节点的左右节点都是null。

　　　　好比我要删除3节点。其实只要直接把3节点reset 为null 就能够了。变成以下

　　　２．第二种状况是删除的节点的2个子节点中有一个子节点为null

　　　　　好比我要删除15。 15 的左节点是12 右节点是 null，因此符合这个状况

　　　　这个时候只须要直接把须要删除的节点 reset 为非空的子节点就能够了

因此在这里只须要把15的值替代为12

　　３．第三种状况是删除的节点的2个子节点都不为null，

　　　　这个时候其实能够有2个选择，一个是把删除的节点替换为右子节点为根节点的那个树中最小的节点

　　　　好比我要删除10，右节点为15（二叉树的删除操做的那个图，不是上面的那个图），15这个节点为根节点的树中总共有2个元素（15和12），12是最小的。因此把须要删除的节点替换为12。删除后以下

　　　　另一种选择是把左节点为根节点的树中最大的值取出来，把须要删除的那个节点替换为这个左节点最大的元素（2个选择没什么区别）

 1     @Override
 2     public void delete(K k) {
 3         delete(root, k);
 4     }
 5     //delete the k in the node tree and reset the size prorperty of this tree and subtrees to correct value 
 6     private Node<K, V> delete(Node<K, V> node, K k) {
 7         if (node == null) return null;  //没有找到这个node
 8         
 9         int cmp = node.k.compareTo(k);
10         if (cmp > 0) {
11             node.left = delete(node.left, k);
12             node.size = size(node.left) + size(node.right) + 1;
13             return node;
14         } else if (cmp < 0) {
15             node.right = delete(node.right, k);
16             node.size = size(node.left) + size(node.right) + 1;
17             return node;
18         } else {    //hit the key 
19             if (node.right == null) //if the right node is null then just replace this node with left node
20                 return node.left;
21             else if (node.left == null) // if the left node is null then just replace this node with right node
22                 return node.right;
23             else {
24                 return deleteMin(node.right); // if both the subnodes are not null replace this node with the smallest node in the right sub node
25             }
26         }
27     }
28     
29     //删除从参数node开始的最小的node
30     private Node<K, V> deleteMin(Node<K, V> node) {
31         return delete(node, min(node));
32     }
33     
34     private Node<K, V> deleteMax(Node<K, V> node) {
35         return delete(node, max(node));
36     }
37     
38     @Override
39     public void deleteMin() {
40         deleteMin(root);
41     }
42     
43     @Override
44     public void deleteMax() {
45         deleteMax(root);
46     }
47     
48     @Override
49     public K min() {
50         return min(root);
51     }
52     
53     //get the smallest node in the given node
54     private K min(Node<K, V> node) {
55         if (node == null) return null;
56         for (; node.left != null; node = node.left);
57         return node.k;
58     }
59     
60     @Override
61     public K max() {
62         return max(root);
63     }
64     //get the most max node in the given node
65     private K max(Node<K, V> node) {
66         if (node == null) return null;
67         for (node = root; node.right != null; node = node.right);
68         return node.k;
69     }

delete operation 删除操做

　　　分析

　　　　BinarySearchTree 有一个最大的缺点，就是若是插入的元素是ordered，好比我插入 1 2 3 4 5 6 这样子，元素都会排在一边。这样子查找起来路径很长，效率很低。

　　　　若是插入的元素是随机的，那么全部的get put 操做的时间复杂度应该是和　log2(N) 成正比的

　　　　具体的实现能够参考这个。https://github.com/Cheemion/algorithms/blob/master/src/com/algorithms/tree/BinarySearchTreeMap.java

　　　　有什么错误的地方欢迎你们指正哈