算法与数据结构——表的实现

/*
 *LinkedList指向下一节点的链称为next链，最后一个next链的引用为null
 *
 * Java Collection中的表
 * 
 * 1.Iterator接口
 * 
 * Collection API位于java.util包中，扩展了Iterable接口
 * 实现Iterable的集合必须提供一个称为Iterator的方法 
 * 当编译器见到一个Iterable的增强for的时候，编译器就用对Iterable的调用来代替增强for已得到一个Iterator对象
 * 然后在此对象上调用next和haasnext
 * 
 * 尽量使用Iterable的remove而不是使用Collec的remove，原因如下：
 * （1).collection的remove方法必须首先找出要背删除的项，开销比较大
 *  (2).如果对正在迭代的集合进行结构上的改变（增删），那么这个迭代器就不再合法，而使用迭代器的remove方法时，这个迭代器仍然是合法的。
 * 
 *  2.List、ArrayList类和LinkedList类
 * 
 *  ArrayList，可增长数组，对get和set的调用花费常数时间，插入和删除的代价比较昂贵，ArrayList的在前端进行添加是O(n)的操作
 *  LinkedList，插入和删除的开销很小；不容易做索引，对get的调用相当昂贵，LinkedList对get的操作为O(n)
 * 搜索都比较低效
 * 
 */
import java.util.ArrayList;
import java.util.Iterator;
import java.util.NoSuchElementException;

public class MyArrayList<T> implements Iterable<T>{
    //设置默认长度
    private static final int DEFAULT_CAPACITY=10;
    private int size;
    private T[] Items;

    public MyArrayList(){
        doClear();
    }

    public void clear(){
        doClear();
    }

    public void doClear(){
        size=0;
        ensureCapacity(DEFAULT_CAPACITY);
    }

    public int size(){
        return size;
    }

    public boolean IsEmpty(){
        return size()==0;
    }

    public void trimToSize(){
        ensureCapacity(size());
    }

    public T get(int idx){
        if(idx<0 || idx>= size())
            throw new ArrayIndexOutOfBoundsException();
        return Items[idx];
    }

    public T set(int idx,T newVal){
        if(idx<0 || idx>= size())
            throw new ArrayIndexOutOfBoundsException();
        T old=Items[idx];
        Items[idx]=newVal;
        return old;
    }

    public void ensureCapacity(int cap){
        if(cap < size)
            return;
        T[] old=Items;
        Items=(T[])new Object[cap];
        for(int i=0; i<size();i++)
            Items[i]=old[i];
    }

    public boolean add(T x){
        add(size(),x);
        return true;
    }

    public void add(int idx,T x){
        if(Items.length==size())
            ensureCapacity(size()*2+1);
        for(int i=size;i>idx;i--)
            Items[i]=Items[i-1];
        Items[idx]=x;
        size++;
    }

    public T remove(int idx){
        T removedItem=Items[idx];
        for(int i=idx;i<size()-1;i++)
            Items[i]=Items[i+1];
        size--;
        return removedItem;
    }

    public Iterator<T> iterator(){
        return new ArrayListIterator();
    }

    private  class ArrayListIterator<T> implements Iterator<T>{
        private int current=0;
//        private MyArrayList<T> marr;
//
//        public ArrayListIterator(MyArrayList<T> alist){
//            marr=alist;
//        }
        public boolean hasNext(){
            return current< size();
        }

        public T next(){
            if(!hasNext())
                throw new NoSuchElementException();
            return (T) Items[current++];
        }

        public void remove(){
            MyArrayList.this.remove(--current);
        }
    }

    public static void main(String[] args){
        MyArrayList myarr=new MyArrayList();
        myarr.add(6);
        myarr.add(8);
        myarr.add(10);
        Iterator it=myarr.iterator();
        while(it.hasNext()){
            int next= (int) it.next();
            System.out.println(next);
        }
    }
}
算法与数据结构——表的实现

猜你喜欢
