《线性表之顺序表》

1. 线性结构定义
   ∮如果一个数据元素序列满足：
   (1)除第一个元素和最后一个元素外有且只有一个前驱元素和一个后继元素；
   (2)第一个元素没有前驱元素；
   (3)最后一个元素没有后继元素；
   则称这样的数据结构为线性结构。
2. 线性表抽象数据类型
   ∮线性表抽象数据类型主要包括两个方面：数据集合和该数据集合上的操作集合。
   ∮数据集合可以表示为a0,a1,a2,…an-1,每个数据元素的数据类型可以是任意的类型。
   ∮操作集合包括如下操作：(增删查改)
   (1)求元素个数
   (2)插入元素
   (3)删除元素
   (4)查找元素
   (5)判断是否为空
   ∮线性表的抽象数据Java接口描述如下：

package dabao.wang;

public interface IList {

    public void clear(); // 清空顺序表

    public boolean isEmpty();// 判读是否为空

    public int length();// 获得顺序表的长度

    public Object get(int index) throws Exception;// 获得下标为index的对象

    public void insert(int index, Object x) throws Exception;// 在下标为index的位置插入元素x

    public void remove(int index) throws Exception;// 移除下标为index的元素

    public int index(Object x);// 如果对象x存在于顺序表中，返回所在的下标，否则返回-1

    public void display();// 遍历顺序表打印
}

要使用线性表的Java接口，还需要具体的类来实例化该接口。对于线性表的Java接口的两种实现方法：一种是基于顺序存储的实现；一种是基于链式存储的实现。
3. 顺序表
∮计算机中有两种基本的存储结构：顺序结构，离散结构。使用顺序结构的线性表称为顺序表。

4. 顺序表实现

package dabao.wang;

public class SequenceList implements IList {

    private Object[] listElem; // 顺序表的存储结构
    private int size; // 顺序表的大小

    public SequenceList(int maxSize) {// 顺序表的构造函数
        this.listElem = new Object[maxSize];
        this.size = 0;
    }

    @Override
    public void clear() {
        for (int i = 0; i < this.listElem.length; i++) {
            this.listElem[i] = null;
        }
        this.size = 0;
    }

    @Override
    public boolean isEmpty() {
        return this.size == 0;
    }

    @Override
    public int length() {
        return this.size;
    }

    @Override
    public Object get(int index) throws Exception {
        if (index < 0 || index >= this.size) {
            throw new Exception("get函数下标越界");
        }
        return this.listElem[index];
    }

    @Override
    public void insert(int index, Object x) throws Exception {
        if (this.size == this.listElem.length) {
            throw new Exception("顺序表已满");
        }

        if (index < 0 || index > this.size) {
            throw new Exception("insert函数下标越界");
        }

        for (int i = this.size - 1; i > index; i++) {
            this.listElem[i + 1] = this.listElem[i];
        }
        this.listElem[index] = x;
        this.size++;
    }

    @Override
    public void remove(int index) throws Exception {
        if (isEmpty()) {
            return;
        }

        if (index < 0 || index > this.size) {
            throw new Exception("remove函数下标越界");
        }

        for (int i = index; i < this.size - 1; i++) {
            this.listElem[i] = this.listElem[i + 1];
        }
        this.listElem[size - 1] = null;
        this.size--;
    }

    @Override
    public int index(Object x) {
        for (int i = 0; i < this.size; i++) {
            if (x.equals(this.listElem[i])) {
                return i;
            }
        }
        return -1;
    }

    @Override
    public void display() {
        for (int i = 0; i < this.size; i++) {
            System.out.print(this.listElem[i] + " ");
        }
        System.out.println();
    }
}

1. 测试顺序表

package dabao.wang;

public class Test {

    public static void main(String[] args) throws Exception {
        SequenceList listArray = new SequenceList(10);
        for (int i = 0; i < 10; i++) {
            listArray.insert(i, (int) (Math.random() * 10) % 10);// 0~10内的随机数
        }
        System.out.println("打印顺序表");
        listArray.display();// 打印
        listArray.remove(7);
        listArray.remove(8);
        System.out.println("打印顺序表");
        listArray.display();
        System.out.println("打印顺序表get");
        for (int i = 0; i < listArray.length(); i++) {
            System.out.print(listArray.get(i) + " ");
        }
    }

}

测试结果：