数据结构基础：顺序表与链表的实现与应用

1. 数据结构入门：为什么每个程序员都该从这里开始

刚入行那会儿，我总想着直接上手框架和项目，结果在第一次代码评审时被前辈问得哑口无言——"这个查询为什么用ArrayList而不用LinkedList？"、"这个数据规模下你的时间复杂度是多少？"。这些问题让我意识到，跳过数据结构直接写代码，就像没学加减法就想解方程。今天我们就从最基础的顺序表和链表开始，用代码说话，看看这些数据结构到底怎么用、为什么用。

数据结构是计算机存储、组织数据的方式，它决定了数据的操作效率和使用场景。顺序表和链表作为线性表的两种基本实现，一个用连续内存空间换取随机访问性能，一个用离散存储换取动态扩展能力。理解它们的差异，你就能在写业务代码时做出更合理的选择——比如电商平台的购物车用ArrayList存储商品，而聊天软件的消息队列更适合LinkedList。

2. 顺序表：数组的华丽变身

2.1 顺序表的本质与实现

顺序表本质上是对数组的封装，它在C语言中通常用结构体表示，在Java/Python中则是ArrayList这样的类。下面用Java实现一个简化版的顺序表：

java复制public class MyArrayList<E> {
    private static final int DEFAULT_CAPACITY = 10;
    private Object[] elementData;
    private int size;

    public MyArrayList() {
        this.elementData = new Object[DEFAULT_CAPACITY];
    }

    public void add(E e) {
        ensureCapacity(size + 1);
        elementData[size++] = e;
    }

    private void ensureCapacity(int minCapacity) {
        if (minCapacity > elementData.length) {
            int newCapacity = elementData.length * 2;
            Arrays.copyOf(elementData, newCapacity);
        }
    }
}

关键点在于：

1. 动态扩容机制：当数组空间不足时，常见策略是扩容为原大小的1.5-2倍（Java的ArrayList是1.5倍）
2. 随机访问：通过下标可直接定位元素，时间复杂度O(1)
3. 尾部插入：平均时间复杂度O(1)，但扩容时需要复制原有数据

实际开发中直接使用语言提供的标准库（如Java的ArrayList）即可，这里手动实现是为了理解原理

2.2 顺序表的性能陷阱与规避

我在第一次实现订单系统时踩过一个坑：用ArrayList存储可能达到百万级的日志数据，结果频繁扩容导致性能骤降。后来改用初始容量参数才解决问题：

java复制// 错误示范 - 默认初始容量10，频繁扩容
List<Log> logs = new ArrayList<>(); 

// 正确做法 - 根据业务预估设置初始容量
List<Log> logs = new ArrayList<>(expectedSize);

顺序表最适用的场景：

• 数据量可预估且变化不大
• 需要频繁按索引随机访问
• 尾部插入/删除操作为主

3. 链表：用指针连接的艺术

3.1 单链表的实现与操作

链表通过节点间的指针链接实现动态存储，下面是Java版的单链表实现：

java复制public class LinkedList<E> {
    private static class Node<E> {
        E data;
        Node<E> next;
        
        Node(E data) {
            this.data = data;
        }
    }
    
    private Node<E> head;
    private int size;
    
    public void addFirst(E e) {
        Node<E> newNode = new Node<>(e);
        newNode.next = head;
        head = newNode;
        size++;
    }
    
    public void addLast(E e) {
        if (head == null) {
            addFirst(e);
            return;
        }
        
        Node<E> current = head;
        while (current.next != null) {
            current = current.next;
        }
        current.next = new Node<>(e);
        size++;
    }
}

链表的核心优势：

1. 动态内存分配：不需要预先知道数据规模
2. 插入/删除效率：在已知节点位置时操作只需O(1)时间
3. 内存利用率：不需要连续内存空间

3.2 链表常见问题解决方案

问题1：如何反转单链表？

面试常考题，我的实现方案：

java复制public void reverse() {
    Node<E> prev = null;
    Node<E> current = head;
    while (current != null) {
        Node<E> next = current.next;
        current.next = prev;
        prev = current;
        current = next;
    }
    head = prev;
}

问题2：检测链表是否有环？

快慢指针法是经典解决方案：

java复制public boolean hasCycle() {
    if (head == null) return false;
    
    Node<E> slow = head;
    Node<E> fast = head.next;
    
    while (fast != null && fast.next != null) {
        if (slow == fast) return true;
        slow = slow.next;
        fast = fast.next.next;
    }
    return false;
}

4. 顺序表 vs 链表：实战选择指南

4.1 性能对比表格

• 链表如果维护尾指针可达O(1)
  ** 需要先找到位置O(n)，之后操作O(1)

4.2 典型应用场景

选择顺序表当：

• 需要频繁按索引访问（如电商商品列表）
• 数据量相对固定（如系统配置项）
• 内存资源紧张（嵌入式系统）

选择链表当：

• 频繁在头部操作（如消息队列)
• 数据规模变化大（如社交网络关系）
• 需要保证插入顺序（如撤销操作栈）

我在开发IM系统时，消息历史用ArrayList存储（需要随机跳转查看），而在线消息推送用LinkedList实现（频繁头部插入）。

5. 避坑指南：新手常见错误

1. 越界访问：顺序表要注意下标检查，链表要注意空指针

   java复制// 错误示范
   for (int i = 0; i <= list.size(); i++) { ... }
   
   // 正确写法
   for (int i = 0; i < list.size(); i++) { ... }
   

2. 并发修改：遍历时修改结构会导致异常

   java复制// 会抛出ConcurrentModificationException
   for (String item : list) {
       if (condition) list.remove(item);
   }
   
   // 应该使用迭代器
   Iterator<String> it = list.iterator();
   while (it.hasNext()) {
       if (condition) it.remove();
   }
   

3. 内存泄漏：链表节点引用未及时清除

   java复制// 错误示范
   Node temp = head;
   head = head.next;
   // 忘记处理temp
   
   // 应该及时置空或加入对象池
   

6. 进阶路线：从实现到应用

理解了基本实现后，可以继续探索：

1. 双向链表：增加prev指针支持反向遍历（Java的LinkedList实现）
2. 循环链表：尾节点指向头节点形成环（解决约瑟夫问题）
3. 跳表：多级索引加速查找（Redis有序集合实现）
4. 应用场景：
   • LRU缓存淘汰算法（链表+哈希表）
   • 多项式运算（用链表存储非零项）
   • 大整数运算（每位数字用节点存储）

我在实现Redis-like缓存时，就用双向链表+哈希表实现了O(1)时间的LRU策略：

java复制class LRUCache {
    class DLinkedNode {
        int key;
        int value;
        DLinkedNode prev;
        DLinkedNode next;
    }
    
    private void addNode(DLinkedNode node) {
        // 总是添加到头部
        node.prev = head;
        node.next = head.next;
        
        head.next.prev = node;
        head.next = node;
    }
    
    private void removeNode(DLinkedNode node) {
        DLinkedNode prev = node.prev;
        DLinkedNode next = node.next;
        
        prev.next = next;
        next.prev = prev;
    }
}

数据结构的学习不是一蹴而就的，建议从手写实现开始，然后对比语言标准库的实现（如Java的ArrayList和LinkedList源码），最后在项目中体会不同选择的性能差异。我至今保持着一个习惯：每当在项目中用到新的数据结构，都会去研究它的实现原理和适用场景——这才是真正提升代码质量的捷径。