数据结构——顺序表

一，什么是顺序表

顺序表是一种线性数据结构 ，它用一组连续的存储空间依次存储数据元素，逻辑上相邻的元素在物理存储位置上也相邻（类似数组）。

它是数组的抽象实现，通过封装操作方法，通过方法操作数组，更方便地管理数据。

二，顺序表核心知识

数组（Array）

• 最基础的线性结构，连续内存存储，支持随机访问（O(1)）。

• 特点：长度固定，插入 / 删除中间元素需移动数据（O(n)）。

• 示例：

  int[] arr = new int[5]; // 整数数组
  String[] strs = {"a", "b"}; // 引用类型数组

字符串（String）

• 底层基于 char 数组实现，不可变（每次修改都会创建新对象）。

• 常用操作：length()、charAt(index)、substring() 等。

三，集合框架

集合框架分为接口 （定义行为）和实现类 （具体实现），核心接口包括 Collection 和 Map

1，. Collection 接口（存储单值元素）

（继承关系：Collection → List / Set / Queue）

（1）List 接口（有序、可重复）

• 特点：元素有序（插入顺序），可通过索引访问，允许重复元素。

• 实现类：

  • ArrayList（重点）：

    • 底层：动态数组（顺序表）。

    • 优势：随机访问快（O(1)），尾部插入 / 删除快（O(1)）。

    • 劣势：中间插入 / 删除慢（需移动元素，O(n)）。

    • 适用场景：频繁查询、少修改。

  • LinkedList：

    • 底层：双向链表。

    • 优势：中间插入 / 删除快（O(1)，只需修改指针）。

    • 劣势：随机访问慢（需遍历，O(n)）。

    • 额外功能：实现 Deque 接口，可作为队列 / 栈使用。

  • Vector（古老类，线程安全但效率低，少用）：

    • 类似 ArrayList，但方法加了 synchronized 锁，性能较差。

（2），Set 接口（无序、不可重复）

• 特点 ：元素无序（或按特定规则排序），不允许重复（依赖 equals() 和 hashCode() 判断）。

• 实现类：

  • HashSet（重点）：

    • 底层：哈希表（数组 + 链表 / 红黑树）。

    • 特点：无序，添加 / 删除 / 查询效率高（平均 O(1)）。

    • 注意：元素需重写 hashCode() 和 equals() 保证去重正确。

  • LinkedHashSet：

    • 继承 HashSet，底层多了一条链表记录插入顺序，兼具哈希表和链表特性。

  • TreeSet：

    • 底层：红黑树（自平衡二叉搜索树）。

    • 特点：元素自动按自然顺序（或自定义比较器）排序，查询 / 添加 / 删除 O(log n)。

（3）Queue 接口（队列，FIFO 先进先出）

• 特点：模拟队列数据结构，通常用于实现排队逻辑。
• 实现类 ：
  • LinkedList （常用）：实现 Queue 接口，作为双向队列使用。
  • PriorityQueue （优先级队列）：
    • 底层：小顶堆（默认），元素按优先级排序（非插入顺序）。
    • 特点：每次取出优先级最高的元素，插入 O(log n)，取队首 O(1)。

2. Map 接口（键值对存储，key 唯一）

• 特点 ：存储 key-value 映射，key 不可重复（重复会覆盖），value 可重复。
• 实现类 ：

  • HashMap（重点）：

    • 底层：哈希表（数组 + 链表 / 红黑树，JDK 8+）。
    • 特点：key 无序，查询 / 添加 / 删除平均 O(1)。
    • 注意：key 需重写 hashCode() 和 equals()，线程不安全。

  • LinkedHashMap：

    • 继承 HashMap，底层多链表记录 key 的插入顺序或访问顺序（可用于实现 LRU 缓存）。

  • TreeMap：

    • 底层：红黑树，key 按自然顺序或自定义比较器排序，操作复杂度 O(log n)。

  • Hashtable（古老类，线程安全但效率低，少用）：

    • 类似 HashMap，但方法加锁，且不允许 key 或 value 为 nu

四，工具类 ArrayList

1，什么是ArrayList

ArrayList 是 Java 集合框架中最常用的类之一，它基于动态数组 实现，属于 List 接口的实现类，具有以下特点：

• 允许存储重复元素，保持插入顺序

• 支持通过索引快速访问元素（随机访问）

• 容量可动态扩展（无需手动管理数组大小）

• 插入或删除中间元素时效率较低（需要移动元素）

2，提供数组操作方法：

方法名	方法
排序	sort()
查找	binarySearch()
获取元素	get（）
删除元素	remove（）
修改元素	set（）
返回元素个数	size（）
判断是否为空	contains（）

3，各方法示例：

package ArraysText;//包名
import java.util.ArrayList;//导入ArrayList类
public class ArrayListText {
    public static void main(String[] args){
        ArrayList<Integer> list = new ArrayList<>();
        ArrayList<String> strList = new ArrayList<>(100);
        //添加元素
        list.add(10);
        list.add(15);//添加元素
        list.add(1,20);//在索引1插入20（后续元素自动后移）

        int num = list.get(0);//获取元素

        int old = list.set(1,16);//修改元素

        int del = list.remove(1);//删除元素

        int size = list.size();//返回元素个数

        boolean empty = list.isEmpty();//判断是否为空（元素个数为0时发挥true，此时为false）
        boolean has20 = list.contains(20);

        //list.clear();清空所有元素

        System.out.println(list);
        System.out.println(num);
        System.out.println(old);
        System.out.println(del);
        System.out.println(size);
        System.out.println(empty);
        System.out.println(has20);

五，顺序表总结

1，优点：

• 效率高，能根据指定下标索引查找元素；时间复杂度为O（1）；
• 更新元素时更新的是指定元素的下标，更新速度快；,

2，缺点：

• 每次插入数据都需要移动元素 ，极端情况下，若插入到0下标，那么移动的元素复杂度为：O（n）；
• 每次删除数据时，都需要移动元素，极端情况下，删除的元素复杂度为：O（n）；
• 当满了之后，需要进行扩容（1.5倍扩容），然而只放了一个元素，可能会浪费空间。

3，应用场景：

• 在经常查找元素或更新元素的场景下，才推荐使用顺序表。

六，应用

杨辉三角

package shunXuBiao;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class YanghuiTriangle {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入杨辉三角的行数：");
        int rows = scanner.nextInt();

        // 生成杨辉三角
        List<List<Integer>> triangle = generateYanghuiTriangle(rows);

        // 打印杨辉三角
        printTriangle(triangle);

        scanner.close();
    }

    /**
     * 生成杨辉三角
     * param numRows 杨辉三角的行数
     * return 包含杨辉三角数据的二维列表
     */
    public static List<List<Integer>> generateYanghuiTriangle(int numRows) {
        // 创建存储整个杨辉三角的列表
        List<List<Integer>> triangle = new ArrayList<>();

        // 处理边界情况
        if (numRows <= 0) {
            return triangle;
        }

        // 第一行总是[1]
        triangle.add(new ArrayList<>());
        triangle.get(0).add(1);

        // 生成后续行
        for (int rowNum = 1; rowNum < numRows; rowNum++) {
            List<Integer> row = new ArrayList<>();
            List<Integer> prevRow = triangle.get(rowNum - 1);

            // 每行的第一个元素总是1
            row.add(1);

            // 填充中间元素，每个元素等于它上方两元素之和
            for (int j = 1; j < rowNum; j++) {
                row.add(prevRow.get(j - 1) + prevRow.get(j));
            }

            // 每行的最后一个元素总是1
            row.add(1);

            triangle.add(row);
        }

        return triangle;
    }

    /*** 打印杨辉三角，使其居中显示
     * */
    public static void printTriangle(List<List<Integer>> triangle) {
        int rows = triangle.size();
        // 计算最大行的宽度，用于居中对齐
        int maxWidth = triangle.get(rows - 1).toString().length();

        for (List<Integer> row : triangle) {
            // 将当前行转换为字符串
            String rowStr = row.toString();
            // 计算需要填充的空格数
            int spaces = (maxWidth - rowStr.length()) / 2;

            // 打印空格实现居中
            for (int i = 0; i < spaces; i++) {
                System.out.print(" ");
            }

            // 打印当前行
            System.out.println(rowStr);
        }
    }
}

运行结果：

请输入杨辉三角的行数：7
          [1]
         [1, 1]
       [1, 2, 1]
      [1, 3, 3, 1]
    [1, 4, 6, 4, 1]
  [1, 5, 10, 10, 5, 1]
[1, 6, 15, 20, 15, 6, 1]

Process finished with exit code 0