符号表

一、无序链表的顺序查找：

import java.util.ArrayList;import java.util.Iterator;public class SequentialSearchST<Key, Value>{private Node first;private int N;private class Node{Key key;Value val;Node next;public Node(Key key, Value val, Node next){this.key = key;this.val = val;this.next = next;}public int size(){return N;}public boolean isEmpty(){return N == 0;}public Iterable<Key> keys(){ArrayList<Key> a = new ArrayList<Key>();for (Node x = first; x != null; x = x.next)a.add(x.key);return a;}public Value get(Key key){for (Node x = first; x != null; x = x.next)if (x.key.equals(key))return x.val;return null;}public void put(Key key, Value val){for (Node x = first; x != null; x = x.next)if (key.equals(x.key))x.val = val;first = new Node(key, val, first);N++;}public void delete(Key key){delete(first, key);}private Node delete (Node x, Key key){if (x == null) return null;if (key.equals(x.key)) {N --;return x.next;}x.next = delete(x.next, key);return x;}}}

二、基于二分查找的有序符号表的实现：

public class BinarySearchST< Key extends Comparable<Key>, Value>{private Key[] keys;private Value[] vals;private int N;public BinarySearchST(int capacity){keys = (Key[])new Comparable[capacity];vals = (Value[])new Object[capacity];}public int size(){return N;}public boolean isEmpty(){return N == 0;}public Value get(Key key){if (isEmpty()) return null;int i = rank(key);if (i < N && keys[i].compareTo(key) == 0)return vals[i];else return null;}public int rank(Key key){int lo = 0; int hi = N - 1;while (lo <= hi){int mid = lo + (hi - lo) / 2;if (keys[mid].compareTo(key) < 0) lo = mid + 1;else if (keys[mid].compareTo(key) > 0) hi = mid - 1;else return mid;}return lo;}public void put(Key key, Value val){int i = rank(key);if (i < N && key.compareTo(keys[i]) == 0){vals[i] = val;return;}for (int j = N ; j > i; j--){keys[j] = keys[j-1];vals[j] = vals[j-1];}keys[i] = key;vals[i] = val;N++;return;}public void delete(Key key){if (isEmpty()) return;int i = rank(key);if (i >= N || keys[i].compareTo(key) != 0)return;for (int j = i; j < N; j++){keys[j] = keys[j+1];vals[j] = vals[j+1];}N--;keys[N] = null;vals[N] = null;} public Key min() {        if (isEmpty()) return null;        return keys[0];  } public Key max() {        if (isEmpty()) return null;        return keys[N-1];  } public Key ceiling(Key key)  {        if (key == null) return null;        int i = rank(key);        if (i == N) return null;         else return keys[i];} public Key floor(Key key)  {        if (key == null) return null;        int i = rank(key);        if (i < N && key.compareTo(keys[i]) == 0) return keys[i];        if (i == 0) return null;        else return keys[i-1];    } public Iterable<Key> keys(Key lo, Key hi)  {         Queue<Key> queue = new Queue<Key>();         if (lo.compareTo(hi) > 0) return queue;        for (int i = rank(lo); i < rank(hi); i++)             queue.enqueue(keys[i]);        if (contains(hi)) queue.enqueue(keys[rank(hi)]);        return queue; } public Key select(int k)  {        return keys[k]; } public boolean contains(Key key)  {        return get(key) != null; }  }

三、二叉查找树的实现：

public class BST<Key extends Comparable<Key>, Value> {private Node root;private class Node{private Key key;private Value val;private Node left, right;private int N;public Node(Key key, Value val, int N){this.key = key;this.val = val;this.N = N;}}public int size(){return size(root);}private int size(Node x){if (x == null) return 0;return x.N;}public Value get(Key key){return get(root, key);}private Value get(Node x, Key key){if (x == null) return null;int cmp = key.compareTo(x.key);if (cmp < 0) return get(x.left, key);else if (cmp > 0) return get(x.right, key);else return x.val;}public void put(Key key, Value val){root = put(root, key, val);}private Node put(Node x, Key key, Value val){if (x == null) return new Node(key, val, 1);int cmp = key.compareTo(x.key);if (cmp < 0) x.left = put(x.left, key, val);else if (cmp > 0) x.right = put(x.right, key, val);else x.val = val;x.N = size(x.left) + size(x.right) + 1;return x;}public Key min(){return min(root).key;}private Node min(Node x){if (x.left == null) return x;elsereturn min(x.left);}public Key max(){return max(root).key;}private Node max(Node x){if (x.right == null) return x;elsereturn max(x.right);}public Key floor(Key key){Node x = floor(root, key);if (x == null) return null;else return x.key;}private Node floor(Node x, Key key){if (x == null) return null;int cmp = key.compareTo(x.key);if (cmp == 0) return x;if (cmp < 0) return floor(x.left, key);Node t = floor(x.right, key);if (t != null) return t;else return x;}public Key select(int k){return select(root, k).key;}private Node select(Node x, int k){if (x == null) return null;int t = size(x.left);if (k < t) return select(x.left, k);else if (k > t) return select(x.right, k-1-t);else return x;}public int rank(Key key){return rank(key, root);}private int rank(Key key, Node x){if (x == null) return 0;int cmp = key.compareTo(x.key);if (cmp < 0) return rank(key, x.left);else if (cmp > 0) return rank(key, x.right) + size(x.left) + 1;else return size(x.left);}public void deleteMin(){root = deleteMin(root);}private Node deleteMin(Node x){if (x.left == null) return x.right;    x.left = deleteMin(x.left);x.N = size(x.left) + size(x.right) + 1;return x;}public void delete(Key key){root = delete(root, key);}private Node delete(Node x, Key key){if (x == null) return null;int cmp = key.compareTo(x.key);if (cmp < 0) x.left = delete(x.left, key);else if (cmp > 0) x.right = delete(x.right, key);else{if (x.left == null) return x.right;if (x.right == null) return x.left;Node t = x;x = min(t.right);x.right = deleteMin(t.right);x.left = t.left;}x.N = size(x.left) + size(x.right) + 1;return x;}public Iterable<Key> keys(){return keys(min(), max());}private Iterable<Key> keys(Key lo, Key hi){Queue<Key> queue = new Queue<Key>();keys(root, queue, lo, hi);return queue;}private void keys(Node x, Queue<Key> queue, Key lo, Key hi){if (x == null) return;int cmplo = lo.compareTo(x.key);int cmphi = hi.compareTo(x.key);if (cmplo < 0) keys(x.left, queue, lo, hi);if (cmplo <= 0 && cmphi >= 0) queue.enqueue(x.key);if (cmphi > 0) keys(x.right, queue, lo, hi);}}

四、红黑树（2-3树）实现：

import BST.Node;public class RedBlackBST<Key extends Comparable<Key>, Value> {private Node root;private static final boolean RED = true;private static final boolean BLACK = false;private class Node{Key key;Value val;Node left, right;int N;boolean color;Node(Key key, Value val, int N, boolean color){this.key = key;this.val = val;this.N = N;this.color = color;}}private boolean isRed(Node x){if (x == null) return false;else return x.color == RED;}Node rotateLeft(Node h){Node x = h.right;h.right = x.left;x.left = h;x.color = h.color;h.color = RED;x.N = h.N;h.N = 1 + size(h.left) + size(h.right);return x;}Node rotateRight(Node h){Node x = h.left;h.left = x.right;x.right = h;x.color = h.color;h.color = RED;x.N = h.N;h.N = 1 + size(h.left) + size(h.right);return x;}void flipcolors(Node h){h.color = RED;h.left.color = BLACK;h.right.color = BLACK;}public int size(){return size(root);}private int size(Node x){if (x == null) return 0;return x.N;}public void put(Key key, Value val){root = put(root, key, val);root.color = BLACK;}private Node put(Node h, Key key, Value val){if (h == null)return new Node(key, val, 1, RED);int cmp = key.compareTo(h.key);if(cmp < 0) h.left = put(h.left, key, val);else if(cmp > 0) h.right = put(h.right, key, val);else h.val = val;if (isRed(h.right)&&!isRed(h.left)) h = rotateLeft(h);if (isRed(h.left)&&isRed(h.left.left)) h = rotateRight(h);if (isRed(h.left)&&isRed(h.right)) flipcolors(h);h.N = size(h.left) + size(h.right) + 1;return h;}}

五、基于拉链法的散列表实现：

public class SeparateChainingHashST<Key, Value> {private int N;private int M;private SequentialSearchST<Key, Value>[] st;public SeparateChainingHashST(){this(997);}private SeparateChainingHashST(int M){this.M = M;st = (SequentialSearchST<Key, Value>[])new SequentialSearchST[M];for(int i = 0; i < M; i++)st[i] = new SequentialSearchST();}private int hash(Key key){return(key.hashCode() & 0x7fffffff) % M;}public Value get(Key key){return (Value)st[hash(key)].get(key);}public void put(Key key, Value val){st[hash(key)].put(key,val);}}

六、基于线性探测法的散列表：

public class LinearProbingHashST<Key, Value> {private int N;private int M = 16;private Key[] keys;private Value[] vals;private LinearProbingHashST(int M){this.M = M;keys = (Key[])new Object[M];vals = (Value[])new Object[M];}private int hash(Key key){return (key.hashCode() & 0x7fffffff) % M;}public void resize(int cap){LinearProbingHashST<Key, Value> t;t = new LinearProbingHashST<Key, Value>(cap);for (int i = 0; i < M; i++)if (keys[i] != null)t.put(keys[i], vals[i]);keys = t.keys;vals = t.vals;M = t.M;}public void put(Key key, Value val){if (N >= M / 2) resize(2 * M);int i;for (i = hash(key); keys[i] != null; i = (i + 1) % M )if (keys[i].equals(key)){vals[i] = val;return;}keys[i] = key;vals[i] = val;N++;}public Value get(Key key){int i;for (i = hash(key); keys[i] != null; i = (i + 1) % M )if (keys[i].equals(key))return vals[i];return null;}private boolean contains(Key key){return get(key) != null;}public void delete(Key key){if (!contains(key)) return;int i = hash(key);while (!key.equals(keys[i]))i = (i + 1) % M;keys[i] = null;vals[i] = null;i = (i + 1) % M;while (keys[i] != null){Key keyRedo = keys[i];Value valRedo = vals[i];keys[i] = null;vals[i] = null;N--;put(keyRedo, valRedo);i = (i + 1) % M;}N--;if (N > 0 && N == M / 8) resize(M / 2);}}