代码随想录刷题笔记2——链表

最新推荐文章于 2024-07-25 14:12:59 发布
最新推荐文章于 2024-07-25 14:12:59 发布
阅读量80 收藏
点赞数
分类专栏： leetcode刷题 文章标签： 笔记 链表 leetcode c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xhj12138/article/details/132656381
版权

移除链表元素

例题203（简单）移除链表元素

注意要点：

  1. 链表题目涉及增减元素，可以设置虚拟头节点，辅助把链表的所有元素的逻辑操作同化；
  2. 删除元素，相当于next变成next->next。

下面贴出代码：

CPP版本

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* dummy = new ListNode(0);
        dummy->next = head;
        ListNode* cur = dummy;
        while (cur->next)
        {
            if (cur->next->val == val)
            {
                ListNode* tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;
            }
            else {cur = cur->next;}
        }
        head = dummy->next;
        delete dummy;
        return head;
    }
};

C版本

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* removeElements(struct ListNode* head, int val){
    if (!head) {return head;}
    struct ListNode* dummyhead = malloc(sizeof(struct ListNode));
    dummyhead->next = head;
    struct ListNode* tail = dummyhead;
    while (tail->next)
    {
        if (tail->next->val == val)
        {
            struct ListNode* temp = tail->next;
            tail->next = tail->next->next;
            free(temp);
        }
        else {tail = tail->next;}
    }
    return dummyhead->next;
}

设计链表

例题707（中等）设计链表

注意要点：

  1. 类中创建时，可以设置private变量：虚拟头结点以及当前链表长度辅助计算；
  2. 增添和删减元素时，涉及index都需要和链表长度先行比较;
  3. get的操作需要从头结点开始，也就是虚拟头结点的next节点；其余操作均从虚拟头结点开始。

下面贴出代码：

CPP版本

class MyLinkedList {
public:
    struct LinkedNode
    {
        int val;
        LinkedNode* next;
        LinkedNode(int val): val(val), next(nullptr){}
    };

    MyLinkedList() {
        dummy = new LinkedNode(0);
        size = 0;
    }
    
    int get(int index) {
        if (index >= size || index < 0) {return -1;}
        LinkedNode* cur = dummy->next;
        while (index--) {cur = cur->next;}
        return cur->val;
    }
    
    void addAtHead(int val) {
        LinkedNode* newhead = new LinkedNode(0);
        newhead->val = val;
        LinkedNode* tmp = dummy->next;
        dummy->next = newhead;
        newhead->next = tmp;
        size++;
    }
    
    void addAtTail(int val) {
        LinkedNode* cur = dummy;
        while (cur->next) {cur = cur->next;}
        LinkedNode* newtail = new LinkedNode(0);
        cur->next = newtail;
        newtail->val = val;
        newtail->next = nullptr;
        size++;
    }
    
    void addAtIndex(int index, int val) {
        if (index > size) {return;}
        if (index < 0) {index = 0;}
        LinkedNode* cur = dummy;
        while (index--) {cur = cur->next;}
        LinkedNode* newnode = new LinkedNode(val);
        newnode->next = cur->next;
        cur->next = newnode;
        size++;
    }
    
    void deleteAtIndex(int index) {
        if (index < 0 || index >= size) {return;}
        LinkedNode* cur = dummy;
        while (index--) {cur = cur->next;}
        LinkedNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete(tmp);
        tmp = nullptr;
        size--;
    }
private:
    LinkedNode* dummy;
    int size;
};

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList* obj = new MyLinkedList();
 * int param_1 = obj->get(index);
 * obj->addAtHead(val);
 * obj->addAtTail(val);
 * obj->addAtIndex(index,val);
 * obj->deleteAtIndex(index);
 */

C版本

struct ListNode* ListNodeCreate(int val)
{
    struct ListNode* node = (struct ListNode* )malloc(sizeof(struct ListNode));
    node->val = val;
    node->next = NULL;
    return node;
}

typedef struct {
    struct ListNode* head;
    int size;
} MyLinkedList;


MyLinkedList* myLinkedListCreate() {
    MyLinkedList* obj = (MyLinkedList* )malloc(sizeof(MyLinkedList));
    obj->head = ListNodeCreate(0);
    obj->size = 0;
    return obj;
}

int myLinkedListGet(MyLinkedList* obj, int index) {
    if (index < 0 || index >= obj->size) {return -1;}
    struct ListNode* cur = obj->head->next;
    while (index--) {cur = cur->next;}
    return cur->val;
}

void myLinkedListAddAtHead(MyLinkedList* obj, int val) {
    struct ListNode* head = obj->head;
    struct ListNode* newhead = ListNodeCreate(val);
    newhead->next = head->next;
    head->next = newhead;
    obj->size++;
}

void myLinkedListAddAtTail(MyLinkedList* obj, int val) {
    struct ListNode* cur = obj->head;
    while (cur->next) {cur = cur->next;}
    struct ListNode* newtail = (struct ListNode* )malloc(sizeof(struct ListNode));
    newtail->val = val;
    cur->next = newtail;
    newtail->next = NULL;
    obj->size++;
}

void myLinkedListAddAtIndex(MyLinkedList* obj, int index, int val) {
    if (index > obj->size) {return;}
    index = fmax(0, index);
    struct ListNode* cur = obj->head;
    while (index--) {cur = cur->next;}
    struct ListNode* newnode = ListNodeCreate(val);
    newnode->next = cur->next;
    cur->next = newnode;
    obj->size++;
}

void myLinkedListDeleteAtIndex(MyLinkedList* obj, int index) {
    if (index < 0 || index >= obj->size) {return;}
    struct ListNode* cur = obj->head;
    while (index--) {cur = cur->next;}
    struct ListNode* tmp = cur->next;
    cur->next = cur->next->next;
    free(tmp);
    obj->size--;
}

void myLinkedListFree(MyLinkedList* obj) {
    struct ListNode* cur = obj->head;
    struct ListNode* tmp = NULL;
    while (cur)
    {
        tmp = cur;
        cur = cur->next;
        free(tmp);
    }
    free(obj);
}

/**
 1. Your MyLinkedList struct will be instantiated and called as such:
 2. MyLinkedList* obj = myLinkedListCreate();
 3. int param_1 = myLinkedListGet(obj, index);
 
 4. myLinkedListAddAtHead(obj, val);
 
 5. myLinkedListAddAtTail(obj, val);
 
 6. myLinkedListAddAtIndex(obj, index, val);
 
 7. myLinkedListDeleteAtIndex(obj, index);
 
 8. myLinkedListFree(obj);
*/

翻转链表

例题206（简单）翻转链表

注意要点：

  1. 本题可以不用虚拟头结点，养成加上的习惯避免不时之需；
  2. 翻转的思路是找到当前节点的前一个节点，并修改当前节点的next指针，然后向后移动一位；所以需要保存pre以及cur->next辅助计算。

下面贴出代码：

CPP版本

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* cur = head;
        ListNode* pre = nullptr;
        while (cur)
        {
            ListNode* tmp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = tmp;
        }
        return pre;
    }
};

C版本

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* reverseList(struct ListNode* head){
    struct ListNode* dummy = (struct ListNode* )malloc(sizeof(struct ListNode));
    dummy->next = head;
    struct ListNode* cur = dummy->next;
    struct ListNode* pre = NULL;
    while (cur)
    {
        struct ListNode* tmp = cur->next;
        cur->next = pre;
        pre = cur;
        cur = tmp;
    }
    return pre;
}

两两交换链表中的节点

例题24（中等）两两交换链表中的节点

注意要点：

  1. 设置虚拟头结点，避免头结点的不同处理；
  2. 交换一共涉及四个节点，分别为待交换的两个节点，以及前一和后一节点；所以需要两个tmp来记录帮助交换（一个也可以，但都是next很容易搞晕）。

下面贴出代码：

CPP版本

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummy = new ListNode(0);
        dummy->next = head;
        ListNode* cur = dummy;
        while (cur->next && cur->next->next)
        {
            ListNode* tmp1 = cur->next;
            ListNode* tmp2 = cur->next->next->next;
            cur->next = tmp1->next;
            tmp1->next->next = tmp1;
            tmp1->next = tmp2;
            cur = tmp1;
        }
        return dummy->next;
    }
};

C版本

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* swapPairs(struct ListNode* head){
    struct ListNode* dummyhead = (struct ListNode* )malloc(sizeof(struct ListNode));
    dummyhead->next = head;
    struct ListNode* cur = dummyhead;
    while (cur->next && cur->next->next)
    {
        struct ListNode* tmp = cur->next;
        struct ListNode* tmp1 = cur->next->next->next;
        cur->next = cur->next->next;
        cur->next->next = tmp;
        cur->next->next->next = tmp1;
        cur = cur->next->next;
    }
    return dummyhead->next;
}

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

例题19（中等）删除链表的倒数第N个节点

注意要点：

  1. 避免删除的是头结点，所以设置虚拟头节点辅助计算；
  2. 通过快慢指针，快指针移动（n+1）次，再与慢指针一起移动直至链表尾部，慢指针所在位置即为倒数（n+1）所在；
  3. 移动n+1次，就可以直接通过next来删除倒数第n个，避免还要记录pre节点。

下面贴出代码：

CPP版本

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummy = new ListNode(0);
        dummy->next = head;
        ListNode* slow = dummy;
        ListNode* fast = dummy;
        while (n--) {fast = fast->next;}
        fast = fast->next;
        while (fast)
        {
            slow = slow->next;
            fast = fast->next;
        }
        ListNode* tmp = slow->next;
        slow->next = slow->next->next;
        delete(tmp);
        tmp = nullptr;
        return dummy->next;
    }
};

C版本

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* removeNthFromEnd(struct ListNode* head, int n){
    struct ListNode* dummyhead = malloc(sizeof(struct ListNode));
    dummyhead->next = head;
    struct ListNode* slow = dummyhead;
    struct ListNode* fast = dummyhead;
    while (n--) {fast = fast->next;}
    fast = fast->next;
    while (fast)
    {
        slow = slow->next;
        fast = fast->next;
    }
    slow->next = slow->next->next;
    return dummyhead->next;
}

链表相交

例题160（简单）链表相交

注意要点：

  1. 通过遍历长度，并使得两链表的当前指针对齐，进而可以同时移动指针判断是否相交；
  2. 对齐方法：计算链表长度差，并在长链表指针移动长度差个次数，来对齐两个指针；
  3. 相交是地址相等，不能简单判断值相等。

下面贴出代码：

CPP版本

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        int totalA = 0, totalB = 0;
        ListNode* curA = headA;
        ListNode* curB = headB;
        //统计两个链表的长度
        while (curA) {curA = curA->next; totalA++;}
        while (curB) {curB = curB->next; totalB++;}

        //移动到距离结尾相同距离处
        curA = headA, curB = headB;
        int sub = totalA - totalB;
        if (sub > 0)
        {
            while (sub--) {curA = curA->next;}
        }
        else {while (sub++) {curB = curB->next;}}

        //判断地址是否相同，而不是val是否相同
        while (curA)
        {
            if (curA == curB) {return curA;}
            else
            {
                curA = curA->next;
                curB = curB->next;
            }
        }
        return NULL;
    }
};

C版本

/**
 1. Definition for singly-linked list.
 2. struct ListNode {
 3.     int val;
 4.     struct ListNode *next;
 5. };
 */
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    struct ListNode* p1 = malloc(sizeof(struct ListNode));
    struct ListNode* p2 = malloc(sizeof(struct ListNode));
    p1->next = headA;
    p2->next = headB;
    int l1 = 0, l2 = 0;
    while (p1->next)
    {
        p1 = p1->next;
        l1++;
    }
    while (p2->next)
    {
        p2 = p2->next;
        l2++;
    }
    p1 = headA;
    p2 = headB;
    int delta = l1 - l2;
    // printf("delta = %d\n", delta);
    // printf("p1 = %d\n", p1);
    if (delta >= 0)
    {
        while(delta--) {p1 = p1->next;}
    }
    else
    {
        while(delta++) {p2 = p2->next;}
    }
    // printf("p1 = %d\n", p1);
    while (p1)
    {
        if (p1 == p2)
        {
            return p1;
        }
        p1 = p1->next;
        p2 = p2->next;
    }
    return NULL;
}

环形链表

例题142（中等）环形链表II

注意要点：

  1. 是否成环的判断：快慢指针，快指针走两步，慢指针走一步，如果能相遇，则证明成环；记录下当前节点；
  2. 寻找成环点：快指针从当前节点出发，慢指针从头结点出发，移动相同步数，相遇点即为成环点。

这道题涉及到的数学推导可以自行退导一下，不乐意推导就直接记结论就可以做题了。

下面贴出代码：

CPP版本

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* slow = head;
        ListNode* fast = head;
        while (fast && fast->next)
        {
            slow = slow->next;
            fast = fast->next->next;
            if (slow == fast)  //有环
            {
                //从相遇节点，slow回到head，再次移动同样步数，再次相遇就是成环点
                slow = head;
                while (slow != fast)
                {
                    slow = slow->next;
                    fast = fast->next;
                }
                return slow;
            }
        }
        return NULL;
    }
};

C版本

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode *detectCycle(struct ListNode *head) {
    struct ListNode* slow = head;
    struct ListNode* fast = head;
    while (fast && fast->next)
    {
        slow = slow->next;
        fast = fast->next->next;
        if (slow == fast)
        {
            while (slow != head)
            {
                slow = slow->next;
                head = head->next;
            }
            return head;
        }
    }
    return NULL;
}

总结

再次白嫖代码随想录，这个总结的思维导图真的好！！！！
链表知识点总结

努力自学的小夏
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
代码随想录-八股文 pdf
04-25
代码随想录-八股文 PDF 代码随想录-八股文 PDF 是一个涵盖了程序员学习必备的内容的知识星球精华，总结了包括 C++、Java、Go 在内的多种编程语言，数据结构和算法、操作系统、数据库、计算机网络、设计模式、Linux ...
LeetCode刷题笔记——19. 删除链表的倒数第N个节点
12-21
【LeetCode刷题笔记——19. 删除链表的倒数第N个节点】 这道LeetCode中的题目属于中等难度，主要考察的是对链表数据结构的理解以及算法设计能力。问题的核心是找到链表中倒数第N个节点，并将其删除。与《剑指Offer...
代码随想录刷题学习笔记——初级篇C++/Python
never_stop_rain的博客
07-29 559
给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值 target，返回 [-1, -1]。你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。来源：力扣（LeetCode）时间复杂度要求—>二分法查找返回两个坐标位置—>二分法分别查找左右边界分析返回的状态：1) [-1,-1]；
代码随想录刷题笔记9——贪心算法
xhj12138的博客
09-25 139
代码随想录的刷题笔记，这一篇是贪心法的相关内容
《代码随想录》刷题笔记——链表篇【java实现】
记录一名在读研究生的学习笔记、感悟、开发产物
09-05 299
录友刷《代码随想录》的做题记录
代码随想录——力扣刷题笔记之链表
m0_49651195的博客
03-18 1009
在这里我使用Python来定义链表节点方式，采用函数的方式（参考力扣上给出的方式）
代码随想录刷题笔记5——双指针
xhj12138的博客
09-05 93
代码随想录的刷题笔记，这一篇是双指针的各种小技巧总结
代码随想录刷题笔记3——哈希表
xhj12138的博客
09-04 70
根据代码随想录的刷题笔记，这一章是哈希表
代码随想录——刷题笔记
qq_63782783的博客
01-18 456
统计两个数组找出两个数组中均存在的元素。快乐数（LeetCode202）按照逻辑写循环代码，终止条件为得到结果为1或出现重复项。
代码随想录刷题学习笔记——高级篇C++/Python
never_stop_rain的博客
09-06 296
代码随想录学习笔记，难度逐渐加深了
电信保温杯笔记——代码随想录 刷题攻略 哈希表
sinat_39448069的博客
02-02 1000
代码随想录 刷题攻略 哈希表 笔记代码随想录 刷题攻略 笔记1.关于链表，你该了解这些！2.链表：听说用虚拟头节点会方便很多？203.移除链表元素总结3.链表：一道题目考察了常见的五个操作！707.设计链表总结4.链表：听说过两天反转链表又写不出来了？206.反转链表方法1方法25.链表：两两交换链表中的节点24. 两两交换链表中的节点6.链表：删除链表的倒数第 N 个结点19.删除链表的倒数第N个节点7.链表：链表相交面试题 02.07. 链表相交方法1方法28.链表：环找到了，那入口呢？142.环形链
LeetCode刷题笔记——#21. 合并两个有序链表
12-22
最终，合并后的链表为 `[1, 1, 2, 3, 4, 4]`。 总结来说，LeetCode 第 21 题主要考察了链表操作和比较排序的知识。解题方法包括递归和迭代，这里主要展示了迭代方法，通过创建一个新链表并将两个输入链表的元素按...
代码随想录 面试大厂必备八股文
07-03
《代码随想录》是众多程序员面试准备的重要参考资料，尤其对于目标是大厂的开发者来说，这本书中的“面试大厂必备八股文”更是不容忽视的内容。这里的“八股文”并非传统意义上的文学形式，而是指在编程面试中经常被...
《剑指Offer》刷题笔记——面试题24. 反转链表
01-20
2、测试用例 3、代码实现 # Definition for singly-linked list. # class ListNode: # def __init__(self, x): # self.val = x # self.next = None from collections import deque class Solution: def reverse...
vite5+vue3开发阅读APP实战笔记20240725
Python私教
07-25 464
修改src/page/home/index.vue，使用组件和API。注意，这里无论是组件还是API，都不需要我们手动引入，我们配置了自动导入以后，vite会帮我们自动导入。创建 src/page/home/index.vue。修改 vite.config.js。修改vite.config.js。修改 src/main.js。修改src/App.vue。
Golang学习笔记20240725，Go语言基础语法
最新发布
Python私教
07-25 571
如果我们在遍历的时候，不想要key或者value，也可以用下划线替代，下划线叫做匿名变量。go语言里面的switch语句每个case天生就是独立的，不需要加break。指针可以直接对内存地址进行操作。使用*表示指针，使用&取地址。切片在go语言里面非常常用，因为其有动态扩展的特性。运行方式3：goland右键运行。使用加号可以对字符串进行拼接。
学习笔记-系统框图传递函数公式推导
weixin_45875994的博客
07-24 875
输出C(s)是前向路径（通过G(s)）的输出与反馈路径（通过H(s)）的输出之差（在负反馈系统中）。因此，我们可以写出以下关系式：这里，G(s)R(s)是前向路径的输出，而G(s)H(s)C(s)是反馈路径的输出（注意，反馈路径的输出先经过H(s)，再与前向路径的输出相减）。
InternLM学习笔记
haveanybody的博客
07-24 292
【代码】InternLM学习笔记。
代码随想录的python版本
07-27
抱歉，我无法理解你的问题。你可以提供更多的上下文或者明确你的问题吗？谢谢！ #### 引用[.reference_title] - *1* [leetcode 刷题记录，链表部分，代码随想录刷题顺序（python实现）](https://blog.csdn.net/yyy199869/article/details/121777716)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值