Java链表反转中的OutOfMemoryError解析与正确实现

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){ // 这个循环将永远不会结束
        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 nextTemp = current.next; // 临时保存当前节点的下一个节点，以便后续移动
        current.next = previous;      // 将当前节点的next指针指向前一个节点，完成反转
        previous = current;           // previous指针向前移动，指向当前节点
        current = nextTemp;           // 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 setters are generally not recommended for public facing Node class
    // but keeping for consistency with original code structure.
    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();
    }

    /**
     * Correctly reverses the linked list using an iterative approach.
     * Time Complexity: O(N)
     * Space Complexity: O(1)
     */
    public void reversal() {
        Node current = this.head;
        Node previous = null;

        while (current != null) {
            Node nextTemp = current.next; // Save the next node
            current.next = previous;      // Reverse the current node's pointer
            previous = current;           // Move previous one step forward
            current = nextTemp;           // Move current one step forward
        }

        this.head = previous; // Update the head of the list
    }

    public static void main(String[] args) {
        MyCodeLink myCodeLink = new MyCodeLink(8);

        System.out.println("Initial list:");
        System.out.println("size: " + myCodeLink.getSize());
        System.out.println(myCodeLink); // Output: 8

        myCodeLink.insertToHead(6);
        System.out.println("\nAfter insertToHead(6):");
        System.out.println("size: " + myCodeLink.getSize());
        System.out.println(myCodeLink); // Output: 6    8

        myCodeLink.insert(1, 7);
        System.out.println("\nAfter insert(1, 7):");
        System.out.println("size: " + myCodeLink.getSize());
        System.out.println(myCodeLink); // Output: 6    7   8

        myCodeLink.insertToLast(9);
        System.out.println("\nAfter insertToLast(9):");
        System.out.println("size: " + myCodeLink.getSize());
        System.out.println(myCodeLink); // Output: 6    7   8   9

        System.out.println("\nReversing the list...");
        myCodeLink.reversal();
        System.out.println("List after reversal:");
        System.out.println("size: " + myCodeLink.getSize());
        System.out.println(myCodeLink); // Output: 9    8   7   6
    }
}