实现Array

实现数组

时间复杂度：  

• 增：O(n)   如果只对最后一个元素操作，依然是O(n)，因为resize
• 删：O(n)   如果只对最后一个元素操作，依然是O(n)，因为resize
• 改：已知索引O(1)，未知索引O(n)
• 查：已知索引O(1)，未知索引O(n)

无泛型

package com.lt.datastructure.Array;
/**
 * 二次封装自己的数组
 */
public class Array{
 
    private  int[] data;
       private int size;
       
       public Array(int capacity){
           data = new int[capacity];
           size = 0;
       }
       public Array(){ 
          this(10);
       }
       //获得数组元素个数
       public int getSize(){
           return size;
       }
       
       //获得数组容量
       public int getCapacity(){
           return data.length;
       }
       
       //判断数组是否为空
       public boolean isEmpty(){
           return size==0;
       }
       
       //向指定位置添加元素
       public void add(int index, int e){
           //判断插入位置，需要在0到size之间
           if(index<0 || index>size){
              throw new IllegalArgumentException("AddLast failed. Required 0=<index<size.");
           }
           //首先依然是保证数组有足够空间容纳
           if(size == data.length){
              resize(2*data.length);
           }
           //移位插入,index到size-1的位置的元素向后移位
           for(int i=size-1; i>=index ; i--){
               data[i+1] = data[i];
           }
           data[index] = e;
           size++;
        }
       //数组扩容
       private void resize(int capacity) {
       int[] newData = new int[capacity];    
       for(int i = 0; i<size; i++){
           newData[i] = data[i];
       }
       data = newData;
    }
    //向数组末尾添加一个元素
       public void addLast(int e){
          add(size,e);
       }
       
       //向数组头添加元素
       public void addFirst(int e){
           add(0,e);
       }
       
       //获取索引位置的元素
       int get(int index){
           if(index<0 || index>=size){
               throw new IllegalArgumentException("index is illegal");
           }
           System.out.println(data[index]);
           return data[index];
       }
       
       //设置指定位置的元素
       void set(int index,int e){
           if(index<0 || index>=size){
               throw new IllegalArgumentException("index is illegal");
           }
           data[index] = e;
       }
       
       //查找是否有元素e
       public boolean contains(int e){
           for(int i=0 ; i<data.length ; i++){
               if(data[i]==e)
                   return true;
           }
           return false;
       }
       
       //查找索引
       public int find(int e){
         for(int i=0; i<data.length; i++){
             if(data[i]==e)
                 return i;
         }
         return -1;
       }
       
       //删除指定位置元素,返回删除的元素
       public int remove(int index){
           if(index<0||index>=size){
              throw new IllegalArgumentException("index is illegal"); 
           }
           int ret = data[index];
           for(int i = index+1;i<size;i++){
               data[i-1] = data[i];
           }
           size--;
           if(size==data.length/2){
               resize(data.length/2);
           }
           return ret;
       }
       
       //移除第一个元素
       public int removeFirst(){
           return remove(0);
       }
       
       //移除最后一个元素
       public int removeLast(){
           return remove(size-1);
       }
       
       //移除某个元素
       public void removeElement(int e){
           int index = find(e);
           if(index!=-1)
           {
               remove(index);
           }
       }
       
       @Override//覆盖父类方法
       public String toString(){
           StringBuilder res = new StringBuilder();
           res.append(String.format("Array:size = %d , capacity = %d\n",size,data.length));
           res.append("[");
           for(int i = 0; i<size ; i++){
               res.append(data[i]);
               if(i!=size - 1)
                   res.append(",");
           }
           res.append("]");
           return res.toString();
       }
}

实现自己的泛型数组

package com.lt.datastructure.Array;
/**
 * 泛型数组
 * @author 李腾
 *
 * @param <E>
 */
public class Array1<E> {     
        private  E[] data;
           private int size;
           
           public Array1(int capacity){
               data = (E[]) new Object[capacity];
               size = 0;
           }
           public Array1(){ 
              this(10);
           }
           //获得数组元素个数
           public int getSize(){
               return size;
           }
           
           //获得数组容量
           public int getCapacity(){
               return data.length;
           }
           
           //判断数组是否为空
           public boolean isEmpty(){
               return size==0;
           }
           
           //向指定位置添加元素
           public void add(int index, E e){
               //判断插入位置，需要在0到size之间
               if(index<0 || index>size){
                  throw new IllegalArgumentException("AddLast failed. Required 0=<index<size.");
               }
               //保证数组有足够空间容纳
               if(size == data.length){
                    resize(2*data.length);
               }
               //移位插入,index到size-1的位置的元素向后移位
               for(int i=size-1; i>=index ; i--){
                   data[i+1] = data[i];
               }
               data[index] = e;
               size++;
            }
           
            //数组扩容
               private void resize(int capacity) {
               E[] newData = (E[]) new Object[capacity]; 
               for(int i=0; i<size; i++){
                   newData[i] = data[i];
               }
               data = newData;
            }
        
           //向数组末尾添加一个元素
           public void addLast(E e){
              add(size,e);
           }
           
           //向数组头添加元素
           public void addFirst(E e){
               add(0,e);
           }
           
           //获取索引位置的元素
           E get(int index){
               if(index<0 || index>=size){
                   throw new IllegalArgumentException("index is illegal");
               }
               System.out.println(data[index]);
               return data[index];
           }
           
           //设置指定位置的元素
           void set(int index,E e){
               if(index<0 || index>=size){
                   throw new IllegalArgumentException("index is illegal");
               }
               data[index] = e;
           }
           
           //查找是否有元素e
           public boolean contains(E e){
               for(int i=0 ; i<data.length ; i++){
                   if(data[i].equals(e))
                       return true;
               }
               return false;
           }
           
           //查找索引
           public int find(E e){
             for(int i=0; i<data.length; i++){
                 if(data[i].equals(e))
                     return i;
             }
             return -1;
           }
           
           //删除指定位置元素,返回删除的元素
           public E remove(int index){
               if(index<0||index>=size){
                  throw new IllegalArgumentException("index is illegal"); 
               }
               E ret = data[index];
               for(int i = index+1;i<size;i++){
                   data[i-1] = data[i];
               }
               size--;
//               data[size]=null;非必要loitering objects != memory leak
               if(size==data.length/2){
                   resize(data.length/2);
               }
               
               return ret;
           }
           
           //移除第一个元素
           public E removeFirst(){
               return remove(0);
           }
           
           //移除最后一个元素
           public E removeLast(){
               return remove(size-1);
           }
           
           //移除某个元素
           public void removeElement(E e){
               int index = find(e);
               if(index!=-1)
               {
                   remove(index);
               }
           }
           
           @Override//覆盖父类方法
           public String toString(){
               StringBuilder res = new StringBuilder();
               res.append(String.format("Array:size = %d , capacity = %d\n",size,data.length));
               res.append("[");
               for(int i = 0; i<size ; i++){
                   res.append(data[i]);
                   if(i!=size - 1)
                       res.append(",");
               }
               res.append("]");
               return res.toString();
           }
    }