Java实现顺序表

---

前言

推荐一个网站给想要了解或者学习人工智能知识的读者，这个网站里内容讲解通俗易懂且风趣幽默，对我帮助很大。我想与大家分享这个宝藏网站，请点击下方链接查看。
https://www.captainbed.cn/f1

Java顺序表是Java中实现线性表结构的一种方式，它采用数组来存储元素，通过下标访问元素，具有快速访问和修改特定位置元素的特点，但插入和删除操作可能涉及较多元素的移动。

---

一、线性表

介绍

线性表（linear list）是n个具有相同特性的数据元素的有限序列。

线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

常见线性表

线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…

总结

线性表是一种数据结构，由一组有序的元素组成，元素之间具有线性关系。线性表中的元素可以是任意类型的数据，每个元素都有一个前驱元素和一个后继元素（除了第一个和最后一个元素）。线性表可以用于存储和操作一系列有序的数据。常见的线性表有数组、链表、栈和队列等。

图解

二、顺序表

概念

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。

顺序表的分类

顺序表一般可以分为

• 静态顺序表：使用定长数组存储。
• 动态顺序表：使用动态开辟的数组存储。

静态顺序表适用于确定知道需要存多少数据的场景.

静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用.相比之下动态顺序表更灵活, 根据需要动态的分配空间大小.

顺序表的实现

throw

在Java中，throw关键字用于抛出异常。throw语句必须在方法体内部使用，并且后面跟着一个异常对象，如下所示：

throw new Exception("异常信息");

throw语句会立即终止当前方法的执行，并将异常抛给调用者处理。如果没有被捕获的异常将会导致程序终止。

在自定义类中，可以通过继承Exception类或其子类来创建自定义异常类。可以在方法中使用throw关键字抛出自定义异常对象，如下所示：

public void someMethod() throws CustomException {
    if (条件) {
        throw new CustomException("异常信息");
    }
}

在调用方代码中，可以使用try-catch语句块来捕获和处理异常，如下所示：

try {
    someMethod();
} catch (CustomException e) {
    // 处理异常逻辑
}

使用throw语句可以将异常主动抛出，从而提供更丰富的异常处理能力。

具体代码

public class SeqList {
    private int[] arr; // 存储顺序表的数组
    private int size; // 记录顺序表中元素的个数
    // 构造函数
    public SeqList(int capacity) {
        arr = new int[capacity];
        size = 0;
    }

    // 打印顺序表
    public void display() {
        for (int i = 0; i < size; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    // 在pos位置新增元素
    public void add(int pos, int data) {
        if (pos < 0 || pos > size) {
            // 位置不合法
            throw new IllegalArgumentException("Invalid position");
        }

        if (size == arr.length) {
            // 数组已满，需要扩容
            int[] newArr = new int[arr.length * 2];
            System.arraycopy(arr, 0, newArr, 0, size);
            arr = newArr;
        }

        // 将pos位置及之后的元素后移
        for (int i = size - 1; i >= pos; i--) {
            arr[i + 1] = arr[i];
        }

        // 插入新元素
        arr[pos] = data;
        size++;
    }

    // 判定是否包含某个元素
    public boolean contains(int toFind) {
        for (int i = 0; i < size; i++) {
            if (arr[i] == toFind) {
                return true;
            }
        }
        return false;
    }

    // 查找某个元素对应的位置
    public int search(int toFind) {
        for (int i = 0; i < size; i++) {
            if (arr[i] == toFind) {
                return i;
            }
        }
        return -1;
    }

    // 获取pos位置的元素
    public int getPos(int pos) {
        if (pos < 0 || pos >= size) {
            // 位置不合法
            throw new IllegalArgumentException("Invalid position");
        }
        return arr[pos];
    }

    // 给pos位置的元素设为value
    public void setPos(int pos, int value) {
        if (pos < 0 || pos >= size) {
            // 位置不合法
            throw new IllegalArgumentException("Invalid position");
        }
        arr[pos] = value;
    }

    // 删除第一次出现的关键字key
    public void remove(int toRemove) {
        int index = search(toRemove);
        if (index == -1) {
            // key不存在
            return;
        }

        // 将index位置及之后的元素前移
        for (int i = index + 1; i < size; i++) {
            arr[i - 1] = arr[i];
        }

        size--;
    }

    // 获取顺序表长度
    public int size() {
        return size;
    }

    // 清空顺序表
    public void clear() {
        size = 0;
    }
}

这是一个实现顺序表的Java类。顺序表是一种线性表，使用数组存储元素，通过下标访问元素。该类提供了一系列操作顺序表的方法。

1. 构造函数：创建一个指定容量的顺序表，并初始化大小为0。
2. display()方法：打印顺序表中的所有元素。
3. add(int pos, int data)方法：在指定位置插入一个新元素。如果位置不合法，抛出IllegalArgumentException异常。如果数组已满，需要扩容。
4. contains(int toFind)方法：判断顺序表中是否包含某个元素。
5. search(int toFind)方法：查找某个元素的位置。如果找到，返回该元素的位置；否则返回-1。
6. getPos(int pos)方法：获取指定位置的元素。如果位置不合法，抛出IllegalArgumentException异常。
7. setPos(int pos, int value)方法：将指定位置的元素设为新值。如果位置不合法，抛出IllegalArgumentException异常。
8. remove(int toRemove)方法：删除顺序表中第一次出现的指定元素。如果元素不存在，不进行任何操作。
9. size()方法：获取顺序表的大小。
10. clear()方法：清空顺序表。

这些方法可以帮助我们对顺序表进行插入、删除、查询和修改等操作。

三、顺序表会出现的问题

1. 顺序表中间/头部的插入删除，时间复杂度为O(N)
2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。

---