标签：head ListNode temp offer next 链表 024 节点

题目：

给定单链表的头节点 head ，请反转链表，并返回反转后的链表的头节点。

示例 1：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例 2：

输入：head = [1,2]
输出：[2,1]

示例 3：

输入：head = []
输出：[]

提示：

链表中节点的数目范围是 [0, 5000]
-5000 <= Node.val <= 5000

代码一：迭代

package jianzhioffer;

public class offer_24 {
    public static void main(String[] args) {
        // 初始化链表
        LinkList list = new LinkList();
        // 初始化节点
        ListNode node1 = new ListNode(1);
        ListNode node2 = new ListNode(2);
        ListNode node3 = new ListNode(3);
        ListNode node4 = new ListNode(4);
        // 添加节点
        list.add(node1);
        list.add(node2);
        list.add(node3);
        list.add(node4);

        ListNode head = node1;
        System.out.println(reverseList(head).val);

    }
    public static ListNode reverseList(ListNode head) {
        ListNode temp;
        // 反转链表的头结点
        ListNode pre = null;
        // 如果链表没有节点或者只有一个节点直接返回头结点即可
        if (head == null || head.next == null) {
            return head;
        }
        // 该指针用来遍历当前链表
        ListNode now = head;
        while (now != null) {
            // 存储当前节点的下一个节点
            temp = now.next;
            // 将原来的链表依次加入新的链表
            // 注意此处的链表是虚拟的，是通过指针的不断移动形成的
            now.next = pre;
            // 反转链表的头指针始终指向第一个节点
            pre = now;
            // 当前指针后移，继续将节点加入反转链表
            now = temp;

        }
        return pre;
    }

    static class ListNode {
        int val;
        ListNode next;
        ListNode (int x) {
            val = x;
            next = null;
        }
    }

    /**
     * 链表类
     */
    static class LinkList {
        ListNode head = new ListNode(0);
        /**
         * 在链表结尾添加元素
         */
        public void add(ListNode node) {
            ListNode temp = head;
            while (true) {
                if (temp.next == null) {
                    break;
                }
                temp = temp.next;
            }
            temp.next = node;
        }
    }

}

解题思路： 

在遍历链表时，将当前节点的 next 指针改为指向前一个节点。由于节点没有引用其前一个节点，因此必须事先存储其前一个节点。在更改引用之前，还需要存储后一个节点。最后返回新的头引用。

代码二：递归

public class Test {
    public static void main(String[] args) {
        // 初始化链表
        LinkList list = new LinkList();
        // 初始化节点
        ListNode node1 = new ListNode(1);
        ListNode node2 = new ListNode(2);
        ListNode node3 = new ListNode(3);
        ListNode node4 = new ListNode(4);
        // 添加节点
        list.add(node1);
        list.add(node2);
        list.add(node3);
        list.add(node4);

        ListNode head = node1;
        System.out.println(reverseList(head).val);

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

        // 从后往前开始反转
        ListNode pre = reverseList(head.next);
        // 当前节点的下一个节点的next指针指向当前节点
        head.next.next = head;
        // 每完成一个节点的反转就让其的next指向空，以免产生环
        head.next = null;
        return pre;

    }

    static class ListNode {
        int val;
        ListNode next;
        ListNode (int x) {
            val = x;
            next = null;
        }
    }

    /**
     * 链表类
     */
    static class LinkList {
        ListNode head = new ListNode(0);
        /**
         * 在链表结尾添加元素
         */
        public void add(ListNode node) {
            ListNode temp = head;
            while (true) {
                if (temp.next == null) {
                    break;
                }
                temp = temp.next;
            }
            temp.next = node;
        }
    }

}

解题思路：

注释。

 参考链接：

力扣

标签：head,ListNode,temp,offer,next,链表,024,节点
来源： https://blog.csdn.net/weixin_43817702/article/details/122265298

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。