C++ Leetcode初级算法之链表篇

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

思路：快慢指针，如果有环必相遇