数据结构之线性表（MyArrayList、MyLinkedList）

线性表概述

线性表是最基本、最简单、也是最常用的一种数据结构。在线性表中数据元素之间的关系是线性，数据元素可以看成是排列在一条线上或一个环上。
线性表分为静态线性表和动态线性表，常见的有顺序表(静态的)、单向链表(动态的)和双向链表(动态的)。

顺序表(ArrayList)的实现

在这里我们提供便于使用的ArrayList泛型类的实现。为了避免与类库中的类相混，这里将把我们的类叫做MyArrayList。

1. MyArrayList将保持基础数组，数组的容量，以及存储在MyArrayList中的当前项数。
2. MyArrayList将提供一种机制以改变基础数组的容量。通过获得一个新数组，将老数组拷贝到新数组中来改变数组的容量，允许虚拟机回收老数组。
3. MyArrayList将提供get和set的实现。
4. MyArrayList将提供基本的例程，如size、isEmpty、和clear，它们是典型的单行程序；还提供remove，以及两种不同版本的add。如果数组的大小和容量相同，那么这两个add例程将增加容量。
5. MyArrayList将提供一个实现Iterator接口的类。这个类将存储迭代序列中的下一项的 下标，并提供next、hasNext和remove等方法的实现。MyArrayList的迭代器方法直接返回Iterator接口的该类的新构造的实例。

package 数据结构;

import java.util.Iterator;
public class MyArrayList<T>implements Iterable<T>{
   
    private T[] items;
    private int size;
    private static final int DEFAULT_CAPACITY=10;
    public MyArrayList(){
   //构造方法
        doClear();
    }
    public void clear(){
   //清空数组
        doClear();
    }
    private void doClear(){
   
        this.size=0;
        ensureCapacity(DEFAULT_CAPACITY);
    }
    private void ensureCapacity(int newCapacity){
   //扩容
        if(newCapacity<size)
            return;
        T[] oldArr=items;//存储对原始数组的一个引用
        this.items=(T[])new Object[newCapacity];//为新数组分配内存，因为泛型数组的创建是非法的，所以使用一个数组进行类型转换
        for(int i=0;i<size;i++){
   
            items[i]=oldArr[i];
        }
    }
    public int size(){
   
        return size;
    }
    public boolean isEmpty(){
   
        return size==0;
    }
    public T get(int index){
   
        if(index>size||index<0)
            throw new ArrayIndexOutOfBoundsException();
        return items[index];
    }
    public T set(int index,T t){
   
        if(index>size||index<0)
            throw new ArrayIndexOutOfBoundsException();
        T old=items[index];
        items[index]=t;
        return old;
    }
    public boolean add(T t){
   
        add(size(),t);
        return true;
    }
    public void add(int index,T t){
   
        if(size()==items.length){
   
            ensureCapacity(items.length*2+1);
        }
        for(int i=size()-1;i>=index;i--){
   //移动数组
            items[i+1]=items[i];
        }
        items[index]=t;
        size++;
    }
    public void remove(int index){
   
        for(int i=index;i<items.length-1;i++){
   
            items[i]=items[i+1];
        }
        size--;
    }
    public Iterator<T>iterator(){
   
        return new MyArrayListIterator();
    }
    private class MyArrayListIterator implements Iterator<T>{
   
        private int current=0;
        public boolean hasNext(){
   
            return current<size;
        }
        public T next(){
   
            if(!hasNext())
                throw new java.util.NoSuchElementException();
            return items[current++];
        }
        public void remove(){
   
            MyArrayList.this.remove(--current);
        }
    }
}

测试类：

package 数据结构;

import java.util.Iterator;
public class Test1{
   
    public static void main(String[] args){
   
        MyArrayList<Integer>list=new MyArrayList<>();
        for(int i=0;i<10;i++){
   
            list.add(i);
        }
        Iterator<Integer> it=list.iterator();
        /*while (it.hasNext()) {
            System.out.print(it.next()+" ");
        }*/
        for(int i=0;i<10;i++){
   
        	System.out.print(list.get(i)+" ");
        }
    }
}

链表（LinkedList）的实现

为了表示每个数据元素ai与其直接后继数据元素ai+1之间的逻辑关系，对数据元素ai来说，除了存储其本身的信息之外，还需存储一个指示其直接后继的信息（即直接后继的存储位置）。我们把存储数据元素信息的域称为数据域，把存储直接后继位置的域称为指针域。指针域中存储的信息称作指针或链。这两部分信息组成数据元素ai的存储映像，称为结点（Node）。
n个结点（ai的存储映像）链接成一个链表，即为线性表（a1，a2，…，an）的链式存储结构，因为此链表的每个结点中只包含一个指针域，所以叫做单链表。

package DS02.动态链表;

import DS01.动态数组.List;

import java.util.Iterator;

public class LinkedList<E> implements List<E> {
   
    private Node head;
    private Node rear;
    private int size;
    public LinkedList(){
   
        head=new Node();
        rear=head;
    }
    private class Node{
   
        E data;
        Node next