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

NewCoderHeu

已于 2023-10-16 19:15:02 修改

阅读量206

点赞数

文章标签：链表数据结构 c++

于 2023-10-13 14:59:13 首次发布

本文链接：https://blog.csdn.net/heuddd/article/details/133804827

版权

理解链表的定义, 其实链表就是一种地址不连续的数组, 为了访问下一个节点, 在链表中定义了指针, 指向下一个节点的地址, 这样我们就可以读取到节点中的值.

为了找到这个链表的位置, 我们必须定义一个头节点来指向第一个节点中的元素, 最后一个节点的指针指向的是NULL.

203.移除链表元素

题意：删除链表中等于给定值 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 输出：[]

题目链接/文章讲解/视频讲解：：代码随想录

思路:

删除链表中的值, 必须知道链表中节点的删除依赖这一个节点的前一个节点和后一个节点, 我们的删除就是让这个节点的前一个节点直接指向后一个节点, 这样要删除的节点就独立出去了, 即被删除. 在C++中还需要释放这个节点的内存, 思路很简单, 难点主要是刚接触链表的结构, 如何用标准的格式来完成自己的想法.

从Carl那里, 学到一个特别好的方法: 虚拟头结点方法.

定义了虚拟头节点之后, 我们就不用再担心当 head 节点与目标元素相等时改变 head 指针的位置造成的麻烦, 能够将链表的遍历变得规范和简单.

链表的节点结构:

struct ListNode {
     int val;        // 节点的值
     ListNode *next; // 指针指向下一个节点
     ListNode() : val(0), next(nullptr) {}  // 定义一个初始化为0, 下一个节点为空的链表
     ListNode(int x) : val(x), next(nullptr) {} 
     // 定义一个初始化为 x, 下一个节点为空的链表
     ListNode(int x, ListNode *next) : val(x), next(next) {}
     // 定义一个初始化为 x, 下一个节点指向next的链表
  };

最终代码如下:

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode *dummyhead = new ListNode(0);
        dummyhead->next = head; // 定义一个虚拟头节点指向原链表的头节点
        //目的是为了方便修改头节点的值等于val的情况

        ListNode *cur = dummyhead; //从头指针开始遍历

        while(cur->next != NULL){
            if (cur->next->val == val){
                ListNode *temp = cur->next;
                cur->next = cur->next->next;// 删除该节点
                delete temp;
            }
            else{
                cur = cur->next;
            }
        }
        dummyhead = dummyhead->next;
        return dummyhead;
    }
};

几个重要知识点:

定义一个虚拟头指针相当于定义一个链表(增加删除节点):
 ListNode *dummyhead = new ListNode(0);
一个节点的指针指向另一个节点:
node1->next = node2;
定义一个遍历指针:
ListNode* cur = dummyhead;
定义一个临时指针, 将要删除的节点释放空间:
ListNode *temp = cur->next; 
cur->next = cur->next->next;// 删除该节点
delete temp;
temp = nullprt;

707.设计链表

建议：这是一道考察链表综合操作的题目，不算容易，可以练一练使用虚拟头结点

题目链接/文章讲解/视频讲解：代码随想录

实现 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 的节点。

内容都是实现链表的操作，看着基础，但是如果开始解答则需要考虑很多东西，今天花费了大量的时间在这道题上... 感觉效果非常不好，这道题还是得多AC几次才行.

最终代码:(这里直接把Carl哥的源码粘过来了, 自己写的实在太丑陋了.)

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;

};

知识点总结:

1. 定义类MyLinkedList

class MyLinkedList{
    public:
        struct LinkedNode{
            int val;             // 值
            LinkedNode *next;    // 指针
            MyLinkedList(int val) : val(val), next(nullprt){}  // 重载MyLinkedList(int val)
        }; //定义一个结构体节点

        int method(){}// 函数定义

    private:
        // 变量名前 _ 符号约定这是一个私有变量

        int _size;              // 链表长度
        LinkedNode *_dummyhead; // 定义一个虚拟头结点
}

遍历一个链表和通过一个索引找到对应节点的值的方法:

int get(int index) {
        if (index < 0 || index > (_size - 1) ) return -1;
        LinkedList* cur = _dummyhead->next;
        while(index--){
            cur = cur->next;
        }
        return cur->val;
    }

删除节点的办法:

void deleteAtIndex(int index) {
        if (index >= _size || index < 0) {
                return;
            }
            LinkedList* cur = _dummyhead;
            while(index--) {
                cur = cur ->next;
            }
            LinkedList* temp = cur->next;
            cur->next = cur->next->next;
            delete temp;
            temp = nullptr;
            _size--;
    }

206.反转链表

题目链接/文章讲解/视频讲解：代码随想录

反转链表的思路:

三个指针, 一个指反转前的节点指针pre, 一个指正在反转的节点cur, 一个指下一个要反转的节点temp. 难点是如何理解反转的次序和反转停止的条件.

代码:

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode *pre = NULL;
        ListNode *cur = head;
        ListNode *temp;
        while(cur != NULL){
                temp = cur->next;
                cur->next = pre;
                pre = cur;
                cur = temp;
        }


        return pre;
    }
};

注意: pre是指向NULL的指针, 因为反转后的链表, 最开始的头结点应该指向NULL.

今天写了6个小时, 明显比数组部分吃力太多了, 主要还是对指针的不熟悉, 写到最后头昏脑胀. 多看多练, 今天晚上好好总结一下链表的操作和理解.

NewCoderHeu

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Day3| 203.移除链表元素/707.设计链表/206.反转链表

理解链表的定义, 其实链表就是一种地址不连续的数组, 为了访问下一个节点, 在链表中定义了指针, 指向下一个节点的地址, 这样我们就可以读取到节点中的值.为了找到这个链表的位置, 我们必须定义一个来指向第一个节点中的元素最后一个节点的指针指向的是NULL题意：删除链表中等于给定值 val 的所有节点。示例 1：输入：head = [1,2,6,3,4,5,6], val = 6 输出：[1,2,3,4,5]示例 2：输入：head = [], val = 1 输出：[]
复制链接

扫一扫