数据结构——线性表

package java.util;

public class SeriesList<E> {

private Object[] elements;

//存储数据个数
private int size;

//修改次数
protected transient int modCount = 0;

public SeriesList(int length) {
elements = new Object[length];
}

private SeriesList() {
this(10);
}

/**
* 通过索引获取
* @param i
* @return
*/
public E get(int i) {
rangeCheck(i);
return (E) elements[i];
}

/**
* 添加
* @param e
*/
public boolean add(E e) {
ensureCapacity(size+1);
elements[size++]=e;
return true;
}

/**
* 删除
*/
public E remove(int i){
rangeCheck(i);
modCount++;
E oldValue = (E) elements[i];

int numMoved = size - i - 1;
if (numMoved > 0)
System.arraycopy(elements, i+1, elements, i,
numMoved);
elements[--size] = null; // Let gc do its work

return oldValue;
}

/**
* 清空
*/
public void clear() {
modCount++;

// Let gc do its work
for (int i = 0; i < size; i++)
elements[i] = null;

size = 0;
}

/**
* 确保数组的长度足够保存相关数据
* @param minCapacity
*/
private void ensureCapacity(int minCapacity) {
modCount++;
int oldLength = elements.length;
if(oldLength<minCapacity) {
int newLength = oldLength*3/2+1;
if(newLength<minCapacity) {
newLength = minCapacity;
}
elements = Arrays.copyOf(elements, newLength);
}
}

/**
* 检查角标越界
* @param i
*/
private void rangeCheck(int i) {
if( i>=size ) {
throw new IndexOutOfBoundsException("Index:"+i+",Size:"+size);
}
}

}

package java.util;

public class LinkedList<E> {

private transient int size = 0;

private transient Entry header = new Entry<E>(null, null, null);

private Entry<E> next;

public LinkedList () {
header.next=header.pre=header;
}

/**
* 添加
* @param e
*/
public void add(E e) {
addBefore(e,header);
}

/**
* 按索引查找
* @return
*/
public E get(int index) {
return entry(index).element;
}

/**
* 查找数据节点
* @return
*/
private Entry<E> entry(int i){
if(i<0||i>=size) {
throw new IndexOutOfBoundsException("Index: "+i+
", Size: "+size);
}

Entry<E> e = header;

if (i < (size >> 1)) {
for (int j = 0; j <= i; j++)
e = e.next;
} else {
for (int j = size; j > i; j--)
e = e.pre;
}
return e;

}
/**
* 删除
* @param index
* @return
*/
public E remove(int index) {
return remove(entry(index));
}

private E remove(Entry<E> e) {
if (e == header)
throw new NoSuchElementException();

E result = e.element;
e.pre.next = e.next;
e.next.pre = e.pre;
e.next = e.pre = null;
e.element = null;
size--;
return result;
}

public Entry addBefore(E e, Entry<E> entry) {
Entry newEntry = new Entry<E>(e, entry.pre, entry);
newEntry.next.pre=newEntry;
newEntry.pre.next=newEntry;
size++;
return newEntry;
}

private static class Entry<E> {

E element;

Entry<E> pre;

Entry<E> next;

public Entry(E element,Entry<E> pre,Entry<E> next){
this.element = element;
this.pre = pre;
this.next = next;
}

}

}