数据结构系列--线性表定义，顺序存储结构

线性表定义

线性表（List）:零个或多个数据元素的有限序列。

注意：是一个序列，每个元素之间是有序的，第一个元素无先驱，最后一个元素无后继

数学定义：

若将线性表记为：（a1,a2,...,ai-1,ai,ai+1...,an）,则ai-1领先于ai,ai+1领先于ai,称ai-1为ai的直接前驱，a1+1为ai的直接后继元素。

线性表里面的元素要为相同的数据类型。

---

线性表的存储结构

顺序存储结构：用一段地址连续的存储单元依次存储线性表的数据元素，如，一维数组

    顺序存储结构的属性：

1. 存储空间的起始位置
2. 线性表的最大存储容量
3. 线性表的当前长度

注意区分：数组长度和线性表的长度

数组长度是存放线性表的存储空间的长度，存储分配后一般不变

线性表的长度是线性表中数据元素的个数，应该是小于等于数组长度的。

地址计算

每个元素不管是什么类型（整数，浮点，字符等）都需要占一定的存储单元空间，假设占用c个存储单元，则线性表中第i个元素和第i+1个元素的存储位置满足：

Loc(ai+1)=Loc(ai)+c

对于任意第i个元素ai的存储位置可以由a1推算出：

Loc(ai)=a1+(i-1)*c

---

顺序存储结构的插入与删除

• 插入：在线性表L的第i个位置插入新元素e

算法：

1. 如果插入位置不合理，抛出异常
2. 如果线性表的长度大于等于数组长度，则抛出异常或动态增加容量
3. 若插入位置不在表尾，则从最后一个元素开始向前遍历到第i个位置，分别将他们都向后移动一个位置
4. 将要插入的元素填入位置i处
5. 线性表长度加1

 

• 删除：在线性表L的第i个位置删除元素e

算法：

1. 如果删除的位置不合理，则抛出异常
2. 取出删除元素
3. 从删除元素的位置开始遍历到最后一个元素的位置，分别将他们都向前移动一个位置
4. 表长度减去1

 

代码：

package thf.linearList;

public class LinearList {
    /**
     * 线性表
     */
    static final int MAX_SIZE = 10;//数组长度
    static int listLen = 0;//线性表长度
    static Object[] objLinearList = new Object[MAX_SIZE];//定义一个长度为10的一维数组

    //构造函数初始化线性表
    public LinearList() {

        for (int i = 0; i < 8; i++) {
            objLinearList[i] = i;
            listLen++;
        }

    }

    /**
     * 插入操作
     *
     * @param location 插入位置
     * @param e        插入的元素
     */
    public Object insertList(int location, Object e) throws MyException {
        //判断插入位置是否合理
        if (location < 1 || location >= MAX_SIZE) {
            throw new MyException("插入位置不合理");

        }
        if (location <= listLen) {
            for (int k = listLen - 1; k >= location - 1; k--) {
                objLinearList[k + 1] = objLinearList[k];//第location个位置后的元素依次后移一位
            }
            objLinearList[location - 1] = e;//插入新元素
            listLen++;//顺序表长度

        }
        return objLinearList;
    }


    /**
     * 删除操作
     */
    public void deleteLinearList(int location) throws MyException {
        if (location < 1 || location >= listLen) {
            throw new MyException("删除的位置不合理");
        }
        if (listLen == 0) {
            throw new MyException("线性表是空表");
        }

        if (location < listLen) {
            Object tmp = objLinearList[location - 1];
            for (int k = location; k <=listLen; k++) {
                objLinearList[k - 1] = objLinearList[k];//将删除位置后继元素前移
            }
            listLen--;//线性表长度减一
        }
    }

    public static void main(String[] args) throws MyException {

        LinearList ll = new LinearList();
        System.out.println("插入元素前的线性表:\n");
        for (int i = 0; i < objLinearList.length; i++) {
            System.out.print(objLinearList[i] + "\t");
        }
        System.out.println();
        //插入元素
        Object result = ll.insertList(3, "AA");

        System.out.println("插入元素后的线性表:\n");
        for (int i = 0; i < objLinearList.length; i++) {
            System.out.print(objLinearList[i] + "\t");
        }

        //删除元素
        System.out.println();
        System.out.println("删除元素;\n");
        ll.deleteLinearList(6);
        for (int i = 0; i < objLinearList.length; i++) {
            System.out.print(objLinearList[i] + "\t");
        }
    }
}

class MyException extends Exception {//自定义类异常
    String msg;

    public MyException(String msg) {
        this.msg = msg;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}

输出：

插入元素前的线性表:

0	1	2	3	4	5	6	7	null	null	
插入元素后的线性表:

0	1	AA	2	3	4	5	6	7	null	
删除元素后的线性表：

0	1	AA	2	3	5	6	7	null	null