package list;/*** Description: 线性表的接口，使用泛型保证类型** @ClassName: List* @author 过道* @date 2018年8月13日 上午10:45:13*/
public interface ListInterface<T> {public void add(T newEntry);public void add(Integer newPosition, T newEntry);public T remove(int givePosition);public void clear();public T replace(int givenPosition, T newEntry);public T getEntry(int givenPosition);public T[] toArray();public boolean contains(T anEntry);public int getLength();public boolean isEmpty();
}

/*** 为了区分java默认的 ArrayList和我的list，所以命名为AList* 因为内部没有实现，所以很简单，就没有写注释*/
public class AList<T> implements ListInterface<T> {@Overridepublic void add(T newEntry) {}@Overridepublic void add(Integer newPosition, T newEntry) {}@Overridepublic T remove(int givePosition) {return null;}@Overridepublic void clear() {}@Overridepublic T replace(int givenPosition, T newEntry) {return null;}@Overridepublic T getEntry(int givenPosition) {return null;}@Overridepublic T[] toArray() {return null;}@Overridepublic boolean contains(T anEntry) {return false;}@Overridepublic int getLength() {return 0;}@Overridepublic boolean isEmpty() {return false;}}

public class AList<T> implements ListInterface<T> {//空数组，用来存放数据T[] list = null;// 当前有效的数字个数int numberOfEntries = 0;//如果用户不给定容量(强烈建议初始化时给定容量)， 默认的数组容量static final int DEFAULT_CAPACITY = 27;@SuppressWarnings("unchecked")public AList(int initialCapacity) {T[] tempList = (T[]) new Object[initialCapacity];list = tempList;numberOfEntries = 0;}public AList() {this(DEFAULT_CAPACITY);}// 其余覆盖的方法
}

    @Overridepublic void add(T newEntry) {// 与ArrayList 不同，我们选择下标从 1 开始。list[numberOfEntries + 1] = newEntry;numberOfEntries++;ensureCapacity();//也可以选择重用其他方法
//        add(numberOfEntries+1,newEntry);
// 这样重用，能有效减少代码，但是理解上稍微有些困难。并且增加了许多无谓的判断，降低了效率(当然这无所谓)
    }/*** 指定位置进行添加某一个数字** @param newPosition* @param newEntry*/@Overridepublic void add(Integer newPosition, T newEntry) {if ((newPosition >= 1) && (newPosition <= numberOfEntries + 1)) {if (newPosition <= numberOfEntries) {makeRoom(newPosition);  // 将给定位置的数字及后续数字全部后移。
            }list[newPosition] = newEntry;numberOfEntries++;ensureCapacity();   // 为下次添加获取足够的空间} else {throw new IndexOutOfBoundsException("给定位置不合法，下标越界");}}/*** @param newPosition*/private void makeRoom(Integer newPosition) {assert (newPosition >= 1) && (newPosition <= newPosition + 1);  //断言，如果不满足断言，则报错，需要手动开启assertint newIndex = newPosition;int lastIndex = numberOfEntries;for (int index = 0; index < newIndex; index++) {list[index + 1] = list[index];  //给定位置之后的数字全部后移一位，将给定位置‘空’下来
        }}/*** 倍扩容量*/private void ensureCapacity() {int capacity = list.length - 1;if (numberOfEntries >= capacity) {int newCapacity = 2 * capacity;list = Arrays.copyOf(list, newCapacity + 1);}}

    @Overridepublic int getLength() {return numberOfEntries;}@Overridepublic boolean isEmpty() {return numberOfEntries == 0;}@Overridepublic void clear() {list = null;    //取消引用，等待GC回收numberOfEntries = 0;}

    @Overridepublic T remove(int givePosition) {if ((givePosition >= 1) && (givePosition <= numberOfEntries)) {assert !isEmpty();T result = list[givePosition];if (givePosition < numberOfEntries) {removeGap(givePosition);    // 移除后出现空隙，我们让之后的元素前移一位，弥补空隙
            }return result;}return null;}/*** 给定位置为空隙，后续元素前进一位，补上空隙*/private void removeGap(int givePosition) {assert (givePosition >= 1) && (givePosition < numberOfEntries);int removedIndex = givePosition;int lastIndex = numberOfEntries;for (int index = givePosition; index < lastIndex; index++) {list[index] = list[index + 1];}}

/*** Trims the capacity of this <tt>ArrayList</tt> instance to be the* list's current size.  An application can use this operation to minimize* the storage of an <tt>ArrayList</tt> instance.*/public void trimToSize() {modCount++;if (size < elementData.length) {elementData = (size == 0)? EMPTY_ELEMENTDATA　　　　// 这是个空数组 ---> {}: Arrays.copyOf(elementData, size);　　//吧数字copy进去，给一个size容量}}

@Overridepublic T[] toArray() {/* 这里千万不能返回我们使用的T[] list* 因为用户可能会对返回数组进行修改，* 如果返回list,那么封装失败。* 也就是说用户可以不使用我们提供的方法进行操作List，这是很恐怖的事情。*/T[] result = (T[]) new Object[numberOfEntries];for (int index = 0; index < numberOfEntries; index++) {result[index] = list[index + 1];}return result;}

    @Overridepublic T replace(int givenPosition, T newEntry) {if ((givenPosition >= 1) && (givenPosition <= numberOfEntries)) {assert !isEmpty();T oldEntry = list[givenPosition];list[givenPosition] = newEntry;return oldEntry;}//省去报错的部分return null;}@Overridepublic T getEntry(int givenPosition) {// 判断给定位置是否合法，不合法就报错。if ((givenPosition >= 1) && (givenPosition <= numberOfEntries)) {assert !isEmpty();return list[givenPosition];}//else就报错，我省去此步return null;}@Overridepublic boolean contains(T anEntry) {boolean found = false;int index = 1;// 遍历寻找，找到一个就结束循环。while (!found && (index <= numberOfEntries)) {if (anEntry.equals(list[index])) {found = true;}index++;}return found;}

package list;import java.util.Arrays;/*** 为了区分java默认的 ArrayList和我的list，所以命名为ArrayList*/
public class AList<T> implements ListInterface<T> {T[] list = null;int numberOfEntries = 0;static final int DEFAULT_CAPACITY = 27;@SuppressWarnings("unchecked")public AList(int initialCapacity) {T[] tempList = (T[]) new Object[initialCapacity];list = tempList;numberOfEntries = 0;}public AList() {this(DEFAULT_CAPACITY);}@Overridepublic void add(T newEntry) {// 与ArrayList 不同，我们选择下标从 1 开始。list[numberOfEntries + 1] = newEntry;numberOfEntries++;ensureCapacity();//也可以选择重用其他方法
//        add(numberOfEntries+1,newEntry);
// 这样重用，能有效减少代码，但是理解上稍微有些困难。并且增加了许多无谓的判断，降低了效率(当然这无所谓)
    }/*** 指定位置进行添加某一个数字** @param newPosition* @param newEntry*/@Overridepublic void add(Integer newPosition, T newEntry) {if ((newPosition >= 1) && (newPosition <= numberOfEntries + 1)) {if (newPosition <= numberOfEntries) {makeRoom(newPosition);  // 将给定位置的数字及后续数字全部后移。
            }list[newPosition] = newEntry;numberOfEntries++;ensureCapacity();   // 为下次添加获取足够的空间} else {throw new IndexOutOfBoundsException("给定位置不合法，下标越界");}}/*** @param newPosition*/private void makeRoom(Integer newPosition) {assert (newPosition >= 1) && (newPosition <= newPosition + 1);  //断言，如果不满足断言，则报错，需要手动开启assertint newIndex = newPosition;int lastIndex = numberOfEntries;for (int index = 0; index < newIndex; index++) {list[index + 1] = list[index];  //给定位置之后的数字全部后移一位，将给定位置‘空’下来
        }}@Overridepublic T remove(int givePosition) {if ((givePosition >= 1) && (givePosition <= numberOfEntries)) {assert !isEmpty();T result = list[givePosition];if (givePosition < numberOfEntries) {removeGap(givePosition);    // 移除后出现空隙，我们让之后的元素前移一位，弥补空隙
            }return result;}return null;}/*** 给定位置为空隙，进行弥补空隙，** @param givePosition*/private void removeGap(int givePosition) {assert (givePosition >= 1) && (givePosition < numberOfEntries);int removedIndex = givePosition;int lastIndex = numberOfEntries;for (int index = givePosition; index < lastIndex; index++) {list[index] = list[index + 1];}}@Overridepublic void clear() {list = null;    //取消引用，等待GC回收numberOfEntries = 0;}@Overridepublic T replace(int givenPosition, T newEntry) {if ((givenPosition >= 1) && (givenPosition <= numberOfEntries)) {assert !isEmpty();T oldEntry = list[givenPosition];list[givenPosition] = newEntry;return oldEntry;}return null;}@Overridepublic T getEntry(int givenPosition) {if ((givenPosition >= 1) && (givenPosition <= numberOfEntries)) {assert !isEmpty();return list[givenPosition];}//else就报错，我省去此步return null;}@Overridepublic T[] toArray() {T[] result = (T[]) new Object[numberOfEntries];for (int index = 0; index < numberOfEntries; index++) {result[index] = list[index + 1];}return result;}@Overridepublic boolean contains(T anEntry) {boolean found = false;int index = 1;while (!found && (index <= numberOfEntries)) {if (anEntry.equals(list[index])) {found = true;}index++;}return found;}@Overridepublic int getLength() {return numberOfEntries;}@Overridepublic boolean isEmpty() {return numberOfEntries == 0;}/*** 倍扩容量*/private void ensureCapacity() {int capacity = list.length - 1;if (numberOfEntries >= capacity) {int newCapacity = 2 * capacity;list = Arrays.copyOf(list, newCapacity + 1);}}
}

int newCapacity = oldCapacity + (oldCapacity >> 1);//old + (old容量/ 2)

package list;/*** 为了区分LinkedList，所以命名为LList，但本质都是双向链表* 下标从 1 开始，与java源码不同（以0开始）*/
public class LList<T> implements ListInterface<T> {@Overridepublic void add(T newEntry) {}@Overridepublic void add(Integer newPosition, T newEntry) {}@Overridepublic T remove(int givePosition) {return null;}@Overridepublic void clear() {size = 0;first = null;}@Overridepublic T replace(int givenPosition, T newEntry) {return null;}@Overridepublic T getEntry(int givenPosition) {return null;}@Overridepublic T[] toArray() {return null;}@Overridepublic boolean contains(T anEntry) {return false;}@Overridepublic int getLength() {return 0;}@Overridepublic boolean isEmpty() {return false;}}

public class LList<T> implements ListInterface<T> {int size;Node firstNode;// 链式实现无法给定容量，所以一个无参构造即可。public LList() {size = 0;firstNode = null;}//省去覆盖方法// 单向结点，只需要next和data就足够了class Node {T data;Node next;public Node() {}public Node(T data) {this(data, null);}public Node(T data, Node next) {this.data = data;this.next = next;}}
}

    @Overridepublic void add(T newEntry) {// 尾部位置进行添加
        add(size, newEntry);}@Overridepublic void add(Integer newPosition, T newEntry) {Node newNode = new Node(newEntry);if (newPosition == 1) {//头结点插入newNode.next = firstNode;firstNode = newNode;} else if (newPosition > 1 && newPosition <= size) {Node beforeNode = firstNode;int count = 1;// 找到链表对应位置的前一位，进行插入操作while (count != newPosition - 1) {beforeNode = beforeNode.next;count++;}// 插入元素newNode.next = beforeNode.next;    // 链接起来了beforeNode.next = newNode;} else {throw new IndexOutOfBoundsException("给定位置越界");}}

package list;/*** 为了区分LinkedList，所以命名为LList，但本质都是双向链表* 下标从 1 开始，与java源码不同（以0开始）*/
public class LList<T> implements ListInterface<T> {private int size;private Node firstNode;public LList() {size = 0;firstNode = null;}@Overridepublic void add(T newEntry) {// 尾部位置进行添加
        add(size, newEntry);}@Overridepublic void add(Integer newPosition, T newEntry) {Node newNode = new Node(newEntry);if (newPosition == 1) {//头结点插入newNode.next = firstNode;firstNode = newNode;} else if (newPosition > 1 && newPosition <= size) {Node beforeNode = firstNode;int count = 1;// 找到链表对应位置的前一位，进行插入操作while (count != newPosition - 1) {beforeNode = beforeNode.next;count++;}// 插入元素newNode.next = beforeNode.next;    // 链接起来了beforeNode.next = newNode;} else {throw new IndexOutOfBoundsException("给定位置越界");}}@Overridepublic T remove(int givePosition) {T result;if ((givePosition >= 1) && (givePosition <= size)) {assert !isEmpty();if (givePosition == 1) {// 头结点的移除result = firstNode.data;firstNode = firstNode.next;} else {Node nodeBefore = getNodeAt(givePosition - 1);Node nodeToRemove = nodeBefore.next;result = nodeBefore.data;Node nodeAfter = nodeToRemove.next;nodeBefore.next = nodeAfter;    // 断开移除结点的两侧
            }size--;return result;} elsethrow new IndexOutOfBoundsException("下标越界");}private Node getNodeAt(int i) {if (i > 0 && i <= size) {Node curNode = firstNode;for (int j = 0; j < i; j++)curNode = curNode.next;return curNode;} elsethrow new IndexOutOfBoundsException("下标越界");}@Overridepublic void clear() {size = 0;firstNode = null;}@Overridepublic T replace(int givenPosition, T newEntry) {// 判断和报错都交给 getNodeAt 方法去做Node nodeToReplace = getNodeAt(givenPosition);T result = nodeToReplace.data;nodeToReplace.data = newEntry;return result;}@Overridepublic T getEntry(int givenPosition) {return getNodeAt(givenPosition).data;}@Overridepublic T[] toArray() {T[] result = (T[]) new Object[size];Node curNode = firstNode;for (int i = 0; i < size; i++) {result[i] = curNode.data;}return null;}@Overridepublic boolean contains(T anEntry) {Node curNode = firstNode;boolean found = false;while (!found && curNode != null) {if (curNode.data.equals(anEntry)) {found = true;}curNode = curNode.next;}return found;}@Overridepublic int getLength() {return size;}@Overridepublic boolean isEmpty() {boolean result = false;// 为了提供更多的报错信息，在这里使用断言，需要手动开启断言功能。且程序开发中不建议使用。if (size == 0) {assert firstNode == null;result = true;} else {assert firstNode != null;result = false;}return result;}class Node {T data;Node next;public Node() {}public Node(T data) {this(data, null);}public Node(T data, Node next) {this.data = data;this.next = next;}}
}