數據結構之順序表

一、順序表定義

順序表是在計算機內存中以數組的形式保存的線性表，是指用一組地址連續的存儲單元依次存儲數據元素的線性結構。[引自維基百科]

二、順序表API

int getSize();
void add(E e, int index);
void addLast(E e);
void delete(E e);
void set(E e, int index);
E get(int index);

其代碼實現如下：
其思路都有在註釋中，且比較簡單，我這裏就不贅述了。

public class DynamicArray<T> {

    private T elements[];
    private int size;

    /**
     * 空參構造函數,默認初始容量爲10
     */
    public DynamicArray(){
        this.size = 0;
        this.elements = (T[])new Object[10];
    }

    /**
     * 自定義初始容量
     * 避免後期動態改變容量，提高性能
     * @param capacity
     */
    public DynamicArray(int capacity){
        this.size = 0;
        elements = (T[])new Object[capacity];
    }

    /**
     * 返回數組元素個數
     * @return
     */
    public int getSize(){
        return this.size;
    }

    /**
     * 數組末尾添加元素
     * @param element
     */
    public void addLast(T element){
       add(element, size);
    }

    /**
     * 添加元素
     * 當數組已滿時進行擴容resize操作
     * @param element
     * @param index
     */
    public void add(T element,int index){
        if(index<0 || index>elements.length){
            throw new IllegalArgumentException(index + "do not correct.");
        }
        if(size==elements.length){
            resize(2*size);
        }
        for(int i=size;i>index;i--){
            elements[i] = elements[i-1];
        }
        elements[index] = element;
        size++;
    }

    /**
     * 刪除一個元素
     */
    public void delete(T element){
        int index = findElement(element);
        for(int i=index;i<size;i++){
            elements[i] = elements[i+1];
        }
        elements[size--] = null;
    }

    /**
     * 修改指定索引處的元素
     * @param element
     * @param index
     */
    public void set(T element,int index){
        if(index<0 || index>elements.length){
            throw new IllegalArgumentException(index + "do not correct.");
        }
        elements[index] = element;
    }

    /**
     * 獲取指定位置的元素
     * @param index
     * @return
     */
    public T get(int index){
        if(index<0 || index>=size){
            throw new IllegalArgumentException(index + "do not correct.");
        }
        return elements[index];
    }


    /**
     * 查找元素的索引
     * @param element
     * @return
     */
    public int findElement(T element){
        for(int i=0;i<size;i++){
            if(element.equals(elements[i])){
                return i;
            }
        }
        return -1;
    }


    /**
     * 動態擴容函數
     * 其實現思路是，創建一個臨時數組，把原來數組元素複製到臨時數組中，
     * 將原來數組的指針指向臨時數組
     * @param newCapacity
     */
    private void resize(int newCapacity){
        T tempArray[] = (T[])new Object[newCapacity];
        for(int i=0;i<size;i++){
            tempArray[i] = elements[i];
        }
        elements = tempArray;
    }
}

三、複雜度分析

對於順序表，其添加元素和刪除元素的最壞時間複雜度爲O(n)，因爲這兩個操作中存在移動元素的操作。而對於查找元素其時間複雜度也爲O(n)，需要遍歷數組。