数据结构学习----线性表(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