链表总结

1.反转链表

输入:1->2->3->4->5->NULL
输出:5->4->3->2->1->NULL

递归方法$(O(n))$

/**
 * 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 || !head->next) return head;
        ListNode* tail = reverseList(head->next);
        head->next->next = head; // 此时head->next为后面一坨子链表的尾结点
        head->next = nullptr;
        return tail;
        
    }
};

• 时间复杂度：由于每个结点只遍历一次，所以时间复杂度是$O(n)$
• 空间复杂度：总共递归n层，系统栈的空间复杂度为$O(n)$，所以程序总共需要的空间复杂度为$O(n)$

迭代方法$O(n)$

• 由于链表只能找到后继结点，所以需要额外的指针保存前驱结点
• 改变当前结点的$next$值时要保存它的后继结点

/**
 * 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* pre = nullptr;
        auto cur = head;
        while (cur){
            auto next = cur->next; // 相当于缓存机制，将当前结点的后继记录下来
            cur->next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
    }
};

• 时间复杂度：链表遍历一次，所以时间复杂度是$O(n)$
• 空间复杂度：只需要三个额外空间，所以程序总共需要的空间复杂度为$O(1)$

2.合并两个排序的链表

输入两个递增排序的链表，合并这两个链表并使新链表中的结点仍然是按照递增排序的。

输入：1->3->5 , 2->4->5

输出：1->2->3->4->5->5