代码随想录算法训练营Day3 | 203.移除链表元素，707.设计链表，206.反转链表

最新推荐文章于 2024-07-25 23:26:35 发布
最新推荐文章于 2024-07-25 23:26:35 发布
阅读量90 收藏
点赞数
分类专栏： 代码随想录刷题训练营 文章标签： 算法 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44687153/article/details/131720937
版权

链表理论基础

文章链接

单链表

只能向后查询

链表1

双链表

可以双向查询

链表2

循环链表

首尾链接

链表4

链表的存储方式

链表在内存中不需要是连续分布的！和数组不同！

链表通过指针域的指针链接在内存中的各个节点，所以可以散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。

链表的定义

C/C++定义链表节点：

struct ListNode {
    int val; // value of the node
    ListNode* next; // pointer points to the next node
    ListNode(int x): val(x), next(NULL) {} // construct function, initialize val and assign next to NULL
};

定义构造函数可以让你初始化节点：

ListNode* head = new ListNode(5);

如果使用C++默认构造函数，在初始化时不可以直接给变量赋值！

ListNode* head = new ListNode();
head->val = 5;

链表的操作

删除节点

链表-删除节点

把C的next指针指向E，把D的指针断开并手动释放D。

在Java，Python等语言中有自己的内存回收机制，不需要自己手动释放。

添加节点

链表-添加节点

C的next指针指向F，F的next指针指向D。

添加和删除都是O(1)，但是要是删除最后一个节点，查找的复杂度是O(N)。

性能分析

链表-链表与数据性能对比

数组的长度是固定的！想改长度只能新建一个新数组！

链表的长度是不固定的，可以动态删减，适用于频繁删减较少查询的场景。

203.移除链表元素 Remove Linked List Elements

题目链接  |  文章链接  |  视频链接 

需要把删除head和删除其他元素分开讨论，但也可以使用虚拟头节点的方式进行统一删除法

C解法

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


struct ListNode* removeElements(struct ListNode* head, int val){

    struct ListNode* temp = head;
    while (head && head->val == val){
        temp = head;
        head = head->next;
        temp->next = NULL;
        free(temp);
    }

    struct ListNode* node = head;

    while (node && node->next){
        while (node->next && node->next->val == val){
            temp = node->next;
            node->next = node->next->next;
            temp->next = NULL;
            free(temp);
        }
        node = node->next;
    }

    return head;
}

C++解法

/**
 * 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* temp;
        while (head && head->val == val){
            temp = head;
            head = head->next;
            temp->next = NULL;
            delete temp;
        }

        ListNode* node = head;

        while (node && node->next){
            while (node->next && node->next->val == val){
                temp = node->next;
                node->next = node->next->next;
                temp->next = NULL;
                delete temp;
            }
            node = node->next;
        }

        return head;
    }
};

Python解法

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def removeElements(self, head, val):
        """
        :type head: ListNode
        :type val: int
        :rtype: ListNode
        """

        while (head and head.val == val):
            head = head.next

        node = head
        while (node and node.next):
            while (node.next and node.next.val == val):
                node.next = node.next.next

            node = node.next
        
        return head

虚拟头节点

Python解法

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def removeElements(self, head, val):
        """
        :type head: ListNode
        :type val: int
        :rtype: ListNode
        """

        dummpyhead = ListNode(next = head)

        node = dummpyhead

        while (node and node.next):
            while (node.next and node.next.val == val):
                node.next = node.next.next

            node = node.next
        
        return dummpyhead.next

707.设计链表 Design Linked List

题目链接  |  文章链接  |  视频链接  |  官方解答

单向链表

需要什么？

  • 定义节点，每个节点需要：
    • val 储存的值
    • next 指向下一个节点的指针
  • 一个虚拟头，Leetcode官方称之为哨兵(sentinel)
  • 一个size参数保存有效节点 （有助于进行与index相关的操作时可以先行判定index的validity

img

 定义节点的方式有很多种：

  • 新建一个class
  • 或者在现有的MyLinkedList里定义一个struct

虚拟头和size则为MyLinkedList Class的variable

一些需要注意的C++ Convention：

The public, protected, and private sections of a class are to be declared in that order (the public section is declared before the protected section which is declared before the private section).

C++解法

要注意addAtIndex这个function的用法，当index==length，操作如同addAtTail

class MyLinkedList {
public:
    MyLinkedList() {
        head = new ListNode();
        size = 0;
    }
    
    int get(int index) {
        if (index < 0 || index > size - 1) {
            return -1;
        } else {
            ListNode* current = head->next;
            while (index--){
                current = current->next;
            }
            return current->val;
        }
    }
    
    void addAtHead(int val) {
        // our "head" is not the real head!!!
        if (val <= 1000){
            ListNode* newHead = new ListNode(val);
            newHead->next = head->next;
            head->next = newHead;
            size++;
        }
    }
    
    void addAtTail(int val) {
        if (val <= 1000){
            ListNode* newTail = new ListNode(val);
            ListNode* current = head;
            while (current->next){
                current = current->next;
            }
            current->next = newTail;
            size++;
        }
    }
    
    void addAtIndex(int index, int val) {
    /** Add a node of value val before the indexth node in the linked list. 
     *  If index equals the length of the linked list, the node will be appended 
     *  to the end of the linked list. If index is greater than the length, 
     *  the node will not be inserted.
    **/
        if (index < 0 || index > size) {
            return;
        } else if (val <= 1000) {
            ListNode* current = head;
            while (index--){
                current = current->next;
            }
            ListNode* newNode = new ListNode(val);
            newNode->next = current->next;
            current->next = newNode;
            size++;
        }
    }
    
    void deleteAtIndex(int index) {
        if (index < 0 || index > size - 1) {
            return;
        } else {
            ListNode* current = head;
            while (index--){
                current = current->next;
            }
            ListNode* deleteNode = current->next;
            current->next = deleteNode->next;
            delete deleteNode;
            size--;
        }
    }

private:
    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) {}
    };
    ListNode* head;
    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的定义很重要！！！

typedef struct MyLinkedList {
    int val;
    struct MyLinkedList* next;    
} MyLinkedList;


MyLinkedList* myLinkedListCreate() {
    MyLinkedList* head = (MyLinkedList*) malloc (sizeof(MyLinkedList));
    head->val = 0;
    head->next = NULL;
    return head;
}

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

void myLinkedListAddAtHead(MyLinkedList* obj, int val) {
    if (val <= 1000){
        MyLinkedList* newObj = (MyLinkedList*) malloc (sizeof(MyLinkedList));
        newObj->val = val;
        newObj->next = obj->next;
        obj->next = newObj;
        obj->val++;
    }
}

void myLinkedListAddAtTail(MyLinkedList* obj, int val) {
    if (val <= 1000){
        MyLinkedList* current = obj;
        MyLinkedList* newObj = (MyLinkedList*) malloc (sizeof(MyLinkedList));
        newObj->val = val;
        newObj->next = NULL;
        while (current->next){
            current = current->next;
        }
        current->next = newObj;
        obj->val++;
    }
}

void myLinkedListAddAtIndex(MyLinkedList* obj, int index, int val) {
    int size = obj->val;
    if (index < 0 || index > size){
        return;
    } else if (val <= 1000){
        MyLinkedList* current = obj;
        MyLinkedList* newObj = (MyLinkedList*) malloc (sizeof(MyLinkedList));
        newObj->val = val;
        newObj->next = NULL;
        while (index--){
            current = current->next;
        }
        newObj->next = current->next;
        current->next = newObj;
        obj->val++;
    }
}

void myLinkedListDeleteAtIndex(MyLinkedList* obj, int index) {
    int size = obj->val;
    if (index < 0 || index > size - 1){
        return;
    } else {
        MyLinkedList* current = obj;
        while (index--){
            current = current->next;
        }
        MyLinkedList* deleteNode = current->next;
        current->next = current->next->next;
        deleteNode->next = NULL;
        free(deleteNode);
        obj->val--;
    }

}

void myLinkedListFree(MyLinkedList* obj) {
    while (obj){
        MyLinkedList* deleteNode = obj;
        obj = obj->next;
        deleteNode->next = NULL;
        free(deleteNode);
    }
}

/**
 * Your MyLinkedList struct will be instantiated and called as such:
 * MyLinkedList* obj = myLinkedListCreate();
 * int param_1 = myLinkedListGet(obj, index);
 
 * myLinkedListAddAtHead(obj, val);
 
 * myLinkedListAddAtTail(obj, val);
 
 * myLinkedListAddAtIndex(obj, index, val);
 
 * myLinkedListDeleteAtIndex(obj, index);
 
 * myLinkedListFree(obj);
*/

Python解法

class ListNode:
    def __init__(self, val):
        self.val = val
        self.next = None

class MyLinkedList(object):

    def __init__(self):
        self.head = ListNode(0)
        self.size = 0

    def get(self, index):
        """
        :type index: int
        :rtype: int
        """
        if (index < 0 or index > self.size - 1):
            return -1
        else:
            curr = self.head.next
            while index:
                curr = curr.next
                index -= 1
            return curr.val

    def addAtHead(self, val):
        """
        :type val: int
        :rtype: None
        """
        if val <= 1000:
            new = ListNode(val)
            new.next = self.head.next
            self.head.next = new
            self.size += 1

    def addAtTail(self, val):
        """
        :type val: int
        :rtype: None
        """
        if val <= 1000:
            curr = self.head
            while (curr.next):
                curr = curr.next
            curr.next = ListNode(val)
            self.size += 1

    def addAtIndex(self, index, val):
        """
        :type index: int
        :type val: int
        :rtype: None
        """
        if (index < 0 or index > self.size):
            return
        elif val <= 1000:
            curr = self.head
            while index:
                index -= 1
                curr = curr.next
            new = ListNode(val)
            new.next = curr.next
            curr.next = new
            self.size += 1

    def deleteAtIndex(self, index):
        """
        :type index: int
        :rtype: None
        """
        if (index < 0 or index > self.size - 1):
            return
        else:
            curr = self.head
            while index:
                index -= 1
                curr = curr.next
            delete = curr.next
            curr.next = curr.next.next
            self.size -= 1

# Your MyLinkedList object will be instantiated and called as such:
# obj = MyLinkedList()
# param_1 = obj.get(index)
# obj.addAtHead(val)
# obj.addAtTail(val)
# obj.addAtIndex(index,val)
# obj.deleteAtIndex(index)

双指针写法可参照Leetcode官方解答：官方解答

206.反转链表 Reverse Linked List

题目链接  |  文章链接  |  视频链接

代码随想录文章里的动图可以很直观的展现这个题的解法

 反转指针：

C++解法

 

/**
 * 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* temp;
        ListNode* curr = head;
        ListNode* prev = nullptr;
        while(curr){
            temp = curr->next;
            curr->next = prev;
            prev = curr;
            curr = temp;
        }
        return prev;
    }
};

C解法

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


struct ListNode* reverseList(struct ListNode* head){
    struct ListNode* temp;
    struct ListNode* curr = head;
    struct ListNode* prev = NULL;
    while (curr) {
        temp = curr->next;
        curr->next = prev;
        prev = curr;
        curr = temp;
    }
    return prev;
}

Python解法

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        curr = head
        prev = None
        while (curr):
            temp = curr.next
            curr.next = prev
            prev = curr
            curr = temp
        return prev

递归法

C++解法

/**
 * 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* reverser(ListNode* prev, ListNode* curr){
        if (!curr) return prev;
        ListNode* temp = curr->next;
        curr->next = prev;
        return reverser(curr, temp);
    }

    ListNode* reverseList(ListNode* head) {
        return reverser(nullptr, head);
    }
};

C解法

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* reverse(struct ListNode* prev, struct ListNode* curr){
    if (!curr){
        return prev;
    }
    struct ListNode* temp = curr->next;
    curr->next = prev;
    return reverse(curr, temp);
}

struct ListNode* reverseList(struct ListNode* head){
    return reverse(NULL, head);
}

Python解法

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def reverse(self, prev, curr):
        if not curr:
            return prev
        temp = curr.next
        curr.next = prev
        return self.reverse(curr, temp)

    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        return self.reverse(None, head)

zxqbsa
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
代码随想录算法训练营第三天| 203.移除链表元素 707.设计链表 206.反转链表
elven_prophecy的博客
02-18 622
力扣 C语言：203.移除链表元素 707.设计链表 206.反转链表
代码随想录算法训练营第三天-链表| 203.移除链表元素 707.设计链表 206.反转链表
m0_65482476的博客
11-04 116
打卡链表-1笔记
代码随想录算法训练营Day3 | 203.移除链表元素 707.设计链表 206.反转链表
qq_24817679的博客
04-08 1658
2. 删除head时候 tmp=head，删除cur->next，tmp=cur->next.1.需判断cur以及cur->next是否为空。
代码随想录算法训练营 DAY3| 203.移除链表元素 707.设计链表 206.反转链表
qq_35904005的博客
03-09 919
记得要写构造函数。// 结点的值int val;// 下一个结点// 节点的构造函数(无参)// 节点的构造函数(有一个参数)// 节点的构造函数(有两个参数)遍历条件里最好不要写cur->next。当cur为null时会空指针异常遍历链表找结束条件就是看 到什么情况下，就停止操作了，找这个临界情况就是while里的判断条件递归需要考虑终止条件，下一次递归的新参数以及返回值。通常另外写一个函数用来递归，在原函数里调用它。
代码随想录算法训练营day3| 203.移除链表元素 707.设计链表 206.反转链表
新源的博客
04-07 171
代码随想录算法训练营
学习记录day18——数据结构 算法
weixin_64918301的博客
07-24 882
程序 = 数据结构 + 算法算法是程序设计的灵魂，结构式程序设计的肉体算法：计算机解决问题的方法护额步骤。
蓝桥杯 2024 年第十五届省赛真题 —— 最大异或结点
执梗的博客
07-23 1554
蓝桥杯 2024 年第十五届省赛真题 —— 最大异或结点
打卡第22天------回溯算法
GodLoveMe的博客
07-24 677
开始学习了，希望我可以尽快成功上岸！
C语言100道基础拔高题（1）
2303_78660417的博客
07-23 2747
最后按最小值，中间值，最大值的顺序打印即可。解题思路：首先输出由这几个数字所组成的所有三位数，接着再设置条件，使其输出的三位数不重复，下面我们来看下源代码。值得注意的是：所以题目的代码都是作者自行编写，如有更好的思路或者代码的优化，还请指出更正。解题思路：首先找到能整除这个正整数的最小正数，接着重置循环初值，让它继续查找最小正数，最后将得到的所有正数放到一个数组里，最后设置好格式之后循环打印出来。解题思路：首先确定好区间，接着判断是否是素数，素数就是一个大于1的数，除了1和它本身之外，不能被其他数整除。
【CodinGame】趣味算法 CLASH OF CODE - 20240724
weixin_73002968的博客
07-24 364
eval不安全，看情况使用。
2024秋招算法
weixin_43364551的博客
07-22 2040
根据代码随想录和力扣进行算法训练的笔记
算法 —— 暴力枚举
最新发布
fen_0108的博客
07-25 3306
第二看纵向宽发生改变，长重置为1，长为1，宽为2的时候，第一行个数为7个，总共有5 x 7 个，长为2，宽为2的时候 第一行个数为6个，共有5 x 6个……首先是横着的长方形，宽始终为1，长不断发生改变，可以看出长为2的时候，第一行个数为6个，总共有6 x 6个，长为3的时候，总共有6 x 5个……这是一道简单的模拟题，枚举出所有可能情况，不会超过规定时间的，以下附上k
河南萌新联赛2024第（二）场：南阳理工学院
a13997460860的博客
07-25 1205
这场比赛里面出到了很多的题，都是需要很多的时间去写，主要考察到了代码的实现能力，与codeforces里面的题有些差距。codeforces打多了还是有点不习惯的。题挺好的，尤其是H题感觉很考代码实现能力与STL的使用熟练度。多写写这样的题还是对我们很有好处的。只不过前三题都太水了，没有一点难度。
力扣34题 双二分查找（简单易懂）
xiaoye7288的博客
07-24 521
正如本题解描述，想清楚三种情况之后，先专注于寻找右区间，然后专注于寻找左区间，左右根据左右区间做最后判断。
大模型算法面试题（十一）
m0_63997552的博客
07-24 1192
数据并行和模型并行各有其优缺点和适用场景。数据并行适用于数据量大、模型规模适中的情况，可以充分利用分布式系统的计算资源来加速训练过程。而模型并行则适用于模型规模极大、无法在单个计算节点上完整加载的情况，通过分割模型来降低内存需求并提高计算效率。在实际应用中，可以根据具体任务的需求和可用硬件资源来选择合适的并行策略，或者将两种策略结合使用以获得最佳性能。
2024.7.24 作业
qq_64434282的博客
07-24 1958
【代码】2024.7.24 作业。
数据结构之《栈》
2303_81098358的博客
07-24 1267
在之前我们已经学习了数据结构中线性表里面的顺序表与链表，了解了如何实现顺序表与链表增、删、查、该等功能。其实在线性表中除了顺序表和链表还有其他的类别，在本篇中我们就将学习另外一种线性表——栈，在通过本篇的学习后，你将会对栈的结构有充足的了解，在了解完结构后我们还将进行栈的实现。
【数据结构】：用Java实现链表
Yechiel的博客
07-24 1361
本篇文章用Java介绍了：链表的概念，以及单链表的主要功能的具体实现方法
数据结构——双向链表及其总结
2406_83392683的博客
07-23 410
1.概述链表根据是否带头、是否双向、是否循环可以分为八种，双向链表是典型的带头双向循环链表。2.双向链表的实现过程及其解析双向链表的实现依旧包含List.h，List.c，test.c2.1 链表初始化双向链表为空的情况：只有一个哨兵位。2.2插入数据。
Linux List.h深度解析：双向链表与数据结构实现
在Linux内核源码中，List.h文件是双向循环链表操作的核心部分，它位于`include/linux`目录下，用于构建复杂的数据结构，如队列和堆栈。双向循环链表相较于单链表，每个节点包含前后两个指针，提供了更灵活的插入和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值