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

无为码匠

已于 2024-02-24 19:00:18 修改

阅读量894

点赞数 12

分类专栏：算法刷题文章标签：算法链表数据结构 c++

于 2024-02-23 19:51:09 首次发布

本文链接：https://blog.csdn.net/weixin_69675605/article/details/136257799

版权

算法刷题专栏收录该内容

29 篇文章 0 订阅

订阅专栏

这里先补充一点，因为LeetCode的刷题机制，链表的节点都默认定义好了，直接用就行了，所以我们都没有注意到链表的节点是如何定义的。
而在面试的时候，一旦要自己手写链表，就容易写的错漏百出。
这里我给出C/C++的定义链表节点方式，如下所示：

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

当然，你在LeetCode刷题的时候，代码上面的注释也会有对于链表的定义：

/**
 * 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) {}
 * };
 */

203.移除链表元素

链接: 移除链表元素

思路

题目要求删除链表中所有满足 Node.val == val 的节点，并返回新的头结点。这可以通过遍历链表并删除满足条件的节点来实现。

思路一：直接遍历链表来删除头结点，但需要注意，如果要删除的结点包括头结点，那么需要而外的代码对头结点进行处理，可能会导致链表结构被破坏，尤其是当需要删除头节点时。
思路二：我们引入一个虚拟头结点来处理头结点，进而降低代码的可读性。

解题方法

创建虚拟头结点：首先，我们创建一个虚拟头结点，并将其 next 指针指向原始的头结点。虚拟头结点的作用是简化头结点的处理，因为我们可以从虚拟头结点开始遍历，而不需要单独处理头结点。
遍历链表：从虚拟头结点开始遍历链表。对于每个节点，我们检查其 val 是否等于给定的 val。
删除节点：如果当前节点的 val 等于 val，则删除该节点。具体做法是，将当前节点的 next 指针指向其下一个节点的下一个节点，然后释放被删除节点的内存(因为本人使用的是C++来进行编程，C++没有内存回收机制，需要手动删除)。
继续遍历：如果当前节点的 val 不等于 val，则继续遍历下一个节点。
返回新头结点：遍历结束后，我们更新头结点为虚拟头结点的 next 指针，并释放虚拟头结点的内存。

复杂度

两种方法的时空复杂度一样

时间复杂度：O(n)
空间复杂度：O(1)

Code

不使用虚拟头结点直接使用原来链表：

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        //删除头结点
        while (head != nullptr && head->val == val) { // 注意这里不是if
            ListNode* temp = head;
            head = head->next;
            delete temp;
        }

        //删除非头结点
        ListNode* cur = head;
        while(cur != nullptr && cur->next != nullptr) {
            if (cur->next->val == val) {
                ListNode* temp = cur->next;
                cur->next = cur->next->next;
                delete temp;
            } else {
                cur = cur->next;
            }
        }
        return head;
    }
};

这里需要注意，使用 while 循环而不是 if 语句的原因是为了处理一种特殊情况：当链表中有多个连续节点的值都等于给定的 val 时。
如果只使用 if 语句，代码只会检查头结点的值是否等于 val，并且只在这种情况下删除头结点。如果链表中紧接着有多个节点的值都是 val，那么这些节点将不会被删除，因为它们不会被 if 语句检查到。

使用 while 循环则可以确保在头结点的值等于 val 的情况下，持续删除头结点，直到遇到一个值不等于 val 的节点或者链表为空（即 head == nullptr）为止。这样，所有值等于 val 的连续节点都会被删除。

使用虚拟头结点：

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        //虚拟头结点
        ListNode* dummyHead = new ListNode(-1);
        dummyHead->next = head;
        ListNode* cur = dummyHead;
        while (cur->next != nullptr) {
            if (cur->next->val == val) {
                ListNode* temp = cur->next;
                cur->next = cur->next->next;
                delete temp;
            } else {
                cur = cur->next;
            }
        }
        head = dummyHead->next;
        delete dummyHead;
        return head;
    }
};

707设计链表

链接: 设计链表
LeetCode的链表操作注释：

/**
 * 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);
 */

思路

本题要求实现单链表或双向链表，我们只实现单向链表，即每个节点仅存储本身的值和后继节点。除此之外，我们还需要一个虚拟头结点，size 参数保存有效节点数。
虚拟头结点是一个常用的技巧，它使得在链表的开始和结束处添加或删除节点变得更加简单和一致。例如，当你需要在链表的前面添加节点时，你只需要更改虚拟头结点的next指针，而不需要检查链表是否为空。同样，当你想在链表的末尾添加节点时，你只需要遍历到最后一个节点（即虚拟头结点的前一个节点），然后更改其next指针。

解题方法

这道题目设计链表的五个接口：

获取链表第index个节点的数值
在链表的最前面插入一个节点
在链表的最后面插入一个节点
在链表第index个节点前面插入一个节点
删除链表的第index个节点

链表操作的两种方式：

直接使用原来的链表来进行操作。
设置一个虚拟头结点在进行操作。
本题我们使用虚拟头结点的技巧来实现，细节的问题我在代码的注释上解释。

复杂度

时间复杂度：涉及 index 的相关操作为 O(index), 其余为 O(1)
空间复杂度：O(n)
所有函数的单次调用空间复杂度均为 O(1)，总体空间复杂度为 O(n)，其中 n 为 addAtHead，addAtTail 和 addAtIndex 调用次数之和。

Code

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

    //成员变量
    int size;
    LinkedNode* dummyHead;

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

    // 获取到第index个节点数值，
    // 如果index是非法数值直接返回-1， 注意index是从0开始的，第0个节点就是头结点
    int get(int index) {
        //对index进行合法判断
        if (index > size - 1 || index < 0) {
            return -1;
        }
        //定义一个临时cur指针来遍历链表而不是直接操作头指针：原因是操作完链表后我们要返回头结点
        //如果一上来就操作头结点，那头结点的值都改了，如何返回链表的头结点
        LinkedNode* cur = dummyHead->next; // 让cur指向头结点
        // cur的定义与while循环一脉相承
        // cur的赋值和while循环里面如何操作，想清楚一个极端情况即可
        //如果链表里让你返回第0个，即头结点的数值
        //看有没有出现类似空指针异常，遍历的是不是第0个结点的情况
        //发现没有边界上的问题，那你的写法就是可以的
        //如果index = 0，while循环就不执行了，直接return cur->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);
        // 一定得保证第index个结点是cur->next而不是cur
        // 我们才能用cur操作在cur->next之前添加一个结点
        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* temp = cur->next;
        cur->next = cur->next->next;
        delete temp;
        //如果不再加上一句tmp=nullptr,tmp会成为乱指的野指针
        //如果之后的程序不小心使用了tmp，会指向难以预想的内存空间
        temp = nullptr;
        size--;
    }
};

注：
在index前插入一个结点时，一定得保证第index个结点是cur->next而不是cur，这样我们才能用cur操作在cur->next之前添加一个结点，不会乱。
补充一个打印链表函数：

 // 打印链表
    void printLinkedList() {
        LinkedNode* cur = dummyHead;
        while (cur->next != nullptr) {
            cout << cur->next->val << " ";
            cur = cur->next;
        }
        cout << endl;
    }

206.反转链表

链接: 反转链表

思路

我们第一个思路是定义一个新的链表，遍历原链表，将链表的最后一个赋给新链表的第一个元素，以此类推。但如果再定义一个新的链表，实现链表元素的反转，其实这是对内存空间的浪费。

我们其实只需要改变链表的next指针的指向，直接将链表反转，而不用重新定义一个新的链表

解题方法

双指针

初始化：

定义三个指针：temp、cur和pre。
temp用于保存cur的下一个节点。
cur初始化为头节点head，表示当前处理的节点。
pre初始化为NULL，表示当前节点的前一个节点，初始时链表没有反转，所以pre为NULL。

遍历链表：

使用while循环遍历链表，直到cur为NULL，表示到达链表末尾。

反转操作：

在循环内部，首先保存cur的下一个节点到temp，因为接下来要修改cur->next。
然后将cur->next指向pre，完成翻转操作。

更新指针：

更新pre和cur指针，将pre指向cur，cur指向temp，准备处理下一个节点。

返回结果：

当cur为nullptr时，遍历结束，此时pre指向反转后的链表的头节点，返回pre。

这个解题思路基于迭代的方法，通过不断修改节点的next指针来实现链表的反转。需要注意的是，在反转过程中要保存当前节点的下一个节点，因为修改next指针后，原来的下一个节点将不再可访问。

递归
递归法相对抽象一些，但是其实和双指针法是一样的逻辑，同样是当cur为空的时候循环结束，不断将cur指向pre的过程。

关键是初始化的地方，可以看到双指针法中初始化 cur = head，pre = nullptr，在递归法中可以从如下代码看出初始化的逻辑也是一样的，只不过写法变了。

复杂度

双指针法

时间复杂度：O(n)
空间复杂度：O(1)

递归法

时间复杂度：O(n),要递归处理链表的每个节点
空间复杂度：O(n),递归调用了 n 层栈空间

Code

双指针

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* temp; // 保存cur的下一个结点
        ListNode* cur = head;
        ListNode* pre = nullptr;
        while(cur) {
            temp = cur->next;// 保存一下 cur的下一个节点，因为接下来要改变cur->next
            cur->next = pre; // 反转操作
            // 更新pre 和 cur 指针
            pre = cur;
            cur = temp;
        }
        return pre;
    }
};

递归

从前往后翻转指针指向

和双指针法实质上都是从前往后翻转指针指向

class Solution {
public:
    ListNode* reverse(ListNode* pre,ListNode* cur){
        if(cur == nullptr) return pre;
        ListNode* temp = cur->next;
        cur->next = pre;
        // 可以和双指针法的代码进行对比，如下递归的写法，其实就是做了这两步
        // pre = cur;
        // cur = temp;
        return reverse(cur,temp);
    }
    ListNode* reverseList(ListNode* head) {
        // 和双指针法初始化是一样的逻辑
        // ListNode* cur = head;
        // ListNode* pre = nullptr;
        return reverse(NULL, head);
    }

};

从后往前翻转指针指向

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        // 边缘条件判断
        if(head == nullptr) return nullptr;
        if (head->next == nullptr) return head;
        
        // 递归调用，翻转第二个节点开始往后的链表
        ListNode *last = reverseList(head->next);
        // 翻转头节点与第二个节点的指向
        head->next->next = head;
        // 此时的 head 节点为尾节点，next 需要指向 nullptr
        head->next = nullptr;
        return last;
    }
};