数据结构 | 如何实现线性表的顺序结构

什么是线性表

线性表就是零个或多个数据元素的有限序列。
首先是一个序列，然后序列之间有顺序，序列中的元素如果存在多个，则第一个元素无前驱，最后一个元素无后继，其他每个元素都有且一个前驱和一个后继。

什么是线性表的顺序存储结构

线性表的顺序存储结构就是用一段地址连续的存储单元依次存储线性表的数据元素，也就是用数组去实现顺序存储结构。
下面用代码实现一下顺序结构。

首先写一个接口

接口主要描述一下实现类要实现哪些方法，这里顺序结构包括三个方法，分别是获得元素，插入元素以及删除元素的方法。

package com.stucture.sqlList;

/**
 * 线性表顺序存储结构的接口
 * 指的是用一段地址连续的存储单元存储线性表的数据元素
 * @ClassName: ISeqList
 * @author cier
 * @date 2018-1-22
 */

public interface ISeqList<T> {
    /**
     * 获得元素
     * @param i 需要获得第i个元素
     * @return
     */
    public T getElem(int i);

    /**
     * 插入元素
     * @param i 元素的插入位置
     * @param t 需要插入的元素
     * @return 是否成功删除
     */
    public boolean insertElem(int i,T t);

    /**
     * 删除元素
     * @param i 需要删除元素的位置
     * @return
     */
    public T deleteElem(int i);
}

然后写一个接口的实现类

该类主要实现了接口的三个方法，下面描述一下三个方法要注意的点。

获得元素方法

1. 因为我这里用的泛型，所以返回的也是泛型的结果，用泛型的优点就是可扩展性更强了，在后面泛型可以不受类型的约束，可以使用整型，字符串型。
2. 因为线性表的下标索引是从1开始的，所以我们返回的是 i-1 的数据元素

插入元素方法

1. 如果插入的位置不合理，打印错误语句并返回。
2. 如果线性表的长度大于等于默认分配的MAXSIZE，答应错误语句并返回。
3. 如果插入的位置不在表尾，那就从最后一个元素开始向前遍历到 i 个位置，分别将他们都向后移动一个位置。
4. 将要插入元素填入数组 i-1 的位置处。
5. 表长加 1。

删除元素方法

1. 如果线性表为空，打印错误语句并返回。
2. 如果删除的位置不合理，打印错误语句并返回。
3. 如果删除的元素不在表尾，那就从删除元素位置开始遍历到最后一个元素位置，分别将它们都向前移动一个位置。
4. 表长减 1。

package com.stucture.sqlList;

/**
 * @author cier
 * @date 2018/1/22 10:57
 */
public class SeqList<T> implements ISeqList<T> {
    public static final int MAXSIZE = 20; // 存储空间的初始化大小

    private T[] data; // 数组存储数据元素
    private int length; // 线性表当前长度

    public SeqList() {
        data = (T[]) new Object[MAXSIZE];
    }

    /**
     * 获得元素
     *
     * @param i 需要获得第i个元素
     * @return
     */
    @Override
    public T getElem(int i) {
        if (i < 0 || i > MAXSIZE) {
            return null;
        }
        T t = data[i - 1];
        return t;
    }

    /**
     * 插入元素
     *
     * @param i 元素的插入位置
     * @param t 插入的元素
     * @return
     */
    @Override
    public boolean insertElem(int i, T t) {
        // 线性表已经满了
        if (length == MAXSIZE) {
            System.out.println("该线性表已经满了");
            return false;
        }
        // 插入的位置不在范围内
        if (i < 1 || i > MAXSIZE) {
            System.out.println("该位置不合法");
            return false;
        }
        // 插入的位置不在表尾
        if (i < length) {
            for (int j = length; j >= i; j--) {
                data[j] = data[j - 1];
            }
        }
        // 线性表的下标是从1开始，但是数组的下标是从0开始的，所以插入的t是在 i-1 的位置
        data[i - 1] = t;
        length++;
        return true;
    }

    @Override
    public T deleteElem(int i) {

        // 线性表为空时
        if (length == 0) {
            System.out.println("线性表为空");
            return null;
        }
        // 删除的数据不在范围内时
        if (i < 1 || i > length) {
            System.out.println("删除位置不在范围内");
            return null;
        }
        T t = data[i - 1];
        for (int j = i; j < length; j++) {
            data[j - 1] = data[j];
        }
        length--;
        return t;
    }

    public T[] getData() {
        return data;
    }

    public void setData(T[] data) {
        this.data = data;
    }

    public int getLength() {
        return length;
    }

    public void setLength(int length) {
        if (length < 0 || length > MAXSIZE){
            System.out.println("长度不合法");
        }
        this.length = length;
    }
}

最后测试线性表

测试线性表需要注意以下几点：

1. 初始化线性表，这里我使用的是伪随机种子设置数组的长度以及数组中元素的值。
2. 随机生成删除元素的下标，满足条件则自动删除元素。
3. 随机生成插入元素的下标和数据，满足条件则自动插入元素。
4. 最后展示线性表中的数据。

package com.stucture.sqlList;

import java.util.Random;

/**
 * 测试线性表
 * @author cier
 * @date 2018/1/22 11:47
 */
public class SeqListTest {
    final int MAX = 25;
    Random r = new Random();
    SeqList<Integer> seqList;

    public SeqListTest(){
        initSeqList();
    }

    /**
     * 创建一个线性表顺序存储结构
     */
    public void initSeqList(){
        seqList = new SeqList<Integer>();
        int length = Math.abs(r.nextInt(MAX));
        System.out.println("产生的数组长度为："+length);

        if (length > SeqList.MAXSIZE) {
            System.out.println("该长度不合法");
        }

        for (int i = 1; i<=length; i++){
            int j = r.nextInt(MAX);
            System.out.print(j + " ");
            if (!seqList.insertElem(i,j)) {
                System.exit(0);
            }
        }
        System.out.println("
原始数组是：");
        display(seqList);
    }

    /**
     * 测试删除元素
     */
    public void deleteElem() {
        int i = r.nextInt(MAX);
        System.out.println("

删除的位置是："+i);
        Integer deleteNumber = seqList.deleteElem(i);
        if(deleteNumber == null) {
            System.exit(0);
        } else {
            System.out.println("删除的元素是："+ deleteNumber);
            System.out.println("删除元素后数组是：");
            display(seqList);
        }
    }

    /**
     * 测试随机插入方法
     */
    public void insertByRandom() {
        int i = r.nextInt(MAX);
        System.out.println("

随机插入的位置是："+i);
        int elem = r.nextInt(MAX);
        System.out.println("随机插入数据是："+elem);
        seqList.insertElem(i,elem);
        System.out.println("随机插入数据后数组是：");
        display(seqList);
    }

    /**
     * 数据展示
     */
    public void display(SeqList seqList) {
        for (int i = 1; i < seqList.getData().length; i++) {
            if (seqList.getElem(i) != null){
                System.out.print(seqList.getElem(i) + " ");
            }
        }
        System.out.println("
数组的长度为："+seqList.getLength());
    }

    /**
     * 获取元素
     */
    public void getElem(){
        int i = r.nextInt(MAX);
        System.out.println("
获取位置为："+i);
        System.out.println("获取到的元素为："+seqList.getElem(i));
    }

    public static void main(String[] args) {
        SeqListTest seqListTest = new SeqListTest();
        seqListTest.insertByRandom();
        seqListTest.deleteElem();
        seqListTest.getElem();
    }
}

关于运行结果

因为不是手动插入数据，删除数据，而是使用随机数自动插入和删除，所以结果会有很多组，不过没关系，多运行几次数据不一样反而能对比着得到结果，下面贴一个完美的运行结果。

产生的数组长度为：16
22 4 8 11 17 3 10 8 18 18 7 9 14 4 3 18
原始数组是：
22 4 8 11 17 3 10 8 18 18 7 9 14 4 3 18
数组的长度为：16

随机插入的位置是：12
随机插入数据是：14
随机插入数据后数组是：
22 4 8 11 17 3 10 8 18 18 7 14 9 14 4 3 18
数组的长度为：17

删除的位置是：15
删除的元素是：4
删除元素后数组是：
22 4 8 11 17 3 10 8 18 18 7 14 9 14 3 18 18
数组的长度为：16

获取位置为：17
获取到的元素为：18