java实现顺序表

顺序表的概念

用一段地址连续的存储单元依次存储数据元素的线性结构。
由于数组类型也具有随机存取的特性，因此，也可以用数组来描述数据结构中的顺序存储结构。

---

顺序表的特点

1.优点：
便于随机存取，读取数据的速度快

2.缺点：
由于它顺序的存储结构，不便于插入和删除

---

代码实现

1.把顺序表的基本操作放在接口中，子类继承接口即可

interface ISeqList {
    /**
     * 初始化顺序表
     * @param initSize 初始化顺序表的大小
     */
    void Init(int initSize);

    /**
     * 销毁顺序表，清空
     */
    void Destroy();

    /**
     * 尾插
     * @param data 插入的数据
     */
    void PushBack(Object data);

    /**
     * 头插
     * @param data 插入的数据
     */
    void PushFront(Object data);

    /**
     * 尾删
     */
    void PopBack();

    /**
     * 头删
     */
    void PopFront();

    /**
     * 指定位置插入数据
     * @param index 指定索引
     * @param data  插入的数据
     */
    void Insert(int index, Object data);

    /**
     * 删除指定索引数据
     * @param index 索引
     */
    void Erase(int index);

    /**
     * 删除遇到的第一个数据
     * @param data 要删除的数据
     */
    void Remove(Object data);

    /**
     * 删除遇到的所有数据
     * @param data 要删除的数据
     */
    void RemoveAll(Object data);

    /**
     * 查找
     * @param data 查找的数据
     * @return 找到了返回第一个遇到的数的下标,没找到返回-1
     */
    int Find(Object data);

    /**
     * 修改指定位置的数据
     * @param index 指定位置索引
     * @param data 要修改的数据
     */
    void Revise(int index, Object data);

    /**
     * 打印顺序表
     */
    void PrintSeqList();
}

---

2.SeqList类实现接口

class SeqList implements ISeqList{
    //顺序表存储空间
    private Object[] array;
    //顺序表容量
    private int size;

    @Override
    public void Init(int initSize) {
        if (initSize >= 0) {
            this.size = 0;
            array = new Object[initSize];//为数组开辟空间
        }else {
            throw new RuntimeException("初始化大小不能小于0："+initSize);
        }
    }

    @Override
    public void Destroy() {
        this.size = 0;
        System.out.println("顺序表已清空,size: "+this.size);
    }

    @Override
    public void PushBack(Object data) {
        //通常情况
        this.array[size] = data;
        this.size++;

        //特殊情况(顺序表满了)
        if (this.size >= array.length) {
            System.out.println("顺序表装满了，size: "+this.size);
            return;
        }
    }

    @Override
    public void PushFront(Object data) {
        //特殊情况(顺序表满了)
        if (this.size >= array.length) {
            System.out.println("顺序表装满了，size: "+this.size);
            return;
        }

        //1.搬移数据
        for (int i=size; i>0; i--) {//i表示的是位置,从后往前搬移，否则会覆盖数据
            array[i] = array[i-1];
        }

        //2.插入数据
        array[0] = data;
        this.size++;
    }

    @Override
    public void PopBack() {
        this.size--;
        //特殊情况
        if (this.size <= 0) {
            System.out.print("顺序表空了！");
            return;
        }
    }

    @Override
    public void PopFront() {
        //1.搬移数据
        for (int i=0; i<this.size-1; i++) {//i表示的是位置,从前往后搬移，防止覆盖数据
            array[i] = array[i+1];
        }
        //2.进行数据的删除
        this.size--;

        //特殊情况
        if (this.size <= 0) {
            System.out.print("顺序表空了！");
            return;
        }
    }

    @Override
    public void Insert(int index, Object data) {
        //1.数据搬移
        if (isIndex(index)) {
            //i表示位置，从后往前搬移，避免覆盖数据
            for (int i=this.size; i>index; i--) {
                array[i] = array[i-1];
            }
        }
        //2.数据插入
        array[index] = data;
        this.size++;

        //特殊情况(顺序表满了)
        if (this.size >= array.length) {
            System.out.println("顺序表装满了，size: "+this.size);
            return;
        }
    }

    @Override
    public void Erase(int index) {

        //1.数据搬移
        if (isIndex(index)) {
            //i表示位置，从前往后搬移，避免覆盖数据
            for (int i=index; i<this.size-1; i++) {
                array[i] = array[i+1];
            }
        }

        //2.删除数据
        this.size--;

        //特殊情况
        if (this.size <= 0) {
            System.out.print("顺序表空了！");
            return;
        }
    }

    @Override
    public int Find(Object data) {
        for (int i=0; i<this.size; i++) {
            if (data == array[i]) {
                return i;
            }
        }
        return -1;
    }

    @Override
    public void Remove(Object data) {
        int index = Find(data);
        if (index == -1) {
            //没找到
            return;
        }
        Erase(index);
        System.out.println("删除成功！");
    }

    @Override
    public void RemoveAll(Object data) {
        int index;
        while ((index = Find(data)) != -1) {
            Erase(index);
        }
        System.out.println("删除成功!");
    }

    @Override
    public void Revise(int index, Object data) {
        if (isIndex(index)) {
            for (int i=0; i<this.size; i++) {
                array[index] = data;
            }
        }
    }

    @Override
    public void PrintSeqList() {
        //遍历顺序表
        for (int i=0; i<this.size; i++) {
            System.out.print(this.array[i]+"、");
        }
        System.out.println("   size: "+this.size);
    }


    /**
     * 判断索引是否合法
     * @param index 索引
     * @return 合法返回true，非法返回false
     */
    private boolean isIndex(int index) {
        if (index >= 0 && index <= this.size) {
            return true;
        }
        else {
            throw new RuntimeException("索引非法");
        }
    }
}

---

3.测试类SeqList_Test

public class SeqList_Test {
    public static void main(String[] args) {
        ISeqList iSeqList = new SeqList();
        iSeqList.Init(10);
        iSeqList.PushBack(1);
        iSeqList.PushBack(2);
        iSeqList.PushBack(3);
        iSeqList.PushBack(4);
        iSeqList.PushBack(5);
        iSeqList.PushFront("hello");
        iSeqList.PushBack("world");
        iSeqList.PopFront();
        iSeqList.PopBack();
        iSeqList.Insert(3,"he");
        iSeqList.Erase(3);
        iSeqList.Insert(3,6);
        iSeqList.Insert(3,6);
        iSeqList.Insert(3,6);
        iSeqList.Remove(6);
        iSeqList.RemoveAll(6);
        iSeqList.Find(5);
        iSeqList.Revise(2,"hello");
        iSeqList.PrintSeqList();
        iSeqList.Destroy();
    }
}