符号表

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

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;
		else
			return min(x.left);
	}
	public Key max()
	{
		return max(root).key;
	}
	private Node max(Node x)
	{
		if (x.right == null) return x;
		else
			return 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);
	}
}