day03 移除链表元素 设计链表 反转链表

最新推荐文章于 2024-11-07 20:05:58 发布
最新推荐文章于 2024-11-07 20:05:58 发布
阅读量911 收藏 22
点赞数 19
文章标签： 链表 算法 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43773652/article/details/135352082
版权

题目1：203 移除链表元素

题目链接：203 移除链表

题意

删除链表中所有满足Node.val==val的节点   返回新的头节点

注意使用cur临时指针，遍历链表，这样才可以最终返回head，不可以拿着head去遍历，否则，头节点会改变，无法返回整个链表

分类讨论

代码

/**
 * 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) {
        //删除头节点
        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;
    }
};
  • 时间复杂度: O(n)
  • 空间复杂度: O(1)

虚拟头节点

本题使用虚拟头节点方法  更优，这样不用分类讨论，可以统一操作

代码

/**
 * 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 *dummyhead = new ListNode(0);
        dummyhead->next = head;
        //定义临时指针cur,遍历链表
        ListNode *cur = dummyhead;
        //遍历所有的链表节点
        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 dummyhead->next;//注意返回的dummyhead一定是新链表的头节点
    }
};
  • 时间复杂度: O(n)
  • 空间复杂度: O(1)

题目2：707 设计链表

题目链接：707 设计链表

题意

链表实现如下功能：

①初始化节点

②获取链表的某个节点值  （index从0开始，head的index为0）

③在头节点前面插入一个节点

④在尾节点后面插入一个节点

⑤在第n个节点处插入一个节点

⑥删除第n个节点

代码

①初始化节点

//定义链表节点结构体
    struct LinkedNode {
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val),next(nullptr){}  //没有分号
        
    };
    //初始化链表
    MyLinkedList() {
        dummyhead = new LinkedNode(0);
        size_ = 0;   
    }

②获取链表的某个节点值  （index从0开始，head的index为0）

法1：cur指向dummyhead

代码1

int get(int index) {
        if(index<0 || index>(size_-1)) return -1;
        LinkedNode* cur = dummyhead;
        while(index){
            cur = cur->next;
            index--;
        }
        return cur->next->val;   
    }
法2：cur指向dummyhead->next

代码2

int get(int index) {
        if(index<0 || index>(size_-1)) return -1;
        LinkedNode* cur = dummyhead->next;
        while(index){
            cur = cur->next;
            index--;
        }
        return cur->val;   
    }

③在头节点前面插入一个节点

注意插入的节点顺序，这非常关键，这也是“坑”

代码

 void addAtHead(int val) {
        LinkedNode* newnode = new LinkedNode(val);
        newnode->next = dummyhead->next;
        dummyhead->next = newnode;
        size_ ++;//注意添加了元素，要在原链表的基础上加1
    }

④在尾节点后面插入一个节点

注意while循环的条件是cur->next!=NULL 不能是size_

代码

void addAtTail(int val) {
        LinkedNode* cur = dummyhead;
        LinkedNode* newnode = new LinkedNode(val);
        while(cur->next!=nullptr){
            cur = cur->next;
        }
        cur->next = newnode;
        size_++;//添加了元素，链表大小加1
    }

！！！错误代码（如果使用size_做循环操作，那么意味着表示链表大小的量size_会发生变化，不能拿代表真实的链表大小了）

void addAtTail(int val) {
        LinkedNode* cur = dummyhead;
        LinkedNode* newnode = new LinkedNode(val);
        while(size_){
            cur = cur->next;
            size_--;
        }
        cur->next = newnode;
        size_++;//添加了元素，链表大小加1
    }

如果想要使用这个量用于while循环的条件判定，可以将size_赋值给一个新变量n，代码如下，这时，代码就是正确的了

void addAtTail(int val) {
        int n = size_;
        LinkedNode* cur = dummyhead;
        LinkedNode* newnode = new LinkedNode(val);
        while(n){
            cur = cur->next;
            n--;
        }
        cur->next = newnode;
        size_++;//添加了元素，链表大小加1
    }

⑤在第n个节点处插入一个节点

注意“坑”       ：即顺序  

在第n个节点处插入一个节点，因此一定要知道第n-1个节点，所以cur=dummyhead

代码

void addAtIndex(int index, int val) {
        if(index>size_) return;
        if(index<0) index = 0;
        LinkedNode* newnode = new LinkedNode(val);
        LinkedNode* cur = dummyhead;
        while(index){
            cur = cur->next;
            index--;
        }
        newnode->next = cur->next;
        cur->next = newnode;
        size_++;//新加入了节点，链表大小要加1
    }

⑥删除第n个节点

删除第n个节点，一定要知道第n-1个节点，因此，cur=dummyhead

代码

void deleteAtIndex(int index) {
        if(index>(size_-1)||index<0) return;
        LinkedNode* cur = dummyhead;
        while(index){
            cur = cur->next;
            index--;
        }
        //注意释放内存
        LinkedNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        tmp = nullptr;
        size_--;//删除了一个元素，链表大小减1
    }

整体代码

class MyLinkedList {
public:
//定义链表节点结构体
    struct LinkedNode {
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val),next(nullptr){}  //没有分号
        
    };
    //初始化链表
    MyLinkedList() {
        dummyhead = new LinkedNode(0);
        size_ = 0;   
    }

    int get(int index) {
        if(index<0 || index>(size_-1)) return -1;
        LinkedNode* cur = dummyhead;
        while(index){
            cur = cur->next;
            index--;
        }
        return cur->next->val;   
    }
    void addAtHead(int val) {
        LinkedNode* newnode = new LinkedNode(val);
        newnode->next = dummyhead->next;
        dummyhead->next = newnode;
        size_ ++;//注意添加了元素，要在原链表的基础上加1
    }
    void addAtTail(int val) {
        LinkedNode* cur = dummyhead;
        LinkedNode* newnode = new LinkedNode(val);
        while(cur->next!=nullptr){
            cur = cur->next;

        }
        cur->next = newnode;
        size_++;//添加了元素，链表大小加1
    }
    
    void addAtIndex(int index, int val) {
        if(index>size_) return;
        if(index<0) index = 0;
        LinkedNode* newnode = new LinkedNode(val);
        LinkedNode* cur = dummyhead;
        while(index){
            cur = cur->next;
            index--;
        }
        newnode->next = cur->next;
        cur->next = newnode;
        size_++;//新加入了节点，链表大小要加1
    }

    void deleteAtIndex(int index) {
        if(index>(size_-1)||index<0) return;
        LinkedNode* cur = dummyhead;
        while(index){
            cur = cur->next;
            index--;
        }
        //注意释放内存
        LinkedNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        tmp = nullptr;
        size_--;//删除了一个元素，链表大小减1
    }
    void printLinkedList() {
        LinkedNode* cur = dummyhead;
        while(cur->next!=nullptr){
            cout<<cur->next->val<<" ";
            cur = cur->next;
        }
        cout<<endl;  
    }
private:
    int size_;
    LinkedNode* dummyhead;
};

/**
 * 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);
 */
 // 打印链表
  • 时间复杂度: 涉及 index 的相关操作为 O(index), 其余为 O(1)
  • 空间复杂度: O(n)  其中 n 为链表的长度。需要为每个节点分配内存空间来存储节点的值和下一个节点的指针，并且还需要一个额外的虚拟头节点指向链表的头部。

题目3：206 反转链表（面试高频）

题目链接：206 反转链表

题意

根据链表的头节点head  返回反转后的链表

双指针

代码

/**
 * 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* pre = NULL;
       ListNode* cur = head;
       while(cur!=NULL){
           ListNode* temp = cur->next;
           cur->next = pre;
           //pre，cur向后移动一位
           pre = cur;
           cur = temp;
       }
       return pre;
    }
};
  • 时间复杂度: O(n)
  • 空间复杂度: O(1)

递归

代码

/**
 * 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* reverse(ListNode* cur, ListNode* pre){
        //终止条件
        if(cur==NULL) return pre;
        //单层递归逻辑
        ListNode* temp = cur->next;
        cur->next = pre;
        return reverse(temp,cur);
    }
    ListNode* reverseList(ListNode* head) {
       return reverse(head,NULL);
    }
};
  • 时间复杂度: O(n), 要递归处理链表的每个节点
  • 空间复杂度: O(n), 递归调用了 n 层栈空间
人来茶热
关注
代码随想录Day03移除链表元素 设计链表 反转链表
smile_Lululu7777的博客
02-23 923
链表基础题目
Day3 移除链表元素 设计链表 反转链表
weixin_51335667的博客
06-26 664
/ 链表变为 1->2->3。// 现在，链表变为 1->3。在这道题中，使用虚拟头节点（哨兵节点）可以方便我们进行链表的增删改的操作。通过让当前节点的next指针指向下下一个节点以达到在链表中删除元素的目的。以指示链表中的上一个节点。假设链表中的所有节点下标从。你可以选择使用单链表或者双链表，设计并实现自己的链表。，请你反转链表，并返回反转后的链表。是指向下一个节点的指针/引用。给你一个链表的头节点。
day03| 移除链表元素、设计链表、反转链表
2301_76909842的博客
06-08 609
思路：首先定义一个cur指针，指向头结点，再定义一个pre指针，初始化为null，还要定义一个next指针用来保存当前节点的后一个节点。循环时需要先赋值next，然后进行翻转操作，之后移动pre，cur两指针。-设置一个虚拟头结点再进行删除操作。-直接使用原来的链表进行删除操作。
day03 移除链表元素、设计链表、反转链表
mqy224512的博客
01-26 445
移除链表元素、设计链表、反转链表
Day3 移除链表元素 设计链表 翻转链表
lxy2966201752的博客
06-25 822
在链表操作中，直接覆盖节点值并不等于删除节点。删除节点不仅需要从链表中移除，还需要正确释放其内存，以防止内存泄漏正确的做法是在移动指针之前保存当前节点的指针，然后在移动指针之后删除当前节点。shanchucurcurcurlinknote*一下这个代码虽然错误百出 但是只有知道每一步的错误原因，才能更好的理解链表。请仔细看下面这个再类中又用到了结构体。
Day03 链表-移除链表元素+设计链表 +反转链表
just_sleeeeeeep的博客
07-20 1071
链表初学。
day03链表基础_移除链表元素_设计链表_反转链表
m0_59684747的博客
12-09 3387
力扣移除链表元素，设计链表，反转链表
day03 链表部分 203移除链表元素 707设计链表 206反转链表
qq_51761883的博客
09-29 604
链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。链表的入口节点称为链表的头结点也就是head。数组是在内存中是连续分布的，但是链表在内存中可不是连续分布的。各个节点分布在内存的不同地址空间上，通过指针串联在一起。：每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。（如上图所示）：单链表中的指针域只能指向节点的下一个节点。，将原链表的所有节点按照统一的方式进行移除。
Day03.移除链表元素、反转链表
izwmain的博客
10-29 1171
代码随想录，刷题笔记，Day03
DAY3:链表（一）：链表基础知识+移除链表元素
CFY1226的博客
05-13 2591
/ 单链表的定义 struct ListNode {int val;//节点上储存的元素 ListNode * next;//指向下一个节点的指针 ListNode(int x) : val(x) , next(NULL) {//节点的构造函数 } }//定义指针，指向链表对象（虚拟头节点用法）所以如果不定义构造函数使用默认构造函数的话，在初始化的时候就不能直接给变量赋值！首先，你需要一个指针来找到要删除的节点。这个指针通常是通过遍历链表得到的。
算法巡练day03Leetcode203移除链表元素707设计链表206反转链表
dc爱傲雪和技术
01-02 1723
给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点。为什么要保存一下这个节点呢，因为接下来要改变 cur->next 的指向了，将cur->next 指向pre ，此时已经反转了第一个节点了。void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。， 这才是新的头结点。变量在删除链表节点的过程中发挥着重要的作用，既确保了链表结构的完整性，又避免了潜在的内存泄漏问题。
Day3:链表part01
最新发布
2401_83448199的博客
11-07 659
1.方法1是常规方法，先要判断头结点是否为需要我们删除的值，然后再判断非头结点。然后while判断里面必须要有的一个条件是判断当前节点是否为空2.方法2是虚拟头结点的方法。相当于凭空new出一个虚拟的头结点，然后让这个头结点指向head。这里面注意返回的是return dummy.next;
【代码随想录训练营】【Day03】第二章｜链表｜链表理论基础｜203.移除链表元素｜707.设计链表｜206.反转链表
士多啤梨先生の博客
02-03 3796
【代码随想录训练营】【Day03】第二章｜链表｜链表理论基础｜203.移除链表元素｜707.设计链表｜206.反转链表
自学Java day12 使用jvav实现链表 从jvav到架构师
qq_68286846的博客
04-07 1185
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(lo...
算法基础-链表
August的专栏
11-05 230
当链表的长度为偶数时，head找到的中点是靠后的，因为fast相对slow移动只快了1步，而head.next找到的中点是靠前的，因为fast相对slow移动快了2步。这2种方式寻找链表的结点主要区别是 当链表的长度为奇偶数时，找到链表中点的位置一个靠后，一个靠前。使用快慢指针寻找链表的中点有2种方式，分别是fast=head;当链表为奇数时 [1->2->3->4->5]当链表长度为奇数时，找到的中点2种方式是一样的。当链表为偶数时 [1->2->3->4]
字符串-06-整数与ip地址之间的转换
qq_45480682的博客
11-04 335
华为od算法——HJ33
【LeetCode】【算法】160.相交链表
passer__jw767的博客
11-05 323
Leetcode 160. 相交链表
【算法】（Python）贪心算法
yannan20190313的博客
11-04 1989
【算法】（Python）贪心算法（最大单元数，买卖股票最佳时机，最低加油次数）
二叉树(一)
m0_74340589的博客
11-05 448
/ 写递归算法的关键是要明确函数的「定义」是什么，然后相信这个定义，利用这个定义推导最终结果，绝不要试图跳入递归。// 再说说归并排序的逻辑，若要对nums[lo…// 再看看回溯算法，前文回溯算法详解干脆直接说了，回溯算法就是个 N 叉树的前后序遍历问题，没有例外。// 其实很多动态规划问题就是在遍历一棵树，你如果对树的遍历操作烂熟于心，起码知道怎么把思路转化成代。//快速排序的逻辑是，若要对nums[lo….所有回溯、动归、分治算法，其实都是树的问题，而树的问题就永远逃不开树的递归遍历。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值