java实现有序线性表

public interface SortedListInterface<T> {
	public boolean add(T newEntry);

	public T remove(T anEntry);
    
	public T remove(int givenPosition);
	
	public void clear();
    
	public T get(int givenPosition);
	
	public int get(T anEntry);

	public boolean contains(T anEntry);

	public int size();

	public boolean isEmpty();

	public boolean isFull();

	public void display();
}

/**
 * 
 * @author Administrator 有序链表
 * @param <T>
 */

public class SortedLinkedList<T extends Comparable<? super T>> implements
		SortedListInterface<T> {
	private Node firstNode;
	private int length;

	private class Node {
		private T data;
		private Node next;

		Node(T dataPortion) {
			data = dataPortion;
			next = null;

		}

		Node(T dataPortion, Node nextNode) {
			data = dataPortion;
			next = nextNode;
		}

		public T getData() {
			return data;
		}

		public void setData(T data) {
			this.data = data;
		}

		public Node getNext() {
			return next;
		}

		public void setNext(Node next) {
			this.next = next;
		}

	}

	public SortedLinkedList() {
		clear();
	}

	public Node getNodeAt(int givenPosition) {
		Node currentNode = firstNode;
		if (!isEmpty() && givenPosition >= 0 && givenPosition < length) {
			for (int i = 0; i < givenPosition; i++) {
				currentNode = currentNode.getNext();
			}
		} else {
			currentNode = null;
		}
		return currentNode;
	}

	@Override
	/**
	 * 迭代实现添加元素
	 */
	public boolean add(T newEntry) {
		Node newNode = new Node(newEntry);
		Node beforeNode = getNodeBefore(newEntry);
		if (isEmpty() || getNodeBefore(newEntry) == null) {
			newNode.setNext(firstNode);
			firstNode = newNode;

		} else {
			Node afterNode = beforeNode.getNext();
			newNode.setNext(afterNode);
			beforeNode.setNext(newNode);
		}
		length++;
		return true;
	}

	private Node getNodeBefore(T newEntry) {
		Node currentNode = firstNode;
		Node beforeNode = null;
		while ((currentNode != null)
				&& (newEntry.compareTo(currentNode.getData()) > 0)) {
			beforeNode = currentNode;
			currentNode = currentNode.getNext();
		}

		return beforeNode;
	}

	/**
	 * 递归实现添加元素
	 */
	// @Override
	// public boolean add(T newEntry) {
	// // TODO Auto-generated method stub
	// firstNode = add(newEntry, firstNode);
	// length++;
	// return true;
	// }
	//
	// private Node add(T newEntry, Node currentNode) {
	// if ((currentNode == null)
	// || newEntry.compareTo(currentNode.getData()) <= 0) {
	// currentNode=new Node(newEntry,currentNode);
	// } else {
	// Node afterNode =add(newEntry, currentNode.getNext());
	// currentNode.setNext(afterNode);
	// }
	// return currentNode;
	// }

	@Override
	public T remove(int givenPosition) {
		// TODO Auto-generated method stub
		T result = null;

		if (!isEmpty() && givenPosition >= 0 && givenPosition < length) {
			if (givenPosition == 0) {
				result = firstNode.getData();
				firstNode = firstNode.getNext();
			} else {
				Node before = getNodeAt(givenPosition - 1);
				Node remove = before.getNext();
				Node after = remove.getNext();
				before.setNext(after);
				result = remove.getData();
			}
			length--;
		} else {
			System.out.println("删除出错");
		}
		return result;
	}

	@Override
	public final void clear() {
		// TODO Auto-generated method stub
		firstNode = null;

		length = 0;
	}

	@Override
	public T get(int givenPosition) {
		// TODO Auto-generated method stub
		T result = null;
		if (!isEmpty() && givenPosition >= 0 && givenPosition < length)
			result = getNodeAt(givenPosition).getData();
		return result;
	}

	@Override
	public boolean contains(T anEntry) {
		// TODO Auto-generated method stub
		boolean isContain = false;
		Node currentnNode = firstNode;
		while (!isContain && currentnNode != null) {
			if (anEntry.equals(currentnNode.getData())) {
				isContain = true;
				System.out.println("包含该元素");
			} else {
				currentnNode = currentnNode.getNext();

			}

		}
		if (isContain == false)
			System.out.println("不包含该元素");
		return isContain;
	}

	@Override
	public int size() {
		// TODO Auto-generated method stub
		System.out.println("size :  " + length);
		return length;
	}

	@Override
	public boolean isEmpty() {
		// TODO Auto-generated method stub
		boolean result;
		if (length == 0 && firstNode == null) {
			result = true;
		} else {
			result = false;
		}
		return result;
	}

	@Override
	public boolean isFull() {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public void display() {

		// TODO Auto-generated method stub
		Node currentNode = firstNode;
		System.out.print("The list : ");
		while (currentNode != null) {
			System.out.print(currentNode.getData() + "  ");
			currentNode = currentNode.getNext();
		}
		System.out.println();
	}

	@Override
	public T remove(T anEntry)
	{
		T result=null;
		Node currenNode = firstNode;
		Node beforeNode = null;
		while (currenNode != null && anEntry.compareTo(currenNode.getData()) > 0) {
			beforeNode = currenNode;
			currenNode = currenNode.getNext();
		}
		if (currenNode != null && anEntry.equals(currenNode.getData())) {
			result = currenNode.getData();
			length--;
			if (currenNode == firstNode)
				firstNode = firstNode.getNext();
			else {
				beforeNode.setNext(currenNode.getNext());
			}


		} else {
			System.out.println("找不到该元素");
		}


		return result;
	}
		

	@Override
	public int get(T anEntry) {
		// TODO Auto-generated method stub

		return findFirstNode(anEntry, firstNode, -1);

	}

	private int findFirstNode(T anEntry, Node currentNode, int index) {
		if ((currentNode == null)
				|| anEntry.compareTo(currentNode.getData()) < 0) {
			return -1;
		} else if (anEntry.compareTo(currentNode.getData()) == 0) {
			return index + 1;

		} else
			return findFirstNode(anEntry, currentNode.getNext(), index + 1);

	}

	public static void main(String argv[]) {

		SortedLinkedList<Integer> list = new SortedLinkedList<Integer>();
		list.add(5);
		list.display();
		list.add(1);
		list.display();
		list.add(3);
		list.display();
		list.add(7);
		list.display();
		list.add(9);
		list.display();
		list.get(1);
		System.out.println(list.get(new Integer(6)));
		System.out.println(list.remove(new Integer(10)));
		list.display();
	}
}