Java单向链表append方法正确实现教程

// 错误的append方法示例
public void append(LinkedList list) {
  head.next = list.head; // 这一行是问题所在
}

public class SinglyLinkedList {

    // 节点类定义
    private static class Node {
        int data;
        Node next;

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

    private Node head; // 链表的头节点
    private int size;  // 可选：记录链表大小

    public SinglyLinkedList() {
        this.head = null;
        this.size = 0;
    }

    /**
     * 向链表末尾添加一个元素（用于构建测试链表）
     * @param data 要添加的数据
     */
    public void addLast(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;
        }
        size++;
    }

    /**
     * 将另一个单向链表追加到当前链表的末尾。
     * @param listToAppend 待追加的链表
     */
    public void append(SinglyLinkedList listToAppend) {
        // 1. 处理待追加链表为空的情况
        // 如果待追加的链表为null或者其head为null，则无需进行任何操作
        if (listToAppend == null || listToAppend.head == null) {
            return;
        }

        // 2. 处理当前链表为空的情况
        // 如果当前链表是空的，那么追加操作就是将待追加链表的头部作为当前链表的头部
        if (this.head == null) {
            this.head = listToAppend.head;
            this.size = listToAppend.size; // 更新大小
            return;
        }

        // 3. 遍历当前链表，找到最后一个节点
        Node current = this.head;
        while (current.next != null) {
            current = current.next;
        }

        // 4. 将当前链表的最后一个节点的next指针指向待追加链表的头部
        current.next = listToAppend.head;
        this.size += listToAppend.size; // 更新大小
    }

    /**
     * 打印链表的所有元素（用于验证）
     */
    public void printList() {
        if (head == null) {
            System.out.println("List is empty.");
            return;
        }
        Node current = head;
        while (current != null) {
            System.out.print(current.data + " -> ");
            current = current.next;
        }
        System.out.println("NULL");
    }

    public static void main(String[] args) {
        System.out.println("--- 演示单向链表append方法 ---");

        // 创建第一个链表
        SinglyLinkedList list1 = new SinglyLinkedList();
        list1.addLast(0);
        list1.addLast(1);
        list1.addLast(2);
        System.out.print("List1: ");
        list1.printList(); // 预期输出: 0 -> 1 -> 2 -> NULL

        // 创建第二个链表
        SinglyLinkedList list2 = new SinglyLinkedList();
        list2.addLast(10);
        list2.addLast(11);
        System.out.print("List2: ");
        list2.printList(); // 预期输出: 10 -> 11 -> NULL

        System.out.println("\n将List2追加到List1...");
        list1.append(list2);
        System.out.print("追加后的List1: ");
        list1.printList(); // 预期输出: 0 -> 1 -> 2 -> 10 -> 11 -> NULL

        // 测试边缘情况：追加到一个空链表
        SinglyLinkedList emptyList = new SinglyLinkedList();
        SinglyLinkedList list3 = new SinglyLinkedList();
        list3.addLast(30);
        list3.addLast(31);
        System.out.print("\n空链表 (emptyList): ");
        emptyList.printList();
        System.out.print("List3: ");
        list3.printList();
        System.out.println("将List3追加到空链表 (emptyList)...");
        emptyList.append(list3);
        System.out.print("追加后的emptyList: ");
        emptyList.printList(); // 预期输出: 30 -> 31 -> NULL

        // 测试边缘情况：追加一个空链表
        SinglyLinkedList list4 = new SinglyLinkedList();
        list4.addLast(40);
        System.out.print("\nList4: ");
        list4.printList();
        SinglyLinkedList anotherEmptyList = new SinglyLinkedList();
        System.out.print("另一个空链表 (anotherEmptyList): ");
        anotherEmptyList.printList();
        System.out.println("将另一个空链表追加到List4...");
        list4.append(anotherEmptyList);
        System.out.print("追加后的List4: ");
        list4.printList(); // 预期输出: 40 -> NULL (不变)
    }
}