单链表翻转

给定链表: A->B->C->D->E
变为 E->D->C->B->A

! 注意,是节点的顺序都要发生变化,不仅仅是值.

对空间没有要求的话:可以创建一个链表,或者一个栈,全放进去,然后一个一个取.

而递归的解决方法好看的多,但是对堆栈结构,对象和对象的引用要求比较高.

# 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(not head or not head.next):
            return head
        rhead = self.reverseList(head.next);
        head.next.next = head
        head.next =None
        return rhead

尤其是对象的引用,我们看到

head.next.next = head
当前对象引用—>其所指向的下一个—->下一个的下一个指向
了自己,
A.next (B).next = A
A<==>B 或者说 A —> B —>A

head.next = None
这个其实是为最后一个做准备,因为之前的实际上都被替代了.

非递归实现: leetcode 不接受,时间超了

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* reverseList(struct ListNode* head) {
    if(head == NULL || head->next == NULL ){
        return head;
    }
    struct ListNode* pre = head;
    struct ListNode* temp = NULL;
    head = head->next;
    while(head != NULL){
        temp = head->next;
        head->next = pre;
        pre = head;
        head = temp;
    }
    return pre;
}