算法力扣刷题记录七【707. 设计链表】

最新推荐文章于 2024-07-08 22:12:26 发布
最新推荐文章于 2024-07-08 22:12:26 发布
阅读量939 收藏 21
点赞数 11
分类专栏： 算法小白力扣刷题记录 文章标签： 算法 leetcode 链表 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/danaaaa/article/details/139871473
版权

前言

记录七：力扣【707. 设计链表】
完成链表索引，增删操作。

一、题目阅读和理解

题目阅读

你可以选择使用单链表或者双链表，设计并实现自己的链表。
单链表中的节点应该具备两个属性：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);	//头部添加元素1
myLinkedList.addAtTail(3);		//尾部添加元素3
myLinkedList.addAtIndex(1, 2);    // 链表变为 1->2->3
myLinkedList.get(1);              // 返回 第一个节点，元素值为2
myLinkedList.deleteAtIndex(1);    // 现在，链表变为 1->3
myLinkedList.get(1);              // 返回 第一个节点，元素值为3

二、第一次尝试

测试通过代码

class MyLinkedList {
private:
    ListNode* head = nullptr;
public:
    MyLinkedList() {
        ListNode* head  = nullptr;
    }
    
    int get(int index) {
        ListNode* cur = head;
        int num = 0;//计数

        while( cur != nullptr){
            if(num == index){
                return cur->val;
            }
            cur = cur->next;
            num++;
        }
        return -1;
    }
    
    void addAtHead(int val) {
        if(head == nullptr){
            head  = new ListNode(val);
            return;
        }else{
             ListNode* node = new ListNode(val);
            node->next = head;
            head = node;
            return;
        }
    }
    
    void addAtTail(int val) {
        ListNode* cur = head;
        if(cur == nullptr){
            ListNode* node = new ListNode(val);
            head = node;
            return;
        }
        while(cur != nullptr){
            if(cur->next == nullptr){
                ListNode* node = new ListNode(val);
                cur->next = node;
                break;
            }else{
                cur = cur->next;
            }
            
        }
        
        
    }
    
    void addAtIndex(int index, int val) {
        ListNode *newnode = new ListNode(val);
        int num = 0;

        ListNode* dummy_node = new ListNode(0,head);
        ListNode* cur = dummy_node;
        while(cur!= nullptr ){
            if(num == index){
                newnode->next = cur->next;
                cur->next = newnode;
                break;
            }else{
                cur = cur->next;
                num++;
            }
        }
        head = dummy_node->next;
        delete dummy_node;

    }
    
    void deleteAtIndex(int index) {
        ListNode* dummy_node = new ListNode(0,head);
        ListNode* cur = dummy_node;
        int num = 0;

        while(cur != nullptr && cur->next != nullptr){
            if(num == index){
                ListNode* tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;
                break;
            }else{
                cur = cur->next;
                num++;
            }
        }
        head = dummy_node->next;
        delete dummy_node;
    }
};

//具体实例化方式和调用方式：
/**
 * 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);
 */

过程解释

（1）构造函数

MyLinkedList() {
        ListNode* head  = nullptr;
    }

调用 MyLinkedList myLinkedList = new MyLinkedList(); //创建对象 时，需要一个头节点，是链表的入口，所以成员ListNode* head头指针应该得到初始化。一开始创建一个空链表，没有节点，所以ListNode* head = nullptr;赋为空。

（2）获取元素

int get(int index) {
        ListNode* cur = head;
        int num = 0;//计数

        while( cur != nullptr){
            if(num == index){
                return cur->val;
            }
            cur = cur->next;
            num++;
        }
        return -1;
    }
  • 用一个cur来查找链表，从头节点开始；
  • 并用num计数，看有没有到达目标节点；
  • 由于不能操作空指针，所以while条件是( cur != nullptr)
  • if(num == index)，则返回节点的值。否则，cur后移。num++；
  • while结束，说明没有找到index，return -1.（因为题目说：下标无效都返回-1）
  • 用边界条件判断逻辑是否正确：
    • 如果head为空，不进入while循环，直接返回-1.（下标无效）
    • 若只有一个节点，index=0，可以获得返回值；如果index=2，说明while循环退出，还没有return，所以最终return -1.（超出下标范围）

所以逻辑正确。

（3）添加头元素

void addAtHead(int val) {
        if(head == nullptr){
            head  = new ListNode(val);
            return;
        }else{
             ListNode* node = new ListNode(val);
            node->next = head;
            head = node;
            return;
        }
    }
  • 添加元素，第一步得创建一个元素，所以ListNode* node = new ListNode(val);
  • 第二步找到head，因为head指向头节点，我多余一步考虑head是不是空；
  • 如果是空，那么head = new ListNode(val);指向新节点，return；
  • 如果不是空，先node->next = head;把新节点后继指向head；再让head换到新节点node：head = node;
  • 最后return;

但是我发现：在else逻辑下，没有head->，说明即使head为空，我也没有访问空指针。那么可以合二为一，无需分开讨论，改进：

void addAtHead(int val) {
        // if(head == nullptr){
        //     head  = new ListNode(val);
        //     return;
        // }else{
            ListNode* node = new ListNode(val);
            node->next = head;
            head = node;
            return;
        //}
    }

（4）在链表尾部添加元素

    void addAtTail(int val) {
        ListNode* cur = head;
        if(cur == nullptr){
            ListNode* node = new ListNode(val);
            head = node;
            return;
        }
        while(cur != nullptr){
            if(cur->next == nullptr){
                ListNode* node = new ListNode(val);
                cur->next = node;
                break;
            }else{
                cur = cur->next;
            }
        }

  • 先创建一个要添加的节点：ListNode* node = new ListNode(val);

  • 找到cur->next == nullptr说明到达链表尾部。修改cur->next = node;

  • 因为用到cur->next，说明cur不能为空。所以我初始考虑cur==nullptr情况，即空链表时：

      if(cur == nullptr){
          ListNode* node = new ListNode(val);
          head = node;
          return;
      }

  • 再while(cur != nullptr)，找到链表尾部。

（5）在下标index之前添加元素

void addAtIndex(int index, int val) {
        ListNode *newnode = new ListNode(val);
        int num = 0;

        ListNode* dummy_node = new ListNode(0,head);
        ListNode* cur = dummy_node;
        while(cur!= nullptr ){
            if(num == index){
                newnode->next = cur->next;
                cur->next = newnode;
                break;
            }else{
                cur = cur->next;
                num++;
            }
        }
        head = dummy_node->next;
        delete dummy_node;

    }
  • 为什么这里突然用上虚拟头节点？如果没有虚拟头节点：
    • 添加操作肯定要cur->next，那么cur不能为空。如果cur = head;(初始)，得先判断cur是不是空；
    • 如果cur是空，整个是空链表，index=0，也不好解释哪里有0号元素。
    • 当index=0，在头节点之前加，得移动head，不用while(cur!= nullptr )；链表中间加，cur已经指向0， 进入while(cur!= nullptr )判断的第一个index=1。所以需要看index是不是0。
  • 所以统一用虚拟头节点，这样cur不会为空，并且index也不会错位。
  • 第一步：要添加的节点先创建出来；并且有num计数，确定index位置；
  • 第二步：创建虚拟头节点，dummy_node;并cur = dummy_node;
  • 第三步：因为在cur后面加，所以用到cur->next，那么while条件是(cur!= nullptr )。
  • 第四步：if(num == index)，添加操作。就可以break;结束循环，因为只加一个节点，已经完成工作。
  • 第五步：如果num != index，cur后移。
  • 第六步：改变head的位置，head = dummy_node->next;
  • 第七步：delete dummy_node;
  • 第八步：判断是不是index之间位置加入节点？用index=1，if判断一下，发现num和index没有错位。
  • 第九步：当index超出长度，while循环结束，也没有用上newnode，的确没有添加，但是newnode此时创建的内存没有释放**（bug）**，所以用上了newnode，不需要delete（当前逻辑）；没有用上，需要delete newnode;（逻辑漏洞）。

改进：

    void addAtIndex(int index, int val) {
        ListNode *newnode = new ListNode(val);
        int num = 0;

        ListNode* dummy_node = new ListNode(0,head);
        ListNode* cur = dummy_node;
        while(cur!= nullptr ){
            if(num == index){
                newnode->next = cur->next;
                cur->next = newnode;
                break;
            }else{
                cur = cur->next;
                num++;
            }
        }
        if(num < index){	//注意这里。没用上newnode，需要释放本次调用创建的内存。
            delete newnode;
        }
        head = dummy_node->next;
        delete dummy_node;

    }

（6）在下标index之前删除元素

void deleteAtIndex(int index) {
        ListNode* dummy_node = new ListNode(0,head);
        ListNode* cur = dummy_node;
        int num = 0;

        while(cur != nullptr && cur->next != nullptr){
            if(num == index){
                ListNode* tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;
                break;
            }else{
                cur = cur->next;
                num++;
            }
        }
        head = dummy_node->next;
        delete dummy_node;
    }
};

思路：用虚拟头节点统一删除操作。cur需要停在删除目标之前。

  • 第一步：创建虚拟头节点，dummy_node;并cur = dummy_node;
  • 第二步：num用来计数，判断有没有到达删除位置。
  • 第三步：删除时，用到cur->next和cur->next->next赋值，所以cur和cur->next不能为空。
  • 第四步：if(num == index)，符合条件，删除节点。循环就可以退出了，所以break;
  • 第五步：else：后移cur。
  • 最后改变head和delete dummy_node;
  • 检查1：举例index=0，进到if(num == index)，的确删除0号元素；
  • 检查2：index无效，如果小于0，没有删除操作。如果大于长度，while结束即可。没有需要释放的内存。
    所以，通过。

改进代码（在过程解释后又有些改进的地方）

两个地方：一、添加头元素；二、在下标index之前添加元素

class MyLinkedList {
private:
    ListNode* head = nullptr;
public:
    MyLinkedList() {
        ListNode* head  = nullptr;
    }
    
    int get(int index) {
        ListNode* cur = head;
        int num = 0;//计数

        while( cur != nullptr){
            if(num == index){
                return cur->val;
            }
            cur = cur->next;
            num++;
        }
        return -1;
    }
    
    void addAtHead(int val) {	//多余if判断
        // if(head == nullptr){
        //     head  = new ListNode(val);
        //     return;
        // }else{
            ListNode* node = new ListNode(val);
            node->next = head;
            head = node;
            return;
        //}
    }
    
    void addAtTail(int val) {
        ListNode* cur = head;
        if(cur == nullptr){
            ListNode* node = new ListNode(val);
            head = node;
            return;
        }
        while(cur != nullptr ){
            if(cur->next == nullptr){
                ListNode* node = new ListNode(val);
                cur->next = node;
                break;
            }else{
                cur = cur->next;
            }
            
        }
        
        
    }
    
    void addAtIndex(int index, int val) {
        ListNode *newnode = new ListNode(val);
        int num = 0;

        ListNode* dummy_node = new ListNode(0,head);
        ListNode* cur = dummy_node;
        while(cur!= nullptr ){
            if(num == index){
                newnode->next = cur->next;
                cur->next = newnode;
                break;
            }else{
                cur = cur->next;
                num++;
            }
        }
        if(num < index){		//这里增加一段if
            delete newnode;
        }
        head = dummy_node->next;
        delete dummy_node;

    }
    
    void deleteAtIndex(int index) {
        ListNode* dummy_node = new ListNode(0,head);
        ListNode* cur = dummy_node;
        int num = 0;

        while(cur != nullptr && cur->next != nullptr){
            if(num == index){
                ListNode* tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;
                break;
            }else{
                cur = cur->next;
                num++;
            }
        }
        head = dummy_node->next;
        delete dummy_node;
    }
};

/**
 * 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);
 */

代码随想录学习

学习内容

（1）虚拟头节点

我是在函数操作（5）（6）在index之前添加/删除元素才考虑到dummy_node，在函数方便使用；
参考教程：直接class MyLinkedList中定义一个dummy_node，所有函数都可以用dummy_node操作。

（2）index
我没有先判断index在不在范围，而是先操作链表，如果index不在范围，最后while结束即可；
参考教程：定义int _size;可以先判断index在不在范围，不在范围就直接return。不用多余浪费时间循环链表。

总结：参考的方法更加统一方便。

重新写一遍，用新思路

我在public中多加了 ListNode* head;创建对象后，可以获取到链表的head，但是dummy_node是隐藏的（在private中）。

//单链表
class MyLinkedList {
private:
    ListNode* dummy_node;
    int _size;//链表节点数量
    
public:
    //struct ListNode{
    //    int val;
    //    ListNode* next;
    //    ListNode():val(0),next(nullptr){}
    //    ListNode(int i):val(i),next(nullptr){}
    //    ListNode(int i,ListNode* next):val(i),next(next){}
    //};
    ListNode* head;//可以加一个头节点
    MyLinkedList() {    //空链表
        dummy_node = new ListNode();
        head = dummy_node->next;
        _size = 0;
    }
    
    int get(int index) {
        if(index < 0 || index >= _size){    //大于等于_size，index才合法。
            return -1;
        }
        ListNode* cur = dummy_node->next;
        while(index--){ //先判断，后--
            cur = cur->next;
        }
        return cur->val;
    }
    
    void addAtHead(int val) {
        ListNode* newnode = new ListNode(val);
        newnode->next = head;
        dummy_node->next = newnode;
        head = dummy_node->next;        //  更改head的位置，始终是dummy_node->next
        _size++;
    }
    
    void addAtTail(int val) {
        ListNode* newnode = new ListNode(val);
        ListNode* cur = dummy_node;
        while(cur->next != nullptr){
            cur = cur->next;
        }
        cur->next = newnode;
        _size++;
    }
    
    void addAtIndex(int index, int val) {
        if(index < 0 || index > _size){	//大于size，当等于size时，可以在尾部添加。
            return;
        }
        ListNode* newnode = new ListNode(val);
        ListNode* cur = dummy_node;
        int num = index;
        while(num--){
            cur=cur->next;
        }
        newnode->next = cur->next;
        cur->next = newnode;
        if(index == 0){ //head需要改变
            head = dummy_node->next;
        }
        _size++;
    }
    
    void deleteAtIndex(int index) {
        if(index < 0 || index >= _size){ //_size是数量，所以最后一个有效的下标是 _size-1
            return;
        }
        ListNode* cur = dummy_node;
        int num = index;	//因为要用index判断head有没有改变。所以给num
        while(num--){
            cur = cur->next;
        }
        ListNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        if(index==0){   //删除0号，所以head改变。
            head = dummy_node->next;
        }
        _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);
 */

总结

链表构建最好有一个虚拟头节点。

（欢迎指正，转载表明出处）

danaaaa
关注
  • 11
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Leetcode刷题笔记03】203.移除链表元素 707.设计链表 206. 反转链表.md
01-13
内容概要:本文包含三道LeetCode链表算法题的刷题笔记,分别是203.移除链表元素、707.设计链表和206.反转链表,记录了详细的题目解析思路以及Java语言的参考代码。 适合人群:学习算法和数据结构的程序员或学生,尤其是...
LeetCode刷题笔记——19. 删除链表的倒数第N个节点
12-21
  这道题本质上和《剑指Offer》刷题笔记——面试题22. 链表中倒数第k个节点是一样的。都可以用单指针两次遍历或者双指针一次遍历解决。 2、代码实现 # Definition for singly-linked list. # class ListNode: # ...
算法力扣刷题记录 十一【160.链表相交】
danaaaa的博客
06-23 376
找链表的交点
算法力扣刷题记录八【206.反转链表】
danaaaa的博客
06-22 384
力扣翻转链表、递归调用
算法力扣刷题记录 十二【142. 环形链表 II】
danaaaa的博客
06-23 230
链表环的确定。
算法力扣刷题记录十【19.删除链表的倒数第N个节点】
danaaaa的博客
06-23 958
力扣【19.删除链表的倒数第N个节点】
算法力扣刷题记录六【203移除链表元素】
danaaaa的博客
06-21 1156
删除链表节点
算法力扣刷题记录九【24. 两两交换链表中的节点】
danaaaa的博客
06-23 533
两两交换链表节点，指针操作练习
算法力扣刷题记录 十三【242. 有效的字母异位词】
danaaaa的博客
06-24 753
哈希介绍。哈希篇第一题
算法力扣刷题记录 十四【349. 两个数组的交集】及unordered_set用法
danaaaa的博客
06-25 1028
哈希结构unordered-set
算法力扣刷题 三十四【71.简化路径】
danaaaa的博客
07-06 564
简化路径，栈使用
【Leetcode刷题笔记04】24. 两两交换节点 19. 删除结点 07. 链表相交 142. 环形链表 II.md
01-13
内容概要:这篇笔记包含4道LeetCode典型链表算法题,分别是24.两两交换链表中的节点、19.删除链表的倒数第N个节点、面试题02.07.链表相交和142.环形链表II。记录了清晰的文字题解+图示以及Java参考代码。 适合人群:...
刷题纯享版.zip
11-24
【标题】"刷题纯享版.zip" 暗示这是一个包含编程或技术面试题目的压缩文件集合，可能用于帮助用户准备技术面试或自我提升编程技能。"纯享版"可能意味着这个版本专注于核心的题目内容，去除了广告或其他非必要元素，...
【代码随想录_Day27】509 斐波那契数 70 爬楼梯 746 使用最小花费爬楼梯
最新发布
qq_43671872的博客
07-08 718
509 斐波那契数70 爬楼梯746 使用最小花费爬楼梯今天的题目难度不低，尽量还是写一些简洁代码 ^ _ ^
算法力扣刷题 三十一【150. 逆波兰表达式求值】
danaaaa的博客
07-04 693
后缀表示法。
【力扣】数组中的第K个最大元素
m0_61876562的博客
07-05 289
l, left]（该部分小于基准元素key）、[left + 1, right - 1]（等于基准元素key）、[right, r]（大于基准元素key）。3、计算每部分所包含的元素个数，分别为a 、b = right - left - 1、 c = r - right + 1;请注意，你需要找的是数组排序后的第。你必须设计并实现时间复杂度为。个最大的元素，而不是第。1、随机选择基准元素。
每周算法：无向图的双连通分量
少儿编程乔老师
07-06 1229
通过Tarjan算法求无向连通图的双连通分量，计算至少添加多少条边可以将原图变为一个双连通分量。
数据结构实现单链表1.初始化 2.清空 3.求链表长度 4.遍历链表（设为输出元素） 5.从链表中查找与给定元素值相同的元素在表中的位置 6.向链表中插入指定的元素 7. 从链表中删除指定的元素 代码
05-22
以下是基于C语言实现的单链表代码： ```c #include <stdio.h> #include <stdlib.h> //定义链表节点 typedef struct Node { int data; struct Node* next; } Node; //初始化链表 Node* initList() { Node* head = (Node*)malloc(sizeof(Node)); head->next = NULL; return head; } //清空链表 void clearList(Node* head) { Node* p, * q; p = head->next; while (p) { q = p->next; free(p); p = q; } head->next = NULL; } //求链表长度 int getLength(Node* head) { int len = 0; Node* p = head->next; while (p) { len++; p = p->next; } return len; } //遍历链表 void traverseList(Node* head) { Node* p = head->next; while (p) { printf("%d ", p->data); p = p->next; } printf("\n"); } //查找元素位置 int findElement(Node* head, int value) { int pos = 0; Node* p = head->next; while (p) { pos++; if (p->data == value) { return pos; } p = p->next; } return -1; } //插入元素 void insertElement(Node* head, int value, int pos) { Node* p = head; Node* newNode = (Node*)malloc(sizeof(Node)); newNode->data = value; newNode->next = NULL; while (pos > 0 && p) { pos--; if (pos == 0) { newNode->next = p->next; p->next = newNode; } p = p->next; } } //删除元素 void deleteElement(Node* head, int value) { Node* p = head; Node* q; while (p->next) { if (p->next->data == value) { q = p->next; p->next = q->next; free(q); return; } p = p->next; } } int main() { Node* head = initList(); insertElement(head, 1, 1); insertElement(head, 2, 2); insertElement(head, 3, 3); insertElement(head, 4, 4); insertElement(head, 5, 5); printf("链表元素为："); traverseList(head); printf("链表长度为：%d\n", getLength(head)); int pos = findElement(head, 3); if (pos == -1) { printf("元素不存在！\n"); } else { printf("元素3在链表中的位置为：%d\n", pos); } deleteElement(head, 4); printf("删除元素4后，链表元素为："); traverseList(head); clearList(head); printf("清空链表后，链表元素为："); traverseList(head); return 0; } ``` 这里的代码实现了单链表的初始化、清空、求链表长度、遍历、查找、插入和删除操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值