1. 刪除連結串列中的節點

請編寫一個函式，使其可以刪除某個連結串列中給定的（非末尾）節點，你將只被給定要求被刪除的節點。

現有一個連結串列 – head = [4,5,1,9]，它可以表示為:

4 -> 5 -> 1 -> 9

示例 1:

輸入: head = [4,5,1,9], node = 5
輸出: [4,1,9]
解釋: 給定你連結串列中值為 5 的第二個節點，那麼在呼叫了你的函式之後，該連結串列應變為 4 -> 1 -> 9.
示例 2:

輸入: head = [4,5,1,9], node = 1
輸出: [4,5,9]
解釋: 給定你連結串列中值為 1 的第三個節點，那麼在呼叫了你的函式之後，該連結串列應變為 4 -> 5 -> 9.
說明:

連結串列至少包含兩個節點。
連結串列中所有節點的值都是唯一的。
給定的節點為非末尾節點並且一定是連結串列中的一個有效節點。
不要從你的函式中返回任何結果。

class Solution {
public:
    void deleteNode(ListNode* node) {
        node->val = node->next->val;
        node->next = node->next->next;
    }
};

思路：將要刪除的結點的值變為下一個結點的值，然後刪除該結點的下一個結點

2. 刪除連結串列的倒數第N個節點

給定一個連結串列，刪除連結串列的倒數第 n 個節點，並且返回連結串列的頭結點。

示例：

給定一個連結串列: 1->2->3->4->5, 和 n = 2.

當刪除了倒數第二個節點後，連結串列變為 1->2->3->5.
說明：

給定的 n 保證是有效的。

進階：

你能嘗試使用一趟掃描實現嗎？

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* front = new ListNode(0);
        front->next = head;
        ListNode* pre = front;
        ListNode* post = front;
        while(pre != nullptr)
        {
            pre = pre->next;
            if(n<0)
                post = post->next;
            n--;
        }
        post->next = post->next->next;
        return front->next;
    }
};
 

思路：定義一個兩個指標pre，post，pre先走ｎ步，當pre到達尾結點時post的下一個結點便是要刪除的結點

３.反轉連結串列

反轉一個單鏈表。

示例:

輸入: 1->2->3->4->5->NULL
輸出: 5->4->3->2->1->NULL
進階:
你可以迭代或遞迴地反轉連結串列。你能否用兩種方法解決這道題？

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head == nullptr)
            return nullptr;
        ListNode* pre = nullptr;
        while(head)
        {
            ListNode* nextNode = head->next;
            head->next = pre;
            pre = head;
            head = nextNode;
        }
        return pre;
    }
};

4.合併兩個有序連結串列

將兩個有序連結串列合併為一個新的有序連結串列並返回。新連結串列是通過拼接給定的兩個連結串列的所有節點組成的。

示例：

輸入：1->2->4, 1->3->4
輸出：1->1->2->3->4->4

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode* list = new ListNode(0);
        ListNode* res = list;
        while(l1 && l2)
        {
            if(l1->val < l2->val)
            {
                list->next = l1;
                l1 = l1->next;
            }else
            {
                list->next = l2;
                l2 = l2->next;
            }
            list = list->next;
        }
        while(l1)
        {
            list->next = l1;
            list = list->next;
            l1 = l1->next;
        }
        while(l2)
        {
            list->next = l2;
            list = list->next;
            l2 = l2->next;
        }
        return res->next;
    }
};

5.迴文連結串列

請判斷一個連結串列是否為迴文連結串列。

示例 1:

輸入: 1->2
輸出: false
示例 2:

輸入: 1->2->2->1
輸出: true
進階：
你能否用 O(n) 時間複雜度和 O(1) 空間複雜度解決此題？

class Solution {
public:
    bool isPalindrome(ListNode* head) {
        int n = len(head);
        if(n == 1 || n == 0)
            return true;
        ListNode* head2 = head;
        for(int i=0;i<(n/2+n%2);i++)
            head2 = head2->next;
        head2 = reverse(head2);
        while(head2)
        {
            if(head2->val != head->val)
                return false;
            else{
                head = head->next;
                head2 = head2->next;
            }
        }
        return true;
    }
        int len(ListNode* head)
        {
            int n = 0;
            while(head)
            {
                head = head->next;
                n++;
            }
            return n;
        }
        ListNode* reverse(ListNode* head)
        {
            ListNode* pre = nullptr;
            while(head)
            {
                ListNode* nextNode = head->next;
                head->next = pre;
                pre = head;
                head = nextNode;
            }
            return pre;
        }
    
};

思路：計算出連結串列的長度ｎ，反轉連結串列的後半段為head2，將head2與head的值比較，有不同則返回false，否則返回true．

6.環形連結串列

給定一個連結串列，判斷連結串列中是否有環。

進階：
你能否不使用額外空間解決此題？

class Solution {
public:
    bool hasCycle(ListNode *head) {
        if(head == nullptr)
            return false;
        ListNode* fast = head;
        ListNode* slow = head;
        while(fast && fast->next)
        {
            fast = fast->next->next;
            slow = slow->next;
            if(fast == slow)
                return true;
        }
        return false;
    }
};

思路：快慢指標，如果有環必相遇