自用算法笔记---死背

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

目录

56.合并区间

在这里插入图片描述

class Solution {
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        int N=intervals.size();
        vector<vector<int>> res;
        sort(intervals.begin(),intervals.end());//先按前端点排序，套路
        int l=intervals[0][0],r=intervals[0][1];
        vector<int> temp;//装每一个子区间的数组
        int i;
        temp.push_back(l);
        for(i=0;i<N;i++){
            if(intervals[i][0]<=r){//只要比之前有边界小都可并进来并更新右边界
                r=max(r,intervals[i][1]);
            }else{
                temp.push_back(r);//把之前收集的最大右边界装好
                res.push_back(temp);//
                l=intervals[i][0];//重新以遍历到的区间为起点
                r=intervals[i][1];
                temp=vector<int>();
                temp.push_back(l);
            }
        }
        if(i==N){//结束加上结尾
            temp.push_back(r);
            res.push_back(temp);
        }
        return res;
    }
};

61.旋转链表

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

/**
 * 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* rotateRight(ListNode* head, int k) {
        ListNode* t0=head;
        if(head==NULL) return NULL;
        ListNode* r;
        int n=0;
        for(auto i=head;i!=NULL;i=i->next){
            n++;//算共有几个节点
            if(i!=NULL&&i->next==NULL) r=i;//顺便找到旋转前的尾节点
        }
        int k0=k%n;//旋转几个点
        int cnt=0;
        ListNode* i;
        for(i=head;cnt+1!=n-k0;i=i->next){
            cnt++;//主要是找到旋转后的尾节点
        }
        r->next=head;//屁股连头
        ListNode* res=i->next;//旋转后的头
        i->next=NULL;//旋转后的尾断尾
        return res;
    }
};

AC.1451单链表快速排序

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* getTail(ListNode* head) {
        while(head->next){
            head=head->next;
        }
        return head;
    }

    ListNode* quickSortList(ListNode* head) {
        if(!head||head->next==NULL) return head;
        auto left=new ListNode(-1),mid=new ListNode(-1),right=new ListNode(-1);//哨兵节点
        auto ltail=left,mtail=mid,rtail=right;//虚拟尾节点
        int val=head->val;
        for(auto i=head;i!=NULL;i=i->next){//以头节点val为标准进行划分，由此可生成三条链表
            if(i->val<val){
                ltail->next=i;
                ltail=ltail->next;
            }
            else if(i->val==val){
                mtail->next=i;
                mtail=mtail->next;
            }else{
                rtail->next=i;
                rtail=rtail->next;
            }
        }
        ltail->next=mtail->next=rtail->next=NULL;//结束符
        left->next=quickSortList(left->next);//左边的链表排序
        right->next=quickSortList(right->next);//右边的连接排序
        getTail(left)->next=mid->next;//左边对接中间
        getTail(left)->next=right->next;//中间对接右边，因为left和mid合成一段了，又因为mid可能为空所以用left表示中间段
        return left->next;//返回真正头节点
    }
};

AC.756蛇形矩阵

在这里插入图片描述

#include<iostream>
using namespace std;
const int N = 110;
int n, m;
int q[N][N];

int main() {
	scanf("%d%d", &n, &m);
	int dx[4] = { 0,1,0,-1 }, dy[4] = { 1,0,-1,0 };
	int x = 0, y = 0,d=0;
	for (int i = 1; i <= n*m; i++) {
		q[x][y] = i;
		int a = x + dx[d], b = y + dy[d];
		if (a < 0 || a >= n || b < 0 || b >= m || q[a][b]) {//||是只要有一个条件满足就重新寻找方向
			d = (d + 1) % 4;
			a = x + dx[d], b = y + dy[d];
		}
		x = a, y=b;将找到的方向赋给x,y
	}
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < m; j++) {
			printf("%d ", q[i][j]);
		}
		puts("");
	}

}

73.矩阵置零

在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    void setZeroes(vector<vector<int>>& matrix) {
        int N=matrix.size();
        int M=matrix[0].size();
        int st1=0,st2=0;//用于判断第0行和第0列是否需要设0
        for(int i=0;i<N;i++){
            if(matrix[i][0]==0){
                st1=1;
                break;
            }
        }
        for(int i=0;i<M;i++){
            if(matrix[0][i]==0){
                st2=1;
                break;
            }
        }
        for(int i=1;i<N;i++){
            for(int j=1;j<M;j++){//从[1][1]开始找一旦有0则记录在对应行
            //和对应列的头部也就是第0行和第0列
                if(matrix[i][j]==0){
                    matrix[i][0]=0;
                    matrix[0][j]=0;
                }
            }
        }
        for(int i=1;i<N;i++){
            if(matrix[i][0]==0){
                for(int j=0;j<M;j++){
                    matrix[i][j]=0;
                }
            }
        }
        for(int i=1;i<M;i++){
            if(matrix[0][i]==0){
                for(int j=0;j<N;j++){
                    matrix[j][i]=0;//i是列噢
                }
            }
        }
        if(st1){//最后才处理第0行和第0列，因为前面拿来装东西了，脏了，所以留最后更新
            for(int i=0;i<N;i++){
                matrix[i][0]=0;
            }
        } 
        if(st2){
            for(int i=0;i<M;i++){
                matrix[0][i]=0;
            }
        }  
    }
};

AC.1452寻找矩阵的极小值

在这里插入图片描述

// Forward declaration of queryAPI.
// int query(int x, int y);
// return int means matrix[x][y].

class Solution {
public:
    vector<int> getMinimumValue(int n) {
        typedef long long LL;//因为是比小，有可能爆int
        int l=0,r=n-1,mid;
        while(l<r){//二分按列进行划分查找，直到找到最后一列
            mid=(l+r)>>1;
            LL val=INT_MAX,res;
            for(int i=0;i<n;i++){//在当前列上找到最小值
                LL val1=query(i,mid);
                if(val1<val){
                    val=val1;
                    res=i;
                }
            }
            int n1=query(res,mid-1);//减少api调用次数
            int n2=query(res,mid+1);
            if((mid>0&&n1>val&&mid<n&&n2>val)||
            (mid==0&&mid<n&&n2>val)||(mid>0&&n1>val&&mid==n-1)){
                return {res,mid};//在左边界和右边界和中间值的极小值情况
            }else if(n2<val){
                l=mid+1;//肯定在mid列的右边列区域
            }else{
                r=mid-1;//左边区域查找
            }
        }
        LL val=INT_MAX,res;
        for(int i=0;i<n;i++){//最后一列上进行查找返回极值
            LL val1=query(i,r);
            if(val1<val){
                val=val1;
                res=i;
            }
        }
        return {res,r};
    }
};

74.搜索二维矩阵

在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        int m=matrix.size(),n=matrix[0].size();
        int l=0,r=m-1;//先在行头二分查找
        while(l<r){
            int mid=(l+r)/2;
            if(matrix[mid][0]<target){
                l=mid+1;
            }else{
                r=mid;//结果会是第一个大于等于目标值的行头
            }
        }
        if(matrix[r][0]==target) return true;
        else if(matrix[r][0]<target){//行头小过目标值说明在当前行
            int l1=0,r1=n-1;
            while(l1<r1){
                int mid=(l1+r1)/2;
                if(matrix[r][mid]<target){
                    l1=mid+1;
                }else{
                    r1=mid;
                }
            }
            if(matrix[r][r1]==target) return true;
            else return false;
        }
        else{//行头大过目标值说明在上一行
            if(r==0) return false;//特殊情况
            int l1=0,r1=n-1;
            while(l1<r1){
                int mid=(l1+r1)/2;
                if(matrix[r-1][mid]<target){
                    l1=mid+1;
                }else{
                    r1=mid;
                }
            }
            if(matrix[r-1][r1]==target) return true;
            else return false;
        }
    }
};

75.颜色分类

在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    void sortColors(vector<int>& nums) {//双指针
        int N=nums.size();
        int cnt0=0,cnt2=N-1;
        for(int i=0;i<N;i++){
            if(nums[i]==0&&i<cnt0){//如果是之前换过来的0就不用判断了
            }else if(i>cnt2){//判断到了2也不用判断了
                break;
            }
            else if(nums[i]==0){//只用排0和2，剩下就是1的位置了
                swap(nums[i],nums[cnt0]);
                cnt0++;
                if(nums[i]!=1) i--;//如果换过来的不是1还得回退重新判断
            }else if(nums[i]==2){
                swap(nums[i],nums[cnt2]);
                cnt2--;
                if(nums[i]!=1) i--;
            }
        }
    }
};

79.单词搜索

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int st[7][7];//避免回走
    int res=0;//结果
    int N,M,L;
    bool exist(vector<vector<char>>& board, string word) {
        memset(st,0,sizeof 0);
        N=board.size(),M=board[0].size(),L=word.size();
        for(int i=0;i<N;i++){
            for(int j=0;j<M;j++){
                if(board[i][j]==word[0]){//起点对了就开始dfs
                    dfs(board,i,j,word,0);
                    if(res==1) return true;
                }
            }
        }
        return res==1;
    }
    void dfs(vector<vector<char>>& board,int x,int y,string& word
    ,int idx){
        if(x<0||y<0||x>=N||y>=M||st[x][y]||word[idx]!=board[x][y]) return;//越界或者回走或者不符
        else{
            if(idx==word.size()-1){//找到，结束
                res=1;
                st[x][y]=1;
                return;
            }
            st[x][y]=1;
        }
        dfs(board,x,y-1,word,idx+1);//四个方向走一下看看
        dfs(board,x-1,y,word,idx+1);
        dfs(board,x+1,y,word,idx+1);
        dfs(board,x,y+1,word,idx+1);
        st[x][y]=0;//恢复现场
    }
};

80.删除有序数组中的重复项Ⅱ

在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int N=nums.size();
        int idx=1;//结果集是下标，原地装，因为结果集元素数必定比原来少或相等
        int cnt=1;//当前数字有几个了
        if(N<=2) return N;
        for(int i=1;i<N;i++){
            if(nums[i]!=nums[idx-1])//和前面不同就清0
                cnt=0;
            if(cnt<2){//装进结果集
                nums[idx++]=nums[i];
                cnt++;
            }
        }
        return idx;
    }
};

81.搜索旋转排序数组Ⅱ

在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    bool search(vector<int>& nums, int target) {
        int n = nums.size();
        if (!n) {
            return false;
        }
        if (n == 1) {
            return nums[0] == target;
        }
        int l = 0, r = n - 1;
        while (l <= r) {
            int mid = (l + r+1) / 2;
            if (nums[mid] == target) return true;
            if(nums[mid]==nums[l]&&nums[mid]==nums[r]){//三都相同无法判断哪边有序，
            //且这仨必定不是目标值，所以一步步减少区间
                l++,r--;
            }else if (nums[l] <= nums[mid]) {//左边有序
                if (nums[l] <= target && target <= nums[mid]) {//目标值在左
                    r = mid - 1;
                } else {//在右
                    l = mid;
                }
            } else {//右
                if (nums[mid] <= target && target <= nums[r]) {
                    l = mid;
                } else {
                    r = mid - 1;
                }
            }
        }
        return false;
    }
};

82.删除排序链表中的重复元素Ⅱ

在这里插入图片描述
在这里插入图片描述

/**
 * 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* deleteDuplicates(ListNode* head) {
        ListNode* pre=new ListNode(-1);//哨兵节点，其与now之间隔了一个节点哈
        if(head==NULL) return NULL;
        ListNode* now=head->next;
        pre->next=head;
        while(now!=NULL){
            if(now->val==pre->next->val){//now的值和前面相邻的值相同
                do{
                    now=now->next;
                }while(now!=NULL&&now->val==pre->next->val);//找到不同的为止
                if(pre->next==head) head=now;//头节点被删的话要改head
                pre->next=now;//删重复的节点
                if(now) now=now->next;//now往下走，要和pre之间隔一个格子的距离哈
            }else{
                pre=pre->next;
                now=now->next;
            }
        }
        return head;
    }
};
孤独时代的罗永浩
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MS SQL 學習紀錄-1
canon760d的博客
05-16 377
MS SQL 學習紀錄-1T-SQL 簡介T-SQL 分類資料庫練習檔案載入AdventureWorksDW資料庫載入AdventureWorks資料庫TSQL2資料庫的壓縮檔建立資料庫圖表SQL 的「查詢」「查詢視窗」各部份說明查詢資料SELECT 查詢邏輯順序編寫基本的 SELECT 查詢以 SELECT 傳回指定欄值或運算式結果使用 DISTINCT 排除重複性記錄別名資料行別名與排序的關係練習 : 編寫基本的 SELECT 查詢CASE 運算式簡單 CASE 運算式：搜尋 CASE 運算式CASE
论文研究 - 水稻几丁质酶基因的表达增强转基因荔枝中的抗真菌反应（cv。Bedana）
05-25
为了增强荔枝的抗真菌反应，通过根癌土壤杆菌介导的转化将玉米几丁质启动子下的水稻几丁质酶基因及其第一个内含子转移到合子胚中，从而产生了转基因植物。 与重组农杆菌共培养2天后，将合子胚转移到Murashige和Skoog...
LeetCode 56.合并区间（C++）
伍粟的博客
01-29 226
解题思路： class Solution { public: vector<vector<int>> merge(vector<vector<int>>& intervals) { //当输入为0的长度时 if (intervals.size() == 0) { return {}; } //排序，规定使用这种按start升序排列 sort(.
leetcode+蛇形数组，就是vector<vector<int>> 的使用
小堃哥的专栏
01-29 777
点击打开链接//蛇形数组，vector> res 赋值，先赋值给一个vectora. a再赋值给res #include #include #include #include #include #include #include #include #include using namespace std; class Solution { public: vector > generate
学习笔记数组--1119
Cheyenne98的博客
11-19 192
56. 合并区间 class Solution { public: vector<vector<int>> merge(vector<vector<int>>& intervals) { vector<vector<int>> ans; sort(intervals.begin(), intervals.end()); int n=intervals.size();
LeetCode-算法
strdhgthbbh的博客
03-25 766
文章目录4.4位运算常见的位运算布赖恩·克尼根算法/popcount/汉明权重lowbit算法位运算进行整数加法格雷码4.5排序选择排序(简单选择、堆)插入排序(直接插入、折半、希尔)交换排序(冒泡排序、快速排序)归并排序(二路归并)几种排序算法的对比(待完成)4.6 查找二分查找基本思路框架二分查找之旋转排序数组二分查找练习题目4.x 贪心算法贪心算法求解区间调度问题贪心法经典题目4.x 动态规划概述状态机动态规划求解背包问题动态规划求解最长公共子序列问题(LCS)动态规划求解最长递增子序列问题(LIS)
Java进阶-反射
最新发布
qq_56999608的博客
02-29 1265
来学习一下Java的反射，通过Class实例获取class信息的方法称为反射（Reflection）
JAVA高级编程基础自学笔记---正则表达式（常用符号死背）
测试领域专家，多领域测试技术、管理、工具都略懂，略懂一二
08-16 286
教学视频：https://edu.51cto.com/course/5667.html?source=so 正则 一、理论 所有的开发中百分百都会使用，不会用复杂的，一般几种情况下使用：验证、拆分、替换； 理论很简单，这里都懒得说了，也没有什么好说的，正则比较普通方法用起来快，比较简化。 二、记忆： 正则是在java1.4版本加入的，最早起源于liunx的，在java中是通...
Vim 使用入门 -- 转载保存
郭立东的个人博客
09-02 526
vim的学习曲线相当的大（参看各种文本编辑器的学习曲线），所以，如果你一开始看到的是一大堆VIM的命令分类，你一定会对这个编辑器失去兴趣的。下面的文章翻译自《Learn Vim Progressively》，我觉得这是给新手最好的VIM的升级教程了，没有列举所有的命令，只是列举了那些最有用的命令。非常不错。 ——————————正文开始—————————— 你想以最快的速度学习人类
读书笔记-袁腾飞讲高效学习法
weixin_33946605的博客
08-20 4921
作者：袁腾飞 李峰学序言1 没有笨学生，只有笨方法也有一些学生，他们该学的时候学，该玩的时候玩，花费的学习时间相对较少，每次考试却总能考高分，让埋头于书山题海的同学羡慕不已。这些学生的智力并不比其他学生高多少，仔细观察，你就会发现他们身上有着两大共同点：一是对学习的兴趣很高，经常保持兴奋的状态；二是很会学习，学习效率很高。主要做两件事：一是调动学生的兴趣；二是教给学生实用、高效的学习方法。序言2 ...
巧学五笔打字-----1小时可学会，不用死背字根.docx
09-27
巧学五笔打字-----1小时可学会，不用死背字根.docx
（预览版1-5页）2023网络建设与运维/网络搭建与应用/网搭Linux部分题解方法-Part4
07-18
原创"极简"与"效率"做题技巧，拒绝硬背死背命令 该链接为Part4！共13页 目录： 模块五：Samba服务 1-1."极简"做法：用户与用户组管理 1-2."效率"做法：使用for循环实现用户的批量创建 2-1."极简"做法：部署Samba...
（预览版1-5页）2023网络建设与运维/网络搭建与应用/网搭Linux部分题解方法-Part5
09-03
原创"极简"与"效率"做题技巧，拒绝硬背死背命令 该链接为Part4！共13页 目录： 模块八：Redis服务 1-1."极简"做法：在单台机器上搭建Redis主从关系 1-2."效率"做法：使用循环语句来批量快速操作 模块九：ISCSI服务 ...
（预览版1-10页）2023网络建设与运维/网络搭建与应用/网搭Linux部分题解方法-Part2
07-13
原创"极简"与"效率"做题技巧，拒绝硬背死背命令 该链接为Part2！共23页 目录： 模块一：DNS服务 1-1."极简"做法：防火墙配置 2-1."极简"做法：部署chrony服务 2-2."效率"做法：使用Ansible部署所有机器的在线软件...
算法-动态规划
weixin_45785536的博客
11-18 2979
这里写目录标题1.最长回文子串 1.最长回文子串 给你一个字符串 s，找到 s 中最长的回文子串。 class Solution { public: string longestPalindrome(string s) { int N=s.size(); int l=0,r=0; vector<vector<int>> dp=vector<vector<int>>(N,vector<int&gt
回溯法和分支限界法题集
weixin_45785536的博客
06-21 1953
目录1.分支限界选择题2.分支限界简答题3.分支限界法简答题4.回溯计算题5.分支限界法选择题![在这里插入图片描述](https://img-blog.csdnimg.cn/20210620161354236.png)6.回溯简答题7.分支限界法计算题8.分支限界法简答题9.八皇后10.带期限作业排序 1.分支限界选择题 2.分支限界简答题 3.分支限界法简答题 需要使用LC1函数选取成本估值函数作为成本函数的下界 4.回溯计算题 5.分支限界法选择题 6.回溯简答题 状态空间树
【力扣打卡--day4】【有注释有思路】
weixin_45785536的博客
01-31 1130
目录1.排序思路2.位运算（快速幂）思路3.bfs思路4.贪心思路5.双指针思路6.贪心思路7.bfs思路8.链表思路9.dp思路10.dp思路 1.排序 class Solution { public: vector<vector<string>> groupAnagrams(vector<string>& strs) { unordered_map<string,vector<string>> hash;
【力扣打卡--day6】
weixin_45785536的博客
02-01 829
目录1.链表2.链表3.栈4.dfs5.dp6.链表7.dfs8.dfs9.dp10.dp 1.链表 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0), next(nullptr) {} * ListNode(int x) : val(x), next(nullptr) {} *
想要将《汉语文化》课程从闭卷考试形式改为开卷考试形式，请你给教务处写一则请示，说明缘由，征求教务处同意。
04-10
开卷考试可以让学生更加注重学科知识的深入理解和掌握，而非死背硬记。也可以减少因为考试压力引发的紧张情绪和考试作弊行为的发生。此外，学校也应该鼓励学生的创造力、思考力和批判性思维能力的发展。希望这些信息...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值