[LeetCode] Reverse Linked List(递归与非递归反转链表)

Reverse a singly linked list.

解题思路

对于非递归实现，思路是依次将从第二个结点到最后一个结点的后继设为头结点，然后将该节点设为头结点（需记住将原头结点的后继设为空）。
对于递归实现，首先反转从第二个结点到最后一个结点的链表，然后再将头结点放到已反转链表的最后，函数返回新链表的头结点。

非递归实现代码1[C++]

//Runtime:10 ms
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if (head == NULL) return NULL;
        ListNode *pre = head;
        ListNode *cur = head->next;
        while (cur != NULL)
        {
            pre->next = cur->next;
            cur->next = head;
            head = cur;
            cur = pre->next;
        }

        return head;
    }
};

非递归实现代码2[C++]

//Runtime:22 ms
class Solution{
public:
    ListNode* reverseList(ListNode* head){
        if (head == NULL) return NULL;
        ListNode *cur = head->next;
        head->next = NULL;
        while (cur != NULL)
        {
            ListNode *temp = cur->next;
            cur->next = head;
            head = cur;
            cur = temp;
        }

        return head;
    }
};

非递归实现代码3[Java]

//Runtime:276 ms
public class Solution {
    public ListNode reverseList(ListNode head) {
        if (head == null) {
            return head;
        }
        ListNode cur = head.next;
        ListNode pre = head;
        while (cur != null){
            pre.next = cur.next;
            cur.next = head;
            head = cur;
            cur = pre.next;
        }

        return head;
    }
}

非递归实现代码4[Python]

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

class Solution:
    # @param {ListNode} head
    # @return {ListNode}
    def reverseList(self, head):
        if head == None:
            return head
        pre = head
        cur = head.next
        while cur != None:
            pre.next = cur.next
            cur.next = head
            head = cur
            cur = pre.next

        return head

s = Solution()
head = ListNode(0);
cur = head
for i in range(1, 10):
    node = ListNode(i)
    cur.next = node
    cur = node
head = s.reverseList(head);
while(head != None):
    print(head.val, end=' ')
    head = head.next

递归实现代码[C++]

//Runtime:10 ms
class Solution{
public:
    ListNode* reverseList(ListNode* head){
        //此处的条件不能写成if(head == NULL)
        if (head == NULL || head->next == NULL) return head;
        ListNode *newhead = reverseList(head->next);
        head->next->next = head;
        head->next = NULL;

        return newhead;
    }
};

C++测试代码如下：

void printList(ListNode *head)
{
    while(head != NULL)
    {
        cout<<head->val<<" ";
        head = head->next;
    }
    cout<<endl;
}

void dropList(ListNode *head)
{
    if (head == NULL) return;
    ListNode *temp;
    while (head != NULL)
    {
        temp = head->next;
        delete head;
        head = temp;
    }
}

int main()
{
    ListNode *head = new ListNode(0);
    ListNode *cur = head;
    for (int i = 0; i < 10; i++)
    {
        ListNode *newnode = new ListNode(floor(rand()%100));
        cur->next = newnode;
        cur = newnode;
    }
    printList(head);
    Solution s;
    head = s.reverseList(head);
    printList(head);
    dropList(head);
}

Java测试代码如下：

public class AA {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ListNode head = new ListNode(0);
        ListNode cur = head;
        for(int i = 1; i < 10; i++){
            ListNode node = new ListNode(i);
            cur.next = node;
            cur = node;
        }

        Solution s = new Solution();
        head = s.reverseList(head);
        print(head);
    }

    static void print(ListNode head){
        while(head != null){
            System.out.println(head.val);
            head = head.next;
        }
    }
}