基于链表的词典

public class Linked_Sorted_Dictionary<K extends Comparable<? super K>,V> implements DictionaryInterface<K, V>{

	private Node firstNode;
	private int currentSize;

	public Linked_Sorted_Dictionary() {
		firstNode=null;
		currentSize=0;
	}

	@Override
	public V add(K key, V value) {
		System.out.print("["+key+","+value+"]"+" ");
		V result=null;
		Node currentNode=firstNode;
		Node beforeNode=null;
		while(currentNode!=null && key.compareTo(currentNode.getKey())>0){
			beforeNode=currentNode;
			currentNode=currentNode.getNextNode();
		}
		if(currentNode!=null && key.compareTo(currentNode.getKey())==0){
			result=currentNode.getValue();
			currentNode.setValue(value);
		}else{
			Node newNode=new Node(key, value);
			currentSize++;
			if(beforeNode==null){
				newNode.setNextNode(firstNode);
				firstNode=newNode;
			}else{
				newNode.setNextNode(currentNode);
				beforeNode.setNextNode(newNode);
			}
		}
		return result;
	}

	@Override
	public V remove(K key) {
		V result=null;
		Node currentNode=firstNode;
		Node beforeNode=null;
		while(currentNode!=null && key.compareTo(currentNode.getKey())>0){
			beforeNode=currentNode;
			currentNode=currentNode.getNextNode();
		}
		if(currentNode!=null && key.compareTo(currentNode.getKey())==0){
			result=currentNode.getValue();
			beforeNode.setNextNode(currentNode.getNextNode());
		}
		return result;
	}

	@Override
	public V getValue(K key) {
		V result=null;
		Node currentNode=firstNode;
		while(currentNode!=null && key.compareTo(currentNode.getKey())>0)
			currentNode=currentNode.getNextNode();
		if(currentNode!=null && key.compareTo(currentNode.getKey())==0)
			result=currentNode.getValue();
		return result;
	}

	@Override
	public boolean contains(K key) {
		Node currentNode=firstNode;
		while(currentNode!=null && key.compareTo(currentNode.getKey())>0)
			currentNode=currentNode.getNextNode();
		return currentNode!=null;
	}

	@Override
	public boolean isEmpty() {
		return currentSize==0;
	}

	@Override
	public boolean isFull() {
		return false;
	}

	@Override
	public int getSize() {
		return currentSize;
	}

	@Override
	public void clear() {
		firstNode=null;
		currentSize=0;
	}

	@Override
	public void display() {
		System.out.println();
		Iterator keyiterator=getKeyIterator();
		Iterator<V> valueiterator=getValueIterator();
		while(keyiterator.hasNext() && valueiterator.hasNext()){
			System.out.print("["+keyiterator.next()+","+valueiterator.next()+"]"+" ");
		}
		System.out.println();
	}

	@Override
	public Iterator<K> getKeyIterator() {
		return new KeyIterator();
	}

	@Override
	public Iterator<V> getValueIterator() {
		return new ValueIterator();
	}

	private class KeyIterator implements Iterator<K>{

		private Node nextNode;

		public KeyIterator() {
			nextNode=firstNode;
		}

		@Override
		public boolean hasNext() {
			return nextNode!=null;
		}

		@Override
		public K next() {
			K result=nextNode.getKey();
			nextNode=nextNode.getNextNode();
			return result;
		}
	}

	private class ValueIterator implements Iterator<V>{

		private Node nextNode;

		public ValueIterator() {
			nextNode=firstNode;
		}

		@Override
		public boolean hasNext() {
			return nextNode!=null;
		}

		@Override
		public V next() {
			V result=nextNode.getValue();
			nextNode=nextNode.getNextNode();
			return result;
		}
	}

	private class Node {
		private K key;
		private V value;
		private Node next;
		private Node(K key,V value) {
			this(key,value,null);
		}

		private Node(K key,V value,Node next){
			this.key=key;
			this.value=value;
			this.next=next;
		}

		private K getKey(){
			return key;
		}

		private V getValue(){
			return value;
		}

		private void setValue(V value){
			this.value=value;
		}

		private Node getNextNode(){
			return next;
		}

		private void setNextNode(Node nextNode){
			next=nextNode;
		}
	}
}

public class main_SortedDictionary {
	
	private static Linked_Sorted_Dictionary<Integer, Integer> list;
	public static void main(String[] args) {
		list=new Linked_Sorted_Dictionary<Integer, Integer>();
		Random ra =new Random();
		for(int i=0;i<10;i++)
			list.add(ra.nextInt(100),ra.nextInt(100));
		list.display();
		list.remove(45);
		list.display();
	}
}

基于数组词典与基于链表词典的比较