【c/c++算法刷题笔记】—— LeetCode打卡06

【前言】链表专题(比较水，复习一下即可)。OJ：AcWing + LeetCode

1 删除链表的倒数第N个节点

题目描述

给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。

样例

给定一个链表: 1->2->3->4->5, 和 n = 2.

当删除了倒数第二个节点后，链表变为 1->2->3->5.

笔记

1. 建立虚拟头节点 ，第一个结点可能被删除，所以设头节点
2. first 向后走 n 步
3. 两个指针同步移动，直到 first 到结尾，second 为倒数第n 个结点。delete 可写可不写，没写也能过，最好还是写上
4. 第一个结点可能被删除，所以设头节点

代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
            ListNode* dummy = new ListNode(-1);   //第一个结点可能被删除，所以设头节点
            dummy->next=head;
            ListNode* first=dummy;
            ListNode* second=dummy;
            
            while(n--) first=first->next;
            while(first->next){
                first=first->next;
                second=second->next;
            }
            second->next=second->next->next;  
            return dummy->next;   
    }
};

2 删除链表中的节点

题目描述

请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点。

现有一个链表 – head = [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.

笔记

1. 结构体的等号“ = ” 是直接复制
2. *(node) = *(node->next);

代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    void deleteNode(ListNode* node) {
        // node->val=node->next->val;
        // node->next=node->next->next;

        *(node) = *(node->next);	//等价于上两行 🐂
    } 
};

3 删除排序链表中的重复元素

题目描述

给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。

样例

示例 1:

输入: 1->1->2
输出: 1->2

示例 2:

输入: 1->1->2->3->3
输出: 1->2->3

笔记

1. 第一个结点可能被删除，所以设头节点
2. 'member access within null pointer of type ‘struct ListNode’，未判断空指针情况

代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        ListNode* p = head;
        while(p&&p->next){
            if(p->val==p->next->val) p->next=p->next->next;
            else p=p->next;
        }
        return head;
    }
};

4 删除排序链表中的重复元素 II

题目描述

给定一个排序链表，删除所有含有重复数字的节点，只保留原始链表中 没有重复出现 的数字。

样例

示例 1:

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

示例 2:

输入: 1->1->1->2->3
输出: 2->3

笔记

'member access within null pointer of type ‘struct ListNode’，未判断空指针情况

代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        ListNode* dummy= new ListNode(-1);
        dummy->next=head;
        ListNode* p = dummy;
        ListNode* q = p->next;
        while(p && q){
            int flag=0;
            while(p->next && q->next && p->next->val==q->next->val){
                flag = 1;
                q=q->next;
            } 
            if(flag) p->next=q->next;
            else p=p->next;
            q=p->next;
        }
        return dummy->next;
    }
};

5 旋转链表

题目描述

给定一个链表，旋转链表，将链表每个节点向右移动 k 个位置，其中 k 是非负数。

样例

示例 1:

输入: 1->2->3->4->5->NULL, k = 2
输出: 4->5->1->2->3->NULL
解释:
向右旋转 1 步: 5->1->2->3->4->NULL
向右旋转 2 步: 4->5->1->2->3->NULL

示例 2:

输入: 0->1->2->NULL, k = 4
输出: 2->0->1->NULL
解释:
向右旋转 1 步: 2->0->1->NULL
向右旋转 2 步: 1->2->0->NULL
向右旋转 3 步: 0->1->2->NULL
向右旋转 4 步: 2->0->1->NULL\

笔记

1. 旋转次数 k%n ，n为节点个数
2. p q 两节点，找到到数第 k%n 个节点
3. 取下这断，放前面

代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) {
        if(!head) return NULL;       	//卡住了，时刻需考虑输入空或0 时的情况
        ListNode* p=head,*q=p;
        int n=0,move;
        while(p) { p=p->next; n++; }
        move = k%n;
        if(move==0) return head;
        while(move--) q=q->next;
        p=head;
        while(p->next && q->next){
            p=p->next;
            q=q->next;
        }
        q->next=head;
        head=p->next;
        p->next=NULL;

        return head;
    }
};