代码随想录算法训练营第三天打卡

最新推荐文章于 2024-08-24 23:54:19 发布
最新推荐文章于 2024-08-24 23:54:19 发布
阅读量54 收藏
点赞数
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50649633/article/details/132751795
版权

1.链表理论基础

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

链表的类型

接下来说一下链表的几种类型:

单链表

刚刚说的就是单链表。

双链表

单链表中的指针域只能指向节点的下一个节点。

双链表：每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。

双链表 既可以向前查询也可以向后查询。

如图所示： 

链表2

循环链表

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

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

链表4

链表的存储方式

了解完链表的类型，再来说一说链表在内存中的存储方式。

数组是在内存中是连续分布的，但是链表在内存中可不是连续分布的。

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

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

如何定义一个单链表也是非常重要的，需要牢记，使用结构体来实现。代码如下：

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

2.移除链表元素

Leetcode题目链接

这道题的方法其实很简单，区别就在于需不需要定义dummy虚拟头节点。如果不定义虚拟头节点的话，链表的第一个元素就需要单独处理，而如果定义虚拟头节点的话，那么整个链表就可以遵循相同的处理规则。

不定义虚拟头节点的方法，代码如下：

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) { //方法一：直接在链表上进行删除操作，分为两部分：1.单独对头节点判断 2.对头节点以外的节点进行判断
        while (head != nullptr && head->val == val) { //单独对头节点判断
            ListNode* temp = head;
            head = head->next;
            delete temp;
        }
        ListNode* curr = head;
        while (curr != nullptr && curr->next != nullptr) {
            if (curr->next->val == val) {
                ListNode* temp = curr->next;
                curr->next = curr->next->next;
                delete temp;
            } else {
                curr = curr->next;
            }
        }
        return head;
    }
};

定义虚拟头节点的方法，代码如下：

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) { //方法二：在头指针之前创建一个虚拟头节点dummy
        ListNode* dummy = new ListNode(0);
        dummy->next = head;
        ListNode* curr = dummy;
        while (curr != nullptr && curr->next != nullptr) {
            if (curr->next->val == val) {
                ListNode* temp = curr->next;
                curr->next = curr->next->next;
                delete temp;
            } else {
                curr = curr->next;
            }
        }
        head = dummy->next;
        delete dummy; //注意：这里容易忘记
        return head;
    }
};

可在本地IDE运行的完整代码如下：

#include <iostream>

using namespace std;


 // Definition for singly-linked list.
struct ListNode { //创建一个单链表的方法
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(nullptr) {} 
};
 
// class Solution {
// public:
//     ListNode* removeElements(ListNode* head, int val) { //方法一：直接在链表上进行删除操作，分为两部分：1.单独对头节点判断 2.对头节点以外的节点进行判断
//         while (head != nullptr && head->val == val) { //单独对头节点判断
//             ListNode* temp = head;
//             head = head->next;
//             delete temp;
//         }
//         ListNode* curr = head;
//         while (curr != nullptr && curr->next != nullptr) {
//             if (curr->next->val == val) {
//                 ListNode* temp = curr->next;
//                 curr->next = curr->next->next;
//                 delete temp;
//             } else {
//                 curr = curr->next;
//             }
//         }
//         return head;
//     }
// };

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) { //方法二：在头指针之前创建一个虚拟头节点dummy
        ListNode* dummy = new ListNode(0);
        dummy->next = head;
        ListNode* curr = dummy;
        while (curr != nullptr && curr->next != nullptr) {
            if (curr->next->val == val) {
                ListNode* temp = curr->next;
                curr->next = curr->next->next;
                delete temp;
            } else {
                curr = curr->next;
            }
        }
        head = dummy->next;
        delete dummy; //注意：这里容易忘记
        return head;
    }
};

void printList(ListNode* head) {
    ListNode* curr = head;
    while (curr != nullptr) {
        cout << curr->val << " ";
        curr = curr->next;
    }
    cout << endl;
}

int main() {
    // 创建链表 1 -> 2 -> 6 -> 3 -> 4 -> 5 -> 6
    ListNode* head = new ListNode(1);
    head->next = new ListNode(2);
    head->next->next = new ListNode(6);
    head->next->next->next = new ListNode(3);
    head->next->next->next->next = new ListNode(4);
    head->next->next->next->next->next = new ListNode(5);
    head->next->next->next->next->next->next = new ListNode(6);
    int val = 6;
    Solution sol;
    ListNode* ans = sol.removeElements(head, val);
    printList(ans);
    while (ans->next != nullptr) { //程序结束之前释放内存
        ListNode* temp = ans;
        ans = ans->next;
        delete temp;
    }
    return 0;
}

3.设计链表

Leetcode题目链接

本题没有什么太多的方法，整体来说就是跟移除链表元素的方法差不多，也就是使用dummy虚拟头节点。但是这个题基本上覆盖了链表中的常见操作，因此还是非常重要的。代码如下：

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;

};

我自己写的版本：

class MyLinkedList {
public:
struct ListNode {
        int val;
        ListNode* next;
        ListNode(int x) : val(x), next(nullptr) {}
    };
    MyLinkedList() { //构造函数
        dummy = new ListNode(0); 
    }
    
    int get(int index) {
        int num = 0;
        ListNode* curr = dummy->next;
        while (curr) {
            if (num == index) {
                return curr->val;
            }
            curr = curr->next;
            num++;
        }
        return -1;
    }
    
    void addAtHead(int val) {
        if (dummy->next == nullptr) {
            dummy->next = new ListNode(val);
        } else {
            ListNode* temp = dummy->next;
            dummy->next = new ListNode(val);
            dummy->next->next = temp;
        }
    }
    
    void addAtTail(int val) {
        ListNode* newNode = new ListNode(val);
        if (dummy->next == nullptr) {
            dummy->next = newNode;
        } else {
            ListNode* current = dummy->next;
            while (current->next) {
                current = current->next;
            }
            current->next = newNode;
        }
    }
    
    void addAtIndex(int index, int val) {
        int num = 0;
        ListNode* newNode = new ListNode(val);
        ListNode* prev = dummy;
        ListNode* curr = dummy->next;
        while (curr) {
            if (num == index) {
                prev->next = newNode;
                newNode->next = curr;
                return;
            }
            prev = prev->next;
            curr = curr->next;
            num++;
        }
        prev->next = newNode;
    }
    
    void deleteAtIndex(int index) {
        int num = 0;
        ListNode* prev = dummy;
        ListNode* curr = dummy->next;
        while (curr) {
            if (num == index) {
                prev->next = curr->next;
                return;
            }
            prev = prev->next;
            curr = curr->next;
            num++;
        }
        return;
    }

    void printList() {
        ListNode* curr = dummy->next;
        while (curr != nullptr) {
            cout << curr->val << " ";
            curr = curr->next;
        }
        cout << endl;
    }

    ~MyLinkedList() {
        ListNode* current = dummy->next;
        while(current) {
            ListNode* temp = current;
            current = current->next;
            delete temp;
        } 
        delete dummy;
    }
private:
    ListNode* dummy;
};

可以在本地IDE运行的完整代码：

#include <iostream>

using namespace std;

class MyLinkedList {
public:
struct ListNode {
        int val;
        ListNode* next;
        ListNode(int x) : val(x), next(nullptr) {}
    };
    MyLinkedList() { //构造函数
        dummy = new ListNode(0); 
    }
    
    int get(int index) {
        int num = 0;
        ListNode* curr = dummy->next;
        while (curr) {
            if (num == index) {
                return curr->val;
            }
            curr = curr->next;
            num++;
        }
        return -1;
    }
    
    void addAtHead(int val) {
        if (dummy->next == nullptr) {
            dummy->next = new ListNode(val);
        } else {
            ListNode* temp = dummy->next;
            dummy->next = new ListNode(val);
            dummy->next->next = temp;
        }
    }
    
    void addAtTail(int val) {
        ListNode* newNode = new ListNode(val);
        if (dummy->next == nullptr) {
            dummy->next = newNode;
        } else {
            ListNode* current = dummy->next;
            while (current->next) {
                current = current->next;
            }
            current->next = newNode;
        }
    }
    
    void addAtIndex(int index, int val) {
        int num = 0;
        ListNode* newNode = new ListNode(val);
        ListNode* prev = dummy;
        ListNode* curr = dummy->next;
        while (curr) {
            if (num == index) {
                prev->next = newNode;
                newNode->next = curr;
                return;
            }
            prev = prev->next;
            curr = curr->next;
            num++;
        }
        prev->next = newNode;
    }
    
    void deleteAtIndex(int index) {
        int num = 0;
        ListNode* prev = dummy;
        ListNode* curr = dummy->next;
        while (curr) {
            if (num == index) {
                prev->next = curr->next;
                return;
            }
            prev = prev->next;
            curr = curr->next;
            num++;
        }
        return;
    }

    void printList() {
        ListNode* curr = dummy->next;
        while (curr != nullptr) {
            cout << curr->val << " ";
            curr = curr->next;
        }
        cout << endl;
    }

    ~MyLinkedList() {
        ListNode* current = dummy->next;
        while(current) {
            ListNode* temp = current;
            current = current->next;
            delete temp;
        } 
        delete dummy;
    }
private:
    ListNode* dummy;
};

int main() {
    MyLinkedList myLinkedList = MyLinkedList();
    myLinkedList.addAtIndex(1,0);
    int m = myLinkedList.get(0);
    myLinkedList.printList();
    cout << m << endl;
    return 0;
}

4.翻转链表

Leetcode题目链接

这道题有两种方法，方法一：双指针法；方法二：递归法

双指针法代码如下：

class Solution { //两种方法，方法一：双指针法，自己画图的话会比较清晰
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* curr = head;
        ListNode* prev = nullptr;
        while (curr) {
            ListNode* temp = curr->next;
            curr->next = prev;
            prev = curr;
            curr = temp;
        }
        return prev;
    }
};

递归法代码如下：

class Solution {
public:
    ListNode* reverse(ListNode* pre,ListNode* cur){ //方法二：递归法，真的妙
        if(cur == NULL) 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 = NULL;
        return reverse(NULL, head);
    }
};

可以在本地IDE运行的完整代码如下：

#include <iostream>

using namespace std;

struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(nullptr) {}
};

// class Solution { //两种方法，方法一：双指针法，自己画图的话会比较清晰
// public:
//     ListNode* reverseList(ListNode* head) {
//         ListNode* curr = head;
//         ListNode* prev = nullptr;
//         while (curr) {
//             ListNode* temp = curr->next;
//             curr->next = prev;
//             prev = curr;
//             curr = temp;
//         }
//         return prev;
//     }
// };

class Solution {
public:
    ListNode* reverse(ListNode* pre,ListNode* cur){ //方法二：递归法，真的妙
        if(cur == NULL) 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 = NULL;
        return reverse(NULL, head);
    }
};

void printList(ListNode* head) {
    ListNode* curr = head;
    while (curr) {
        cout << curr->val << " ";
        curr = curr->next;
    }
    cout << endl;
}

int main() {
    Solution sol;
    ListNode* head = new ListNode(1);
    head->next = new ListNode(2);
    head->next->next = new ListNode(3);
    head->next->next->next = new ListNode(4);
    head->next->next->next->next = new ListNode(4);
    head->next->next->next->next->next = new ListNode(5);
    head->next->next->next->next->next->next = new ListNode(6);
    ListNode* reversed = sol.reverseList(head);
    printList(reversed);
    return 0;
}

今毕。

qq_50649633
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
代码随想录算法训练营打卡第一天
weixin_46724054的博客
03-01 1659
代码随想录算法训练营第1天 | Leetcode704 二分查找， 27 移除元素。
代码随想录算法训练营第七天
qq_41225184的博客
01-17 113
算法训练营
代码随想录算法训练营第三天打卡| Leetcode 203、Leetcode 707、Leetcode 206
m0_61340606的博客
07-01 602
代码随想录算法训练营第三天打卡| Leetcode 203、Leetcode 707、Leetcode 206
代码随想录算法训练营第一天 - 704. 二分查找
05-08
代码随想录算法训练营第一天 - 704. 二分查找
代码随想录训练营第五天
07-23
### 代码随想录训练营第五天：深入理解哈希表及其实现 #### 哈希表概述 哈希表是一种数据结构，它能够通过关键码的值来进行快速访问。这种数据结构允许我们实现非常高效的查找、插入和删除操作。在哈希表中，每个...
代码随想录算法PDF.zip
05-29
《代码随想录》是一本深受程序员喜爱的算法学习书籍，其PDF版本为读者提供了方便的电子阅读体验。这本书主要针对准备参加编程面试或者想要提升自己算法能力的开发者，通过实例解析和实战演练，帮助读者深入理解算法...
代码随想录算法PDF.rar
08-06
《代码随想录》是一本深受程序员喜爱的算法学习书籍，尤其对于初学者来说，它提供了深入浅出的讲解和实战演练。这本书的核心是通过实际编程来帮助读者理解和掌握算法，提升编程技能，特别是C++语言的应用。在C++这个...
代码随想录算法训练营第一天- 977.有序数组的平方 ， 209.长度最小的子数组，59.螺旋矩阵II
10-12
代码随想录算法训练营第一天- 977.有序数组的平方 ， 209.长度最小的子数组，59.螺旋矩阵II
数据结构之并查集
我要学编程的博客
08-21 1176
并查集相关概念、模拟实现并查集、并查集的应用：省份的数量、等式方程的可满足行
数据结构-时间、空间复杂度-详解
2401_86587256的博客
08-23 1010
数据结构-时间、空间复杂度-详解
数据结构（邓俊辉）学习笔记】优先级队列 06——完全二叉堆：批量建堆
weixin_44399845的博客
08-18 894
完全二叉堆：批量建堆
Leetcode每日刷题之1658.将x减到0的最小操作数(C++)
2301_80689220的博客
08-21 223
【代码】Leetcode每日刷题之1658.将x减到0的最小操作数(C++)
二叉树(源码+lw+部署文档+讲解等)
lpw1012的博客
08-21 720
🌞博主介绍：✌全网粉丝15W+,CSDN特邀作者、211毕业、高级全栈开发程序员、大厂多年工作经验、码云/掘金/华为云/阿里云/InfoQ/StackOverflow/github等平台优质作者、专注于Java、小程序技术领域和毕业项目实战，以及程序定制化开发、全栈讲解、就业辅导✌🌞👇🏻精彩专栏 推荐订阅👇🏻2023-2024年最值得选的微信小程序毕业设计选题大全：100个热门选题推荐✅2023-2024年最值得选的Java毕业设计选题大全：500个热门选题推荐✅Java精品实战案例《500套》
【JAVA入门】Day24 - 排序算法
oo00Z00oo的博客
08-21 962
排序，是把混乱的数据排成从小到大或从大到小。。在这里，我们着重介绍前四种。
C语言程序设计（初识C语言后部分）
2402_85207276的博客
08-24 362
·数组 ·冒泡排序算法
【冒泡排序算法】输入n个数进行排序
最新发布
qq_64108165的博客
08-24 283
输入n个数进行排序，使用冒泡排序算法
数据结构-栈与队列-数组和链表的推广运用-第六天
qq_33867768的博客
08-24 405
总结： 1. 栈是一种先入后出的数据结构，类似于“铁饼堆叠游戏”。2. 队列是一种先入先出的数据结构，类似于“数据进入不能回头的管道”。
数据结构-堆(二叉树的特殊)-第四天
qq_33867768的博客
08-21 207
堆是一棵完全二叉树，根据成立条件可分为大顶堆和小顶堆。大（小）顶堆的堆顶元素是最大（小）的。堆（Heap）是一种特殊的完全二叉树数据结构，通常用于实现优先队列。它是一种完全二叉树，除了最后一层外，每一层都是完全填充的。最后一层的所有节点都尽可能地靠左排列。堆中的每个节点的值与其子节点的值之间有一定的关系，这取决于堆的类型。堆是一种高效的数据结构，通常用于实现优先队列和排序算法。
代码随想录算法训练营第二十二天
09-13
第二十二天的算法训练营主要涵盖了Leetcode题目中的三道题目，分别是Leetcode 28 "Find the Index of the First Occurrence in a String"，Leetcode 977 "有序数组的平方"，和Leetcode 209 "长度最小的子数组"。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值