算法训练营 Day 3

最新推荐文章于 2024-07-20 09:51:47 发布
最新推荐文章于 2024-07-20 09:51:47 发布
阅读量398 收藏 4
点赞数 4
文章标签： 算法 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NEWSBOYNEWSBOY/article/details/138794654
版权

1、移除链表元素

第一种方法，使用不带虚你头结点的链表

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        // 删除头结点
        while (head != nullptr && head->val == val) {
            ListNode* tmp = head;
            head = head->next;
            delete tmp;
        }

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

第二种方法，使用带虚拟头结点的链表

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* dummyHead = new ListNode(0); 
        dummyHead->next = head; // 把不带虚拟头的转化为带虚拟头的
        ListNode* cur = dummyHead;
        while (cur->next != nullptr) {
            if(cur->next->val == val) {
                ListNode* tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;
            } else {
                cur = cur->next;
            }
        }
        head = dummyHead->next;
        delete dummyHead;
        return head;
    }
};

2、设计链表

使用带虚拟头结点的链表，这样更方便

使用C++去实现：

#include <iostream>

using namespace std;

class MyLinkedList {
public:
    // 定义链表节点结构体
    struct LinkedNode { //类中可以定义结构体，也可以定义类
        int val;
        LinkedNode* next;
        explicit 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); //当新建一个结点时，它的next指针已经指向了nullptr
        LinkedNode* cur = _dummyHead;

        while(cur->next) //找到最后的一个结点
            cur = cur->next;

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

    // 在第index个节点之前插入一个新节点
    void addAtIndex(int index, int val) {
        // 如果index大于链表的长度，则返回空
        if(index > _size)
            return;
        // 如果index小于0，则在头部插入节点
        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个节点
    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;
        tmp = nullptr; //如果确定之后不会再使用tmp，也可以不设置其为nullptr
        _size--;
    }

    // 打印链表
    void printLinkedList() {
        LinkedNode* cur = _dummyHead; //由于在类里，所以不用再传结构体指针
        while (cur->next) {
            cout << cur->next->val << " -> ";
            cur = cur->next;
        }
        cout << "nullptr" << endl;
    }
private:
    int _size; //链表长度，不包括虚拟头
    LinkedNode* _dummyHead; //声明一个指向虚拟头的结构体指针
};

int main() {
    MyLinkedList LinkedList;
    
    for (int i = 1; i <= 5; ++i)
        LinkedList.addAtTail(i);

    LinkedList.printLinkedList();
}

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

使用C语言去实现：

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

typedef int E;

// 带头结点链表
typedef struct ListNode {
    E val;
    struct ListNode *next;
} ListNode, *Node; //ListNode是结点，Node是链表头指针

void initList(Node head) {
    head->next = NULL;
}

bool insertList(Node head, E val, int index) {
    if (index < 1) { //限定左边界
        printf("插入失败\n");
        return false;
    }

    while (--index) {
        head = head->next; //找到要插入位序的前驱节点
        if (!head) { //限定右边界
            printf("插入失败\n");
            return false;
        }
    }

    Node node = malloc(sizeof(ListNode));
    if (!node) {
        printf("内存分配失败\n");
        return false;
    }

    node->val = val;
    node->next = head->next;
    head->next = node;
    return true;
}

//头插法
bool insertFrontList(Node head, E val) {
    Node node = malloc(sizeof(ListNode));
    if (!node) {
        printf("内存分配失败\n");
        return false;
    }

    node->val = val;
    node->next = head->next;
    head->next = node;
    return true;
}

//尾插法
bool insertEndList(Node head, E val) {
    Node node = malloc(sizeof(ListNode));
    if (!node) {
        printf("内存分配失败\n");
        return false;
    }

    while (head->next)
        head = head->next; 
    
    node->val = val;
    node->next = NULL;
    head->next = node;
    return true;
}

bool deleteList(Node head, int index) {
    if (index < 1) { //限定左边界
        printf("删除失败\n");
        return false;
    }

    while (--index) {
        head = head->next; //找到要删除位序的前驱节点
        if (!head->next) { //限定右边界
            printf("删除失败\n");
            return false;
        }
    }
    
    if(head->next == NULL) {
        printf("删除失败\n");
        return false;
    }

    Node tmp = head->next;
    head->next = head->next->next;
    free(tmp);
    return true;
}

E *getList(Node head, int index) { //这里返回指针是为了防止隐式类型转换
    if (index < 1) { //限定左边界
        printf("获取失败\n");
        return NULL;
    }    

    do { //因为头结点不存放数据，所以用do...while
        head = head->next; //这里head指向该位序的节点
        if (!head) {
            printf("获取失败\n");
            return NULL;
        }
    } while (--index);
    return &head->val;
}

int findList(Node head, E val) {
    head = head->next; //带结点和不带结点的区别
    int i = 1;
    while (head) {
        if (head->val == val)
            return i;
        head = head->next;
        i++;
    }
    return -1;
}

int sizeList(Node head) {
    int i = 0;
    while (head->next) {
        head = head->next;
        i++;
    }
    return i;
}

void printList(Node head) {
    while (head->next) {
        head = head->next;
        printf("%d -> ", head->val);
    }
    printf("NULL\n");
}

int main() {
    ListNode head;
    initList(&head);
    
    for (int i = 1; i <= 2; ++i) 
        insertList(&head, i * 100, i);
    
    deleteList(&head, 1);
    printList(&head);
}

3、反转链表

截屏2024-05-12 11.33.49

第一种方法，双指针，先用C来实现

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

typedef struct ListNode {
    int val;
    struct ListNode *next;
} ListNode, *Node;

void initList(Node *head) {
    *head = NULL;
}

bool insertEndList(Node *head, int val) {
    Node node = malloc(sizeof(ListNode));
    if (!node) {
        printf("内存分配失败\n");
        return false;
    }

    node->val = val;
    node->next = NULL;

    if (!*head) {
        *head = node;
    } else {
        Node tmp = *head; //保持头结点不动
        while (tmp->next)
            tmp = tmp->next;
        tmp->next = node;
    }
    return true;
}

Node reverseList(Node head) { //由于改变了头指针指向的内容，所以只能返回指针类型
    Node node = NULL;
    Node tmp;
    while (head) {
        tmp = head->next; 
        head->next = node;
        node = head;
        head = tmp;
    }
    return node;
}

void printList(Node head) { //只读取，不改变结构体指针的指向
    while (head) {
        printf("%d -> ", head->val);
        head = head->next;
    }
    printf("NULL\n");
}

int main() {
    Node head;
    initList(&head);

    for (int i = 1; i <= 5; ++i)
        insertEndList(&head, i);
    printList(head);

    Node node = reverseList(head);
    printList(node);
}

再用C++来实现

#include <iostream>

using namespace std;

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

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; //这里其实可以直接移动head
    }
};

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

int main() {
    // 创建一个简单的链表: 1 -> 2 -> 3 -> 4 -> 5
    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(5);
    printList(head);

    Solution solution;
    ListNode *node = solution.reverseList(head);
    printList(node);
}

第二种方法，利用递归

class Solution {
public:
    ListNode* reverse(ListNode* pre,ListNode* cur){
        if(cur == NULL) 
            return pre;
        ListNode* temp = cur->next;
        cur->next = pre;
        return reverse(cur,temp);
    }
    ListNode* reverseList(ListNode* head) {
        return reverse(NULL, head);
    }
};

第二种递归不太好理解，

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head == NULL) 
            return NULL;
        if (head->next == NULL) 
            return head;
        
        // 递归调用，翻转第二个节点开始往后的链表
        ListNode *last = reverseList(head->next);
        // 翻转头节点与第二个节点的指向
        head->next->next = head;
        // 此时的 head 节点为尾节点，next 需要指向 NULL
        head->next = NULL;
        return last;
    }
};
progressiveboy
关注
  • 4
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
算法训练营Day3
2301_79304312的博客
01-17 399
203.移除链表元素： 707.设计链表: 206.反转链表
代码随想录算法训练营Day3
DetouringSnail的博客
06-08 236
707设计链表：理解链表的运作逻辑不难，难的是写代码时添加对于输入的判断。一写全是问题，还需要通过debug找问题出在哪里。还有就是class的基础语法问题（又是渣基础导致的问题。206反转列表： 理解了双指针法后，写起来意外的简单。能理解递归的代码，但是自己写写不出来。方法一：先判断是否删除头节点，之后遍历链表，注意头节点要用while持续删除。因为头节点之前没有节点，所以难以删除。明天还需要重新debug设计链表的代码找一下问题。方法二：创建虚拟头节点，统一删除规则。还需要注意C++中释放内存的写法。
代码随想录算法训练营day3
weixin_44520607的博客
11-22 292
代码随想录算法训练营day3
代码随想录算法训练营day3（链表）
qq_44195388的博客
05-24 495
今天学习链表，训练营进度有点快感觉跟不太上了。
AI基础实战营Day1ppt
02-02
【AI基础实战营Day1】课程主要探讨了计算机视觉领域，并深入介绍了OpenMMLab开源算法体系。计算机视觉是一门研究如何使机器“看”并理解图像和视频内容的科学。这一领域的应用广泛，从日常的微信扫一扫识物功能，到...
飞象工场七日数据刷题营Day11
08-03
处理缺失值的策略可以帮助保持数据的完整性和准确性，估算问题的解决能力反映了数据分析的逻辑思维，而区分监督和无监督学习以及理解数据挖掘的任务则有助于选择合适的算法模型进行建模。相关系数和决定系数的理解则...
数据-行业数据-《1223TikTok训练营1群Day28精华》(2).rar
09-12
《1223TikTok训练营1群Day28精华》(2).rar 这个压缩包文件，从标题和描述中我们可以推测，它包含了关于TikTok平台的特定培训资料，特别是针对数据分析和行业趋势的部分。TikTok作为全球最热门的短视频社交平台之一，...
数据-行业数据-《1224TikTok训练营1群Day29精华》(2).rar
09-12
总的来说，《1224TikTok训练营1群Day29精华》(2).pdf这份文件可能涵盖了TikTok平台的数据分析方法、广告投放策略、算法优化技巧以及合作营销案例，对于想要在TikTok上进行有效推广的行业人士来说，是一份非常实用的...
day03.zip
04-02
描述中的"day03.zip"可能暗示这是一个教学或学习系列的一部分，可能是某个课程、训练营或者项目中的第三天的资料。这些压缩文件经常被用作教程资源，包含代码、文档、图片或其他素材，以便学生或参与者可以下载并...
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 241
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
插入和选择排序
c23856的博客
07-20 227
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
算法刷题笔记 排列数字（C++实现）
hanmo22357的博客
07-17 273
一道简单的深度优先搜索（DFS）模板题，给出了DFS问题的一般思路以及C++代码实现
完全二叉树的节点个数-递归
qq_45031559的博客
07-19 220
完全二叉树的节点个数-递归
python实现图像缩放算法
最新发布
qq_42568323的博客
07-20 262
它通过选择离目标像素最近的原始像素的颜色值来确定目标像素的颜色值。它通过考虑目标像素周围16个像素的颜色值，使用双三次插值公式计算出目标像素的颜色值。相较于双线性插值，双三次插值能生成更平滑、更细腻的图像效果。它通过考虑目标像素周围四个像素的颜色值，使用双线性插值公式计算出目标像素的颜色值。尽管最近邻插值在某些应用场景中足够使用，但在需要更高质量图像的场景中，通常会选择更加复杂的插值方法，如双线性插值或双三次插值。双三次插值是图像缩放中高质量的方法之一，适合需要高质量图像处理的应用场景。
拆分整数 java
laocooon的博客
07-16 680
输入: n = 10输出: 36解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36。输入: n = 2输出: 1解释: 2 = 1 + 1, 1 × 1 = 1。），并使这些整数的乘积最大化。你可以获得的最大乘积。
(算法)区间调度问题
2202_75519246的博客
07-17 219
此外,参与工作的时间段不能重复(即使是开始的瞬间和结束的瞬间的重叠也是不允许的). 你的目标是参与尽王多的工作,那么最多能参与多少项工作呢?有n项工作,每项工作分别在s时间开始,在t时间结束. 对于每项工作,你都可以选择参与与否,如果选择了参与,那么自始至终都必须全程参与.
算法力扣刷题记录 五十【106.从中序与后序遍历序列构造二叉树】和【105.从前序与中序遍历序列构造二叉树】
danaaaa的博客
07-17 1069
构造二叉树
前缀和算法——部分OJ题详解
aaqq800520的博客
07-17 979
（文章的题目解释可能存在一些问题，欢迎各位小伙伴私信或评论指点（双手合十））
dijkstra 算法训练营 邓俊辉
10-08
邓俊辉教授是计算机科学与技术领域著名的教育家和研究者。他在清华大学担任教授，并负责计算机算法与理论方向的研究和教学工作。邓俊辉教授是中国计算机学会副理事长、国际著名科技出版社Springer中国系列丛书主编、IEICE China Communications主编、Journal of Internet Technology编委、《数据结构与算法教程》作者等。 在邓俊辉教授的指导下，他办了多次Dijkstra算法训练营，旨在培养学生对于算法学习的兴趣与能力。Dijkstra算法是一种用于图论中求解最短路径问题的经典算法，具有广泛的应用领域，如路由算法、网络规划和GPS导航系统等。在训练营中，邓俊辉教授通过讲解算法的原理和思想，引导学生进行编程实践和案例分析，帮助他们深入理解Dijkstra算法的应用场景与实际解决问题的能力。 邓俊辉教授所组织的Dijkstra算法训练营受到了广大学生的欢迎和积极参与。通过训练营的学习，学生不仅可以掌握Dijkstra算法的具体实现过程，还能了解算法设计的思路和应用的局限性。在训练营中，学生还可以与同学们进行交流和合作，共同解决实际问题，促进彼此的学术成长和人际交往能力的培养。 总之，邓俊辉的Dijkstra算法训练营为学生提供了一个系统、全面学习算法知识的平台，帮助他们培养解决实际问题的能力和思维方式。通过这样的培训，学生不仅能在学术领域取得更好的成绩，还可以为将来的职业发展打下坚实的基础。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值