线性表的顺序和链式存储结构

1、线性表：每个元素一个前驱一个后继，一个第一元素，一个最后一个元素
2、实现
      顺序结构实：所有元素用一组连续的地址空间来存储
      链式结构实现：通过指向的方式来寻找下一个节点
3、顺序结构只要知道表的起始地址就能随机的访问任意元素的位置，所以线性表的顺序存储结构也是一种随机存储结构。
      顺序结构的简易实现：
      public class ArrayList  {
    /* 存储数据的数组 */
    private Object[] objects;
    /* 当前元素的个数 */
    private int size;
    /* 数组的容量 */
    private int length;
    /* 数组大小太大时增加容量大小 */
    private int addsize = 10;
    
    public ArrayList() {
        // 默认构造方法的实现
        size = 0;
        length = 10;
        objects = new Object[length];
    }
    
    public ArrayList(int length) {
        size = 0;
        this.length = length;
        objects = new Object[length];
    }
    
    public void clear() {
        for(int i=0; i<size; i++) {
            objects[i] = null;
        }

    }
    
    public boolean isEmpty() {
        return size==0;
    }
    public int size() {
        return size;
    }
    
    private void rangeCheck(int index) {
        if(index>=size) {
            throw new IndexOutOfBoundsException("index:" + index+",size:" + size);
        }
    }
    public Object get(int i) {
        rangeCheck(i);
        return objects[i];
    }
    
    private void sureCapicaty(int minsize) {
        if(length<minsize) {
            // 空间不足，要增加分配
            Object[] temp = objects;
            int tlength = length;
            length += addsize;
            objects = new Object[length];
            for(int i=0;i<tlength; i++) {
                objects[i] = temp[i];
            }
        }
    }
    // 增加一个元素，在末尾增加
    public void add(Object o) {
        sureCapicaty(size+1);
        objects[size++] = o;
    }
    // 指定位置上增加元素o
    public void add(int i,Object o) {
        sureCapicaty(size+1);
        for(int j=size;j>=i;j--) {
            objects[j+1] = objects[j];
        }
        objects[i] = 0;
        size++;
    }
    // 移除一个元素
    public void remove(int i) {
        rangeCheck(i);
        for(int j=i;j<size;j++) {
            objects[j] = objects[j+1];
        }
        size--;
    }
    
    public static void main(String[] args)
    {
        ArrayList list = new ArrayList(3);
        list.add(1);
        list.add(2);
        list.add(3);
        System.out.println(list.get(0));
        list.add(0, 3);
        System.out.println(list.get(0));
        System.out.println(list.get(1));
        System.out.println(list.get(2));
        
        list.remove(1);
        System.out.println(list.get(0));
        System.out.println(list.get(1));
        System.out.println(list.get(2));
        System.out.println(list.get(3));
    }
    
}
4、链式结构的实现，克服了顺序实现在插入和删除时元素的移动，同时也失去了顺序结构对元素的随机访问。
5、C语言中实现链式的结构可基于指针的实现，每个元素除了有数据项外，还包含指向下一个元素的指针（地址），当中也在包含指向上一个元素的地址形成双向链表，
      在JAVA中是没有指针这个概念，我们可让元素的数据项保存外，下一项或者上一项，用一个对象来存储即可。当然 其实意思还是一样的。效果也一样。
6、链式结构的基本JAVA实现
      public class LinkedList<E> {
    /* 当前元素数量 */
    private int size;
    
    private Entry<E> header;
    
    public LinkedList() {
        size = 0;
        header = new Entry<E>(null, null);
    }
    
    public void addFirst(E o) {
        size ++;
        Entry<E> newE = new Entry<E>(o, header.next);
        header.next = newE;
    }
    
    public void addLast(E o) {
        size++;
        Entry<E> nowc = header;
        while(nowc.next!=null) nowc = nowc.next;
        Entry<E> newE = new Entry<E>(o, null);
        nowc.next = newE;
    }
    
    public E getFirst() {
        return header.next.data;
    }
    public E getLast() {
        Entry<E> nowc = header;
        while(nowc.next!=null) nowc = nowc.next;
        return nowc.data;
    }
    
    public E getIndex(int index) {
        if(index >= size) {
            throw new IndexOutOfBoundsException("size:" + size+",index:" + index);
        }
        Entry<E> nowc = header.next;
        int i=0;
        while(nowc.next!=null && (i!=index)) {
            i++;
            nowc = nowc.next;
        }
        return nowc.data;
    }
    
    public E delete(int index) {
        if(index<0) throw new IndexOutOfBoundsException("index:" + index);
        int i= 0;
        Entry<E> nowc = header;
        while(nowc.next!=null && i<index) {
            nowc = nowc.next;
            i++;
        }
        nowc.next = nowc.next.next;
        size--;
        return nowc.next.data;
        
    }
    
    public void add(int index,E o) {
        size++;
        Entry<E> nowc = header;
        int i=0;
        while(nowc.next!=null && (i!=index)) {
            i++;
            nowc = nowc.next;
        }
        Entry<E> in = new Entry<E>(o, nowc.next);
        nowc.next = in;
    }
    
    public int size()  {
        return size;
    }
    
    public void union(LinkedList<E> other) {
        Entry<E> nowA = header.next;
        Entry<E> nowB = other.header.next;
        Entry<E> nowC = header;
        this.size = this.size + other.size;
        while(nowA!=null && nowB!=null) {
            int a = (Integer) nowA.data;
            int b = (Integer)nowB.data;
            if(a<b) {
                nowC.next = nowA;
                nowC = nowA;
                nowA = nowA.next;
                
            }else {
                nowC.next = nowB;
                nowC = nowB;
                nowB = nowB.next;
            }
        }
        nowC.next = nowA==null?nowB:nowA;
    }
    
    public static void main(String[] args)
    {
        LinkedList<Integer> list = new LinkedList<Integer>();
        list.addLast(1);
        list.addLast(3);
        list.addLast(5);
        
        LinkedList<Integer> list1 = new LinkedList<Integer>();
        list1.addLast(2);
        list1.addLast(4);
        list1.addLast(6);
        list.union(list1);
        
        System.out.println(list.getIndex(0));
        System.out.println(list.getIndex(1));
        System.out.println(list.getIndex(2));
        System.out.println(list.getIndex(3));
        System.out.println(list.getIndex(4));
        System.out.println(list.getIndex(05));
    }
}


class Entry<E> {
    public E data;
    public Entry<E> next;
    
    public Entry(E data,Entry<E> next) {
        this.data = data;
        this.next = next;
    }
}
7、循环链表：最后的一个节点的指针指向头指针就成的循环链表。
8、双向链表：每个数据同时拥有指向上一个节点和下一个节点的指针。
      JAVA的基本实现
   package voice;

/**
 * 双向循环链表
 *
 * @author jianfu
 *
 */
public class DoubleForLinkedList
{ /* 当前节点数 */
    private int size;
    /* 头节点 */
    private EntryB header;

    public DoubleForLinkedList()
    {
        // 构造空的表
        size = 0;
        header = new EntryB(null, null, null);
        // 空的时候下一个节点和上一个节点都节向自身
        header.next = header;
        header.prvious = header;
    }

    public void add(Object data)
    {
        // 默认在头部增加节点
        // 生成新节点
        // 新节点的下一个节点是header的next,上一个节点是header
        EntryB newL = new EntryB(data, header.next, header);
        // 头节点的下一个节点的上一个节点是新节点
        header.next.prvious = newL;
        // 头节点的下一节点是新节点
        header.next = newL;
        size ++;
    }

    public void addEnd(Object data)
    {
        // 在尾部增加节点
        // 生成新节点
        // 新节点的下一个节点是header,上一个节点是header的prvious
        EntryB newL = new EntryB(data, header, header.prvious);
        // 头节点的上一节点的下一节点是新节点
        header.prvious.next = newL;
        // 头节点的上一节点是新节点
        header.prvious= newL;
        size ++;
    }
    // 插入次序遍历节点
    public void showAfter() {
        EntryB c = header;
        while(c.prvious!=header) {
            c = c.prvious;
            System.out.println(c.data);
        }
    }
    // 插入次序反方向遍历节点
    public void showBefore() {
        EntryB c = header;
        while(c.next!=header) {
            c = c.next;
            System.out.println(c.data);
        }
    }
    /* 获取某个位置上的元素 */
    public EntryB getEntry(int index) {
        if(index >= size) {
            // 要求的位置超过总数，抛错
            throw new IndexOutOfBoundsException("size:" + size + ",index:" + index);
        }
        EntryB nowC = header.next;
        int i=0;
        while(nowC!=header && i<index) {
            i++;
            nowC = nowC.next;
        }
        return nowC;
    }
    
    public void insertBeforeIndex(int i,Object d) {
        // 在第i个位置的前面插入数据d
        // 获取i上的数据
        EntryB b = getEntry(i);
        EntryB newL = new EntryB(d,b,b.prvious);
        b.prvious.next = newL;
        b.prvious = newL;
    }
    public void insertAfterIndex(int i,Object d) {
        // 在第i个位置的后面插入数据d
        EntryB b = getEntry(i);
        EntryB newL = new EntryB(d,b.next,b);
        b.next.prvious = newL;
        b.next = newL;
        
        
    }
    /* 删除第i个节点 */
    public Object DeleteAtIndex(int i) {
        EntryB b = getEntry(i);
        b.prvious.next = b.next;
        b.next.prvious = b.prvious;
        return b.data;
    }
    public static void main(String[] args)
    {
        DoubleForLinkedList dfl = new DoubleForLinkedList();
        dfl.add(1);
        dfl.add(3);
        dfl.add(4);
        dfl.showAfter();
        System.out.println("=========");
        
        /**System.out.println(dfl.getEntry(0).data);
        System.out.println("------------------");
        
        DoubleForLinkedList dfl2 = new DoubleForLinkedList();
        dfl2.addEnd(1);
        dfl2.addEnd(3);
        dfl2.addEnd(4);
        dfl2.showAfter();
        System.out.println("=========");
        dfl2.showBefore();
        System.out.println(dfl2.getEntry(0).data);*/
        System.out.println("---------------------------");
        dfl.insertBeforeIndex(0, 2);
        dfl.showAfter();
        
        System.out.println("+++++++++++");
        System.out.println(dfl.DeleteAtIndex(0));
        
        System.out.println("]]]]]]]]]]]");
        dfl.showAfter();
    }
}

class EntryB
{
    /* 数据域 */
    public Object data;
    /* 下一个节点 */
    public EntryB next;
    /* 上一个节点 */
    public EntryB prvious;

    /* 构造节点 */
    public EntryB(Object data, EntryB next, EntryB prvious)
    {
        this.data = data;
        this.next = next;
        this.prvious = prvious;
    }
}