【算法day3】链表：增删改查及其应用

游是水里的游2024-12-01 2:34

题目引用

  1. 移除链表元素
  2. 设计链表
  3. 翻转链表

链表介绍

链表与数组不同的是，它是以指针串联在一起的分布在内存随机位置上的，而不是像指针一样占用整块的连续空间。因此也不支持通过指针++读取。所以在题目里面总是比较抽象，需要通过画图来帮助解题。一般出现在算法里面的都会是单链表，结构形如

cpp 复制代码 
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) {}

1.移除链表元素

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

示例 1：

输入：head = [1,2,6,3,4,5,6], val = 6

输出：[1,2,3,4,5]

示例 2：

输入：head = [], val = 1

输出：[]

示例 3：

输入：head = [7,7,7,7], val = 7

输出：[]

来看一下题目~

题目要求我们删除链表中 ==val 的元素，因此我们需要遍历一遍数组将 ==val 的节点删掉,怎么删呢？

首先定义一个cur指针，当cur指针所在节点的下一个节点的值 ==val 时，我们使用一个tmp指针指向它，然后 cur指针指向的节点将 next 指向 tmp 的下一个节点，完成删除。



最后附上代码：

cpp 复制代码 
 ListNode* removeElements(ListNode* head, int val) {
        while(head!=NULL&&head->val==val){
            ListNode*tmp=head;
            head=head->next;
            delete tmp;
        }

        ListNode* cur=head;
        while(cur!=NULL && cur->next!=NULL){
            if(cur->next->val==val){
                ListNode* tmp=cur->next;
                cur->next=cur->next->next;
                delete tmp;
            }else{
                cur=cur->next;
            }
        }

        return head;
    }

这里值得注意的是头结点位置的值，如果头结点的值 ==val 的话，需要我们直接从头结点删除，并把头结点指针移动到下一个位置。

设计链表

你可以选择使用单链表或者双链表，设计并实现自己的链表。

单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。

如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。

实现 MyLinkedList 类：

MyLinkedList() 初始化 MyLinkedList 对象。

int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。

void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。

void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。

void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。

void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。

示例：

输入

"MyLinkedList", "addAtHead", "addAtTail", "addAtIndex", "get", "deleteAtIndex", "get"

\[\], \[1\], \[3\], \[1, 2\], \[1\], \[1\], \[1\]

输出

null, null, null, null, 2, null, 3

解释

MyLinkedList myLinkedList = new MyLinkedList();

myLinkedList.addAtHead(1);

myLinkedList.addAtTail(3);

myLinkedList.addAtIndex(1, 2); // 链表变为 1->2->3

myLinkedList.get(1); // 返回 2

myLinkedList.deleteAtIndex(1); // 现在，链表变为 1->3

myLinkedList.get(1); // 返回 3

这里我们就选择难度较大的单链表来实现吧

首先需要自己定义一个链表节点，这个在文章开头就有，直接copy~

然后在类内初始化链表长度_size和一个虚拟头指针dummyhead。

首先是构造函数，在构造函数内给_size和dummyhead赋值和开辟空间

cpp 复制代码 
MyLinkedList() {
        _size=0;
        dummyHead=new ListNode(0);        
    }

然后是get函数，返回index位置的值,这里需要判断index位置是否越界，接着遍历链表找到index位置的节点并返回val。

cpp 复制代码 
int get(int index) {
        if(index<0||index>(_size-1))
            return -1;
        ListNode* cur=dummyHead->next;
        while(index--){
            cur=cur->next;
        }
        return cur->_val;
    }

头插函数，这里new一个新节点，将新节点的next指针指向dummyhead的下一个节点，dummyhead的next指向新节点，别忘了++_size。

cpp 复制代码 
 void addAtHead(int val) {
        ListNode* newNode=new ListNode(val);
        newNode->next=dummyHead->next;
        dummyHead->next=newNode;
        _size++;
    }

尾插，一路循环到链表的尾节点，将尾节点的next指针指向新节点

cpp 复制代码 
void addAtTail(int val) {
        ListNode* newNode=new ListNode(val);
        ListNode*cur=dummyHead;
        while(cur->next!=nullptr){
            cur=cur->next;
        }
        
        cur->next=newNode;
        _size++;
    }

接下来的插入删除指定位置函数都比较简单，就直接上完整代码吧

cpp 复制代码 
class MyLinkedList {
public:
    struct ListNode{
    struct ListNode* next;
    int _val;
    ListNode(int val):_val(val),next(nullptr){}
    };

    MyLinkedList() {
        _size=0;
        dummyHead=new ListNode(0);        
    }
    
    int get(int index) {
        if(index<0||index>(_size-1))
            return -1;
        ListNode* cur=dummyHead->next;
        while(index--){
            cur=cur->next;
        }
        return cur->_val;
    }
    
    void addAtHead(int val) {
        ListNode* newNode=new ListNode(val);
        newNode->next=dummyHead->next;
        dummyHead->next=newNode;
        _size++;
    }
    
    void addAtTail(int val) {
        ListNode* newNode=new ListNode(val);
        ListNode*cur=dummyHead;
        while(cur->next!=nullptr){
            cur=cur->next;
        }
        
        cur->next=newNode;
        _size++;
    }
    
    void addAtIndex(int index, int val) {
        if(index>_size)
            return;
        if(index<0) index=0;
        ListNode* newNode=new ListNode(val);
        ListNode* cur=dummyHead;
        while(index--){
            cur=cur->next;
        }
        
        newNode->next=cur->next;
        cur->next=newNode;
        _size++;
    }
    
    void deleteAtIndex(int index) {
        if(index<0||(index>=_size))
            return;
        ListNode* cur=dummyHead;
        while(index--){
            cur=cur->next;
        }
        ListNode* tmp=cur->next;
        cur->next=cur->next->next;
        delete tmp;
        _size--;
    }
private:
    int _size;
    ListNode* dummyHead;
};

反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：

输入：head = [1,2,3,4,5]

输出：[5,4,3,2,1]

我们来看一下题目，让我们将链表翻转之后返回头节点的指针。

这里有两种办法：一种从前往后遍历数组，一边将当前节点next指针指向下一个，一边向前遍历，最后返回当前节点的指针。

另一种通过递归直接来到倒数第二个节点位置，将尾节点的next的指针指向自己，再返回上一层调用。

我们两种都讲

第一种

我们定义cur指针指向head，pre指针用于指向cur的前一个节点，再定义一个tmp用于记录cur指针的下一个位置

只要cur指针指向的节点存在，就使tmp指向cur指针的下一个节点，并把cur的next指针指向pre所在位置，再将pre移动到cur位置cur移动到tmp位置，三个指针一次循环同时向前移动一次直到循环结束。

这里就附上代码供大家理解一下：

cpp 复制代码 
ListNode* reverseList(ListNode* head) {
        ListNode* pre=NULL; 
        ListNode* cur=head;
        ListNode* tmp;
        while(cur){
            tmp=cur->next;
            cur->next=pre;
            pre=cur;
            cur=tmp;
        }

        return pre;
    }

第二种写法：

我们利用递归找到倒数第二个节点，利用倒数第二个节点将尾节点的next指针指向自己，然后返回上一层递归，不断调用直到所有节点的next指针都被翻转，返回接收的头指针。来看一下图。

附上代码：

cpp 复制代码 
ListNode* reverseList(ListNode* head) {
        // 边缘条件判断
        if(head == NULL) return NULL;
        if (head->next == NULL) return head;
        
        // 递归调用，翻转第二个节点开始往后的链表
        ListNode *last = reverseList(head->next);
        // 翻转头节点与第二个节点的指向
        head->next->next = head;
        // 此时的 head 节点为尾节点，next 需要指向 NULL
        head->next = NULL;
        return last;
    }

总结

在遇到链表问题时，初学者切忌空想，一定要多画图，多思考，当你做出来一道时，就离做出一百道不远啦~

相关推荐
软件派24 分钟前
基于YOLO算法的目标检测系统实现指南
算法·yolo·目标检测
代码小将2 小时前
Leetcode209做题笔记
java·笔记·算法
Musennn3 小时前
leetcode 15.三数之和 思路分析
算法·leetcode·职场和发展
CM莫问6 小时前
＜论文＞（微软）避免推荐域外物品：基于LLM的受限生成式推荐
人工智能·算法·大模型·推荐算法·受限生成
康谋自动驾驶7 小时前
康谋分享 | 自动驾驶仿真进入“标准时代”：aiSim全面对接ASAM OpenX
人工智能·科技·算法·机器学习·自动驾驶·汽车
C++ 老炮儿的技术栈8 小时前
什么是函数重载？为什么 C 不支持函数重载，而 C++能支持函数重载？
c语言·开发语言·c++·qt·算法
yychen_java8 小时前
R-tree详解
java·算法·r-tree
MarkHard1239 小时前
Leetcode （力扣）做题记录 hot100（62，64，287，108）
算法·leetcode·职场和发展
王RuaRua9 小时前
[数据结构]5. 栈-Stack
linux·数据结构·数据库·链表
一只鱼^_9 小时前
牛客练习赛138(首篇万字题解？？？)
数据结构·c++·算法·贪心算法·动态规划·广度优先·图搜索算法
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】03从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑04【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！05Coze扣子平台完整体验和实践（附国内和国际版对比）06DeepSeek各版本说明与优缺点分析07【解决】Android Gradle Sync 报错 Could not read workspace metadata08YOLOv5改进 | 添加CA注意力机制 + 增加预测层 + 更换损失函数之GIoU09苍穹外卖面试总结10组基轨迹建模 GBTM的介绍与实现（Stata 或 R）