LeetCode——Reverse Linked List

LeetCode——Reverse Linked List

# 206

Reverse a singly linked list.

这一题的目的是反转一个单链表。是对链表操作的一个经典题目。第一个想到的思路是利用一个栈。C++语言中用栈实现的话，我只能将val保存到栈中，因为指针的问题，我解决的不好，但是Java的话，因为不用指针，就可以轻松地写出来。所以下面两个版本，其实不太一样。Python的话用的是列表。

• 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) {
        if(head == NULL)
            return 0;
        stack<int> s; 
        ListNode* rev = head;
        while(rev != NULL) {
            s.push(rev -> val);
            rev = rev -> next;
        }
        rev = head;
        while(!s.empty()) {
            head -> val = s.top();
            head = head -> next;
            s.pop();
        }
        return rev;
    }
};

• Java

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        Stack<ListNode> stack = new Stack<>();
        while (head != null) {
            stack.push(head);
            head = head.next;
        }
        ListNode tempNode = stack.pop();
        ListNode resultNode = tempNode;
        while (!stack.isEmpty()) {
            tempNode.next = stack.pop();
            tempNode = tempNode.next;
        }
        tempNode.next = null;
        return resultNode；
    }
}

• 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
        """
        p = head
        newList = []
        while p:
            newList.insert(0, p.val)
            p = p.next

        p = head
        for v in newList:
            p.val = v
            p = p.next
        return head

这里都是用的栈的方法，还有一种思想就是重组链表，分别可以用递归跟迭代的方法来实现。

• 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;
}

• 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;
}