LC第十天

最新推荐文章于 2023-06-16 13:23:16 发布
最新推荐文章于 2023-06-16 13:23:16 发布
阅读量192 收藏
点赞数
分类专栏： leetcode 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44747789/article/details/114482574
版权

深拷贝！

  • 暴力法 直接AC ，而且效率还不错

  • 哈希表 map用的太妙了

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/
class Solution {
public:
    Node* copyRandomList(Node* head) {
    
    Node* pre=nullptr;
    Node* cur=head;
    if(head==nullptr)
    {
        return pre;
    }
    //复制val和next
    Node* new_node=new Node(cur->val);
    pre=new_node;
    cur=cur->next;
    Node* res=pre;
    while(cur!=nullptr)
    {
        new_node=new Node(cur->val);
        pre->next=new_node;
        cur=cur->next;
        pre=pre->next;
    }
    //复制random
    cur=head;
    pre=res;
    while(cur!=nullptr)
    {   
        Node* go=head;
        Node* go1=res;
        while(go!=nullptr)
        {
            if(cur->random == go)
            {
                pre->random=go1;
                break;
            }
            go=go->next;
            go1=go1->next;
        }
        cur=cur->next;
        pre=pre->next;
    }

    return res;
    }
};

因为第二次循环 的时候查找很费劲，所以用哈希表很舒服！

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/
class Solution {
public:
    Node* copyRandomList(Node* head) {
        if(head == nullptr) return nullptr;
        Node* cur = head;
        unordered_map<Node*, Node*> map;
        //  复制各节点，并建立 “原节点 -> 新节点” 的 Map 映射
        while(cur != nullptr) {
            map[cur] = new Node(cur->val);
            cur = cur->next;
        }
        cur = head;
        //  构建新链表的 next 和 random 指向
        while(cur != nullptr) {
            map[cur]->next = map[cur->next];
            map[cur]->random = map[cur->random];
            cur = cur->next;
        }
        //  返回新链表的头节点
        return map[head];
    }
};

 

递归！！中序遍历的理解要加深

二叉搜索树的 中序遍历是递增的排序序列！

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;

    Node() {}

    Node(int _val) {
        val = _val;
        left = NULL;
        right = NULL;
    }

    Node(int _val, Node* _left, Node* _right) {
        val = _val;
        left = _left;
        right = _right;
    }
};
*/
class Solution {
public:
    Node* pre,* head;
    void inorder(Node* cur)
    {
        if(cur==nullptr)
        return ;

        inorder(cur->left);
        if(pre!=nullptr)
        pre->right=cur;
        else
        head=cur;
        cur->left=pre;
        pre=cur;
        inorder(cur->right);
    }

    Node* treeToDoublyList(Node* root) {
      if(root==nullptr)
    return root;
    inorder(root);
    head->left=pre;
    pre->right=head;
    return head;
    }
};

全排列问题，DFS+剪枝

  • ps:之前做过，但没有很熟练，这次还是不会，有时间再多做几次（现在看代码很简单）
  • 需要注意这里 set的妙用，主要是用 find（）；
  • 还要注意这个 swap和for 的搭配
  • 具体细节还可以看《LC第一天》前两题
class Solution {
public:
    vector<string> permutation(string s) {
    dfs(s,0);
    return res;
    }
private:
    vector<string> res;
    void dfs(string s,int index)
    {
        if(index==s.size()-1)
        {   
            res.push_back(s);
            return;
        }

        set<int> st;
        for(int i=index;i<s.size();++i)
        {
            if(st.find(s[i])!=st.end())//重复，因此剪枝
            continue;
            st.insert(s[i]);
            swap(s[i],s[index]);    //交换，将s[i]固定在Index的位置
            dfs(s,index+1);         //递归下一位
            swap(s[i],s[index]);    //恢复交换
        }
    }
};

三种解法：

  • 哈希表统计
  • 数组排序法

  • 摩尔投票法：核心观念正负抵消；关键在于题意 这个数比一半都多。（最佳解法）

class Solution {
public:
    int majorityElement(vector<int>& nums) {
    int res=nums[0];
    int times=1;
    for(int i=1;i<nums.size();++i)
    {
        if(nums[i]==res)
        ++times;
        else
        --times;
        if(times==0)
        {
            res=nums[i];
            times=1;
        }
    }
    return res;
    }
};

 

经典：topK 问题，很容易出面试题

  • 自己实现 快速排序 O（nlogn) 重点是要会自己手撕快排！

  • 基于快排的数组划分，完成topK就，不排完 O(n)

  • 最大堆 O（nlogk)  红黑树什么的

快速排序，两个核心：哨兵划分+递归！

class Solution {
public:
    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        quickSort(arr,0,arr.size()-1);
        vector<int> res;
        res.assign(arr.begin(),arr.begin()+k);
        return res;
    }
private:
    void quickSort(vector<int>& arr,int left,int right)
    {
        //子数组长度为1时终止递归
        if(left>=right) return;
        //哨兵划分操作（以arr[left]作为基准数）
        int i=left,j=right;
        while(i<j)
        {
            while(i<j && arr[j]>=arr[left]) j--;
            while(i<j && arr[i]<=arr[left]) i++;
            swap(arr[i],arr[j]);
        }
        swap(arr[i],arr[left]);
        //递归左（右）子数组执行哨兵划分
        quickSort(arr,left,i-1);
        quickSort(arr,i+1,right);
    }
};

 基于快排的数组划分

class Solution {
public:
    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        if(k>=arr.size()) return arr;
        return quickSort(arr,k,0,arr.size()-1)
    }
private:
    vector<int> quickSort(vector<int>&arr,int k,int left,int right)
    {
        int i=left,j=right;
        while(i<j)
        {
            while(i<j && arr[j]>=arr[left]) --j;
            while(i<j && arr[i]<=arr[left]) ++i;
            swap(arr[i],arr[j]);
        }
        swap(arr[i],arr[left]);
        if(i>k) return quickSort(arr,k,left,i-1);
        if(i<k) return quickSort(arr,k,i+1,right);
        vector<int> res;
        res.assign(arr.begin(),arr,begin()+k);
        return res;
    }
};

 C++中 优先队列 为大根堆！可以拿来直接用

class Solution {
public:
    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        vector<int> vec(k,0);
        if(k==0) return vec;
        priority_queue<int> Q;
        for(int i=0;i<k;++i)
        {
            Q.push(arr[i]);
        }
        for(int i=k;i<arr.size();++i)
        {
            if(Q.top()>arr[i])
            {
                Q.pop();
                Q.push(arr[i]);
            }
        }
        for(int i=0;i<k;++i)
        {
            vec[i]=Q.top();
            Q.pop();
        }
        return vec;
    }
};

 上述2、3方案对比：

  • 2方案需要修改原数组，如果原数组不能修改了话，还需要拷贝一份数组，空间复杂度就上去了！

  • 3方案，如果把数据看成输入流的话，使用堆的方法是来一个处理一个，不需要保存数据，只需要保存 k 个元素的最大堆。而快速选择的方法需要先保存下来所有的数据，再运行算法。当数据量非常大的时候，甚至内存都放不下的时候，就麻烦了。所以当数据量大的时候还是用基于堆的方法比较好。

动态规划！

代码 不是严格 按照上面的思路，但本质上是一样的！ 

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int res=nums[0];
        int cur=nums[0];
        for(int i=1;i<nums.size();++i){
            cur=cur+nums[i];
            if(cur<nums[i])
            cur=nums[i];
            res=max(res,cur);
        }
        return res;
    }
};

迭代+求整/求余

class Solution {
public:
    int findNthDigit(int n) {
        int digit=1;
        long long start=1;
        long long count=9;
        //求出是几位数的范围
        while(n>count)
        {
            n-=count;
            digit+=1;
            start*=10;
            count=digit*start*9;
        }
        //求出是哪个数
        long long num=start+(n-1)/digit;
        //确定所求数位在num的哪一数位
        vector<int> s;
        while(num)
        {
            s.push_back(num%10);
            num=num/10;
        }
        int len=s.size();
        int res=s[len-(n-1)%digit-1];
        return res;
    
    }
};

 

两米七的大白菜
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LC3使用指南-中文1
08-08
这个示例的目标是读取存储在内存 x3100 至 x3109 的十个数字，将它们相加，并将结果存储在寄存器 R1 中。这个过程涉及到了数据的存储、加载、运算以及条件判断等基本概念。 第二章介绍模拟器的用户界面，包括如何与...
LC脚本引擎-易语言
06-14
10. **文档完善**：为了方便用户学习和使用，LC脚本引擎应该有详细的文档说明，包括API参考、教程和示例代码，帮助开发者快速入门和进阶。 综上所述，LC脚本引擎结合易语言的特性，为编程爱好者和专业人士提供了一...
STL —— map、set模拟实现
weixin_59913110的博客
03-15 405
map和set的使用通过查找相关文档即可熟悉。使用map解题使用map解题使用set解题使用map解题。
LeetCode 复杂链表的复制
最新发布
qq_62829518的博客
06-16 231
请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。
复杂链表的复制
weixin_39889618的博客
02-22 764
复杂链表的复制的难点就是如何把random节点的复制出来，正常链表的复制就是遍历链表，复制节点，但是这里有乱序节点，有可能当指针指向时还未生成该链表，所以可以用哈希表来存储节点，第一次遍历链表，将每个节点放入哈希表，同时，存入一个新的节点newNode(cur->val)，此时他作为value值只是一个单节点，没有next也没有random，而原来cur作为key，这里没一个节点包含一个完整的链表结构，拥有他的next和random，第一次遍历相当于，图1，构建原链表和新未连接的链表节点，第二次...
剑指Offer 35 —复杂链表的复制
qq_39172845的博客
04-08 164
剑指Offer—复杂链表的复制
剑指 Offer 35. 复杂链表的复制(逻辑)1
秋雨行舟
12-10 163
请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。 示例 1： 输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]] 输出：[[7,null],[13,0],[11,4],[10,2],[1,0]] 示例 2： 输入：head = [[1,1],[2,1]] 输出：[[1,1],[2,1]] 示例 3： 输入
LC阵列：探索章节阵列
02-23
LC阵列，或者称为章节目录数组，是编程领域中的一种数据结构，特别是在解决算法问题时经常被提及。它通常用于存储线性结构中的元素，比如书籍的章节、文章的段落或者其他有顺序的信息单元。在Java编程语言中，我们...
c#入门经典 第十版 附录练习题答案
04-06
"C#入门经典 第十版 附录练习题答案" 本资源为 C# 入门经典第十版的附录练习题答案，涵盖 C# 和 .NET 5 的基础知识。 知识点 1：为什么程序员可以使用不同的语言编写运行在 .NET 上的应用程序？ 答案：.NET 支持...
lc_daily
03-18
同时，可能会用到编程语言内置的模块或第三方库，例如Python的`collections`用于高级数据结构，或`unittest`进行测试。 4. **控制流**：包括条件语句（if-else）、循环（for、while）以及异常处理，这些都是解决...
C++中"str.find(i) != str.end()"和"str.find(i) = str.end()"到底啥意思
恋蛩音的博客
03-12 6888
区分"str.find(i) != str.end()"和"str.find(i) = str.end()"的含义
力扣138. 复制带随机指针的链表
weixin_43795939的博客
03-03 644
题目链接 给你一个长度为 n 的链表，每个节点包含一个额外增加的随机指针 random ，该指针可以指向链表中的任何节点或空节点。 构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成，其中每个新节点的值都设为其对应的原节点的值。新节点的 next 指针和 random 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。 例如，如果原链表中有 X 和 Y 两个节点，其中 X.random --> Y 。
leetcode复杂链表的复制
天启的博客
04-08 316
1.使用map 如果按照正常的链表复制那样做，由于存在随机节点，可能会出现环， 所以，使用map存在每一个节点与其随机指针的指向， 然后遍历map，复制链表 代码如下： /* // Definition for a Node. class Node { public: int val; Node* next; Node* random; N...
[算法] - 复制含有随机指针节点的链表【 额外空间复杂度O(1)】
Snoopy_Dream
01-04 524
复制含有随机指针节点的链表 【 题目】 一种特殊的单链表节点类描述如下 class Node { int value; Node next; Node rand; Node(int val) { value = val;}} rand指针是单链表节点结构中新增的指针， rand可能指向链表中的任意一个节点， 也可能指向null。 给定一个由Node节点类型组成的无环单链表...
能带你起飞的【数据结构】成王第十六篇:Map和Set 2
m0_64397675的博客
07-12 275
解题分析代码实现771. 宝石与石头 - 力扣（LeetCode）代码实现代码实现代码实现插入删除全部代码
Leetcode 刷题笔记----138.复制带随机指针的链表（链表）
qq_35225663的博客
10-20 200
题目描述： 给定一个链表，每个节点包含一个额外增加的随机指针，该指针可以指向链表中的任何节点或空节点。 要求返回这个链表的深拷贝。 思路：双指针 看到这道题的时候，我的第一个思路就是遍历链表，但是如果链表存在环的化，那么程序会永远执行下去。所以想到了使用hashmap数据结构； 原地处理，将克隆结点放在原结点后面，在原链表上处理克隆结点的random指针，最后分离两个链表 ...
删除链表中所有值为val的结点
qq_43632625的博客
08-31 350
题目： 删除链表中等于给定值 val 的所有结点。 思路： （1）遍历链表，等于val的结点直接删除。（注意：当删除一个结点需要它的前驱结点） （2）需要考虑如果头结点的值为val该怎么办。 删除值相等的结点： while(cur != null){ if(cur.val == val){ pre.next = cur.next; }else{ pre = cur; } cur =...
剑指 Offer 35. 复杂链表的复制（中等）
di_ko的博客
05-01 106
思路： 方法一：使用哈希表 方法二：原地修改 代码： 方法一： /* // Definition for a Node. class Node { int val; Node next; Node random; public Node(int val) { this.val = val; this.next = null; this.random = null; } } */ class Solut.
LC3 JSR指令中第十一位是如何决定寻址模式的
05-25
LC-3的JSR指令中，第十一位是指示寻址模式的位，我们称之为“p位”。当p位为0时，JSR指令的目标地址采用PC相对寻址模式。当p位为1时，JSR指令的目标地址采用绝对寻址模式。在PC相对寻址模式下，JSR指令的目标地址是相对于当前指令地址的偏移量。在绝对寻址模式下，JSR指令的目标地址是指令中的地址字段所指定的地址。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值