表，队列，栈入门

表

表的定义

形如 $A_0$ ,$A_1$ ,…,$A_{N-1}$的一系列数据

表的简单数组实现

public class Array {
    public static void main(String[] args) {
        int []arr =new int[10];
        //生成一个两倍的新数组
        int []newarr= new int[arr.length*2];
        for (int i=0;i< arr.length;i++){
            newarr[i]=arr[i];
        }
    }
}

数组实现表分析：

1. 打印遍历表 printlist 以线性时间被执行
2. 查找表的元素 花费o（1） //直接通过下标查找
3. 插入或删除第一个元素，要将整个数组后移 花费o（n）
4. 插入或删除表的末尾，花费o（1）

链表

链表由节点组成，每一个节点都含有元素和后继节点的指针

分析：

1. 遍历表花费o（n）
2. 查找表的数据o（n）
3. 删除数据o（1）

collection接口

public interface Collection<E> extends Iterable<E> {
    int size();  //返回集合的项数
    boolean isEmpty(); //返回集合是否为空
    boolean contains(Object o); //如果o在集合中，返回true
    Iterator<E> iterator();
    Object[] toArray(); //集合变成对象数组
    <T> T[] toArray(T[] a);
    boolean add(E e);//添加元素进集合
    boolean remove(Object o); //删除元素
    boolean containsAll(Collection<?> c);
    boolean addAll(Collection<? extends E> c);
    boolean removeAll(Collection<?> c);
}

Iterator接口

通过iterator方法，每个集合可以创建返回一个iterator对象，并将当前位置的概念存储下来

使用iterator的remove会比Collection的remove方法效率要高，不需要寻找位置

对集合修改的时候 iterator会非法

public interface Iterator<E> {
    boolean hasNext();//是否存在下一项
    E next();//移到下一项
    default void remove() { //删除元素
        throw new UnsupportedOperationException("remove");
    }
    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

List接口

List接口继承了Collection接口

public interface List<E> extends Collection<E> {
    //数组内排序
    default void sort(Comparator<? super E> c) {
        Object[] a = this.toArray();
        Arrays.sort(a, (Comparator) c);
        ListIterator<E> i = this.listIterator();
        for (Object e : a) {
            i.next();
            i.set((E) e);
        }
    }
    //获取位置索引上的元素
     E get(int index);
}

ArrayList，LinkedList都实现了List接口

1. 在末端添加数据构造List 花费o（n）
2. 在前端添加数据 ，ArrayList花费o（$N^2$）,LinkedList花费O（N）
3. 计算List所有元素的和 LinkedList花费o（$N^2$），ArrayList花费o（N）

删除数据的讨论

例：删除表中偶数的数据

1. 一边遍历，一边remove，o（$N^2$）
2. 使用迭代器找LinkedList的节点 ，O（$N^2$）

public static void main(List<Integer> lst) {
    Iterator<Integer> iterator = lst.iterator();
    while (iterator.hasNext()){
        if (iterator.next()%2==0){
            iterator.remove();
        }
    } 
}

实现自己的ArrayList

public class MyArryList<E> implements Iterable<E> {
    //默认数组大小
    private static final int large= 10;
    //数组目前元素个数
    private int thisSize;
    //数组目前实体
    private E [] thisItem;
    /**
     * 构造器
     * @return void
     */
    public MyArryList(){
        doclear();
    }
    public void clear(){
        doclear();
    }
    /**
     * 初始化数组
     */
    private  void doclear(){
        thisSize=0;
        createArray(large);
    }
    public int size(){
        return thisSize;
    }
    public boolean isEmpty(){
        return size()==0;
    }
    /**
     * 数组大小匹配元素
     */
    private void trimtoSize(){
        createArray(size());
    }
    /**
     * get方法
     * @return E
     */
    public Object get(int index){
        //元素坐标越界
        if (index<0||index>size()) {
            return  new ArrayIndexOutOfBoundsException();
        }
        return thisItem[index];
    }
    /**
     * set方法
     * @param index 更新的坐标
     * @param a1 更新的数据
     * @return 更新前的数据
     */
    public Object set(int index,E a1){
        if (index<0||index>size()) {
            return  new ArrayIndexOutOfBoundsException();
        }
        E old = thisItem[index];
        thisItem[index]=a1;
        return old;
    }
    public boolean add(E x){
        add(size(),x);
        return true;
    }

    public void add(int size, E x) {
        //数组空间不够
        if (thisItem.length==size()){
            createArray(size()*2+1);
            for (int i = thisSize;i>size;i--) {
                //依次后移数据
                thisItem[i] = thisItem[i - 1];
            }
            thisItem[size]=x;
            thisSize++;
        }
    }
    public E remove(int index){
        E removeitem=thisItem[index];
        //集体前移一位
        for (int i=index;i<size()-1;i++){
            thisItem[i]=thisItem[i+1];
        }
        thisSize--;
        return removeitem;
    }
    /**
     * 扩容数组
     * 如果元素个数大于先有容量，则扩充数组
     * @param size
     */
    public void createArray(int size){
        if (size<thisSize){
            return;
        }
        E [] old= thisItem;
        E[] es = (E[]) new Object[size];
        //复制数据
        for (int i=0;i<thisSize;i++){
            es[i]=old[i];
        }
    }
    @Override
    public java.util.Iterator iterator() {
        return new ArrayListIterator();
    }
    private class ArrayListIterator implements java.util.Iterator<E>{

        private int current=0;
        @Override
        public boolean hasNext() {
            return current<size();
        }
        @Override
        public E next() {
            if (!hasNext()){
                throw new java.util.NoSuchElementException();
            }
            return thisItem[current++];
        }
        @Override
        public void remove() {
            MyArryList.this.remove(--current);
        }
    }
    @Override
    public void forEach(Consumer<? super E> action) {
    }
    @Override
    public Spliterator<E> spliterator() {
        return null;
    }
}

栈

定义

限制插入和删除只能在一个位置上的表，该位置是表的末端，叫做栈的顶

实现

1. 链表实现，插入表的顶端实现push，删除表的顶端实现pop
2. 数组实现，用一个数值指针N指向栈顶，空栈N=-1，push进栈后N+1，POP后N-1

应用

1. 平衡符号

   左右匹配符号就出栈，用来检查符号缺失

2. 后缀表达式

3. 方法调用，将本身函数的变量推进栈中（保护现场），失控递归可能使用掉全部的栈帧空间

队列

定义

插入在一端进行而删除则在另一端进行

实现

1. 数组实现
2. 链表实现

应用

缓冲队列

表的顶端实现push，删除表的顶端实现pop
2. 数组实现，用一个数值指针N指向栈顶，空栈N=-1，push进栈后N+1，POP后N-1

应用

1. 平衡符号

   左右匹配符号就出栈，用来检查符号缺失

2. 后缀表达式

3. 方法调用，将本身函数的变量推进栈中（保护现场），失控递归可能使用掉全部的栈帧空间

队列

定义

插入在一端进行而删除则在另一端进行

实现

1. 数组实现
2. 链表实现

应用

缓冲队列