单向链表基础回顾
在深入探讨append方法之前，我们首先回顾一下单向链表的基本结构。一个单向链表由一系列节点组成，每个节点包含两部分：数据（data）和指向下一个节点的引用（next）。链表的起点由head节点标识，最后一个节点的next引用通常为null。
public class SinglyLinkedList {
private Node head; // 链表的头节点
// 内部类定义链表节点
private static class Node {
int data; // 节点存储的数据
Node next; // 指向下一个节点的引用
public Node(int data) {
this.data = data;
this.next = null; // 新节点默认指向null
}
}
// 构造函数，初始化空链表
public SinglyLinkedList() {
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;
System.out.print("[");
while (current != null) {
System.out.print(current.data);
if (current.next != null) {
System.out.print(", ");
}
current = current.next;
}
System.out.println("]");
}
}理解append操作的本质
append操作（或称为连接、拼接操作）的目的是将一个链表（list2）的所有节点连接到另一个链表（list1）的末尾。例如，如果list1 = [0, 1, 2]而list2 = ['A', 'B']，那么list1.append(list2)的结果应该是list1 = [0, 1, 2, 'A', 'B']。
常见误区分析
在实现append方法时，一个常见的错误是将当前链表的head.next直接指向要追加链表的head。例如：
// 错误的append方法示例
public void appendIncorrect(SinglyLinkedList listToAppend) {
if (this.head != null) {
this.head.next = listToAppend.head; // 错误：这只会替换当前链表的第二个节点
} else {
// 如果当前链表为空，直接将要追加的链表作为当前链表
this.head = listToAppend.head;
}
}这种做法的问题在于，它只修改了当前链表的第二个节点（如果存在）的next引用，使其指向了listToAppend的头部，从而丢失了当前链表原有的大部分节点，并且没有达到将整个listToAppend连接到当前链表“末尾”的目的。
正确实现append方法
正确的append方法需要找到当前链表的最后一个节点，然后将该节点的next引用指向要追加链表的head。在实现时，还需要考虑一些边界条件。
java-api-doc-generator
下载
分析 Java Spring Boot 后端 Controller 代码，自动生成 Markdown 格式的接口文档。当用户说“生成 Java 接口文档”、“生成 API 文档”、“从 Spring 代码生成文档”时触发。
立即学习“Java免费学习笔记（深入）”；
实现策略：
- 处理当前链表为空的情况： 如果当前链表（this）是空的，那么追加操作的结果就是将listToAppend直接赋值给当前链表。
- 处理待追加链表为空的情况： 如果listToAppend是空的，则无需进行任何操作。
- 遍历查找尾节点： 从当前链表的head开始，一直遍历到current.next == null的节点，这个current就是当前链表的最后一个节点。
- 连接链表： 将找到的最后一个节点的next引用指向listToAppend的head。
public class SinglyLinkedList {
private Node head;
// ... (Node 内部类, 构造函数, add, printList 方法同上) ...
/**
* 将另一个单向链表的所有元素追加到当前链表的末尾。
*
* @param listToAppend 待追加的链表
*/
public void append(SinglyLinkedList listToAppend) {
// 1. 如果待追加的链表为空，则无需操作，直接返回
if (listToAppend == null || listToAppend.head == null) {
return;
}
// 2. 如果当前链表为空，则直接将待追加的链表作为当前链表
if (this.head == null) {
this.head = listToAppend.head;
return;
}
// 3. 遍历当前链表，找到最后一个节点
Node current = this.head;
while (current.next != null) {
current = current.next;
}
// 4. 将当前链表的最后一个节点的next指向待追加链表的头节点
current.next = listToAppend.head;
}
// ... (其余方法) ...
public static void main(String[] args) {
// 创建第一个链表
SinglyLinkedList list1 = new SinglyLinkedList();
list1.add(0);
list1.add(1);
list1.add(2);
System.out.print("List1 初始状态: ");
list1.printList(); // 输出: List1 初始状态: [0, 1, 2]
// 创建第二个链表
SinglyLinkedList list2 = new SinglyLinkedList();
list2.add(10);
list2.add(20);
System.out.print("List2 初始状态: ");
list2.printList(); // 输出: List2 初始状态: [10, 20]
// 执行 append 操作
list1.append(list2);
System.out.print("List1 append List2 后: ");
list1.printList(); // 期望输出: List1 append List2 后: [0, 1, 2, 10, 20]
// 测试边界条件：当前链表为空
SinglyLinkedList emptyList = new SinglyLinkedList();
SinglyLinkedList list3 = new SinglyLinkedList();
list3.add(30);
list3.add(40);
System.out.print("List3 初始状态: ");
list3.printList(); // 输出: List3 初始状态: [30, 40]
emptyList.append(list3);
System.out.print("空链表 append List3 后: ");
emptyList.printList(); // 期望输出: 空链表 append List3 后: [30, 40]
// 测试边界条件：待追加链表为空
SinglyLinkedList list4 = new SinglyLinkedList();
list4.add(50);
System.out.print("List4 初始状态: ");
list4.printList(); // 输出: List4 初始状态: [50]
SinglyLinkedList anotherEmptyList = new SinglyLinkedList();
list4.append(anotherEmptyList);
System.out.print("List4 append 空链表 后: ");
list4.printList(); // 期望输出: List4 append 空链表 后: [50]
}
}注意事项与总结
- 所有权转移： append操作通常意味着listToAppend的节点被“转移”到了this链表。如果listToAppend之后仍被独立使用，它的head将指向原位置，但其节点现在也成为了this链表的一部分。在某些场景下，你可能希望append操作后listToAppend变为空，这可以通过在current.next = listToAppend.head;之后添加listToAppend.head = null;来实现。
- 时间复杂度： 寻找当前链表尾部的时间复杂度为O(N)，其中N是当前链表的长度。因此，append操作的整体时间复杂度是O(N)。
- 内存管理： Java的垃圾回收机制会自动处理不再引用的节点。当listToAppend的节点被this链表引用后，只要this链表存在，这些节点就不会被回收。
- 通用性： 上述示例使用了int类型的数据。在实际应用中，Node类通常会使用泛型来存储任意类型的数据，以提高代码的通用性。
通过以上详细的教程和代码示例，我们清晰地展示了如何在Java单向链表中正确实现append方法，并强调了关键的逻辑和边界条件处理，以确保链表操作的健壮性和正确性。
