Java实现单链表反转

可以使用迭代或递归的方式实现单链表反转。以下是迭代方式的代码示例：

public ListNode reverseList(ListNode head) {
    ListNode prev = null;
    ListNode curr = head;
    while (curr != null) {
        ListNode next = curr.next;
        curr.next = prev;
        prev = curr;
        curr = next;
    }
    return prev;
}

其中，ListNode 是单链表节点的定义，包含一个 val 属性和一个 next 属性，表示节点的值和下一个节点的指针。

相关问题

单链表反转java头插法

单链表反转是指将链表中的节点顺序颠倒，即原来的头节点变为尾节点，原来的尾节点变为头节点。其中，头插法是一种常用的反转单链表的方法。

在Java中，可以通过以下代码实现单链表的反转（使用头插法）：

class ListNode {
    int val;
    ListNode next;

    ListNode(int val) {
        this.val = val;
    }
}

public class LinkedListReverse {
    public static ListNode reverse(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }

        ListNode newHead = null;
        while (head != null) {
            ListNode next = head.next;
            head.next = newHead;
            newHead = head;
            head = next;
        }

        return newHead;
    }

    public static void main(String[] args) {
        // 创建一个示例链表：1 -> 2 -> 3 -> 4 -> 5
        ListNode head = new ListNode(1);
        ListNode node2 = new ListNode(2);
        ListNode node3 = new ListNode(3);
        ListNode node4 = new ListNode(4);
        ListNode node5 = new ListNode(5);
        head.next = node2;
        node2.next = node3;
        node3.next = node4;
        node4.next = node5;

        // 反转链表
        ListNode reversedHead = reverse(head);

        // 输出反转后的链表：5 -> 4 -> 3 -> 2 -> 1
        while (reversedHead != null) {
            System.out.print(reversedHead.val + " ");
            reversedHead = reversedHead.next;
        }
    }
}

以上代码中，`reverse`方法使用了头插法来反转单链表。首先判断链表是否为空或只有一个节点，若是，则直接返回原链表。然后，通过循环遍历链表，每次将当前节点的`next`指针指向已反转部分的头节点，并更新新的头节点为当前节点。最后返回新的头节点即可。

java 单链表翻转四种方法

Java 单链表翻转可以采用以下四种方法：

1. 迭代法：
迭代法是通过遍历链表，将每个节点的指针指向前一个节点来实现翻转。需要用到三个指针，分别是当前节点、当前节点的前一个节点和当前节点的后一个节点。具体步骤如下：
- 初始化当前节点为头节点，前一个节点和后一个节点都为 null。
- 进入循环，循环条件是当前节点不为 null。
- 在循环内部，先用一个临时变量保存当前节点的后一个节点。
- 将当前节点的指针指向前一个节点。
- 更新前一个节点为当前节点，当前节点为临时变量保存的后一个节点。
- 重复上述步骤直到当前节点为 null。
- 最后将头节点指向反转后的链表的头节点，并返回头节点。

2. 递归法：
递归法是利用递归的思想实现链表翻转。
- 首先判断链表是否为空或者只有一个节点，如果是，则直接返回该链表。
- 否则，递归调用翻转链表函数，将头节点的下一个节点作为参数传入。
- 在翻转函数内部，先递归翻转后面的链表。
- 接着将头节点的下一个节点的下一个节点指向头节点，同时将头节点的下一个节点指向 null。
- 最后返回翻转后的链表的头节点。

3. 栈法：
栈法是利用栈的先进后出特性实现链表翻转。
- 先将链表的所有节点依次入栈。
- 然后从栈中依次弹出节点，每次弹出的节点都是从末尾开始的，依次指向前一个弹出的节点。
- 最后返回栈顶节点作为新的链表的头节点。

4. 头插法：
头插法是依次将链表的节点插入到一个新的链表中，并将新的链表的头节点指向原链表的尾节点。
- 首先创建一个新的空链表和一个指向原链表的头节点的指针。
- 进入循环，循环条件是原链表的指针不为 null。
- 在循环内部，先保存原链表指针的下一个节点，然后将原链表指针当前指向的节点插入到新链表的头部。
- 更新原链表指针为保存的下一个节点。
- 重复上述步骤直到原链表指针为 null。
- 最后返回新链表的头节点。

以上四种方法都可以实现单链表的翻转，具体选择哪种方法取决于个人偏好和场景需求。