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

Rhys_Luo

已于 2025-03-30 01:17:37 修改

阅读量515

点赞数 10

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

于 2025-03-30 01:16:56 首次发布

本文链接：https://blog.youkuaiyun.com/2301_80170790/article/details/146719030

版权

算法 C++ 专栏收录该内容

12 篇文章

订阅专栏

链表理论基础

类型

单链表：

链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成：数据域(记录当前节点的数据)和指针域(记录下一个节点的指针位置，最后一个节点指针域是null，称为空指针)。

双链表：

双指针：每一个节点有两个指针域，一个指向前一个节点，一个指向后一个指针；可以向前查询也可以向后查询。

循环链表：

链表首尾相连，可以解决约瑟夫环问题
存储方式

数组地址是连续分布的，但是链表不是。链表通过指针连接在内存中的各个节点(节点散乱分布在内存中的某地址上)
定义
```
struct ListNode{
    int val; //数据域
    ListNode *next; //指向下一个节点的指针
    ListNode(int x):val(x) next(NULL){}//节点的构造函数
};
```
注意：C++默认生成节点的构造函数，所以代码中可以不构造，但自己不构造的话，初始化的时候不能直接给变量赋值。

如果用上面的自定义构造函数初始化节点：
```
ListNode* head = new ListNode(5);
```
使用默认构造函数初始化节点：
```
ListNode* head = new ListNode();
head->val = 5;
```
操作

删除节点：

如有A,B,C三个节点，删除B，只需要将A的next指针指向C就可以，然后手动释放B节点内存；

添加节点：
```
// 正确顺序：
newNode->next = current->next;
current->next = newNode;
```
5.例题：

（1）203.移除链表元素

给定一个链表的头节点 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, 104] 内
1 <= Node.val <= 50
0 <= val <= 50

解释：

考察删除节点，先验证头节点是否需要删除，再进行删除节点操作，比较简单。

代码：

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

（2）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);
myLinkedList.addAtTail(3);
myLinkedList.addAtIndex(1, 2);    // 链表变为 1->2->3
myLinkedList.get(1);              // 返回 2
myLinkedList.deleteAtIndex(1);    // 现在，链表变为 1->3
myLinkedList.get(1);              // 返回 3

提示：

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

代码：

class MyLinkedList {
private:
    // 定义链表节点结构体
    struct LinkedNode {
        int val;
        LinkedNode* next;
    };
    int _size;
    LinkedNode* head;
public:
    //初始化链表
    MyLinkedList() {
        head = new LinkedNode();// 这里定义的头结点 是一个虚拟头结点，而不是真正的链表头结点
        head->val=0;
        _size = 0; 
    }
    //获取链表中下标为index的节点的值
    int get(int index) {
        if (index > (_size - 1) || index < 0) {
            return -1;
        }
        LinkedNode* cur = head->next;
        while(index--)
        {
            cur=cur->next;
        }
        return cur->val;
    }
    
    void addAtHead(int val) {
        if(val < 0 || val > 1000) return;
        LinkedNode* p=new LinkedNode();
        p->val = val;
        p->next=head->next;//将p的指针域指向未修改的第一个实际节点
        head->next=p;//令p成为链表的实际节点
        _size++;
    }
    
    void addAtTail(int val) {
        if(val < 0 || val > 1000) return;
        LinkedNode* tail=new LinkedNode();
        tail->val=val; 
        LinkedNode* p=head;
        while(p->next)
        {
            p=p->next;   
        }
        p->next = tail;
        _size++;
    }
    
    void addAtIndex(int index, int val) {
        if(val<0 || val>1000 ||index > _size) return;
        if(index <= 0) addAtHead(val);
        else if(index==_size)
        {
            addAtTail(val);
        }
        else
        {
            LinkedNode* newNode=new LinkedNode();
            newNode->val = val;
            LinkedNode* p=head;
            while(index--)
            {
                p=p->next;
            }
            newNode->next=p->next;
            p->next=newNode;
            _size++;
        }
    }
    
    void deleteAtIndex(int index) {
            if(index < 0 || index > _size-1) return;
            LinkedNode* tmp=nullptr;
            LinkedNode* p=head;
            while(index--) p=p->next;
            tmp = p->next;
            p->next = tmp->next;
            delete tmp;
            //delete命令指示释放了tmp指针原本所指的那部分内存，
            //被delete后的指针tmp的值（地址）并非就是NULL，而是随机值。也就是被delete后，
            //如果不再加上一句tmp=nullptr,tmp会成为乱指的野指针
            //如果之后的程序不小心使用了tmp，会指向难以预想的内存空间
            tmp=nullptr;
            _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);
 */

（3）206.反转链表

给你单链表的头节点 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

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

代码：

/**
 * 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* cur=head;
        ListNode* pre=nullptr;
        while(cur)
        {
            ListNode* tmp=cur->next;
            cur->next=pre;
            pre=cur;
            cur=tmp;
        }
        return pre;
    }
};