代码随想录算法训练营第3天|链表part01

于 2024-08-03 11:35:48 发布
阅读量571 收藏 14
点赞数 11
分类专栏： C++学习 文章标签： 算法 链表 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxjiaya/article/details/140868336
版权

今日任务

  • 链表理论基础
  • 203.移除链表元素
  • 707.设计链表
  • 206.反转链表

链表理论基础

建议：了解一下链表基础，以及链表和数组的区别

文章链接：代码随想录

struct ListNode {
    int val;  // 节点上存储的元素
    ListNode *next;  // 指向下一个节点的指针
    ListNode(int x) : val(x), next(NULL) {}  // 节点的构造函数
};

链表的定义还是比较简单的，定义一个结构体，一个val值，next指针，再加上一个构造函数。如果不定义构造函数使用默认构造函数的话，在初始化的时候就不能直接给变量赋值！也比较好理解，相当于重新写个构造函数。

学习了点.，at，this的区别

在C++中，->、this、和.都是用于访问对象的成员的运算符或方法。

  1. ->（箭头运算符）：

    • 用于指针指向的对象来访问其成员。
    • 当有一个指向对象的指针时，可以使用->来访问该对象的成员。
    • 例如，如果有一个指向myclass类型的指针ptr，可以使用ptr->myvar来访问myvar成员变量。

  2. this（指向当前对象的指针）：

    • 是一个隐式的参数，存在于非静态成员函数中，指向调用该成员函数的对象。
    • 它通常用于需要引用当前对象的情况，比如在成员函数内部传递当前对象的引用或指针给其他函数。
    • 例如，this->myvar在成员函数中访问myvar成员变量，与直接使用myvar是等效的。

  3. .（点运算符）：

    • 用于非指针的对象来访问其成员。
    • 当对象已经被实例化，不是通过指针访问时，可以使用.来访问该对象的成员。
    • 例如，如果有myclass类型的对象obj，可以使用obj.myvar来访问myvar成员变量。

  4. 总结来说，this是一个指针，通常在成员函数内部使用，而->和.是访问成员的运算符，其中->用于指针，.用于非指针对象。

203.移除链表元素

建议： 本题最关键是要理解 虚拟头结点的使用技巧，这个对链表题目很重要。

题目链接/文章讲解/视频讲解：：代码随想录

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

    }
};

还是要注意开始删除头节点的时候要用while循环而不是if，我一开始也被绕进去了，仔细想想就知道保证第一个结点给删了，万一第二个也要删怎么办，就会漏掉呢。

第一种方法，就是对头节点进行特殊处理。还是比较简单的，就是发现节点值要删掉，就把前面节点指向后一个结点，然后释放当前结点。我这里用的是tmp1，临时结点，发现这种命名方式还是不太好，超过，两个temp临时变量，就还是用具体含义命名，否则确实容易绕脑子。

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

    }
};

我又想到一个问题，完全可以先把头节点后面的元素进行移除，最后再判断头节点。感觉可行，不知道有没有问题。

707.设计链表 

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

    };
    MyLinkedList() {
        dummpyHead=new LinkedNode(0);
        size=0;
    }
    
    int get(int index) {
    if (index >= size || index < 0)
        return -1;

    LinkedNode* cur = dummpyHead->next;

    // Check if cur is null before accessing its members
    if (cur == nullptr)
        return -1;

    while (index--) {
        cur = cur->next;
        // Check if cur is null during traversal
        if (cur == nullptr)
            return -1;
    }

    return cur->val;
}
    
    void addAtHead(int val) {
        LinkedNode* insert=new LinkedNode(val);
        insert->next=dummpyHead->next;
        dummpyHead->next=insert;
        size++;
      

    }
    
    void addAtTail(int val) {
        LinkedNode* insert=new LinkedNode(val);
        LinkedNode* cur=dummpyHead;

        while(cur->next!=nullptr)
        cur=cur->next;
        
        cur->next=insert;
        size++;
    }
    
    void addAtIndex(int index, int val) {
        if(index>size||index<0)
        return;
        
        LinkedNode* insert=new LinkedNode(val);
        LinkedNode* cur=dummpyHead;

        while(index--)
        cur=cur->next;
        insert->next=cur->next;
        cur->next=insert;
        size++;
    }
    
    void deleteAtIndex(int index) {
        if(index>=size||index<0)
        return ;
        LinkedNode* cur=dummpyHead;
        while(index--)
        {
            cur=cur->next;
        }
        LinkedNode* tmp=cur->next;
        cur->next=cur->next->next;
        delete tmp;
        size--;
        

    }
    private :
    int size;
    LinkedNode* dummpyHead;
};

/**
 * 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结构体，总是忘掉最后大括号后面加个;另外插入和删除操作，忘了可以插在最后面，确实也可以>size。还有delete以后别忘了size--；一些小的错误，很容易被忽视掉，然后浪费时间去查找。

206.反转链表

建议先看视频讲解，视频讲解中对 反转链表需要注意的点讲的很清晰了，看完之后大家的疑惑基本都解决了。

/**
 * 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* temp; // 保存cur的下一个节点
        ListNode* cur = head;
        ListNode* pre = NULL;
        while(cur!=NULL)
        {
            temp=cur->next;
            cur->next=pre;
            pre=cur;
            cur=temp;
            }
  return pre;

    }
};

稍微有点绕，但是其本质就是用两只手抓住两端，先修理左手的，修理完左手的。把右手的给左手，抓住一个。继续修理左手的，直到修理完，就彻底完了，就是把当前的结点，然后再往下移动，不过我在想，他不考虑最后加个虚结点吗？

最后可以加上这两句

 dummy->next = pre; // 将虚拟节点指向反转后的头节点

        return dummy->next; // 返回虚拟节点的下一个节点，即反转后的头节点

这才理解，根本没有虚结点，所以也不要考虑。

/**
 * 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* pre,ListNode* cur) {
       if(cur==nullptr)return pre;
        ListNode* temp = cur->next;
            cur->next=pre;
            return reverse(cur,temp);
            }
    ListNode* reverseList(ListNode* head) {
           
  return reverse(nullptr,head);
    }
};

所谓的递归方法，递归函数本身定义为reverse(ListNode* pre,ListNode* cur)，本质上就是把pre=cur;   cur=temp;替换变成  return reverse(cur,temp);稍微绕一点，但并不算难。

题目链接/文章讲解/视频讲解：代码随想录

tt555555555555
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值