[数据结构与算法]【算法笔记】链表相关

LC141 环形链表

注意快慢指针的使用

bool hasCycle(ListNode *head) {
    //快慢指针
    if(head == nullptr) return false;
    ListNode *fast = head, *slow = head;
    while(fast->next && fast->next->next) {
        /*
        * 在链表中只有一个节点时，快慢指针都为nullptr，返回true，错误！
        * fast = fast->next ? fast->next->next : fast->next;
        */
        slow = slow->next;
        fast = fast->nex
        if(fast == slow) return true; //指针相遇，则有环
    }
    return false;
}

LC206 反转链表

//迭代
ListNode* reverseList(ListNode* head) {
    ListNode *cur = head, *pre = nullptr;
    while(cur) {
        ListNode *tmp = cur->next;
        cur->next = pre;
        pre = cur;
        cur = tmp;
    }
    return pre;
}

//递归
ListNode* reverseList(ListNode* head) {
    return reverse(head, nullptr);
}
ListNode* reverse(ListNode* cur, ListNode* pre) {
    if(cur == nullptr) return pre;
    ListNode *tmp = cur->next;
    cur->next = pre;
    return reverse(tmp, cur);
}

LC234 回文链表

时间复杂度：O(n)
空间复杂度：O(1)

bool isPalindrome(ListNode* head) {
    ListNode *slow = head, *fast = head, *prev = nullptr;
    //通过快慢指针找到链表中间位置
    while(fast) {
        slow = slow->next;
        /*
		* 注意slow最终的指向
		* 1->2->2->1
		*       |
		*     slow
		*/
        fast = fast->next ? fast->next->next : fast->next;
    }
    //反转链表
    while(slow) {
        ListNode *tmp = slow->next;
        slow->next = prev;
        prev = slow;
        slow = tmp;
    }
    //遍历检查
    while(head && prev) {
        if(head->val != prev->val) return false;
        head = head->next;
        prev = prev->next;
    }
    return true;
}