代码随想录算法训练营第3天 | 链表理论基础+203.移除链表元素， 707.设计链表，206.反转链表

今日任务
链表理论基础，文章链接：https://programmercarl.com/
● 203.移除链表元素
● 707.设计链表
● 206.反转链表
状态：1刷

---

前言

C/C++的定义链表节点方式，如下所示：
注：节点的构造函数，不定义构造函数使用默认构造函数的话，在初始化的时候就不能直接给变量赋值！
};

// 单链表
struct ListNode {
    int val;  // 节点上存储的元素
    ListNode *next;  // 指向下一个节点的指针
    ListNode(int x) : val(x), next(NULL) {}  // 节点的构造函数，不定义构造函数使用默认构造函数的话，在初始化的时候就不能直接给变量赋值！
};

---

一、203.移除链表元素

题意：删除链表中等于给定值 val 的所有节点。
思路：可以设置一个虚拟头结点，这样原链表的所有节点就都可以按照统一的方式进行移除了
ListNode dummyHead = new ListNode(0);*
代码：

/**
 * 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) {}
 * };
 */
 // solution2 :dummy 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){// NULL 要大写，遍历链表
            if (cur->next->val == val){
                ListNode* tmp = cur->next;// delete cur->next
                cur->next = cur->next->next;
                delete tmp;// delete cur->next
            }else{
                cur = cur->next;// 下一个
            }
        }
        head = dummyHead->next;// delete dummyHead，这才是是新的头结点，容易忘
        delete dummyHead;
        return head;
    }
};

二、707.设计链表

在链表类中实现这些功能：
get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。
思路：设置一个虚拟头结点，进行操作。
代码如下（示例）：

class MyLinkedList {
public:
// 定义链表节点结构体
    struct LinkedNode{
        int val;
        LinkedNode* next;
        LinkedNode(int val): val(val), next(nullptr){}// 节点的构造函数
    };
    // 初始化链表
    MyLinkedList() {
        _dummyHead = new LinkedNode(0);
        _size = 0;
    }
    // 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1;注意index是从0开始的，第0个节点就是头结点
    int get(int index) {
        if (index > _size - 1 || index < 0){
            return -1;
        }
        LinkedNode* cur = _dummyHead->next;
        while(index--){
            cur = cur->next;
        }
        return cur->val;
    }
    // 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
    void addAtHead(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        newNode->next = _dummyHead->next;
        _dummyHead->next= newNode;
        _size++;
    }
    // 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
    void addAtTail(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(cur->next != nullptr){
            cur = cur->next;
        }
        cur->next = newNode;
        _size++;
    }
    // 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。
    // 如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。
    // 如果 index 比长度更大，该节点将不会插入到链表中。
    void addAtIndex(int index, int val) {
        if (index > _size) return;
        if (index < 0) index = 0;
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(index--){
            cur = cur->next;
        }
        newNode->next = cur->next;
        cur->next = newNode;
        _size++;
    }
    // 删除第index个节点，如果index 大于等于链表的长度，直接return
    // 注意index是从0开始的,如果下标有效，则删除链表中下标为 index 的节点
    void deleteAtIndex(int index) {
        if (index >= _size || index < 0) return;//注意等号
        LinkedNode* cur = _dummyHead;
        while (index--){
            cur = cur->next;
        }
        LinkedNode* tmp =  cur->next;
        cur->next = cur->next->next;
        delete tmp;
        //delete命令指示释放了tmp指针原本所指的那部分内存，
        //被delete后的指针tmp的值（地址）并非就是NULL，而是随机值。也就是被delete后，
        //如果不再加上一句tmp=nullptr,tmp会成为乱指的野指针
        //如果之后的程序不小心使用了tmp，会指向难以预想的内存空间
        //tmp = nullptr;
        _size--;
    }
    // 打印链表
    void printLinkedList() {
        LinkedNode* cur = _dummyHead;
        while (cur->next != nullptr) {
            cout << cur->next->val << " ";
            cur = cur->next;
        }
        cout << endl;
    }
    private:
    int _size;
    LinkedNode* _dummyHead;
};

注：在C++中，nullptr是一个空指针常量。它是C++11标准引入的，用于明确表示一个空指针。在此之前，程序员通常使用NULL或者0来表示空指针。
1.使用nullptr有以下优点：

明确性：nullptr明确表示空指针的概念，避免了与整数值混淆的可能性。它可以提高代码的可读性和可维护性。

类型安全性：nullptr是一个特殊的空指针类型，它没有与整数类型的空指针混淆。这样可以在编译时捕捉到一些错误，例如将空指针赋给非指针类型的变量。

模板推断：nullptr在模板函数中使用时，可以帮助编译器正确地推断函数模板的参数类型。
在上述代码中，private关键字用于声明类的私有成员。私有成员只能在类的内部访问，对外部不可见。

2.Private:
在这种情况下，_dummyHead和_size是类的内部数据成员，用于维护链表的状态。将它们声明为私有成员可以隐藏这些实现细节，防止外部代码直接访问和修改它们。这符合面向对象编程的封装原则，可以提高代码的安全性和可维护性。

通常情况下，类的接口应该由公共成员函数来定义，而不是直接暴露内部的数据成员。这样可以封装类的实现细节，并提供对外的操作接口，以便其他代码可以通过这些接口来使用和操作类的对象。

因此，私有成员的作用是限制对类内部的细节访问，强调类的封装性和隐藏实现细节。

---

三、206.反转链表

题意：反转一个单链表。

示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL
思路：只需要改变链表的next指针的指向，直接将链表反转 ，而不用重新定义一个新的链表
代码示例：

// 双指针法
// 时间复杂度: O(n)
// 空间复杂度: O(1)
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* cur = head;
        ListNode* temp;// temp = cur->next
        ListNode* pre = NULL;// 大写 NULL
        while(cur){
            temp = cur->next;// 保存cur的下一个节点，next要反转了
            cur->next = pre;// 翻转
            pre = cur;// 更新pre, cur
            cur = temp;
        }
    return pre;
    }
};

总结

注意虚拟头节点的用法