數據結構學習----線性表(Java版的實現)

線性表接口LList：

package com.clarck.datastructure.linear;

/**
 * 線性表接口LList，描述線性表抽象數據類型，泛型參數T表示數據元素的數據類型
 * 
 * @author clarck
 *
 */
public interface LList<T> {
    /**
     * 判斷線性表是否空
     * @return
     */
    boolean isEmpty();
    
    /**
     * 返回線性表長度
     * @return
     */
    int length();
    
    /**
     * 返回第i（i≥0）個元素
     * @param i
     * @return
     */
    T get(int i);
    
    /**
     * 設置第i個元素值為x
     * @param i
     * @param x
     */
    void set(int i, T x);
    
    /**
     * 插入x作為第i個元素
     * @param i
     * @param x
     */
    void insert(int i, T x);
    
    /**
     * 在線性表最后插入x元素
     * @param x
     */
    void append(T x);
    
    /**
     * 刪除第i個元素並返回被刪除對象
     * @param i
     * @return
     */
    T remove(int i);
    
    /**
     * 刪除線性表所有元素
     */
    void removeAll();
    
    /**
     * 查找，返回首次出現的關鍵字為key元素
     * @param key
     * @return
     */
    T search(T key);
}

順序表（線性表的順序存儲結構）類，實現線性表接口，T是泛型參數，指定任意類

package com.clarck.datastructure.linear;

/**
 * 順序表（線性表的順序存儲結構）類，實現線性表接口，T是泛型參數，指定任意類
 * 
 * @author clarck
 * 
 * @param <T>
 */
public class SeqList<T> implements LList<T> {
    /**
     * 對象數組，保護成員
     */
    protected Object[] element;

    /**
     * 順序表長度，記載元素個數
     */
    protected int len;

    /**
     * 默認構造方法，創建默認容量的空表
     */
    public SeqList() {
        this(64);
    }

    /**
     * 構造方法，創建容量為size的空表
     * 
     * @param size
     */
    public SeqList(int size) {
        this.element = new Object[size];
        this.len = 0;
    }

    /**
     * 判斷順序表是否空，若空返回true，O(1)
     */
    @Override
    public boolean isEmpty() {
        return this.len == 0;
    }

    /**
     * 返回順序表長度，O(1)
     */
    @Override
    public int length() {
        return this.len;
    }

    /**
     * 返回第i（≥0）個元素。若i<0或大於表長則返回null，O(1)
     */
    @SuppressWarnings("unchecked")
    @Override
    public T get(int i) {
        if (i >= 0 && i < this.len) {
            return (T) this.element[i];
        }
        return null;
    }

    /**
     * 設置第i（≥0）個元素值為x。若i<0或大於表長則拋出序號越界異常；若x==null，不操作
     */
    @Override
    public void set(int i, T x) {
        if (x == null)
            return;

        if (i >= 0 && i < this.len) {
            this.element[i] = x;
        } else {
            throw new IndexOutOfBoundsException(i + ""); // 拋出序號越界異常
        }
    }

    /**
     * 順序表的插入操作 插入第i（≥0）個元素值為x。若x==null，不插入。 若i<0，插入x作為第0個元素；若i大於表長，插入x作為最后一個元素
     */
    @Override
    public void insert(int i, T x) {
        if (x == null)
            return;

        // 若數組滿，則擴充順序表容量
        if (this.len == element.length) {
            // temp也引用elements數組
            Object[] temp = this.element;
            // 重新申請一個容量更大的數組
            this.element = new Object[temp.length * 2];
            // 復制數組元素，O(n)
            for (int j = 0; j < temp.length; j++) {
                this.element[j] = temp[j];
            }
        }

        // 下標容錯
        if (i < 0)
            i = 0;

        if (i > this.len)
            i = this.len;

        // 元素后移，平均移動len/2
        for (int j = this.len - 1; j >= i; j--) {
            this.element[j + 1] = this.element[j];
        }
        this.element[i] = x;
        this.len++;
    }

    /**
     * 在順序表最后插入x元素
     */
    @Override
    public void append(T x) {
        insert(this.len, x);
    }

    /**
     * 順序表的刪除操作 刪除第i（≥0）個元素，返回被刪除對象。若i<0或i大於表長，不刪除，返回null。
     */
    @SuppressWarnings("unchecked")
    @Override
    public T remove(int i) {
        if (this.len == 0 || i < 0 || i >= this.len) {
            return null;
        }

        T old = (T) this.element[i];
        // 元素前移，平均移動len/2
        for (int j = i; j < this.len - 1; j++) {
            this.element[j] = this.element[j + 1];
        }
        this.element[this.len - 1] = null;
        this.len--;
        return old;
    }

    /**
     * 刪除線性表所有元素
     */
    @Override
    public void removeAll() {
        this.len = 0;
    }

    /**
     * 查找，返回首次出現的關鍵字為key元素
     */
    @SuppressWarnings("unchecked")
    @Override
    public T search(T key) {
        int find = this.indexOf(key);
        return find == -1 ? null : (T) this.element[find];
    }

    /**
     * 順序表比較相等 比較兩個順序表是否相等 ，覆蓋Object類的equals(obj)方法，O(n)
     */
    @SuppressWarnings("unchecked")
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;

        if (obj instanceof SeqList) {
            SeqList<T> list = (SeqList<T>) obj;
            // 比較實際長度的元素，而非數組容量
            for (int i = 0; i < this.length(); i++) {
                if (!this.get(i).equals(list.get(i))) {
                    return false;
                }
            }
            return true;
        }
        return false;
    }

    /**
     * 順序查找關鍵字為key元素，返回首次出現的元素，若查找不成功返回-1
     * 
     * @param key
     *            可以只包含關鍵字數據項，由T類的equals()方法提供比較對象相等的依據
     * @return
     */
    public int indexOf(T key) {
        if (key != null) {
            for (int i = 0; i < this.len; i++) {
                // 對象采用equals()方法比較是否相等
                if (this.element.equals(key)) {
                    return i;
                }
            }
        }
        return -1;
    }

    // 返回順序表所有元素的描述字符串，形式為“(,)”，覆蓋Object類的toString()方法
    public String toString() {
        String str = "(";
        if (this.len > 0)
            str += this.element[0].toString();
        for (int i = 1; i < this.len; i++)
            str += ", " + this.element[i].toString();
        return str + ") "; // 空表返回()
    }
}

線性表的順序表示和實現，測試類：

package com.clarck.datastructure.linear;

/**
 * 線性表的順序表示和實現
 * 
 * @author clarck
 * 
 */
public class SeqList_test {
    public static void main(String args[]) {
        //空表
        SeqList<String> lista = new SeqList<String>(4);
        System.out.println("lista is empty: "+lista.toString());
        //擴容
        for (int i = 5; i >= 0; i--) {
            lista.insert(i, new String((char)('A' + i) + ""));
        }
        System.out.println("lista insert finished: "+lista.toString());
        lista.set(3, new String((char)(lista.get(3).charAt(0) + 32) + ""));
        System.out.println("lista set 3 : "+lista.toString());
        lista.remove(0);
        System.out.println("lista remove 0 position: "+lista.toString());
        lista.remove(3);
        System.out.println("lista remove 3 position: "+lista.toString());
    }
}

輸出結果：

lista is empty: () 
lista insert finished: (A, F, B, E, C, D) 
lista set 3 : (A, F, B, e, C, D) 
lista remove 0 position: (F, B, e, C, D) 
lista remove 3 position: (F, B, e, D) 

 

源碼：https://github.com/clarck/DataStructure/tree/master/Linear/src/com/clarck/datastructure/linear