算法备赛模板（临时）

已于 2023-09-08 08:01:24 修改
阅读量9.4k 收藏
点赞数
分类专栏： # PTA 文章标签： 数据结构 后端 算法
于 2022-04-08 23:55:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46833224/article/details/124053710
版权

⭐简单说两句⭐

作者：后端小知识

CSDN个人主页：后端小知识

🔎GZH：后端小知识

🎉欢迎关注🔎点赞👍收藏⭐️留言📝

文章目录

基础算法

一些技巧算法

前缀和

#include<bits/stdc++.h>
#define ll long long 
#define maxn 1000010
using namespace std; 
int sum[maxn]; 
int main(){
	int n,m;	cin>>n>>m;
	for(int i=1;i<=n;i++){
		int x;	cin>>x;
		sum[i]=sum[i-1]+x; 
	}
	while(m--){
		int l,r;	cin>>l>>r;
		cout<<sum[r]-sum[l-1]<<"\n"; 
	}
	return 0; 
}

差分

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10;
int a[N],b[N];//b数组为差分数组  a 数组是 b 数组的前缀和
int n,m;
int main(){
    cin.tie(0);
    ios::sync_with_stdio(false);
    cin>>n>>m;
    for(int i=1;i<=n;i++) { cin>>a[i]; b[i]=a[i]-a[i-1]; }
    while(m--){
        int l,r,c;  cin>>l>>r>>c;
        b[l]+=c; b[r+1]-=c;  //这里一定要记住 要给 b[r+1]减去 c ,
    }
    for(int i=1;i<=n;i++){
        a[i]=a[i-1]+b[i]; //求前缀和
        cout<<a[i]<<" ";
    }
    return 0;
}

字符串

回文字符串

#include <bits/stdc++.h>
using namespace std; 
int main() {
    //freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
    string s;
    cin >> s;
    int n = s.length();
    bool is = true; //bool 类型的值只有 true 和 false
    for (int i = 0; i < n / 2; i++) {
        if (s[i] != s[n - 1 - i]) {
            is = false;
        }
    }
    cout << (is ? "Yes" : "No") << "\n";
    return 0;
}

数学

前言：

求n的因子：从 1到 sqrt(n) 循环判断即可，不需要从 1 到 n

快速幂模板

#include<bits/stdc++.h>
#define ll long long 
using namespace std; 
int ans;//存结果 
//求  a的b次方 对 mode 求余的结果  即  (a^b)%mod 
//思路是将 b 转成二进制 
// 2^16次方  就是 2^8 * 2^8   ,2^8 就是 2^4 * 2^4  ... 
int quickPow(int a,int b,int mod){
	int res=1;
	while(b){
		if(b&1) res=res*a%mod;
		b>>=1;
		a=a*a%mod; 
	}
	return res; 
} 
int main(){
	int a,b,mod;
	cin>>a>>b>>mod;
	ans = quickPow(a,b,mod);
	cout<<ans; 
	return 0; 
}

矩阵快速幂

看不懂就不看

struct Mat
{
    LL m[101][101];
};//存储结构体
Mat a,e; //a是输入的矩阵，e是输出的矩阵
Mat Mul(Mat x,Mat y)
{
    Mat c;
    for(int i=1;i<=n;++i){
        for(int j=1;j<=n;++j){
            c.m[i][j] = 0;
        }
    }
    for(int i=1;i<=n;++i){
        for(int j=1;j<=n;++j){
            for(int k=1;k<=n;++k){
                c.m[i][j] = c.m[i][j]%mod + x.m[i][k]*y.m[k][j]%mod;
            }
        }
    }
    return c;
}
Mat pow(Mat x,LL y)//矩阵快速幂
{
    Mat ans = e;
    while(y){
        if(y&1) ans = Mul(ans,x);
        x = Mul(x,x);
        y>>=1;
    }
    return ans;
}

gcd与lcm

#include<bits/stdc++.h>
#define ll long long 
using namespace std; 
// 定理  gcd(a,b)*lcm(a,b) = a*b  
//最大公约数  求 a 与 b 的最大公约数 
int gcd(int a,int b){
	if(b==0) return a;
	return gcd(b,a%b);
}
//最小公倍数 
int lcm(int a,int b){
	return a*b/gcd(a,b); // 
} 
int main(){
	int a,b;
	cin>>a>>b;
	int ans1=gcd(a,b);
	int ans2=lcm(a,b);
	cout<<ans1; 
	cout<<"\n"; 
	cout<<ans2;
	return 0; 
}

闰年判断

#include<bits/stdc++.h>
using namespace std;
int main(){
	ios::sync_with_stdio(false);
	int n;	cin>>n;
	if( (n%4==0&&n%100!=0) || n%400==0) cout<<"yes";
  	else cout<<"no";
	return 0; 
}

质数

判断是不是质数

int f(int x){ //判断 x 是不是质数  
	if(x==1) return 0;
	for(int i=2;i<=sqrt(x);i++) if(x%i==0) return 0;
	return 1;
}

质因数分解

#include<bits/stdc++.h>
using namespace std;
int a,b;
int prime[1000010];//存储质数
int ht[1000010];
struct tx{
	int x,y;
}c[20];
int ans[100];
int ct1=0;
int main(){
	ios::sync_with_stdio(false);
	cin>>a>>b;
	int ct=0;
	for(int i=2;i<=b;i++){//预处理质数
		if(!ht[i]){
			prime[ct++]=i;// 将质数加入到 数组中
			for(int j=i*i;j<b;j=j+i) ht[j]=true;  //将 改质数的倍数全部 标记为合数
		}
	}
	//分解质因数 
	for(int i=a;i<=b;i++){ //对 a  到 b 的每一数进行分解
		int t=i;
		int len=0;
		for(int j=0;j<ct;j++){ //这里是核心
			if(t%prime[j]==0){
				c[len].x=prime[j];
				c[len].y=0;
				while(t%prime[j]==0){
					c[len].y++;
					t/=prime[j];
				}
				len++;
			}
		}
		cout<<i<<"=";
		for(int j=0;j<len;j++){
			int t2 = c[j].y;
			for(int k=0;k<t2;k++){
				ans[ct1++]=c[j].x;
			}
		}
		for(int j=0;j<ct1;j++){
			if(j!=0) cout<<"*"; cout<<ans[j];
		}
		ct1=0;
		cout<<"\n";
//		memset(c,0,sizeof(c));
		memset(ans,0,sizeof(ans));
	}
    return 0;
}

组合

image-20220408231820834

图片来自acwing

https://www.acwing.com/problem/content/887/

普通版的递推求法，还没有优化

#include<bits/stdc++.h>
#define ll long long 
#define maxn 2010 
using namespace std; 
int n;
int mod = 1e9+7;
int c[maxn][maxn];//和数学中的求组合一样， 表示几个中选几个的结果 
void init(){
	for(int i=0;i<=2000;i++){
		for(int j=0;j<=i;j++){
			if(!j) c[i][j]=1;
			else c[i][j]=(c[i-1][j]+c[i-1][j-1])%mod;
		}
	}
} 
int main(){
	init(); 
	cin>>n;
	while(n--){
		int a,b;	cin>>a>>b;
		cout<<c[a][b]<<"\n";
	}
	return 0; 
}

卡特兰数

image-20220409073253643

1 2 5 14 42 132 429

class Solution {
public:
    int numTrees(int n) {
        long long C = 1;
        for (int i = 0; i < n; ++i) {
            C = C * 2 * (2 * i + 1) / (i + 2);
        }
        return (int)C;
    }
};

杨辉三角

普通法

#include<bits/stdc++.h>
using namespace std;
int n;
int a[100][100];//存储杨辉三角每一行的内容
int main(){
	cin>>n;
	for(int i=1;i<=n;i++){//控制行
		for(int j=1;j<=i;j++){
			if(i==j||j==1) a[i][j]=1;//根据观察得出的
			else a[i][j]=a[i-1][j]+a[i-1][j-1]; //根据观察易得
		}
	}
	for(int i=1;i<=n;i++){
		for(int j=1;j<=i;j++){
			cout<<a[i][j]<<" ";
		}
		cout<<"\n";
	}
	return 0;
}

搜索

全排列

#include<bits/stdc++.h>
using namespace std;
int n;
int a[10];
bool b[10];
int dfs(int x){
    if(x==n){
        for(int i=0;i<n;i++) cout<<a[i]<<" ";
        cout<<"\n";
        return 0;
    }
    for(int i=1;i<=n;i++){
        if(!b[i]){
            a[x]=i;
            b[i]=true;
            dfs(x+1);
            b[i]=false;
        }
    }
}
int main(){
    cin>>n;
    dfs(0);
    return 0;
}

组合

#include<bits/stdc++.h>
using namespace std;
int a[10],b[10];
int n;
void dfs(int x,int st){
    if(x>=3){
        for(int i=0;i<3;i++) cout<<a[i];
        cout<<"\n";
        return ;
    }
    for(int i=st;i<=n;i++){
        if(!b[i]){
            a[x]=i;
            b[i]=true;
            dfs(x+1,st+1);
            b[i]=false;
        }
    }
}
int main(){
    cin>>n;
    dfs(0,1);
    return 0;
}

迷宫

#include<bits/stdc++.h>
using namespace std;
int n,m;
typedef pair<int,int> PII; //用来存点，用pair方便点点
const int N=110; //数据范围
int g[N][N],d[N][N];// g数组装整个图，  d数组表示某点到原点的距离
int bfs(){
    queue<PII> q;
    q.push({0,0});//首先起点入队
    memset(d,-1,sizeof d);//将最开始的所有点到起点的距离都设置为-1
    d[0][0]=0;//起点到起点的距离设置为0,
    int dx[4]={0,1,0,-1},dy[4]={1,0,-1,0}; /*方向数组，随便向那个方向扩展都得行，
    我的是上(x不变，y会加1)右（x会加1，y不变）下（x不变，y会减1）左（x会减1，y不变）*/
    while(!q.empty()){
        auto t = q.front();//取出队首元素
        q.pop();//队首出队
        for(int i=0;i<4;i++){//向4个方向扩展
            // x,y 为扩展后的， t装的是拓展前的坐标
            int x=t.first+dx[i];
            int y=t.second+dy[i];
            //满足边界条件，拓展的点的位置没有障碍，在之前没有被访问过（距离为-1就表示没访问过）
            if(x>=0&&x<n&&y>=0&&y<m&&g[x][y]==0&&d[x][y]==-1){
                d[x][y]=d[t.first][t.second]+1;//更新距离
                q.push({x,y});//将成功扩展的点入队
            }
        }
    }
    return d[n-1][m-1];//最终 d[n-1][m-1] 就是右下角到左上角的需要移动的最短距离
}
int main(){
    cin>>n>>m;
    //读入图的信息
    for(int i=0;i<n;i++)
        for(int j=0;j<m;j++)
            cin>>g[i][j];
    cout<<bfs()<<"\n";//输出结果
}

并查集

#include<bits/stdc++.h>
using namespace std;
// const int n=1000010;
int m,n;
int p[1000010];//存储节点的父亲
int findX(int x){//采用了路径压缩
    if(x!=p[x]) p[x]=findX(p[x]);
    return p[x];
}
int main(){
//    cin.tie(0);
//    ios::sync_with_stdio(false);
    cin>>n>>m;
    for(int i=1;i<=n;i++) p[i]=i;
    while(m--){
        string x;
        int a,b;
        cin>>x>>a>>b;
        if(x=="M") p[findX(a)] = findX(b);
        else{
            if(findX(a)==findX(b)) cout<<"Yes\n";
            else cout<<"No\n";
        }
    }

    return 0;
}

图

spfa求最短路

#include<bits/stdc++.h>
using namespace std;
#define maxn 1000010
int n,m;
//dist表示某点到起点的距离  
//st表示某个点是否加入队列 true表示没加入,反之则加入 
int dist[maxn],st[maxn];  
// h:头结点  w:权重  e:边  ne:下一个点   idx就表示节点 
int h[maxn],w[maxn],e[maxn],ne[maxn],idx;
void add(int a,int b,int c){//邻接表  模板，背到就可以   
	e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}
int spfa(){
	memset(dist,0x3f,sizeof(dist));//将初始距离设为很大的数 
	queue<int> q;
	dist[1]=0;// 初始化第一个点到第一个点的距离为 0 ,方便后面的计算 
	q.push(1);// 先将第一个点加入队列 
	st[1]=true;//第一个点加入了队列，所以 st[1] = true 
	while(!q.empty()){//广搜的模板 
		int t = q.front();//取出第一个节点 
		q.pop();//取出了后，就要出队列 
		st[t]=false;//取出后，没在队列了，设置为 false 
		for(int i=h[t];i!=-1;i=ne[i]){//更新t的出边 
			int j = e[i];//获得和t相连的点
			if(dist[j]>dist[t]+w[i]){//如果可以距离变得更短，则更新距离
				dist[j]=dist[t]+w[i];
				if(!st[j]){//如果没在队列中,可以入队 
					q.push(j);
					st[j]=true;//入队了，设置为false 
				} 
			}
		}
	}
	return dist[n]==0x3f3f3f3f?-2:dist[n];
}
int main(){
	cin>>n>>m;
	memset(h,-1,sizeof(h));//这一步不能忘记 
	while(m--){
		int x,y,z;	cin>>x>>y>>z;
		add(x,y,z);
	}
	int ans=spfa();
	if(ans!=-2) cout<<dist[n];
	else cout<<"impossible"; 
	
	return 0;
}

参考了博客：https://www.acwing.com/solution/content/105508/

动态规划

01背包

https://www.acwing.com/problem/content/2/

#include<bits/stdc++.h>
#define ll long long 
using namespace std; 
#define maxn 10010
int N,V;// N件物品，V为背包体积 
int v[maxn],w[maxn];// v数组装物品的体积 , w数组装物品的价值 
int dp[10010];
int main(){
	cin>>N>>V;
	for(int i=1;i<=N;i++) cin>>v[i]>>w[i];
	for(int i=1;i<=N;i++){
		for(int j=V;j>=v[i];j--){//dp[j]为 容量为j的背包所背的最大价值 
			dp[j]=max(dp[j],dp[j-v[i]]+w[i]);	
		}
	} 
	cout<<dp[V]; 
	return 0; 
}

完全背包

https://www.acwing.com/problem/content/description/3/

#include<bits/stdc++.h>
#define ll long long 
using namespace std; 
#define maxn 10010
int N,V;// N件物品，V为背包体积 
int v[maxn],w[maxn];// v数组装物品的体积 , w数组装物品的价值 
int dp[10010];
int main(){
	cin>>N>>V;
	for(int i=1;i<=N;i++) cin>>v[i]>>w[i];
	for(int i=1;i<=N;i++){
		for(int j=v[i];j<=V;j++){//dp[j]为 容量为j的背包所背的最大价值 
			dp[j]=max(dp[j],dp[j-v[i]]+w[i]);	
		}
	} 
	cout<<dp[V]; 
	return 0; 
}

多重背包

https://www.acwing.com/problem/content/description/4/

强制拆分成 01 背包来做

#include<bits/stdc++.h>
#define ll long long 
using namespace std; 
#define maxn 100010
int N,V;// N件物品，V为背包体积 
int v[maxn],w[maxn];// v数组装物品的体积 , w数组装物品的价值 
int dp[10010];
int len=0;//用来记录 v 与 w 数组的长度 
int main(){
	cin>>N>>V;
	for(int i=1;i<=N;i++){
		int vi,wi,s;	cin>>vi>>wi>>s;
		while(s--){//拆成 01 背包来做
			v[++len]=vi;
			w[len]=wi; 
		} 
	} 
	for(int i=1;i<=len;i++){//这里就是有 len 个物品了
		for(int j=V;j>=v[i];j--){//dp[j]为 容量为j的背包所背的最大价值 
			dp[j]=max(dp[j],dp[j-v[i]]+w[i]);	
		}
	} 
	cout<<dp[V]; 
	return 0; 
}

分组背包

#include<bits/stdc++.h>
#define ll long long 
using namespace std; 
#define maxn 150
int N,V;// N件物品，V为背包体积 
int v[maxn][maxn],w[maxn][maxn],s[maxn];// v数组装物品的体积 ,w数组装物品的价值 ,s数组表示第每组物品的个数 
int dp[10010];
int len=0;//用来记录 v 与 w 数组的长度 
int main(){
	cin>>N>>V;
	for(int i=1;i<=N;i++){
		cin>>s[i];
		for(int j=0;j<s[i];j++){
			cin>>v[i][j]>>w[i][j];
		}
	} 
	for(int i=1;i<=N;i++){// n组 
		for(int j=V;j>=0;j--){
			for(int k=0;k<s[i];k++){
				if(v[i][k]<=j) dp[j]=max(dp[j],dp[j-v[i][k]]+w[i][k]);
			}
		}
	} 
	cout<<dp[V]; 
	return 0; 
}

【都看到这了，点点赞点点关注呗，爱你们】😚😚

抽象工厂 引导关注

结语

谢谢你的阅读，由于作者水平有限，难免有不足之处，若读者发现问题，还请批评，在留言区留言或者私信告知，我一定会尽快修改的。若各位大佬有什么好的解法，或者有意义的解法都可以在评论区展示额，万分谢谢。
写作不易，望各位老板点点赞，加个关注!😘😘😘

💬

作者：后端小知识

CSDN个人主页：后端小知识

🔎GZH：后端小知识

🎉欢迎关注🔎点赞👍收藏⭐️留言📝

小叮当撩编程
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
算法竞赛 Linux操作 Linux 备赛
10-05
介绍Linux系统下vscode的命令 准备CCF相关比赛的OIer 赛前复习 记得保存~~
数据结构与算法比赛常用核心模板板子
04-18
大学四年打比赛用的所有板子，数据结构与算法中常用的核心算法，大家在拿到之后使用最好加以理解，这样才能真正内化到自己的知识库里，量多且实惠，背住你就无敌了
算法比赛模板
03-16
通过一些宏定义等，降低写代码的数量
用于 ACM 类比赛的算法代码模板.zip
06-06
ACM 类比赛的算法代码模板.zip用于 ACM 类比赛的算法代码模板.zip用于 ACM 类比赛的算法代码模板.zip用于 ACM 类比赛的算法代码模板.zip用于 ACM 类比赛的算法代码模板.zip用于 ACM 类比赛的算法代码模板.zip用于 ...
建议收藏算法基础课模板大全
08-12
基础算法 —— 代码模板链接 常用代码模板1——基础算法 排序 二分 高精度 前缀和与差分 双指针算法 位运算 离散化 区间合并 数据结构 —— 代码模板链接 常用代码模板2——数据结构 链表与邻接表：树与图的存储 ...
插入和选择排序
c23856的博客
07-20 522
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
【数据结构】搜索二叉树
dab112的博客
07-24 517
介绍了二叉搜索树的实现与模拟
数据结构（二叉树-1）
2401_83968713的博客
07-20 1062
树是⼀种⾮线性的数据结构，它是由nn>=0） 个有限结点组成⼀个具有层次关系的集合。把它叫做 树是因为它看起来像⼀棵倒挂的树，也就是说它是根朝上，⽽叶朝下的。有⼀个特殊的结点，称为根结点，根结点没有前驱结点。除根结点外，其余结点被分成M(M>0)个互不相交的集合T1T2……Tm，其中每⼀个集合⼜是⼀棵结构与树类似的⼦树。每棵⼦树的根结点有且只有⼀个前驱，可以有0个或多个后继。因此，树是递归定义的。树形结构中，⼦树之间不能有交集，否则就不是树形结构。
【手撕数据结构】把玩顺序表
apple_61439616的博客
07-19 955
顺序表是⽤⼀段物理地址连续的存储单元依次存储数据元素的线性结构，⼀般情况下采⽤数组线性结构又是什么意思，这就不得不提到线性表了线性表（linear list）是n个具有相同特性的数据元素的有限序列线性表是⼀种在实际中⼴泛使 ⽤的数据结构，常⻅的线性表：顺序表、链表、栈、队列、字符串注意的是，他在逻辑结构上一定是连续的，但在物理结构上不一定是连续的.线性表在物理上存储时，通常以数组和链式结构的形式存储那么我们知道，数组在内存中存储也是连续的，并且也是类型一致，那么他与顺序表的区别是什么呢.
数据结构——二叉树定义
鲸落博客
07-23 364
二叉树是一种树形数据结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点。每个子节点本身又可以是一个二叉树。二叉树在计算机科学中有着广泛的应用，例如在搜索算法、排序算法等领域二叉树(Binary Tree)是n(n≥0)个结点的有限集合，该集合 或者为空集(称为空二叉树),或者由一个根结点和两棵互不相交 的、分别称为根结点的左子树和右子树的二叉树组成。
《数据结构：栈和队列》
2401_83305953的博客
07-19 660
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行插入和删除操作的一端称为栈顶，另一端称为栈底。概念：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)队列也可以由数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。：栈的插入操作叫做进栈/压栈/入栈/，入数据在栈顶。
2024.7.24 作业
qq_64434282的博客
07-24 321
【代码】2024.7.24 作业。
数据结构的概念和术语
最新发布
2303_78660417的博客
07-24 332
数据结构是一门研究非数值计算的程序设计中计算机的操作对象以及它们之间的关系和操作的学科。数据结构的基本数据结构包括两部分，线性结构跟非线性结构。
数据结构：二叉搜索树（简单C++代码实现）
2301_79171011的博客
07-22 825
本文将深入探讨二叉搜索树这一重要的数据结构。二叉搜索树不仅是一个功能强大的数据结构，而且在实际应用中展现出了极高的实用性。它以其独特的组织方式，使得查找、插入和删除操作都能在平均对数到线性时间内完成，从而大大提高了数据处理的效率。为了更好地理解二叉搜索树的工作原理，我们使用C++语言实现了一个简单的二叉搜索树。通过本文的阐述，相信你应该对二叉搜索树的基本概念、特性以及操作方法已经有了一定的了解。不过想要掌握这个数据结构，还需要亲自上手编写一个二叉搜索树的代码。通过编码实践，才能更深刻体会到内部的工作机制。
数据结构（1）
m0_63067779的博客
07-22 255
集合举例：候车室线性举例：排队问题，随着时间推移，后面不断地有人来，我慢慢往前挪树：图：网络节点，地图路线顺序存储：数组存链式：malloc申请空间，用链表存左边最好，右边最差。
初识数据结构中的“栈”
D1557329860的博客
07-21 214
除了入栈和出栈操作外，还可以对栈进行其他操作，如查看栈顶元素（peek）和判断栈是否为空等。此外，由于栈的后进先出特性，它也常被用于实现一些需要这种特性的算法，如深度优先搜索等。此外，在算法设计中，栈也常被用于实现一些复杂的逻辑，如表达式求值、括号匹配等。在栈中，数据的添加和移除都仅在栈顶进行，这种操作方式使得栈具有一种“后进先出”的特性。也就是说，最后一个被放入栈中的元素将会是第一个被取出的元素。总的来说，栈是一种非常有用的数据结构，它的后进先出特性和基本操作方式使得它在处理特定问题时具有独特的优势。
（10）深入理解pandas的核心数据结构：DataFrame高效数据清洗技巧
架构筑梦的Cherry Yang的博客
07-20 1096
# 1. DataFrame数据清洗 在Python中，使用pandas库处理DataFrame时，高效的数据清洗是数据预处理的关键步骤之一。以下是一些高效的数据清洗技巧： ## 1.1 处理缺失值（NaNs） 在现实世界中，数据大多是杂乱无章的;它有多种形式和形状，并且有许多缺失值。有趣的是，根据 IBM Data Analytics 的数据，数据科学家花费高达 80% 的时间来查找、清理和组织数据。幸运的是，pandas 提供了许多强大、快速和高效的方法来检测、删除和替换 pandas DataFra
【手撕数据结构】把玩栈
apple_61439616的博客
07-21 188
栈(stack)，栈遵守先进后出的原则，即先入栈的数据后出栈，插入数据是在栈顶插入，被称为压栈。出栈也是与顺序表的尾删一样的，这里直接将top减减，不影响后面再次在那个位置插入数据，会直接覆盖.但需检测栈是否为空，若为空，则不能进行出栈操作。进行入栈操作前，我们需要检测栈的当前状态，若已满，则需要先对其进行增容，然后才能进行入栈操作。栈的内存空间是动态开辟出来的，当我们使用完后必须释放其内存空间，避免内存泄漏。因为栈也是一种线性表，并且在物理结构上也是连续的，所以我们底层采用数组(顺序表)实现。
【数据结构】稀疏数组
2302_78914800的博客
07-24 214
当一个数组中大部分元素为0，或者为同一个值时，可以使用稀疏数组来保存该数组。稀疏数组的处理方法是：①记录数组一共有几行几列有多少个不同的非零值（该内容放在稀疏数组的第一行）②把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模稀疏数组总是一个 ”行不确定但是列是三列“ 的数组。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小叮当撩编程

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值