206. 反转链表 （精选）

合集 - 算法(25)

1.1. 两数之和2023-11-072.383. 赎金信2023-11-083.15. 三数之和 12023-11-084.15. 三数之和 22023-11-095.18. 四数之和2023-11-096.344. 反转字符串2023-11-107.541. 反转字符串 II2023-11-108.54. 替换数字（第八期模拟笔试）2023-11-119.151. 反转字符串中的单词 12023-11-1110.55. 右旋字符串（第八期模拟笔试）2023-11-1211.28. 找出字符串中第一个匹配项的下标 12023-11-1212.28. 找出字符串中第一个匹配项的下标 22023-11-1313.459. 重复的子字符串2023-11-1314.kmp算法2023-11-1415.459. 重复的子字符串 （精选）2023-11-1516.27. 移除元素2023-11-1617.344. 反转字符串2023-11-1618.54. 替换数字（卡码网 第八期模拟笔试）2023-11-1619.151. 反转字符串中的单词2023-11-17

20.206. 反转链表 （精选）2023-11-18

21.19. 删除链表的倒数第 N 个结点2023-11-2022.面试题 02.07. 链表相交2023-11-2123.142. 环形链表 II2023-11-2124.15. 三数之和2023-11-2225.18. 四数之和2023-11-22

收起

2023-11-18

206. 反转链表 - 力扣（LeetCode）

思路：

注意leetcode是没有头节点的，只有数据节点

1 先将指针放到最后，然后从开头取节点，放到此节点后面 遍历2遍，不好

2 引入头节点，头插法 可以就用本来的链表 / 定义一个新的链表

3 原地反转链表的线

迭代（双指针）

递归 相当于1的思路

1简单，就没有代码了

2：

引入头节点的头插法（用本来链表）;

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        //原地反转  双指针
        //递归
        //栈
        //引入头节点  头插法
 
 
        //引入头节点，头插法
 
        if(head==null || (head!=null && head.next==null)){
            return head;
        }
    
        ListNode l=new ListNode();
        l.next=head;
        
        ListNode now=head;
 
        while(now.next!=null){
            ListNode temp=now.next;
            now.next=now.next.next;
            temp.next=l.next;
            l.next=temp;
        }
 
        return l.next;
 
 
 
 
    }
}

定义新链表的头插法：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        //注意leetcode是没有头节点的，只有数据节点
 
        //1 先将指针放到最后，然后从开头取节点，放到此节点后面     遍历2遍，不好
        //2 引入头节点，头插法       可以就用本来的链表 /   定义一个新的链表
        //3 原地反转链表的线
            //迭代
            //递归  /   循环
        
        ListNode  l=new ListNode();
 
        ListNode now=head;
        ListNode t;
        while(now!=null){
            t=now.next;
            now.next=l.next;
            l.next=now;
            now=t;
        }
 
        return l.next;
 
 
 
    }
}

3：

递归：

每一层返回的都是最后一个节点，但是在返回的同时将线反转

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        //注意leetcode是没有头节点的，只有数据节点
 
        //1 先将指针放到最后，然后从开头取节点，放到此节点后面     遍历2遍，不好
        //2 引入头节点，头插法       可以就用本来的链表 /   定义一个新的链表
        //3 原地反转链表的线
            //迭代
            //递归  /   循环
        
        
        //原地反转的递归写法        后面是反转完的，前面是待反转的，相当于先将指针指向最后
        if(head==null || head.next==null){
            return head;
        }
 
        ListNode newHead = reverseList(head.next);
        head.next.next = head;
        head.next = null;
        return newHead;
 
 
 
 
    }
}

迭代/双指针：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        //原地反转  双指针
        //递归
        //栈
        //引入头节点  头插法
 
 
        //双指针
        if(head==null || (head!=null && head.next==null)){
            return head;
        }
 
        ListNode pre=null;
        ListNode now=head;
 
        ListNode temp;
        while(true){
            temp=now.next;
            now.next=pre;
            pre=now;
            if(temp==null){
                break;
            }
            now=temp;
        }
        
        return now;
 
 
 
    }
}