《数据结构Java语言版》-- 顺序表

顺序表说的是存储结构，它的逻辑结构是线性表结构。线性表表的数据之间逻辑关系是：数据之间是顺序关系，即除了首位两个元素，其他元素都只有一个直接前驱，一个直接后继（首位元素无前驱，有一个后继，末位元素无后继，有一个前驱）。顺序表在存储的时候是存储在一片连续的地址区域，Java语言可以用数组实现顺序表的存储。

首先定义数据的操作接口类：

package com.snail.chapter2;

public interface List {
	/** 返回线性表的大小，即数据元素的个数 */
	public int getSize();

	/** 如果线性表为空返回true, 否则返回false。 */
	public boolean isEmpty();

	/** 判断线性表是否包含数据元素e */
	public boolean contains(Object e);

	/** 返回数据元素e在线性表中的序号 */
	public int indexOf(Object e);	
	
	/** 在线性表最后边添加数据 */
	public void add(Object e);
	
	/** 将数据元素e插入到线性表中i号位置 */
	public void insert(int i, Object e) throws IndexOutOfBoundsException;

	/** 将数据元素e插入到元素obj之前 */
	public boolean insertBefore(Object obj, Object e);

	/** 将数据元素e插入到元素obj之后 */
	public boolean insertAfter(Object obj, Object e);

	/** 删除线性表中序号为i的元素，并返回之该元素 */
	public Object remove(int i) throws IndexOutOfBoundsException;

	/** 删除线性表中第一个与e相同的元素 */
	public boolean remove(Object e);

	/** 替换线性表中序号为i的数据元素为e，返回原数据元素 */
	public Object replace(int i, Object e) throws IndexOutOfBoundsException;

	/** 返回线性表中序号为i的数据元素 */
	public Object get(int i) throws IndexOutOfBoundsException;
}

线性表实现类：

package com.snail.chapter2;

public class ArrayList implements List {

	private final int LEN = 8; // 数组默认大小
	private Strategy strategy; // 数组元素比较策略
	private int size;// 线性表中数据元素的个数
	private Object[] elements;// 数据元素数组

	/** 无参构造函数其实也是执行了有参构造函数，只不过传递了默认比较方法 */
	public ArrayList() {
		this(new DefaultStrategy());
	}

	/**
	 * @param strategy
	 *            该对象的类Strategy自定义实现了特定的比较方法
	 */
	public ArrayList(Strategy strategy) {
		this.strategy = strategy;
		size = 0; // 开始顺序表的大小为0
		elements = new Object[LEN];// 首先分配LEN个Object大小的空间
	}

	@Override
	public int getSize() {
		return this.size;// 直接返回当前size
	}

	@Override
	public boolean isEmpty() {
		return size == 0;// 为空即size=0
	}

	@Override
	public boolean contains(Object e) {
		for (int i = 0; i < size; i++) {
			if (strategy.equal(e, elements[i])) {
				return true;
			}
		}
		return false;
	}

	@Override
	public int indexOf(Object e) {
		for (int i = 0; i < size; i++) {
			if (strategy.equal(e, elements[i])) {
				return i;
			}
		}
		return -1;
	}

	public void add(Object e) {
		insert(size, e);
	}

	@Override
	public void insert(int i, Object e) throws IndexOutOfBoundsException {
		if (i < 0 || i > size) {
			throw new IndexOutOfBoundsException("插入数据下标越界");
		}
		if (size >= elements.length) {
			expandSpace();
		}
		for (int j = size; j > i; j--) {
			elements[j] = elements[j - 1];
		}
		elements[i] = e;
		size++;
	}

	/**
	 * 私有方法：扩充顺序表长度
	 */
	private void expandSpace() {
		Object[] a = new Object[elements.length * 2];
		for (int i = 0; i < elements.length; i++) {
			a[i] = elements[i];
		}
		elements = a;
	}

	@Override
	public boolean insertBefore(Object obj, Object e) {
		int i = indexOf(obj);
		if (i < 0) {
			return false;
		}
		insert(i, e);
		return true;
	}

	@Override
	public boolean insertAfter(Object obj, Object e) {
		int i = indexOf(obj);
		if (i < 0) {
			return false;
		}
		insert(i + 1, e);
		return true;
	}

	@Override
	public Object remove(int i) throws IndexOutOfBoundsException {
		if (i < 0 || i > size) {
			throw new IndexOutOfBoundsException("删除序号越界");
		}
		Object obj = elements[i];
		for (int j = i; j < size - 1; j++) {
			elements[i] = elements[i + 1];
		}
		elements[--size] = null;
		return obj;
	}

	@Override
	public boolean remove(Object e) {
		int i = indexOf(e);
		if (i < 0) {
			return false;
		}
		remove(i);
		return true;
	}

	@Override
	public Object replace(int i, Object e) throws IndexOutOfBoundsException {
		if (i < 0 || i >= size) {
			throw new IndexOutOfBoundsException("替换元素时，下标越界");
		}
		Object obj = elements[i];
		elements[i] = e;
		return obj;
	}

	@Override
	public Object get(int i) throws IndexOutOfBoundsException {
		if (i < 0 || i >= size) {
			throw new IndexOutOfBoundsException("获取元素时，下标越界");
		}
		return elements[i];
	}

}

上面实现类的构造方法中有一个参数为Strategy strategy，该类是为了实现不同数据类型的比较。通常Java本身的数据类型可以直接用equals方法比较内容是否相等，但是要比较自定义类是否相等，就需要我们去实现具体的比较方法。

下面是对Student类做相等比较的一个例子。

public class StudentStrategy implements Strategy {
	public boolean equal(Object obj1, Object obj2) {
		if (obj1 instanceof Student && obj2 instanceof Student) {
		Student s1 = (Student)obj1;
		Student s2 = (Student)obj2;
		return s1.getSId().equals(s2.getSId());
		}
		return false;		
    }
	public int compare(Object obj1, Object obj2) {
		if (obj1 instanceof Student && obj2 instanceof Student) {
		Student s1 = (Student)obj1;
		Student s2 = (Student)obj2;
		return s1.getSId().compareTo(s2.getSId());
		}
		return obj1.toString().compareTo(obj2.toString());
	}
}