线性表

一、线性表

    定义：存在唯一的头元素和尾元素，除第一个元素外，每一个元素有且仅有一个前驱，除最后一个元素外，每一个元素有且仅有一个后继

    分类：顺序表和链表

二、顺序表

       1.记录长度

       2.判空、清空、移除元素并返回

       3.增加元素，指定位置增加元素

       4.遍历

       5.容量的增加和缩小

          1）如果在插入元素时，容器的长度已经大于或等于容器容量，那么就要扩容：将重新创建一个容器时原容器的二倍，然后将原容器的元素copy到新容器中。

          2）如果在删除元素后，容器的长度已经小于容器容量的1/4，那么就要缩小容量：将重新创建一个容器时原容器的1/2，然后将原容器的元素copy到新容器中。

public class Sort01<T> implements Iterable<T> {

private T[] eles;
        //记录当前的长度
        private int N;
    //初始化
    public Sort01(int n) {
        this.eles= (T[]) new Object[n];
        this.N = 0;
    }
    //根据新容器的大小，来进行扩容
    public void resize(int newSize){
        //创建一个临时数组指向原数组
        T[] temp=eles;
        //创建新数组
       else=Arrays.copyOf(temp,newSize);

       //eles= (T[]) new Object[newSize];
        //将原数组的值拷贝到新数组
        /*1. for (int i=0;i<N;i++){
            eles[i]=temp[i];
        }*/
        //2.System.arraycopy(temp,0,eles,0,N);
    }
    //将线性表置为空
    public void clear(){
     this.N=0;
    }
    //判断当前线性表是否为空
    public boolean isEmpry(){
     return N==0;
    }

    //获取线性表的长度
    public int length(){
        return N;
    }
   //获取指定位置的元素
    public T get(int i){
        return eles[i];
    }
    //向线性表中添加元素
    public void insert(T t){
        if(N==eles.length){
            resize(eles.length*2);
        }
      eles[N++]=t;
    }
    //向指定位置添加元素

    public void insert(int i,T t){
        if(N==eles.length){
            resize(eles.length*2);
        }
      for (int j=N;j>i;j--){
          eles[j]=eles[j-1];
      }
        N++;
      eles[i]=t;
    }
    //删除指定位置元素，返回该元素
    public T remove(int i){
        T t = eles[i];
          for (int j=i;j<N-1;j++){
              eles[j]=eles[j+1];
          }
          N--;
        if(N<eles.length/4){
            resize(eles.length/2);
        }
        return t;
    }
    //查找元素第一次出现的位置
    public int indexOf(T t){
        for (int i=0;i<=N-1;i++){
            if (eles[i].equals(t)){
                return i;
            }
        }
        return -1;
    }

    /**
     * 顺序表遍历
     * 1）让类实现Iterable接口，重写iterator方法
     * 2）在类内部提供一个内部类SIterator,实现iteator接口，重写hasNext和Next方法
     */
    @Override
    public Iterator<T> iterator() {
        return new SIterator();
    }
    private class SIterator implements Iterator{
       private int c;
       public SIterator(){
           this.c=0;
       }
        /**
         * 是否还有元素
         * @return
         */
        @Override
        public boolean hasNext() {
            return c<N;
        }

        /**
         * 返回下一个元素
         */
        @Override
        public Object next() {
            return eles[c++];
        }
    }
}

public class SortTest {
    public static void main(String[] args) {

        Quence<String> list =new Quence<>(10);
        list.insert("张三");
        list.insert("李四");
        list.insert(1,"王五");
        //遍历
        list.forEach(quence-> System.out.println(quence));
        System.out.println("-------------");
        System.out.println(list.remove(1));
        System.out.println(list.get(1));
    }
}