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

最新推荐文章于 2024-11-06 10:46:33 发布

EAFQUAKE

最新推荐文章于 2024-11-06 10:46:33 发布

阅读量1.7k

点赞数 1

分类专栏：力扣刷题文章标签：算法链表 java

本文链接：https://blog.csdn.net/weixin_73775782/article/details/132233381

版权

力扣刷题专栏收录该内容

9 篇文章 0 订阅

订阅专栏

在做今天的题目之前，我们需要了解关于链表章节的有关知识

有关链表的基础知识：

引入

链表是一种存储数据的数据结构，由于链表是通过指针连接的，一个节点由一个数据域和一个指针域构成，指针域用来存放下一个节点的指针（即起到了连接下一个节点的作用），头结点一般被命名为head，尾结点指向NULL（空指针）。

链表的特征是插入和删除数据操作十分方便，又由于其数据的存放的地址不是连续的，所以，对于它的数据查询、读取能力较差。

链表的类型

单链表

一个节点由一个数据域和一个指针域构成，指针域用来存放下一个节点的指针（即起到了连接下一个节点的作用）（引入部分讲解的就是单链表）

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

不写构造节点的函数也可以，但是这个构造函数不会初始化任何成员变量

双链表

双向链表中同样有数据域和指针域。不同之处在于，指针域有左右（或上一个、下一个）之分，用来连接上一个结点、当前结点、下一个结点。

struct ListNode {
  int val;
  ListNode *left;
  ListNode *right;
  ListNode(int x) : val(x) , left(NULL) ,right(NULL){ }
};

循环链表

循环链表，顾名思义，就是链表首尾相连。

循环链表可以用来解决约瑟夫环问题。

链表的定义

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

可以使用节点的构造函数，也可以不使用，不定义构造函数，C++默认生成一个构造函数

Listlode(int x) : val(x)， next (NULL) 是一构造函的定义，它属于构体 ListNode在 C++ 中，结构体可以拥有自己的构造函数。
这个构造函数的作用是创建 ListNode 对象时进行初始化。它接受一个整数参数，并使用参数对成员变量 val 进行初始化。同时，它将成员变量 next初始化为 NULL.
换句话说，当你创建一个ListNode 对象时，可以通过调用这构造函数，并传入一个整数值来初始化 val 成员变量，并将 next 成员变量设置为 NULL，这样你就可以方便地创建一个已经初始化好的 ListNode 对象。

通过自己定义构造函数初始化节点函数，可以直接在初始化的适合对变量赋值：

ListNode* head = new ListNode(5);

而使用默认构造就不行，需要手动多写一步来初始化节点

ListNode* head = new ListNode();
head->val = 5;

总之如果不定义构造函数使用默认构造函数的话，在初始化的时候就不能直接给变量赋值！

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) {
        ListNode* fake_head=new ListNode(0);
        fake_head->next=head;
        //以上  设置虚拟头结点
        ListNode* cur=fake_head;
        while(cur->next!=NULL){
            if(cur->next->val==val){
                ListNode* tmp=cur->next;
                cur->next=cur->next->next;
                delete tmp;
            }else{
                cur=cur->next;
            }
        }
        head=fake_head->next;
        delete fake_head;
        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) {
        //删除头结点
        while(head!=NULL&&head->val==val){
            ListNode* tmp=head;
            head=head->next;
            delete tmp;
        }
        //删除非头结点
        ListNode* cur=head;
        while(cur!=NULL&&cur->next!=NULL){
            if(cur->next->val==val){
                ListNode* tmp=cur->next;
                cur->next=cur->next->next;
                delete tmp;
            }else{
                cur=cur->next;
            }
            
        }
        return head;
    }
};

707. 设计链表

这道题目主要是考查对链表操作的熟练度，如果这道题能熟练掌握的话，关于链表的基本操作就没问题了

具体代码如下：

class MyLinkedList {
public:
    // 定义链表节点结构体
    struct LinkedNode {
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val), next(nullptr){}
    };

    // 初始化链表
    MyLinkedList() {
        _dummyHead = new LinkedNode(0); // 这里定义的头结点 是一个虚拟头结点，而不是真正的链表头结点
        _size = 0;
    }

    // 获取到第index个节点数值，如果index是非法数值直接返回-1， 注意index是从0开始的，第0个节点就是头结点
    int get(int index) {
        if (index > (_size - 1) || index < 0) {
            return -1;
        }
        LinkedNode* cur = _dummyHead->next;
        while(index--){ // 如果--index 就会陷入死循环
            cur = cur->next;
        }
        return cur->val;
    }

    // 在链表最前面插入一个节点，插入完成后，新插入的节点为链表的新的头结点
    void addAtHead(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        newNode->next = _dummyHead->next;
        _dummyHead->next = newNode;
        _size++;
    }

    // 在链表最后面添加一个节点
    void addAtTail(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(cur->next != nullptr){
            cur = cur->next;
        }
        cur->next = newNode;
        _size++;
    }

    // 在第index个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
    // 如果index 等于链表的长度，则说明是新插入的节点为链表的尾结点
    // 如果index大于链表的长度，则返回空
    // 如果index小于0，则在头部插入节点
    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开始的
    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;

};

206. 反转链表

设置一个空节点pre 反转后头结点的指向pre

设置一个cur指向head

设置一个tmp用于存放即将断裂的链表节点

具体代码如下：

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