线性表(LinearList)

1，抽象数据类型

public interface LinearList {
	public boolean isEmpty();
	public int size();
	public Object get(int index);
	public int indexOf(Object theElement);
	public Object remove(int index);
	public void add(int index, Object theElement);
	public String toString();
}

2，数组表示形式

public class ArrayLinearList implements LinearList {
	protected Object[] element;
	protected int size;

	public ArrayLinearList(int initialCapacity) {
		if (initialCapacity < 1)
			throw new IllegalArgumentException("initialCapacity must be >= 1");
		element = new Object[initialCapacity];
	}

	public ArrayLinearList() {
		this(10);
	}

	public boolean isEmpty() {
		return size == 0;
	}

	public int size() {
		return size;
	}

	private void checkIndex(int index) {
		if (index < 0 || index >= size)
			throw new IndexOutOfBoundsException("index = " + index + "  size = " + size);
	}

	public Object get(int index) {
		checkIndex(index);
		return element[index];
	}

	public int indexOf(Object theElement) {
		for (int i = 0; i < size; i++)
			if (element[i].equals(theElement))
				return i;
		return -1;
	}

	public Object remove(int index) {
		checkIndex(index);
		Object removedElement = element[index];
		for (int i = index + 1; i < size; i++)
			element[i - 1] = element[i];
		element[--size] = null;
		return removedElement;
	}

	public void add(int index, Object theElement) {
		if (index < 0 || index > size)
			throw new IndexOutOfBoundsException("index = " + index
					+ "  size = " + size);
		if (size == element.length)
			element = ChangeArrayLength.changeLength1D(element, 2 * size);
		for (int i = size - 1; i >= index; i--)
			element[i + 1] = element[i];
		element[index] = theElement;
		size++;
	}

	public String toString() {
		StringBuffer s = new StringBuffer("[");
		for (int i = 0; i < size; i++)
			if (element[i] == null)
				s.append("null, ");
			else
				s.append(element[i].toString() + ", ");

		if (size > 0)
			s.delete(s.length() - 2, s.length()); // remove last ", "
		s.append("]");
		return new String(s);
	}

	public Iterator iterator() {
		return new ArrayLinearListIterator(this);
	}

	private class ArrayLinearListIterator implements Iterator {
		private ArrayLinearList list;
		private int nextIndex;

		public ArrayLinearListIterator(ArrayLinearList theList) {
			list = theList;
			nextIndex = 0;
		}

		public boolean hasNext() {
			return nextIndex < list.size;
		}

		public Object next() {
			if (nextIndex < list.size)
				return list.element[nextIndex++];
			else
				throw new NoSuchElementException("No next element");
		}

		public void remove() {
			throw new UnsupportedOperationException("remove not supported");
		}
	}
}

 3，链节点定义

public class ChainNode {
	public Object element;
	public ChainNode next;

	ChainNode() {
	}

	ChainNode(Object element) {
		this.element = element;
	}

	ChainNode(Object element, ChainNode next) {
		this.element = element;
		this.next = next;
	}
}

 4，链表表示

public class Chain implements LinearList {
	protected ChainNode firstNode;
	protected int size;

	public Chain(int initialCapacity) {
	}

	public Chain() {
		this(0);
	}

	public boolean isEmpty() {
		return size == 0;
	}

	public int size() {
		return size;
	}

	private void checkIndex(int index) {
		if (index < 0 || index >= size)
			throw new IndexOutOfBoundsException("index = " + index
					+ "  size = " + size);
	}

	public Object get(int index) {
		checkIndex(index);

		ChainNode currentNode = firstNode;
		for (int i = 0; i < index; i++)
			currentNode = currentNode.next;

		return currentNode.element;
	}

	public int indexOf(Object theElement) {
		ChainNode currentNode = firstNode;
		int index = 0;
		while (currentNode != null && !currentNode.element.equals(theElement)) {
			currentNode = currentNode.next;
			index++;
		}
		if (currentNode == null)
			return -1;
		else
			return index;
	}

	public Object remove(int index) {
		checkIndex(index);

		Object removedElement;
		if (index == 0) // remove first node
		{
			removedElement = firstNode.element;
			firstNode = firstNode.next;
		} else { // use q to get to predecessor of desired node
			ChainNode q = firstNode;
			for (int i = 0; i < index - 1; i++)
				q = q.next;

			removedElement = q.next.element;
			q.next = q.next.next; // remove desired node
		}
		size--;
		return removedElement;
	}

	public void add(int index, Object theElement) {
		if (index < 0 || index > size)
			throw new IndexOutOfBoundsException("index = " + index
					+ "  size = " + size);

		if (index == 0)
			firstNode = new ChainNode(theElement, firstNode);
		else {
			ChainNode p = firstNode;
			for (int i = 0; i < index - 1; i++)
				p = p.next;
			p.next = new ChainNode(theElement, p.next);
		}
		size++;
	}

	public String toString() {
		StringBuffer s = new StringBuffer("[");
		ChainNode currentNode = firstNode;
		while (currentNode != null) {
			if (currentNode.element == null)
				s.append("null, ");
			else
				s.append(currentNode.element.toString() + ", ");
			currentNode = currentNode.next;
		}
		if (size > 0)
			s.delete(s.length() - 2, s.length()); // remove last ", "
		s.append("]");
		return new String(s);
	}

	public Iterator iterator() {
		return new ChainIterator();
	}
	
	private class ChainIterator implements Iterator {
		private ChainNode nextNode;

		public ChainIterator() {
			nextNode = firstNode;
		}

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

		public Object next() {
			if (nextNode != null) {
				Object elementToReturn = nextNode.element;
				nextNode = nextNode.next;
				return elementToReturn;
			} else
				throw new NoSuchElementException("No next element");
		}

		public void remove() {
			throw new UnsupportedOperationException("remove not supported");
		}
	}
}