【代码随想录】DAY 3 链表（移除链表元素、设计链表、反转链表）

已于 2023-08-23 21:04:03 修改
阅读量422 收藏
点赞数
文章标签： 链表 数据结构
于 2023-07-14 23:18:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43785314/article/details/131732814
版权

链表基础：

链表：由一串节点node组成，node里有一个data数据域和一个next指针域（存放指向下一个节点的指针），第一个节点为head，这是单链表；

双链表：node里还有一个prev，指向上一个节点的next，因此双链表可以向前查询也可以向后查询。

循环链表：就是单链表的头尾连接起来了

删除节点只需要将前一个节点的next指向后一个节点就行，但最好自己手动释放删除节点的内存。

第一题

力扣

我都想不通为啥我照抄的代码随想录的代码还是AC不了，服了

/**
 * 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 (val == head->val && head !=NULL)
    {
        ListNode* p = head;
        head = head->next;
        delete p;
    }
    ListNode* p = head;
    while (p->next != NULL && p!=NULL)
    {
        if (p->next->val == val)
        {
            ListNode* d = p->next;
            p->next = p->next->next;
            delete d;
        }
        else 
        {p = p->next;
        }
    }
    return head;
    }
};

但是直接copy上面的又过了......无语无语！

学习记录：

/**
 * 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) 
    {
        //删除头节点，不能是if
        while (head != nullptr && head->val == val)
        {
            head = head->next;
        }
        ListNode* cur_node = head;
        while( cur_node != nullptr && cur_node->next != nullptr )
        {
            if (cur_node->next->val == val)
            {
                cur_node->next = cur_node->next->next;
            }
            else 
            {
                cur_node = cur_node->next;
            }
        }
        
        return head;
    }
};

在删除头节点的while循环处，不能为if的原因是，后面的if判断的都是当前节点的下一个节点值是否=val，如果用if只判断一次，那遇到前几个节点值都为val的情况，始终会留下一个节点值为val的头节点不会被判断到。 

如果想判断当前节点值，则需要增加一个哑节点，作为头节点前一个节点：

/**
 * 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(0);
        dummy.next = head;
        ListNode* cur_node = head;
        ListNode* prev_node = &dummy;
        while (cur_node != nullptr)
        {
            if (cur_node->val == val)
            {
                prev_node->next = cur_node->next;
                delete cur_node;
                cur_node = prev_node->next;
            }
            else 
            {
                prev_node = cur_node;
                cur_node = cur_node->next;
            }
        }
        return dummy.next;
    }
};

代码随想录的解:

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        // 删除头结点
        while (head != NULL && head->val == val) { // 注意这里不是if
            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;
    }
};
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* dummyHead = new ListNode(0); // 设置一个虚拟头结点
        dummyHead->next = head; // 将虚拟头结点指向head，这样方面后面做删除操作
        ListNode* cur = dummyHead;
        while (cur->next != NULL) {
            if(cur->next->val == val) {
                ListNode* tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;
            } else {
                cur = cur->next;
            }
        }
        head = dummyHead->next;
        delete dummyHead;
        return head;
    }
};

第二题

力扣

 学习记录：

在构建链表时，记得先定义节点结构体：

struct ListNode{

        ListNode* next;

        int val;

}

 同样的，链表里面还有private数据成员，虚拟节点和链表长度：

private:

ListNode* dummy_node;

int size;

在写增删改查的函数时，注意遍历节点cur_node到底是=dummy_node还是=dummy_node->next；

删除节点时，记得定义一个临时节点存储要删除的节点，然后delete释放内存，再将指针置空：

ListNode* tmp = cur_node->next;

delete tmp;

tmp = nullptr;

如果是节点型指针，构造时要么为空，要么=new ListNode，访问成员时要用->：

 ListNode* cur_node = new ListNode(0)；

cur_node->next; 

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

    MyLinkedList() {
        dummy_node = new ListNode(0);
        size = 0;
    }
    
    int get(int index) {
        if (index > size-1 || index < 0) {
            return -1;
        }
        ListNode* cur_node = dummy_node->next;
        while (index){ //每找一次就减一次index，直到index为0表示已经找到当前index对应的节点
            cur_node = cur_node->next;
            index--;
        }
        return cur_node->val;
    }
    
    void addAtHead(int val) {
        ListNode* add_node = new ListNode(val);
        add_node->next = dummy_node->next;
        dummy_node->next = add_node;
        size++;
    }
    
    void addAtTail(int val) {
        ListNode* cur_node = dummy_node; //注意这里cur=虚拟节点而不是头节点
        while (cur_node->next != nullptr) {
            cur_node = cur_node->next;
        }
        ListNode* add_node = new ListNode(val);
        cur_node->next = add_node;
        size++;
    }
    
    void addAtIndex(int index, int val) {
        if (index > size) {
            return;
        }
        else if (index == size) {
            addAtTail(val);
        }
        else {
            ListNode* cur_node = dummy_node;
            ListNode* add_node = new ListNode(val);
            while (index) {
                cur_node = cur_node->next;
                index--;
            }
            add_node->next = cur_node->next;
            cur_node->next = add_node;
            size++;
        }
    }
    
    void deleteAtIndex(int index) {
        if (index > size-1 || index < 0) {
            return;
        }
        ListNode* cur_node = dummy_node;
        while (index){ 
            cur_node = cur_node->next;
            index--;
        }
        ListNode* tmp = cur_node->next;
        cur_node->next = cur_node->next->next;
        delete tmp; //记得清内存
        tmp = nullptr; //避免成为野指针
        size--;
    }

private:
    ListNode* dummy_node;
    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);
 */

复习：

struct ListNodes {
    ListNodes* next;
    int val;
    ListNodes():val(0), next(nullptr){};
    ListNodes(int x):val(x), next(nullptr){};
};

class MyLinkedList {
public:
    MyLinkedList() {
        dummyhead = new ListNodes();
        length = 0;
    }
    
    int get(int index) {
        if (index < 0 || index >= length) return -1;
        ListNodes* cur = dummyhead->next;
        while (index--) {
            cur = cur->next;
        }
        return cur->val;
    }
    
    void addAtHead(int val) {
        ListNodes* newHead = new ListNodes(val);
        newHead->next = dummyhead->next;
        dummyhead->next = newHead;
        length++;
    }
    
    void addAtTail(int val) {
        ListNodes* newTail = new ListNodes(val);
        ListNodes* cur = dummyhead;
        while (cur->next != nullptr) cur = cur->next;
        cur->next = newTail;
        length++;
    }
    
    void addAtIndex(int index, int val) {
        if (index < 0 || index > length) return;
        if (index == length) {
            addAtTail(val);
            return;
            }
        else {
            ListNodes* cur = dummyhead;
            while (index--) {
                cur = cur->next;
            }
            ListNodes* temp = new ListNodes(val);
            temp->next = cur->next;
            cur->next = temp;
            length++;
        }
    }
    
    void deleteAtIndex(int index) {
        if (index < 0 || index >= length) return;
        else {
            ListNodes* cur = dummyhead;
            while (index--) {
                cur = cur->next;
            }
            ListNodes* toDelete = cur->next;
            cur->next = cur->next->next;
            delete toDelete;
            length--;
        }
    }

private:
    ListNodes* dummyhead;
    int length;

};

 

第三题

力扣

 这道题自己没有想出来，但是看了代码随想录的解释，瞬间觉得太牛了

学习记录：

首先明确的是只需要修改节点的指向，并且一次只能修改一个节点的指向。

如图所示，因为修改的是遍历节点cur到next的指向，所以需要将原本的cur->next记录为temp，在将cur->next改为指向prev后，cur不能再用cur=cur->next的方式遍历（因为next的地址已经更改），但是可以通过赋值的方式，即cur=temp，如此和剩下的链表衔接起来，在挪动cur之前，因先将prev赋值为当前的cur，再完成下一个节点的指向修改。

 其中需要注意1、prev的初始化，可以联想为初始化的prev最终会变为尾节点的next，而尾节点的next都是null，因此需要将prev设为Null，即ListNode* prev=NULL。

2、最后返回值prev，因为每次循环的顺序为先改cur->next，然后temp++，cur++，prev++，当最后一条指向修改完毕后，根据执行顺序temp、cur、prev都还要往右挪一个，此时只有prev才指向修改完的头节点。

/**
 * 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* prev_node = nullptr;//因为最后的尾节点要指向null
        ListNode* temp;
        ListNode* cur_node = head; //遍历节点
        while (cur_node != nullptr) {
            temp = cur_node->next; //保存原本下一个节点
            cur_node->next = prev_node; //改变当前节点的next指向
            prev_node = cur_node; //prev++
            cur_node = temp; //cur++
        }
        return prev_node;
    }
};

复习：

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* preNode = nullptr; //最后尾节点必须指向null
        ListNode* curNode = head;
        ListNode* tempNode;
        while (curNode != nullptr) {
            tempNode = curNode->next; //先记录马上要断掉的next
            curNode->next = preNode; //紧跟着更新next
            preNode = curNode; //然后更新pre
            curNode = tempNode; //最后cur继续遍历
        }
        return preNode; //最后cur遍历到了原本尾节点的next（即null），那么pre就变成了翻转后的head
    }
};

Pearl。
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
移除链表元素_移除链表元素_
10-02
删除链表中的某个特定的元素，根据《大话数据结构》中c语言版本代码进行的改写。
【Leetcode刷题笔记03】203.移除链表元素 707.设计链表 206. 反转链表.md
01-13
设计链表和206.反转链表,记录了详细的题目解析思路以及Java语言的参考代码。 适合人群:学习算法和数据结构的程序员或学生,尤其是想系统学习链表操作的人。 能学到什么:掌握链表虚拟头节点设置方法;练习链表基本...
Leetcode 移除链表元素.go
02-21
LeetCode 203的题目是“移除链表元素”，要求从一个链表中删除所有值等于给定值val的节点，并返回新链表的头节点。这个问题考验的是对链表数据结构的理解和操作能力，包括如何遍历链表、如何处理边界条件（如头节点...
c语言链表的基本操作之移除链表元素.zip
03-28
c语言链表的基本操作 c语言链表的基本操作之移除链表元素
python算法题 链表反转详解
01-20
链表的反转是一个很常见、很基础的数据结构题，输入一个单向链表，输出逆序反转后的链表，如图：上面的链表转换成下面的链表。实现链表反转有两种方式，一种是循环迭代，另外一种方式是递归。 第一种方式：循坏...
数据结构逻辑
qq_42129915的博客
06-10 322
1、线性关系2：树型关系3：图像关系。
【排序算法】计数排序（CountSort）
SWsunlight的博客
06-08 614
计数排序
排序-快速排序
18602
06-15 170
快速排序（Quick Sort）是一种高效的排序算法，由英国计算机科学家霍尔（C. A. R. Hoare）在1960年提出。它的基本思想是：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
数据结构之LinkedList与链表（上）
我要学编程的博客
06-12 1116
手动实现单链表的源码 手动实现双链表的源码 分析LinkedList 的源码 LinkedList的使用：常用方法 ArrayList 和 LinkedList的区别
C语言刷题（函数）
2303_82176667的博客
06-09 768
一个数如果恰好等于它的所有因子(不包括它本身)之和，这个数就称为“完数”。
数据结构分类总结[多达80种,offer收割机]
爱学习_萌萌哒
06-14 422
线性结构： 数组（Array） 链表（Linked List）：包括单链表、双向链表和循环链表 栈（Stack）：后进先出（LIFO）的数据结构 队列（Queue）：先进先出（FIFO）的数据结构 双端队列（Deque）：允许在两端进行插入和删除操作 非线性结构： 树（Tree）：包括二叉树、平衡二叉树、二叉搜索树、AVL树、红黑树等 图（Graph）：包括有向图、无向图、加权图、无权图等 散列结构： 哈希表（Hash Table）：通过哈希函数将键映射到表中的位置
数据结构——队列(Queue)详解
Yuan_o_的博客
06-14 140
队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)的性质入队列：进行插入操作的一端称为队尾(Tail/Rear)出队列：进行删除操作的一端称为队头(Head/Front)
数据结构02 队列及其应用【C++实现】
bigbigli
06-14 278
队列是一种特殊的线性表，它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，前端一般叫做队头，后端叫队尾。队列就像学校做操站队一样，来的人一个一个往后站，走的时候从前往后一个一个走。
数据结构篇：旋转操作在AVL树中的实现过程
weixin_41489908的博客
06-15 214
本文详细介绍了AVL树中的旋转操作及其实现过程，包括右旋、左旋、左右旋和右左旋。通过多个代码案例，我们展示了这些旋转操作的应用和效果。在实际开发中，AVL树通过旋转操作保持平衡，从而保证二叉搜索树的高效性能。希望这些示例和注意事项能帮助你更好地理解和应用AVL树中的旋转操作。
数组的最大美丽值
__1_1__的博客
06-15 310
2.对于所有nums[i]-k < 0 的部分都可以用0代为表示，即[-3, a], [-6, b], [-9, c]与[0, a], [0, b], [0, c]的最大美丽值是一样的，因为nums[i]>=0, 区间有小于0的部分时，区间必然包含整数 0。题目可以理解为nums[i]是一个范围为[ nums[i] - k, nums[i] + k]的区间，然后要求所有区间叠加后重复最多的元素个数是多少。将 nums[i] 替换为范围 [nums[i] - k, nums[i] + k] 内的任一整数。
数据结构-3、栈、队列和数组
最新发布
qq_66013948的博客
06-15 562
​ 队列，也是一种操作受限的线性表，只允许在表的一端进行插入，而表的另一端进行删除。向队列中插入元素成为入队或进队；删除元素称为出队或离队。这和我们日常生活中的排队时一致的，最早排队的也是最早离队的，其操作的特性是先进先出（FIFO），如下图：​ 对头。允许删除的一端，又称队首。​ 队尾。允许插入的一端。​ 空队列。不含任何元素的空表。
【数据结构】——常见排序
super_coders的博客
06-15 458
在开始之前先准备一个交换数据的函数，排序会经常用到。
数据结构篇：链表和树结构的操作方法
weixin_41489908的博客
06-15 685
本文详细介绍了链表和树结构的基本操作方法，包括单链表、双链表、循环链表的插入和删除操作，以及二叉树、二叉搜索树和AVL树的插入、查找和删除操作。通过这些代码案例，可以帮助你更好地理解和应用链表和树结构。在实际开发中，选择合适的数据结构和操作方法，可以显著提升代码的效率和可维护性。希望这些示例和注意事项能帮助你更好地掌握链表和树结构的操作方法。
力扣114. 二叉树展开为链表
akdjfhx的博客
06-15 75
力扣114. 二叉树展开为链表
Java代码实现反转链表
08-02
以下是Java代码实现反转链表的示例： ```java private static Node reverseLinkedList(Node head) { Node prev = null; Node current = head; Node next = null; while (current != null) { next = current.next; current.next = prev; prev = current; current = next; } return prev; } ``` 这段代码中，我们使用了三个指针prev、current和next来完成链表的反转操作。prev指向当前节点的前一个节点，current指向当前节点，next指向当前节点的下一个节点。在每一次循环中，我们将current的next指针指向prev，然后更新prev、current和next的指向，直到遍历完整个链表。最后，返回反转后的链表的头节点。 你可以使用这个方法来反转一个链表，并通过遍历链表的方法验证反转的准确性。例如，你可以使用上面提到的showLink方法来打印反转后的链表。 希望这个示例能够帮助到你！

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值