_3LeetCode代码随想录算法训练营第三天-C++链表 | 203.移除链表元素 707.设计链表 206.反转链表

Jasmine-Lily

已于 2023-02-03 13:06:54 修改

阅读量173

点赞数 1

分类专栏： Algorithms 文章标签：算法 c++ 链表

于 2022-12-11 12:32:40 首次发布

本文链接：https://blog.csdn.net/weixin_44410704/article/details/128273609

版权

Algorithms 专栏收录该内容

54 篇文章 0 订阅

订阅专栏

_3LeetCode代码随想录算法训练营第三天-C++链表 | 203.移除链表元素 707.设计链表 206.反转链表

203.移除链表元素
707.设计链表
206.反转链表

链表理论基础

代码随想录地址：https://programmercarl.com/%E9%93%BE%E8%A1%A8%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80.html

203.移除链表元素

代码随想录地址：https://programmercarl.com/0203.%E7%A7%BB%E9%99%A4%E9%93%BE%E8%A1%A8%E5%85%83%E7%B4%A0.html

题目

给你一个链表的头节点 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
输出：[]

提示：

列表中的节点数目在范围 [0, $10^4$ ] 内
1 <= Node.val <= 50
0 <= val <= 50

代码原链表删除元素

此时对于头节点元素等于val的情况和对于其他节点元素等于val的情况处理方式不一样。

/*
 * @lc app=leetcode.cn id=203 lang=cpp
 *
 * [203] 移除链表元素
 */

// @lc code=start
/**
 * 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* temp;
        //当头节点的元素等于val时
        while(head != nullptr && head->val == val)//为什么使用while而不使用if,因为删除头节点之后，新的头节点元素也有可能等于val
        {
            temp = head;//存储头节点指针
            head = head->next;//删除头节点
            delete temp;//清除原头节点内存
        }
        //当头节点元素不等于val时
        ListNode* cur = head;
        while(cur != nullptr && cur->next != nullptr)//要求当前节点不为空并且当前节点指向的节点也不为空
        {
            if(cur->next->val == val)//如果元素等于val，则删除元素
            {
                temp = cur->next;//存储被删除节点指针
                cur->next = cur->next->next;//删除节点
                delete temp;//清空内存
            }
            else//否则，指向下一个元素
                cur = cur->next;        
        }
        return head;
    }
};
// @lc code=end

代码使用虚拟头节点

使用虚拟头节点，就可以使得处理方式比较统一。

/*
 * @lc app=leetcode.cn id=203 lang=cpp
 *
 * [203] 移除链表元素
 */

// @lc code=start
/**
 * 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* preHead = new ListNode(0, head);//设置一个虚拟头节点
        ListNode* temp;
        //对于不同节点采取统一的方式
        ListNode* cur = preHead;//从虚拟头节点开始
        while(cur != nullptr && cur->next != nullptr)//要求当前节点不为空并且当前节点指向的节点也不为空
        {
            if(cur->next->val == val)//如果元素等于val，则删除元素
            {
                temp = cur->next;//存储被删除节点指针
                cur->next = cur->next->next;//删除节点
                delete temp;//清空内存
            }
            else//否则，指向下一个元素
                cur = cur->next;        
        }
        return preHead->next;//返回的时候一定要返回虚拟头节点的下一个元素，因为虚拟头节点的下一个元素才指向头节点
    }
};
// @lc code=end

707.设计链表

代码随想录地址：https://programmercarl.com/0707.%E8%AE%BE%E8%AE%A1%E9%93%BE%E8%A1%A8.html

题目

设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。

在链表类中实现这些功能：

get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

示例：

MyLinkedList linkedList = new MyLinkedList();
linkedList.addAtHead(1);
linkedList.addAtTail(3);
linkedList.addAtIndex(1,2);   //链表变为1-> 2-> 3
linkedList.get(1);            //返回2
linkedList.deleteAtIndex(1);  //现在链表是1-> 3
linkedList.get(1);            //返回3

提示：

0 <= index, val <= 1000
请不要使用内置的 LinkedList 库。
get, addAtHead, addAtTail, addAtIndex 和 deleteAtIndex 的操作次数不超过 2000。

代码

元素下标从0开始。

/*
 * @lc app=leetcode.cn id=707 lang=cpp
 *
 * [707] 设计链表
 */

// @lc code=start
class MyLinkedList {
public:
    struct LinkNode
    {
        int val;
        LinkNode* next;
        LinkNode(int mval):val(mval),next(nullptr){}
    };
    //构造函数
    MyLinkedList() {
        preHead = new LinkNode(0);//这里定义的是虚拟头节点
        size = 0;
    }
    //成员函数
    int get(int index) {
        if(index > size - 1 || index < 0)//判断索引是否合法，如果不合法就返回-1
            return -1;
        LinkNode* cur = preHead->next;//目的是找到节点，而不是节点之前的节点，因此赋值为preHead->next
        while(index--)
        {
            cur = cur->next;
        }
        return cur->val;
    }
    
    void addAtHead(int val) {
        LinkNode* temp = preHead->next;//首先存住头节点的位置
        preHead->next = new LinkNode(val);
        preHead->next->next = temp;
        size++;
    }
    
    void addAtTail(int val) {
        LinkNode* cur = preHead;
        while(cur->next != nullptr)//找到尾节点
        {
            cur = cur->next;
        }
        cur->next = new LinkNode(val);
        size++;
    }
    //这个函数，我在写的时候分为了好几种情况，还利用了addAtHead()和addAtTail()函数
    //像这样写成统一的方式更好
    void addAtIndex(int index, int val) {
        if(index < 0)
            index = 0;//使得后面的处理方式统一
        LinkNode* cur = preHead;
        LinkNode* temp;
        if(index >= 0 && index <= size)
        {
            while(index--)
            {
                cur = cur->next;
            }
            temp = cur->next;
            cur->next = new LinkNode(val);
            cur->next->next = temp;
            size++;
        }
    }
    
    void deleteAtIndex(int index) {
        if(index >= 0 && index < size)
        {
            LinkNode* cur = preHead;//目的是找到要删除节点的前一个节点，因此赋值为preHead
            while(index--)
            {
                cur = cur->next;
            }
            LinkNode* temp = cur->next;
            cur->next = cur->next->next;
            delete temp;
            size--;
        }
    }
private:
    //成员变量
    LinkNode* preHead;
    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);
 */
// @lc code=end

206.反转链表

代码随想录地址：https://programmercarl.com/0206.%E7%BF%BB%E8%BD%AC%E9%93%BE%E8%A1%A8.html

题目

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

示例 1：

在这里插入图片描述

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

示例 2：

在这里插入图片描述

输入：head = [1,2]
输出：[2,1]

示例 3：

输入：head = []
输出：[]

提示：

链表中节点的数目范围是 [0, 5000]
-5000 <= Node.val <= 5000

**进阶：**链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？

代码

/*
 * @lc app=leetcode.cn id=206 lang=cpp
 *
 * [206] 反转链表
 */

// @lc code=start
/**
 * 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 = nullptr;
        ListNode* cur = head;
        ListNode* temp;
        while(cur != nullptr)//这里要注意一下，容易出错
        {
            temp = cur->next;//存储cur的下一个节点
            cur->next = pre;//将cur指向前一个节点
            pre = cur;//将pre赋值为cur
            cur = temp;            
        }
        return pre;
    }
};
// @lc code=end

Jasmine-Lily

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
_3LeetCode代码随想录算法训练营第三天-C++链表 | 203.移除链表元素 707.设计链表 206.反转链表

_3LeetCode代码随想录算法训练营第三天-C++链表 | 203.移除链表元素 707.设计链表 206.反转链表
复制链接

扫一扫