算法学习Day03 | 链表理论基础、LeetCode 203.移除链表元素、LeetCode 707.设计链表、LeetCode 206.反转链表

不会写代码的里奇

已于 2023-11-23 22:49:21 修改

阅读量106

点赞数 1

分类专栏：算法文章标签：算法链表 leetcode 数据结构 c++ c语言笔记

于 2023-10-26 17:21:30 首次发布

本文链接：https://blog.csdn.net/2301_80211119/article/details/133975675

版权

算法专栏收录该内容

9 篇文章 0 订阅

订阅专栏

一、链表理论基础

链表的定义

链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向NULL。

C/C++的定义链表节点方式

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

链表的类型

1、单链表

2、双链表

3、循环链表

链表的存储方式

链表是通过指针域的指针链接在内存中各个节点。

链表中的节点在内存中不是连续分布的，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。

链表的操作

删除节点

删除D节点，如图所示：

只要将C节点的next指针指向E节点就可以了。

在C++里最好是再手动释放这个D节点，释放这块内存。

添加节点

链表的特性和数组的特性的对比

二、LeetCode 203.移除链表元素

题目链接：203. 移除链表元素 - 力扣（LeetCode）

1、不带头结点

代码

/**
 * 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) {}
 * };
 */
// 定义一个名为Solution的类  
class Solution {  
public:  
    ListNode* removeElements(ListNode* head, int val) { 
        // 当头结点存在并且头结点的值等于val时 
        while (head != nullptr && head->val == val) { // 注意这里不是if  
            // 声明一个临时变量tmp来保存头结点的地址  
            ListNode* tmp = head;  
            // 将头结点指向下一个节点，即删除头结点  
            head = head->next;  
            // 删除临时变量tmp所指向的头结点，即释放头结点所占用的内存空间  
            delete tmp; 
            tmp = nullptr; 
        }  
  
        ListNode* curr = head;  
        // 当前节点不为空且其下一个节点不为空时，执行循环
        while (curr != nullptr && curr->next != nullptr) {  
            // 如果当前节点的下一个节点的值等于要删除的值val
            if (curr->next->val == val) {  
                // 声明一个临时变量tmp来保存下一个节点的地址  
                ListNode* tmp = curr->next;  
                // 将当前节点的下一个节点指向下一个节点的下一个节点，即删除下一个节点  
                curr->next = curr->next->next;  
                // 删除临时变量tmp所指向的节点，即释放该节点所占用的内存空间  
                delete tmp;
                tmp = nullptr;
            } else {  
                // 如果当前节点的下一个节点的值不等于要删除的值val，则移动curr指针到下一个节点  
                curr = curr->next;  
            }  
        }  
        // 返回处理过的链表的头结点  
        return head;  
    }  
};

复杂度分析

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

2、带虚拟头结点

代码

/**
 * 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) {
        // 如果链表为空，直接返回空指针  
        if (!head) {  
            return nullptr;  
        }  
  
        // 创建一个虚拟头节点，值为0，next指向原链表的头节点  
        ListNode* dummyHead = new ListNode(0);   
        dummyHead->next = head;   
        // 定义一个指针curr，初始指向虚拟头节点，便于后续操作  
        ListNode* curr = dummyHead;   
  
        // 遍历链表，直到curr->next为空为止  
        while (curr->next != nullptr) {  
            // 如果当前节点的值等于要删除的值val，则进行删除操作  
            if (curr->next->val == val) {  
                // 临时保存当前要删除的节点  
                ListNode* tmp = curr->next;   
                // 将curr的next指向当前要删除节点的下一个节点，实现删除操作  
                curr->next = curr->next->next;   
                // 释放被删除节点的内存空间  
                delete tmp;   
            } else {  
                // 如果当前节点的值不等于要删除的值val，则将curr指针移动到下一个节点  
                curr = curr->next;   
            }  
        }  
        // 返回虚拟头节点的下一个节点作为新的链表头节点，并释放虚拟头节点的内存空间  
        head = dummyHead->next;   
        delete dummyHead;   
        return head;   
    }  
};

复杂度分析

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

三、LeetCode 707.设计链表

题目链接：707. 设计链表 - 力扣（LeetCode）

代码

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

    // MyLinkedList 的构造函数，初始化链表
    MyLinkedList() {
        // 初始化一个值为0的 LinkedNode，并将其作为链表的头节点，这里定义的头结点 是一个虚拟头结点，而不是真正的链表头结点
        _dummyHead = new LinkedNode(0);
        _size = 0;
    }

    // get 方法，获取指定索引的元素，如果索引超出链表范围，返回 -1 
    int get(int index) {
        if (index < 0 || index >= _size) {
            return -1;
        }

        LinkedNode* curr = _dummyHead->next;

        while (index--) { // 如果--index 就会陷入死循环
            curr = curr->next;
        }

        return curr->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* curr = _dummyHead;

        while (curr->next != nullptr) {
            curr = curr->next;
        }

        curr->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* curr = _dummyHead;

        while (index--) {
            curr = curr->next;
        }

        newNode->next = curr->next;
        curr->next = newNode;
        ++_size;
    }

    // 删除第index个节点，如果index 大于等于链表的长度，直接return
    void deleteAtIndex(int index) {
        if ( index < 0 || index >= _size) {
            return;
        }

        LinkedNode* curr = _dummyHead;

        while (index--) {
            curr = curr->next;
        }
        
        LinkedNode* tmp = curr->next;
        curr->next = curr->next->next;
        delete tmp;
        //delete命令指示释放了tmp指针原本所指的那部分内存，
        //被delete后的指针tmp的值（地址）并非就是NULL，而是随机值。也就是被delete后，
        //如果不再加上一句tmp=nullptr,tmp会成为乱指的野指针
        //如果之后的程序不小心使用了tmp，会指向难以预想的内存空间
        tmp = nullptr;
        --_size;
    }

    // 打印链表
    void printLinkedList() {
        LinkedNode* curr = _dummyHead;
        while (curr->next != nullptr) {
            cout << curr->next->val << " ";
            curr = curr->next;
        }
        cout << endl;
    }
    
    private:
        int _size;
        LinkedNode* _dummyHead;
};
/**
 * 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);
 */

复杂度分析

时间复杂度: 涉及 index 的相关操作为 O(index), 其余为 O(1)
空间复杂度: O(n)

四、LeetCode 206.反转链表

题目链接：206. 反转链表 - 力扣（LeetCode）

1、双指针法（从前往后翻转）

思路

首先需要两个指针，一个 curr 指针，指向头结点，一个 prev 指针，初始化为 nullptr 。

然后需要把 curr->next 的节点用 temp 指针保存一下，因为接下来要改变 curr->next 的指向了，将 curr->next 指向 prev，此时就反转了第一个节点了。接下来，继续移动 prev 和 curr 指针。

当 curr 指针指向 nullptr 时，循环结束，链表反转完毕。prev 指针就指向了新的头结点。

代码

/**
 * 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* temp = nullptr;  
        ListNode* prev = nullptr;  
        ListNode* curr = head;  
        
  
        while (curr != nullptr) {  
            // 保存curr的下一个节点到temp，因为接下来要改变cur->next
            temp = curr->next;  
            // 翻转操作  
            curr->next = prev;  
            // 更新pre 和 cur指针
            prev = curr;   
            curr = temp;  
        }  
          
        // 返回反转后的链表的头节点，即原链表的最后一个节点prev  
        return prev;  
    }
};

复杂度分析

时间复杂度：O(n)，其中 n 是链表的长度。需要遍历链表一次。
空间复杂度：O(1)。

2、递归法

代码

/**
 * 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* reverse(ListNode* prev,ListNode* curr){
        if (curr == nullptr) return prev;
        ListNode* temp = curr->next;
        curr->next = prev;
        // 相当于双指针法的下面两步
        // prev = curr;
        // curr = temp;
        return reverse(curr,temp);
    }

    ListNode* reverseList(ListNode* head) {
        // 和双指针法初始化是一样的逻辑
        // ListNode* curr = head;
        // ListNode* prev = nullptr;
        return reverse(nullptr, head);
    }

};

复杂度分析

时间复杂度：O(n)，其中 n 是链表的长度。需要对链表的每个节点进行反转操作。

空间复杂度：O(n)，其中 n 是链表的长度。空间复杂度主要取决于递归调用的栈空间，最多为 n 层。

3、递归（从后往前翻转）

代码

/**
 * 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) {
        // 边缘条件判断
        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;
    }
};

复杂度分析

时间复杂度：O(n)，其中 n 是链表的长度。需要对链表的每个节点进行反转操作。

空间复杂度：O(n)，其中 n 是链表的长度。空间复杂度主要取决于递归调用的栈空间，最多为 n 层。

不会写代码的里奇

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
算法学习Day03 | 链表理论基础、LeetCode 203.移除链表元素、LeetCode 707.设计链表、LeetCode 206.反转链表

链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向NULL。
复制链接

扫一扫