题目地址:https://leetcode.com/problems/reverse-linked-list/open in new window

Total Accepted: 105474 Total Submissions: 267077 Difficulty: Easy

题目描述

Reverse a singly linked list.

Example:

Input: 1->2->3->4->5->NULL
Output: 5->4->3->2->1->NULL

Follow up:

Alinked list can be reversed either iteratively or recursively. Could you implement both?

题目大意

翻转单链表。

解题方法

迭代

迭代解法,每次找出老链表的下一个结点,插入到新链表的头结点,这样就是一个倒着的链。

举例说明:

old->3->4->5->NULL
new->2->1
然后把3插入到new的后边,会变成:
old->4->5->NULL
new->3->2->1

Java代码如下:

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

1 2 3 4 5 6 7 8 9 10 11

二刷,python。

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        if head == None or head.next == None:
            return head
        newHead = None
        while head != None:
            temp = head.next
            head.next = newHead
            newHead = head
            head = temp
        return newHead

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

三刷,python。下面的解法打败了100%.

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        dummy = ListNode(-1)
        while head:
            nodenext = head.next
            head.next = dummy.next
            dummy.next = head
            head = nodenext
        return dummy.next

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

四刷,C++代码如下:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* dummy = new ListNode(0);
        while (head) {
            ListNode* old = dummy->next;
            ListNode* nxt = head->next;
            dummy->next = head;
            head->next = old;
            head = nxt;
        }
        return dummy->next;
    }
};

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

递归

递归,先把除了head以外的后面部分翻转,然后把head放到已经翻转了的链表的结尾即可。需要注意的是找到已经翻转了的链表结尾并不是遍历找的,而是通过head.next.next = head;这一步,原因是head.next是老链表的除了head以外的头,也就是说新链表的结尾。

1→ … → nk-1 → nk → nk+1 → … → nm → Ø

Assume from node nk+1 to nm had been reversed and you are at node nk.

n1 → … → nk-1 → nk → nk+1 ← … ← nm

We want nk+1’s next node to point to nk.

So,

nk.next.next = nk;

Be very careful that n1's next must point to Ø. If you forget about this, your linked list has a cycle in it. This bug could be caught if you test your code with a linked list of size 2.

Java代码如下:

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

1 2 3 4 5 6 7

另外一种递归解法是新增加一个函数,让其有两个参数,第一个参数表示剩余链表的头,第二个参数表示新链表的头。每次把剩余链表的头插入到新链表的头部,返回该新的头部即可,这样的翻转就更直观了。

python的递归写法。

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        return self.reverse(head, None)
        
    def reverse(self, head, newHead):
        if not head:
            return newHead
        headnext = head.next
        head.next = newHead
        return self.reverse(headnext, head)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

C++代码如下:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        return reverse(head, nullptr);
    }
    ListNode* reverse(ListNode* oldHead, ListNode* newHead) {
        if (!oldHead) return newHead;
        ListNode* nxt = oldHead->next;
        oldHead->next = newHead;
        return reverse(nxt, oldHead);
    }
};

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

DDKK.COM 弟弟快看-教程,程序员编程资料站,版权归原作者所有

本文经作者:负雪明烛 授权发布,任何组织或个人未经作者授权不得转发