Java语言的链表删除

原创于 2025-04-01 09:19:40 发布

· 487 阅读

13 ·

版权

文章标签：

#golang #开发语言 #后端

包罗万象专栏收录该内容

24 篇文章

订阅专栏

Java语言中的链表删除操作详解

在计算机科学中，链表是一种常用的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。与数组相比，链表的优势在于插入和删除操作的效率，因为在链表中，可以直接通过指针修改节点关系，而不需要移动大量数据。在本文中，我们将深入探讨链表的删除操作，具体包括单向链表的基本概念、实现、删除操作的详细步骤以及时间复杂度分析等。

一、链表基本概念

1.1 链表的定义

链表（Linked List）是一种线性数据结构，由一系列节点组成。每个节点包含两部分：数据部分以及指向下一个节点的引用。链表的特点是动态分配内存，这使得它在元素个数频繁变化的情况下更为高效。

1.2 链表的类型

主要有以下几种类型的链表：

单向链表：每个节点只有一个指向下一个节点的指针。
双向链表：每个节点有两个指针，分别指向前一个节点和下一个节点。
循环链表：尾节点指向头节点，形成一个环状结构，可以是单向的或双向的。

本篇文章将主要关注单向链表的删除操作。

二、单向链表的实现

2.1 节点类的定义

首先，我们需要定义一个链表节点类。每个节点包含一个数据字段和一个指向下一个节点的指针。

```java class Node { int data; // 节点数据 Node next; // 指向下一个节点的指针

public Node(int data) {
    this.data = data;
    this.next = null;
}

} ```

2.2 链表类的定义

接下来，我们定义一个链表类，它包含对节点的操作，如添加节点、删除节点等。

```java class LinkedList { Node head; // 链表的头结点

// 构造函数
public LinkedList() {
    this.head = null;
}

// 添加节点到链表尾部
public void add(int data) {
    Node newNode = new Node(data);
    if (head == null) {
        head = newNode;
    } else {
        Node current = head;
        while (current.next != null) {
            current = current.next;
        }
        current.next = newNode;
    }
}

// 打印链表
public void printList() {
    Node current = head;
    while (current != null) {
        System.out.print(current.data + " ");
        current = current.next;
    }
    System.out.println();
}

} ```

2.3 删除节点的基本思路

链表的删除操作通常包括以下步骤：

确定要删除的节点的值或位置。
遍历链表，找到要删除节点的前一个节点。
修改前一个节点的next指针，使其指向要删除节点的下一个节点。
释放要删除节点的内存（在Java中，通常通过垃圾回收机制自动完成）。

三、单向链表的删除操作实现

3.1 按值删除节点

首先实现按值删除节点的方法：

```java public void deleteByValue(int value) { if (head == null) { return; // 链表为空，直接返回 }

// 特殊情况：删除头节点
if (head.data == value) {
    head = head.next;
    return;
}

Node current = head;
Node previous = null;

while (current != null && current.data != value) {
    previous = current;
    current = current.next;
}

if (current == null) {
    return; // 没有找到要删除的值
}

previous.next = current.next; // 删除节点

} ```

3.2 按位置删除节点

接下来实现按位置删除节点的方法：

```java public void deleteByPosition(int position) { if (head == null || position < 0) { return; // 链表为空或位置不合法，直接返回 }

// 特殊情况：删除头节点
if (position == 0) {
    head = head.next;
    return;
}

Node current = head;
Node previous = null;
int count = 0;

while (current != null && count < position) {
    previous = current;
    current = current.next;
    count++;
}

if (current == null) {
    return; // 位置超出链表长度
}

previous.next = current.next; // 删除节点

} ```

3.3 代码的完整示例

将以上部分组合在一起，形成完整的链表实现代码：

```java class Node { int data; Node next;

public Node(int data) {
    this.data = data;
    this.next = null;
}

}

class LinkedList { Node head;

public LinkedList() {
    this.head = null;
}

public void add(int data) {
    Node newNode = new Node(data);
    if (head == null) {
        head = newNode;
    } else {
        Node current = head;
        while (current.next != null) {
            current = current.next;
        }
        current.next = newNode;
    }
}

public void deleteByValue(int value) {
    if (head == null) {
        return;
    }

    if (head.data == value) {
        head = head.next;
        return;
    }

    Node current = head;
    Node previous = null;

    while (current != null && current.data != value) {
        previous = current;
        current = current.next;
    }

    if (current == null) {
        return;
    }

    previous.next = current.next;
}

public void deleteByPosition(int position) {
    if (head == null || position < 0) {
        return;
    }

    if (position == 0) {
        head = head.next;
        return;
    }

    Node current = head;
    Node previous = null;
    int count = 0;

    while (current != null && count < position) {
        previous = current;
        current = current.next;
        count++;
    }

    if (current == null) {
        return;
    }

    previous.next = current.next;
}

public void printList() {
    Node current = head;
    while (current != null) {
        System.out.print(current.data + " ");
        current = current.next;
    }
    System.out.println();
}

}

public class LinkedListDemo { public static void main(String[] args) { LinkedList list = new LinkedList(); list.add(10); list.add(20); list.add(30); list.add(40); list.add(50);

    System.out.println("原始链表:");
    list.printList();

    list.deleteByValue(30);
    System.out.println("删除值为30的节点后:");
    list.printList();

    list.deleteByPosition(1);
    System.out.println("删除位置为1的节点后:");
    list.printList();
}

} ```