Java单链表反转方法导致OutOfMemoryError的深度解析与正确实践

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
    at java.base/java.util.Arrays.copyOf(Arrays.java:3537)
    at java.base/java.lang.AbstractStringBuilder.ensureCapacityInternal(AbstractStringBuilder.java:228)
    at java.base/java.lang.AbstractStringBuilder.append(AbstractStringBuilder.java:829)
    at java.base/java.lang.StringBuilder.append(StringBuilder.java:253)
    at com.company.MyCodeLink.toString(MyCodeLink.java:74)
    at java.base/java.lang.String.valueOf(String.java:4218)
    at java.base/java.io.PrintStream.println(PrintStream.java:1047)
    at com.company.MyCodeLink.main(MyCodeLink.java:132)

public void reversal(){
    Node p1 = this.head;
    Node p2 = p1.next;

    while (p2 != null){
        Node temp = p2.next;
        p2.next = p1; // 关键错误点：p2指向p1
        p1 = p2;
        p2 = temp;
    }

    this.head = p1;
}

@Override
public String toString(){
    StringBuilder s = new StringBuilder();
    Node cur = head;
    while (cur != null){ // cur 永远不会为 null
        s.append(cur.val).append("\t"); // 不断追加字符
        cur = cur.next; // 在 A 和 B 之间循环
    }
    return s.toString();
}

public void reversal(){
    Node current = this.head; // 从链表头部开始
    Node previous = null;    // 反转后，原头节点的下一个节点应为null

    while (current != null){
        Node temp = current.next;   // 1. 临时保存当前节点的下一个节点，防止链表断裂
        current.next = previous;    // 2. 反转指针：当前节点指向前一个节点
        previous = current;         // 3. previous 向前移动一步，成为新的前一个节点
        current = temp;             // 4. current 向前移动一步，处理下一个节点
    }

    this.head = previous; // 循环结束后，previous 指向原链表的最后一个节点，它现在是新链表的头部
}

package com.company;

import java.util.ArrayList;

class Node {
    public Node(int val, Node next) {
        this.val = val;
        this.next = next;
    }

    public Node(int val) {
        this(val, null);
    }

    int val;
    Node next;

    // 保持私有，通常通过链表类的方法修改
    private void setVal(int newVal) {
        this.val = newVal;
    }

    private void setNext(Node newNextNode) {
        this.next = newNextNode;
    }
}

public class MyCodeLink {
    private Node head;
    private int size;

    public MyCodeLink(int val) {
        this.head = new Node(val, null);
        this.size = 1;
    }

    public void insert(int index, int val) {
        if (index < 0 || index > this.getSize()) {
            throw new IndexOutOfBoundsException("index must >= 0 and <= size");
        }
        if (index == 0) {
            this.head = new Node(val, head);
            this.size++;
            return;
        }

        Node cur = head;
        for (int i = 0; i < index - 1; i++) {
            cur = cur.next;
        }

        Node node = new Node(val, cur.next);
        cur.next = node;
        this.size++;
    }

    public void insertToHead(int val) {
        insert(0, val);
    }

    public void insertToLast(int val) {
        insert(this.getSize(), val);
    }

    public int getSize() {
        return this.size;
    }

    public Node getHead() {
        return head;
    }

    @Override
    public String toString() {
        StringBuilder s = new StringBuilder();
        Node cur = head;
        while (cur != null) {
            s.append(cur.val).append("\t");
            cur = cur.next;
        }
        return s.toString();
    }

    /**
     * 正确的链表反转方法（迭代法）
     */
    public void reversal() {
        Node current = this.head;
        Node previous = null;

        while (current != null) {
            Node temp = current.next;   // 1. 临时保存当前节点的下一个节点
            current.next = previous;    // 2. 反转当前节点的指针，使其指向前一个节点
            previous = current;         // 3. previous 指针向前移动一步
            current = temp;             // 4. current 指针向前移动一步
        }

        this.head = previous; // 更新链表头部为原链表的最后一个节点
    }

    public static void main(String[] args) {
        MyCodeLink myCodeLink = new MyCodeLink(8);
        System.out.println("Initial list: " + myCodeLink); // 8
        System.out.println("Size: " + myCodeLink.getSize()); // 1

        myCodeLink.insertToHead(6);
        System.out.println("After insertToHead(6): " + myCodeLink); // 6   8
        System.out.println("Size: " + myCodeLink.getSize()); // 2

        myCodeLink.insert(1, 7);
        System.out.println("After insert(1, 7): " + myCodeLink); // 6   7   8
        System.out.println("Size: " + myCodeLink.getSize()); // 3

        myCodeLink.insertToLast(9);
        System.out.println("After insertToLast(9): " + myCodeLink); // 6   7   8   9
        System.out.println("Size: " + myCodeLink.getSize()); // 4

        System.out.println("--- Reversing the list ---");
        myCodeLink.reversal();
        System.out.println("After reversal: " + myCodeLink); // 9   8   7   6
        System.out.println("Size: " + myCodeLink.getSize()); // 4

        // 验证空链表或单节点链表反转
        MyCodeLink emptyList = new MyCodeLink(10);
        emptyList.head = null; // 创建一个空链表
        System.out.println("\nEmpty list before reversal: " + emptyList);
        emptyList.reversal();
        System.out.println("Empty list after reversal: " + emptyList);

        MyCodeLink singleNodeList = new MyCodeLink(100);
        System.out.println("Single node list before reversal: " + singleNodeList);
        singleNodeList.reversal();
        System.out.println("Single node list after reversal: " + singleNodeList);
    }
}