【简易轮子】Java单向链表的实现

在计算机科学中，链表是一种常见的数据结构，用于存储一系列元素。其中，单向链表是一种简单的链表类型，在每个节点中只包含一个指向后继节点的指针。

定义

单向链表由一系列节点组成，每个节点包含两个部分：数据和指针。其中，数据是所存储的元素，而指针则指向链表中下一个节点。

在 Java 中，我们可以使用以下类定义一个单向链表的节点：

 /**
   * 节点类
   *
   * @param <T> 泛型类型
   */
  private static class Node<T> {
    /**
     * 节点值
     */
    T value;
    /**
     * 下一个节点
     */
    Node<T> next;

    /**
     * 构造函数
     *
     * @param value 节点值
     */
    Node(T value) {
      this.value = value;
    }
  }

其中，T 是存储的元素类型，data 是节点存储的数据，next 是指向下一个节点的指针。在构造函数中，我们将 next 初始化为 null，表示该节点没有后继节点。

操作

添加元素

要向单向链表中添加新元素，我们需要找到链表的尾节点，并将其 next 指针指向一个包含新元素的新节点。如果链表为空，则将新节点设置为头节点。

以下是在 Java 中实现向单向链表中添加元素的代码：

  /**
   * 添加元素到链表末尾
   *
   * @param element 待添加的元素
   */
  public void add(T element) {
    // 创建一个新节点
    Node<T> node = new Node<>(element);

    if (head == null) {
      // 如果链表为空，将该节点作为头节点
      head = node;
    } else {
      // 否则找到链表的最后一个节点，将该节点追加在其后面
      Node<T> temp = head;
      while (temp.next != null) {
        temp = temp.next;
      }
      temp.next = node;
    }
      size++;
  }

其中，T 是存储的元素类型，data 是要添加的元素。变量 head 是指向链表头节点的指针，而 size 则记录链表中元素的个数。

获取元素

要获取单向链表中指定位置的元素，我们需要遍历链表，直到找到指定位置的节点。以下是在 Java 中实现获取单向链表中指定位置元素的代码：

 /**
   * 获取指定位置的元素
   *
   * @param index 位置
   * @return 元素值
   * @throws IndexOutOfBoundsException 如果位置越界
   */
  public T get(int index) {
    if (index < 0 || index >= size()) {
      throw new IndexOutOfBoundsException();
    }

    Node<T> temp = head;
    for (int i = 0; i < index; i++) {
      // 找到指定位置的节点
      temp = temp.next;
    }
    return temp.value;
  }

其中，T 是存储的元素类型，index 是要获取的元素的下标。如果索引越界，则会抛出一个 IndexOutOfBoundsException 异常。变量 head 是指向链表头节点的指针，而 size 则记录链表中元素的个数。

删除元素

要从单向链表中删除指定的元素，我们需要找到前一个节点，并将其 next 指针指向下一个节点。如果要删除的是头节点，则需要特别处理。

以下是在 Java 中实现从单向链表中删除指定元素的代码：

  /**
   * 从链表中删除指定元素
   *
   * @param element 待删除的元素
   * @return true：删除成功；false：没有找到待删除元素
   */
  public boolean remove(T element) {
    if (head == null) {
      return false;
    }

    if (head.value.equals(element)) {
      // 如果待删除的元素是头节点，直接将头节点指向下一个节点
      head = head.next;
      return true;
    }

    Node<T> prev = head;
    Node<T> current = head.next;
    while (current != null) {
      if (current.value.equals(element)) {
        // 如果待删除的元素不是头节点，找到该元素所在的节点，将其前驱节点指向后继节点
        prev.next = current.next;
        return true;
      }
      prev = current;
      current = current.next;
    }

    return false;
  }

总结

链表的增删操作相对于数组来说是比较快的，因为链表中的元素在物理上不需要连续的存储空间，而是通过指针相互连接。因此，当需要插入或删除一个元素时，只需要修改该元素前后节点的指针即可完成操作，时间复杂度为 O(1)。

然而，由于链表中的元素并非连续存放，因此在进行查找操作时必须从头结点开始依次遍历每个节点才能找到目标元素，这就使得查找操作的时间复杂度变成了 O(n)，其中 n 表示链表中元素的个数。与之相反，数组中元素的内存地址是连续的，可以直接通过下标访问，所以数组的查找操作时间复杂度为 O(1)。

因此，链表适合频繁的插入和删除操作，但对于查找操作，数组更加高效。