代码随想录 | Day05 | 链表：移除链表元素&&设计链表&&反转链表

已于 2024-05-30 12:58:19 修改
阅读量793 收藏 17
点赞数 8
分类专栏： 刷题记录 文章标签： 链表 数据结构
于 2024-05-22 19:09:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74795952/article/details/139127468
版权

代码随想录 | Day05 | 链表：移除链表元素&&设计链表&&反转链表

主要学习内容：

1.链表删除操作

2.设计自己的链表

3.双指针操作链表

203.移除链表元素

203. 移除链表元素 - 力扣（LeetCode）

解法1：设置虚拟头结点

设置一个虚拟头结点用虚拟头结点的next进行判断

好处是不需要写关于头结点的处理逻辑，比较容易处理

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode * t=new ListNode;
        ListNode * q=new ListNode;
        t->next=head;
        q=t;
        while(t->next!=NULL)
        {
            if(t->next->val==val)
            {
                ListNode *tmp=t->next;
                t->next=t->next->next;
                delete tmp;
            }
            else
                t=t->next;
        }
        return q->next;
    }
};
关键点：

1.设置一个额外的指针q指向虚拟头结点，head节点可能会被删除，最后无法返回结果

2.手动释放内存 delete

解法2：直接删除

思路：先处理头节点再处理其余节点

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        while(head && head->val==val)
        {
            ListNode * tmp= head;
            head=head->next;
            delete tmp;
        }
        ListNode * t=new ListNode;
        t=head;
        while(t && t->next!=NULL)
        {
            if(t->next->val==val)
            {
                ListNode *tmp=t->next;
                t->next=t->next->next;
                delete tmp;
            }
            else
                t=t->next;
        }
        return head;
    }
};

关键点：

1.头结点是val头结点连着的下面几个可能也是val，所以要用while而不是if来处理头结点

2.没有了虚拟头结点，我们就不知道第一个到底是不是为空，则需要在两个while（）处加入head不为空的判断条件

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

    MyLinkedList() {
        prenode=new ListNode;
        _size=0;
    }
    
    int get(int index) {

        if(index>(_size-1)||index<0)
            return -1;

        int n=index+1;
        ListNode *p=new ListNode;
        p=prenode;
        while(n--&&p->next!=NULL)
            p=p->next;
        return p->val;
        
    }
    
    void addAtHead(int val) {
        ListNode* p=new ListNode;
        p->next=prenode->next;
        prenode->next=p;
        if(p->next!=nullptr)
            p->next->pre=p;
        p->val=val;
        p->pre=prenode;
        _size++;
    }
    
    void addAtTail(int val) {
        ListNode* p=new ListNode;
        p->next=NULL;
        p->val=val;
        ListNode* q=new ListNode;
        q=prenode;
        while(q->next!=NULL)
            q=q->next;
        q->next=p;
        p->pre=q;
        _size++;
    }   
    
    void addAtIndex(int index, int val) {
        if(index<0)
        {
            addAtHead(val);
        }
           
        if(index>_size)
            return ;
        else if(index==_size)
        {
            addAtTail(val);
        }
        else
        {
            int n=index;
            ListNode *p=new ListNode;
            p=prenode;
            ListNode *q=new ListNode;
            while(n--&&p->next!=NULL)
                p=p->next;
            q->next=p->next;
            p->next=q;
            q->val=val;
            _size++;
        }
    }
    
    void deleteAtIndex(int index) {
        if(_size==0)
            return;
        if(index>=_size||index<0)
            return ;
        int n=index;
        ListNode *p=new ListNode;
        p=prenode;
        while(n--&&p->next!=NULL)
            p=p->next;
        if(p->next==nullptr)
            return;
        ListNode *q=p->next;
        p->next=q->next;
        if (q->next != NULL)
        {
            q->next->pre = p;//更新前后节点的连接
        }
        _size--;
    }
private:
    ListNode *prenode;
    int _size;
};

707.设计链表

707. 设计链表 - 力扣（LeetCode）

解法一：单链表

注意的点：

addAtIndex函数的if条件里面是要index>size而不是index>=size，因为=的时候是要插入到末尾

（改了2小时才发现，无语住了╭(╯^╰)╮）

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

    MyLinkedList()
    {
        size = 0;
        prenode = new ListNode;
    }

    int get(int index)
    {
        if (index < 0 || index >= size)
            return -1;
        ListNode* t = new ListNode;
        t = prenode;
        int n = index + 1;
        while (n--)
        {
            t = t->next;
        }
        return t->val;
    }

    void addAtHead(int val)
    {
        ListNode* t = new ListNode;
        t->val = val;
        t->next = prenode->next;
        prenode->next = t;
        size++;
    }

    void addAtTail(int val)
    {
        ListNode* t = prenode;
        int n = size;
        while (n--&& t->next != NULL)
            t = t->next;

        ListNode* tmp = new ListNode;
        tmp->val = val;
        tmp->next = NULL;
        t->next = tmp;
        size++;
    }

    void addAtIndex(int index, int val)
    {
        if (index < 0 || index > size)
            return;
        ListNode* t = prenode;
        if (index == 0)
            addAtHead(val);
        else
        {
            while (index--)
                t = t->next;
            ListNode* q = new ListNode;
            q->val = val;
            q->next = t->next;
            t->next = q;
            size++;
        }
    }

    void deleteAtIndex(int index)
    {
        if (size == 0)
            return;
        if (index < 0 || index >= size)
            return;
        if (index == 0)
        {
            ListNode* t = new ListNode;
            t = prenode->next;
            prenode->next = prenode->next->next;
            size--;
            delete t;
        }
        else
        {
            ListNode* t = prenode;
            while (index-- && t->next)
                t = t->next;
            ListNode* p = new ListNode;
            p = t->next;
            t->next = t->next->next;
            delete p;
            size--;
        }
    }

private:
    ListNode* prenode;
    int size;
    
};
解法二：双链表
class MyLinkedList {
public:
    struct ListNode
     {
     int val;
     ListNode *next;
     ListNode *pre;
     ListNode() : val(0), next(nullptr),pre(nullptr) {}
 };

    MyLinkedList() {
        prenode=new ListNode;
        _size=0;
    }
    
    int get(int index) {

        if(index>(_size-1)||index<0)
            return -1;

        int n=index+1;
        ListNode *p=new ListNode;
        p=prenode;
        while(n--&&p->next!=NULL)
            p=p->next;
        return p->val;
        
    }
    
    void addAtHead(int val) {
        ListNode* p=new ListNode;
        p->next=prenode->next;
        prenode->next=p;
        if(p->next!=nullptr)
            p->next->pre=p;
        p->val=val;
        p->pre=prenode;
        _size++;
    }
    
    void addAtTail(int val) {
        ListNode* p=new ListNode;
        p->next=NULL;
        p->val=val;
        ListNode* q=new ListNode;
        q=prenode;
        while(q->next!=NULL)
            q=q->next;
        q->next=p;
        p->pre=q;
        _size++;
    }   
    
    void addAtIndex(int index, int val) {
        if(index<0)
        {
            addAtHead(val);
        }
           
        if(index>_size)
            return ;
        else if(index==_size)
        {
            addAtTail(val);
        }
        else
        {
            int n=index;
            ListNode *p=new ListNode;
            p=prenode;
            ListNode *q=new ListNode;
            while(n--&&p->next!=NULL)
                p=p->next;
            q->next=p->next;
            p->next=q;
            q->val=val;
            _size++;
        }
    }
    
    void deleteAtIndex(int index) {
        if(_size==0)
            return;
        if(index>=_size||index<0)
            return ;
        int n=index;
        ListNode *p=new ListNode;
        p=prenode;
        while(n--&&p->next!=NULL)
            p=p->next;
        if(p->next==nullptr)
            return;
        ListNode *q=p->next;
        p->next=q->next;
        if (q->next != NULL)
        {
            q->next->pre = p;//更新前后节点的连接
        }
        _size--;
    }
private:
    ListNode *prenode;
    int _size;
};
关键点：

1.记得释放空间

2.很需要虚拟头指针和size，可以对很多操作进行简化

206.反转链表

206. 反转链表 - 力扣（LeetCode）

解法1：双指针

快慢指针分别指向需要改变指向的两个结点，然后进行翻转即可

206.翻转链表

//自己写的
class Solution {
public:
    ListNode* reverseList(ListNode* head) 
    {
        if(head==NULL)
            return head;
        ListNode * pre=NULL;//慢指针
        ListNode * cur=head;//快指针
        ListNode * tmp=head->next;//保存节点所用
        while(cur)
        {
            cur->next=pre;//翻转操作
            //快慢指针更新
            pre=cur;
            cur=tmp;
            if(tmp)
                tmp=tmp->next;//更新保存点
        }
        return pre;
    }
};

//代码随想录的
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* temp; // 保存cur的下一个节点
        ListNode* cur = head;
        ListNode* pre = NULL;
        while(cur) {
            temp = cur->next;  // 保存一下 cur的下一个节点，因为接下来要改变cur->next，改变后依靠这个才能找到下一结点
            cur->next = pre; // 翻转操作
            // 更新pre 和 cur指针，pre和cur前移
            pre = cur;
            cur = temp;
        }
        return pre;
    }
};

改进：

用tmp=cur->next来更新tmp，使得cur和tmp产生关联，和循环条件统一起来，当tmp=NULL时，不会因为使用tmp->next而报错。

解法2：递归法

递归由方法一改写而来

递归结束条件对应while循环结束条件

快慢指针前移过程由向下一个递归函数进行赋值来代替，下一次的pre和cur（即需要翻转的两个结点）作为形参传入

最后返回的就是pre

（如果不太明白的小伙伴可以暂时放一放，可以等做完回溯章节再回来，会好很多很多很多很多）

class Solution {
public:
    ListNode* re(ListNode *cur,ListNode * pre)
    {
        if(cur==NULL)//递归结束条件对应while循环条件
            return pre;//返回头结点
        ListNode * tmp=cur->next;//保存cur的下一结点
        cur->next=pre;//翻转操作
        //递归的过程就是快慢指针前移的过程
        //pre=cur;
        //cur=tmp;
        return re(tmp,cur);
    }
    ListNode* reverseList(ListNode* head) 
    {
        return re(head,NULL);
    }
};
丶Darling.
关注
  • 8
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
删除整个链表的方法
qq_62846665的博客
08-31 2033
删除整个链表的方法
【数据结构】链表：插入、删除
Swillow_的博客
07-01 3017
我是通过b站的教程(如下图)学习的，这里记录下学习笔记。数据结构简单导言(为什么会出现数据结构？在日常生活中，为了组织不同类型的数据，我们需要不同类型的结构，帮助我们更高效更方便的找到想要的数据。
数据结构之链表的删除
StevenBian的博客
05-06 7477
思路分析 1：因为题目中只给定了要删除的节点,并没有给出链表的头结点，所以无法通过遍历查询到待删除节点的上一个节点，然后执行删除操作 2：对此，我们利用给定的待删除节点的信息，将待删除节点的下一个节点的值付给待删除的节点，这样就可以将待删除节点的next指针域指向下一个节点的下一个，从而实现删除操作 class Solution { public void deleteNode(ListNode node) {
DAY3:链表（一）：链表基础知识+移除链表元素
CFY1226的博客
05-13 2436
/ 单链表的定义 struct ListNode {int val;//节点上储存的元素 ListNode * next;//指向下一个节点的指针 ListNode(int x) : val(x) , next(NULL) {//节点的构造函数 } }//定义指针，指向链表对象（虚拟头节点用法）所以如果不定义构造函数使用默认构造函数的话，在初始化的时候就不能直接给变量赋值！首先，你需要一个指针来找到要删除的节点。这个指针通常是通过遍历链表得到的。
链表的删除—做题总结 203. 移除链表元素
yavlgloss的博客
11-10 233
力扣 203. 移除链表元素 做题总结
移除链表元素_移除链表元素_
10-02
删除链表中的某个特定的元素，根据《大话数据结构》中c语言版本代码进行的改写。
leetcod 203.移除链表元素：
08-24
题目描述 给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。...解题思路有两种：（一）要移除...具体思路详解请看拿捏链表（一）---------移除链表元素
leetcode：移除链表元素 python解法
12-21
在LeetCode上，有一道经典的链表操作问题——移除链表元素。这个问题要求我们从给定的单链表中删除所有值等于`val`的节点。本文将深入解析问题的解决方案，并提供一种使用Python实现的方法。 ### 1. 题目说明 题目...
【Leetcode刷题笔记03】203.移除链表元素 707.设计链表 206. 反转链表.md
01-13
设计链表和206.反转链表,记录了详细的题目解析思路以及Java语言的参考代码。 适合人群:学习算法和数据结构的程序员或学生,尤其是想系统学习链表操作的人。 能学到什么:掌握链表虚拟头节点设置方法;练习链表基本...
数据结构链表：单链表的代码实现
最新发布
03-20
本文通过数据结构教程的方法利用C++语言写了单链表的各项功能 功能包括 1.链表的初始化 2.链表的查找和判断是否为空表 3.插入 4.取值 ...每个知识点都是自己在写代码的过程中的自我总结和归纳的规律
链表(Linked List) - 链表的创建、遍历和插入与删除
BuiderCodes的博客
12-27 1596
链表是由一系列结点组成的，每个结点包含数据以及指向下一个结点的引用。
链表的基本操作(增删改查)
weixin_44517656的博客
07-22 1997
链表的基本操作(增删改查) 前提： 节点的类型： typedef struct Node { int id; struct Node* next; }SNode; 目录： 1链表的创建； 2 链表的插入； 3 链表的删除； 4 改，查； 5 链表的排序； 6 链表的翻转； 7 链表的打印； 1 链表的创建 //创建链表 SNode *CreateList() { SNode *head = NULL; head = (SNode*)malloc(sizeof(SNode)); head-&g
链表的插入与删除
yyyy11665的博客
08-14 6413
.实现链表的三种删除方法：头删法，尾删法，中间删除法。1.实现链表的三种插入方法：头插法，尾插法，中间插入。*同时为了验证结果实现了链表的显示。
链表之三种删除
weixin_55152654的博客
03-07 1032
链表–删除 ：首先要清楚把一个节点删除，要考虑删除节点的上一个节点next指针，不能删除空的东西 #include<stdio.h> #include<stdlib.h> struct Node { int data; struct Node* next; }; //创建表头 struct Node* createHead() { struct Node* headNode = (struct Node*)malloc(sizeof(struct Node)); if (h
链表的遍历、插入、删除、清空、销毁操作
qq_45432387的博客
05-03 3895
一、在这里链表的基本操作包括以下几点： 1.初始化链表：输入-1退出链表，输入其他值写入链表 2.遍历链表：打印输入的数字 3.插入链表：插入链表的基本思想为 1）创建指针pCurrent指向要查找的数字 2）初见前置指针pPrve指向查找数字的前一级 3）插入后建立指针关系，即插入的新数字的指针newNode指向查找数字的指针pCurrent，查找数字的前一级的指针pPrve指向插入的新数字的指针newNoded newNode->next = pCurrent; pPrve-&
C语言-链表-删除
m0_55823320的博客
05-10 599
删除的原理：改变指向地址。
C语言学习-13-链表-练习01-删除、插入、释放动态链表
qq_45111959的博客
01-12 1457
本文介绍C语言-数据结构之链表的动态删除、插入与释放，包含示意图和示例源码，分享给大家。
链表的删除和插入---超简单版（实验一）C语言
李小阳先森的学习日记
11-17 1893
1、这里用的是头插法建表，等有时间回头再写尾插法建表 2、在这里也只是一个初步的运用，适合初学者看看 #include <stdio.h> #include <stdlib.h> typedef struct Node { int date; struct Node* next; int len;//长度 }Node; Node* CreateL(Node* H)//【头插法建表】 { int i,n; printf("请确定输入元素的个数为：\n"); scanf(
[宫水三叶的刷题日记]：链表1
08-03
宫水三叶的刷题日记中的这一篇是关于链表操作的，具体是删除链表的倒数第n个节点。从目标出发，我们需要确定倒数第n个节点的位置，而为了找到倒数第n个节点，我们可以利用双指针的思想。 首先，我们定义两个指针 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值