寒假第一周总结（c++）

最新推荐文章于 2024-07-18 17:40:16 发布
最新推荐文章于 2024-07-18 17:40:16 发布
阅读量1.9k 收藏 56
点赞数 44
文章标签： c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fearlessness6/article/details/135851795
版权

寒假第一周总结

一.排序

1.1快速排序

算法思想：分治，将要排序的部分分为两部分，通过比较互换是得左半部分比由半部分都要小，再对两部分继续以上步骤，可以递归实现。
【模版题】
快速排序
下面展示一些 代码。

#include <iostream>
using namespace std;
#define N 100005
int a[N];
void sort(int a[],int l,int r){
	if(l >= r)return;//先判断退出条件
	int i = l - 1,j = r + 1,x =a[r + l>>1];//r + l >> 1就等同于(r + l)/2,这里l - 1和r + 1是因为下面用的是do,while，用x来分割
	while(i < j){
		
		do i++;while(a[i] < x);//i 从小开始增加，找到第一个大于x的值
		do j--;while(a[j] > x);//j 从大开始减，找到第一个小于x的值
		if(i < j) swap(a[i],a[j]);//将他们互换可以让小的去左部分，大的去右边
	}
	sort(a,l,j),sort(a,j+1,r);//再对左右两部分分别操作
}
int n;

int main() {
	cin >> n;
	for(int i = 1;i <= n;i++) {
		cin >> a[i];
	}
	sort(a,1,n);
	for(int i = 1;i <= n;i++) {
		cout<< a[i]<<' ';
	}
	return 0;
}

主要思路：找基准值，不断找左半部分大于基准值的与右半部分小于基准值的进行互换，让醉半部分都小于基准值，右半部分大于基准值。

1.2归并排序

主要思想：将数组不断二分，对每个子数组进行排序，然后将已经排序的数组合并为一个有序的数组。
【模版题】
归并排序
下面展示一些 代码。

#include<iostream>
using namespace std;
const int N = 1000010;

int n;
int q[N], tmp[N];

void merge_sort( int q[], int l, int r)//传入要排序数组，传入左右边界
{
	if(l >= r) return;//运用递归函数一定要先判断结束条件避免死循环
	
	int mid = l + r >> 1;//l + r >> 1等同于(l + r)/2，找到中间位置接下来分解
	
	merge_sort(q, l, mid),merge_sort(q, mid + 1, r);//将数组不断分解直到只有一个元素，在这里默认只有一个元素的时候是有序的
	
	int k = 0, i = l, j = mid + 1;//这里i和j为分成的两部分的起始位置,开始合并数组
	while(i <= mid && j <= r)
		if(q[i] < q[j]) tmp[k++] = q[i++];//左右两部分开始遍历，将娇小的一个先放进tmp里这样tmp就是有序的
	else tmp[k++] = q[j++];
	while(i <= mid) tmp[k++] = q[i++];//这里是合并的时候可能左部分或有部分都放进了tmp里，因为两部分都是有序的所以直接把剩余的加入
	while(j <= r) tmp[k++] = q[j++];//看上行解释
	for(i = l, j = 0; i <= r; i++, j++) q[i] = tmp[j];//传入的左右区间是l,r这里重新把tmp的值赋给q
}

int main()
{
	scanf("%d", &n);
	for(int i = 0; i < n; i++) scanf("%d", &q[i]);
	merge_sort(q, 0, n - 1);
	for(int i = 0; i < n; i++) printf("%d ", q[i]);
	return 0;
}

【例题】求逆序对的个数
求逆序对的个数
思路：将数组不断二分但是他们的下标还是从大到小的，这里我们只要在归并排序的前提下稍微一变就可以了，当出现了q[ i ] > q[ j ],又因为是有序的，说明左半部分剩余的元素都能与当前的这个q[ j ]组成逆序对

主要修改部分：
下面展示一些 主要修改部分（就归并排序）。

 while(i <= mid && j <= r)
        if(q[i] <= q[j]) tmp[k++] = q[i++];
        else tmp[k++] = q[j++],ans+=mid-i+1;//这里是关键，因为左部分i <= mid,下标只差需要加一，比如3 ~ 5 ——>5 - 3 + 1 = 3;

下面展示一些 完整代码。

#include<iostream>
using namespace std;
const int N = 1000010;
 
int n;
long long ans;
int q[N], tmp[N];
 
void merge_sort( int q[], int l, int r)
{
    if(l >= r) return;
 
    int mid = l + r >> 1;
 
    merge_sort(q, l, mid),merge_sort(q, mid + 1, r);
 
    int k = 0, i = l, j = mid + 1;
    while(i <= mid && j <= r)
        if(q[i] <= q[j]) tmp[k++] = q[i++];
        else tmp[k++] = q[j++],ans+=mid-i+1;
    while(i <= mid) tmp[k++] = q[i++];
    while(j <= r) tmp[k++] = q[j++];
    for(i = l, j = 0; i <= r; i++, j++) q[i] = tmp[j];
}
 
int main()
{
    scanf("%d", &n);
    for(int i = 1; i <= n; i++) scanf("%d", &q[i]);
    merge_sort(q, 1, n );
    cout << ans<< endl;
    return 0;
}

二.二分

思想：首先确定搜索区间，然后比确认新的搜索区间，再进行归并查找时间复杂度为O(logN),比较快，（有序）
有个基本的框架
下面展示一些 基本框架。


            int l = 0, r = n - 1;
            while (l < r)
            {
                int mid = l + r + 1 >> 1;
                if (q[mid] <= x) l = mid;
                else r = mid - 1;
            }

            cout << l << endl;

【模版题】
二分模版
思路：通过用两次二分找到左右区间，每次比较中间值
下面展示一些 参考代码。

#include <iostream>

using namespace std;

const int N = 500010;

int n, m;
int q[N];

int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; i ++ ) scanf("%d", &q[i]);

    while (m -- )
    {
        int x;
        scanf("%d", &x);

        int l = 0, r = n - 1;
        // 二分查起始位置
        while (l < r)
        {
            int mid = l + r >> 1;
            if (q[mid] >= x) r = mid;
            else l = mid + 1;
        }
        
        if (q[l] != x) cout << "-1 -1" << endl;
        
        else
        {
            cout << l << ' ';

            int l = 0, r = n - 1;
            while (l < r)
            {
                int mid = l + r + 1 >> 1;
                if (q[mid] <= x) l = mid;
                else r = mid - 1;
            }

            cout << l << endl;
        }
    }

    return 0;
}

三.高精度

一般都有A + B , A - B , A * B（高**低） , A / B（高 / 低）。
这里用数组存储

3.1加法

直接上模版题
高精度加法
思路：输入字符串代表要相加的数，每一位逆序存入数组，便于从个位对齐，再用一个数组存储相加之后的值，用temp存储进位。
下面展示一些 内联代码片。

#include<iostream>
#include<stdio.h>
#include<cstring>
#include<cmath>
using namespace std;
#define N 100005
int a[N],b[N],all[N];
char ac[N],bc[N];
int len1,len2,len3;
int main(){
	cin>>ac>>bc;
	len1 = strlen(ac);//计算位数
	len2 = strlen(bc);
	len3 = max(len1,len2) + 1;//可能进位需要预留
	int temp = 0;//进位
	for(int i = 0;i < len1;i ++) a[i] = ac[len1 - i - 1] - '0';//字符要转化为数字，逆序相加
	for(int i = 0;i < len2;i ++) b[i] = bc[len2 - i - 1] - '0';
	for(int i = 0;i < len3;i ++){
		all[i] = a[i] + b[i] + temp;//模拟算式相加
		temp = all[i]/10;
		all[i] %= 10;//取个位
		
	}
	while(len3 > 0 && all[len3] == 0)len3--;
	for(int i = len3;i >= 0;i --){
		cout<<all[i];
	}
	return 0;
}

3.2减法

思路；同样模拟数学中的计算过程，但是需要判断一下第一个数与第二个数的大小，逐位相减；
【模版题】
高精度减法
下面展示一些 代码。

#include<iostream>
#include<vector>
using namespace std;//需要计算当前结果和处理借位和进位

bool cmp(vector <int>A,vector <int>B)
{
	if(A.size()!=B.size()) return A.size()>B.size();
	for(int i=A.size()-1;i>=0;i--){
		if(A[i]!=B[i])
			return A[i]>B[i];
	}
	return true;
}

vector<int> sub(vector <int>A,vector<int>B)
{
	vector<int>v;
	for(int i=0,t=0;i < A.size();i++){
		t=A[i]-t;
		if(i < B.size())t-=B[i];
		v.push_back((t+10)%10);
		if(t<0)t = 1;
		else t=0;
	}
	while(v.size()>1 && v.back()==0) v.pop_back();
	return v;
	
}
int main()
{
	string a,b;
	vector <int>v1,v2;
	cin>>a>>b;
	vector <int>c;
	for(int i=a.size()-1;i>=0;i--)v1.push_back(a[i]-'0');//字符转化为数字
	for(int i=b.size()-1;i>=0;i--)v2.push_back(b[i]-'0');
	if(cmp(v1,v2))  c=sub(v1,v2);
	else  {
		c=sub(v2,v1);
		cout<<'-';
	}
	for(int i=c.size()-1;i>=0;i--)
		cout<<c[i];
	cout<<endl;
	return 0;
}

3.3乘法

高精度*低精度，尽量把低精度数看成一个整体，用一个变量存储进位后剩余的数用于加到下一位；
【模版】
下面展示一些 参考代码。

#include<iostream>
#include<vector>
using namespace std;

vector<int>mul(vector<int>A,int b)
{
	vector<int>c;
	int t=0;
	for(int i=0;i<A.size()||t;i++){
		if(i<A.size())t+=A[i]*b;// 
		c.push_back(t%10);
		t/=10;
	}
	while(c.size()>1 && c.back()==0) c.pop_back();
	return c;
}
int main()
{
	string a;
	int b;
	cin>>a>>b;
	vector <int>v;
	for(int i=a.size()-1;i>=0;i--) v.push_back(a[i]-'0');//记得转化为数字做的时候忘记了
	auto c=mul(v,b);//auto 很好用它会根据c的类型而定
	for(int i=c.size()-1;i>=0;i--) cout<<c[i];
	cout<<endl;
	return 0;
}

3.4除法

高精度 ÷ 低精度 除法从数学算式可以看出来是高位对齐，所以不需要倒序
请添加图片描述
下面展示一些 内联代码片。

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

vector<int> div(vector<int> A,int b,int &r){
    vector<int> C;
    r = 0;
    for(int i = A.size() - 1;i >= 0;i--){
        r = r*10 + A[i];
        C.push_back(r/b);
        r %= b;
    }
    reverse(C.begin(),C.end());
    while(C.size() > 1 && C.back() == 0) C.pop_back();
    return C;
}

int main(){
    string a;
    int b;
    cin >> a >> b;
    vector<int> A;
    for(int i = a.size()-1;i >= 0;i--) A.push_back(a[i]-'0');//记得转化为数字
    int r;
    auto C = div(A,b,r);//auto自动根据输入判断类型
    for(int i = C.size()-1;i >=0;i--) cout << C[i] ;
    cout << endl;
    cout << r << endl;
    return 0;
    
}

四.前缀和和差分

前缀和最好是从下标1开始不用处理边界问题

4.1一维前缀和

用另一个数组sum来存储前面的和，sum[ i - 1] + a[i];
【模版】前缀和

下面展示一些 内联代码片。

#include <iostream>
using namespace std;
const int N = 1e5 + 10;
int n,q,a[N],s[N];
int main()
{
	cin >> n >> q;
	for(int i = 1;i <= n;i++) cin >> a[i];
	for(int i = 1;i <= n;i++) s[i] = s[i - 1] + a[i];//记录前i项的和
	while(q--)
	{
		int l,r;
		cin >> l >> r;
		if(l > r)//注意l和r的大小关系
		{
			int temp = l;
			l = r;
			r = temp;
		}
		cout << s[r] - s[l - 1] << endl;//记得l - 1,l那一位也要加上
	}
	return 0;
}

4.2二维前缀和

放在一个二维表格中来看，两条边还是一位前缀和，但其他位置就是sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + sum[i][j];
计算的时候有重复减掉的区域要加上
请添加图片描述

【模版】
请添加图片描述
下面展示一些 参考代码。

#include <iostream>
using namespace std;

const int N=1005;
int s[N][N];
int main()
{
    int n,m,q;
    cin>>n>>m>>q;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            cin>>s[i][j];
            s[i][j]+=s[i-1][j]+s[i][j-1]-s[i-1][j-1];
        }
    }
    while(q--)
    {
        int x1,y1,x2,y2;
        cin>>x1>>y1>>x2>>y2;
        cout<<s[x2][y2]-s[x1-1][y2]-s[x2][y1-1]+s[x1-1][y1-1]<<endl;
    }
    return 0;
}

4.3差分

建造一个新数组q对于存入l ~ r都加c，只需要b[l] += c,b[r + 1] -= c,再对b数组进行前缀和操作加上原数组就是最后的值
【模版】
请添加图片描述
下面展示一些 差分代码。

#include<iostream>
using namespace std;
int n,m;
const int  N = 100005;
int a[N],b[N]; 

void insert(int l ,int r,int c){
	
	b[l]+=c; 
	
	b[r+1]-=c; 
}

int main(){
	cin >> n >> m;
	for(int i = 1; i <= n;i++) scanf("%d",&a[i]);
	
	for (int i = 1; i <= n; i ++ ) insert(i, i, a[i]);
	while(m --){
		int l , r, c;
		cin >> l >> r >> c;
		insert(l,r,c);
	}
	
	for(int i = 1;i <= n;i++) b[i] += b[i-1];//对b进行前缀和，这样就实现了l到r都加上了目标值
	for(int i = 1;i <= n;i++) printf("%d ",b[i]);
	return 0;
}

4.4二维差分

如果给b[ i ][ j ]加上c则右下角的数都会加上c
这样就需要特殊处理
主要部分
这样就把不需要加的部分给减掉了
要加上a[x2 + 1][y2 + 1] = c.因为右下角被减了两遍
【模版】

差分矩阵
下面展示一些 内联代码片。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>

using namespace std;
int a[1010][1010];
void fun(int x1,int y1,int x2,int y2,int c){//主要代码
    a[x1][y1]+=c;
    a[x2+1][y1]-=c;
    a[x1][y2+1]-=c;
    a[x2+1][y2+1]+=c;
}
int main(){
    int n,m,q;
    cin>>n>>m>>q;
    int t;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++){
            cin>>t;
            fun(i,j,i,j,t);
        }
    int x1,x2,y1,y2,k;
    while(q--){
        scanf("%d%d%d%d%d",&x1,&y1,&x2,&y2,&k);
        fun(x1,y1,x2,y2,k);
    }
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            a[i][j]+=a[i-1][j]+a[i][j-1]-a[i-1][j-1];
            printf("%d ",a[i][j]);
        }
        cout <<endl;
    }

    return 0;
}

五.双指针算法

有左右指针还有快慢指针等，优点可以通过特殊指针操作节省时间，可以让指针逐渐靠近达到目的，比较灵活好用，避免循环1嵌套；
一般都是先想到暴力的解法然后再想优化
【模版】

最长连续不重复子序列
下面展示一些 参考代码。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
#define N 100005
int n,ans;
int a[N],b[N];
int main(){
    cin >> n;
    for(int i = 0;i < n;i++) {
        cin >> a[i];
    }
    int i = 0,j=0;
    for( i = 0,j=0;i < n;i++) {
        b[a[i]]++;//记录每个数字出现的次数
        while(b[a[i]] > 1){//说明已经有重复数字j开始向右移动
            b[a[j]]--;
            j++;
        }
        ans=max(ans,i-j+1);
    }
    cout<<ans;
    return 0;
}

六.位运算

【例题】
二进制一的个数
***思路：***这里用一种比较巧妙的思路，定义一个变量f为一于目标值相与如果为一答案加一然后f = f << 1;直到f == 0 为止
下面展示一些 内联代码片。

#include<iostream>
using namespace std;
int n;
int sum(int x){
	int cnt = 0;
	int f = 1;
	while(f){//当 f 左移32位后就是0
		if(f&x){
			cnt++;	
		}
		f = f << 1;//逐渐左移只有相与一位是一其他都是零
	}
	return cnt;
}
int main(){
	cin>>n;
	for(int i = 1;i <= n;i ++){
		int p;
		cin>>p;
		cout<<sum(p)<<' ';
	}
	return 0;
}

七.离散化

将跨度很大但是个数不多的数据离散化成连续的数据
1.先排序：对要离散化的数据排序，可以使用sort
2.去重：然后去重，c++可以使用unique（）和lower_bound,
3.索引
可以节省空间
sort(alls.begin(),alls.end());
alls.erase(unique(alls.begin(),alls.end()),alls.end());
对于unique 返回的是去重后的末尾的迭代器，注意重复部分并没有被去掉只是变成了任意值放在了后面所以要用erase去除

auto 可以根据输入自动判断类型
【例题】
区间和
下面展示一些 内联代码片。

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
const int N = 300005;
int n,m;
typedef pair<int ,int> pII;
int a[N],s[N];//a[N]数组存储离散化后对应的下标的值，s[N]是a的前缀和
vector<int> alls;//alls是存储所有的要用到的下标，具体离散化的主题
vector<pII> add,query;//键值对，记录插入和询问的操作，
int find(int x){//主要部分二分查找离散化后对应的坐标
	int l = 0,r = alls.size() - 1;
	while(l < r){
		int mid = l + r >> 1;
		if(alls[mid] >= x) r = mid;
		else{
			l = mid + 1;
		}
	}
	return r + 1;
}
int main(){
	cin>>n>>m;
	for(int i = 0;i < n;i ++){
		int x,c;
		cin>>x>>c;
		add.push_back({x,c});
		alls.push_back(x);//把要用到的坐标记录
	}
	for(int i = 0;i < m;i ++){
		int l , r;
		cin>>l>>r;
		query.push_back({l,r});
		alls.push_back(l);//把要用到的坐标记录
		alls.push_back(r);//把要用到的坐标记录
	}
	sort(alls.begin(),alls.end());
	alls.erase(unique(alls.begin(),alls.end()),alls.end());//必须是在有序的前提下一般伴随sort
	//unique是去重操作返回的是去重后的末尾的迭代器再结合erase去掉重复的
	for(auto item : add){
		int x = find(item.first);
		a[x] +=item.second;
	}
	for(int  i = 1;i <= alls.size();i ++)s[i] = s[i - 1] + a[i];
	
	for(auto item : query){
		int l = find(item.first),r = find(item.second);//l,r必须是离散化之后的值
		cout<<s[r] - s[l - 1]<< endl;
	}
	return 0;
}

八.区间合并

要用到pair键值对

关于pair

定义：typedef pair<int ,int > PII
头文件：#include
赋值：push_back({a,b})
排序：sort默认先排序以第一个数即first，再根据second排序
vecotr 遍历for(auto item:query)
访问：PII a：a.first , a.second
【例题】

区间合并
直接对键值对排序看一下是否相交或包含，存入vector最后输出size（）
下面展示一些 参考代码。

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

typedef long long ll;

typedef pair<int ,int >PII;
vector<PII>segs;

void merge(vector<PII> & segs)
{
	vector<PII>res;
	sort(segs.begin(),segs.end());
	int st = -2e9,ed = -2e9;
	for(auto seg:segs)
	{
		if(ed < seg.first){
			if(st != -2e9) res.push_back({st , ed});
			st = seg.first, ed = seg.second;
		}
		else ed = max(ed , seg.second);//注意右边要取最大，因为可能出现包含和相交
	}
	if(st != -2e9) res.push_back({st , ed});
	segs = res;
}
int main()
{
	int n;
	cin >> n;
	while(n --){
		int l ,r;
		cin >> l >> r;
		segs.push_back({l ,r});
	}
	merge(segs);
	cout << segs.size() <<endl;
	return 0;
}
李泉良001
关注
  • 44
    点赞
  • 踩
  • 56
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
个人寒假第一周总结
yu_annn的博客
01-16 218
这周学习加深了对递归算法及深度优先遍历的理解， 初步认识了快速幂以及二维前缀和。 在递归算法和深度优先遍历的学习中的递归指数型枚举中， 让我知道对于遍历到的每个数据可以设定多个状态（如选择读取这个数据的状态或者选择不读取这个数据的状态），以此来决定最终在屏幕上打印的结果。 在二维前缀和学习中让我懂得了画图对于算法学习的重要性。。 这周的学习内容感觉颇多， 感觉难以完全消化，对于递归和二维前缀和类的学习也只会写些简单题，看来接下来几周还需继续努力 ...
寒假第二周 总结与反思
平平无奇的小天才
01-27 382
寒假第二周，总结与反思 总结：本周学习强度略有提高，日均在8小时左右，下周要继续加强学习强度，提高到日均10小时。 英语方面：背了510个单词。————————————————当前进度1000/5500 数学方面：学习了高数三，四章，完成了330题前四章习题。——当前进度4/14 编程方面：学习了python基础语法，c++算法动态规划。————当前进度 237/417 反思：在刷题中，认识到了高数前期应稳扎稳打，不可好高骛远，编程方面，java在寒假开始以后就没有碰过，现在手生了很多，应当经常练习。在下周
寒假第一周学习总结
清霂的博客
01-21 380
目录计算机语言python汇编语言debug的基础指令汇编程序exe的形成CTFACM 计算机语言 python 字典 (内部由‘键’和‘值’组成，可包含列表) 字典.keys(),.values()函数来遍历字典 集合与字典都用花括号{ }定义，但集合没有‘值’ while循环—> while 某一条件: 了解了一些爬虫知识 汇编语言 这周主要学了汇编的前五章 计算机中用二进制来表示指令和数据，指令和数据本质上无任何区别 CPU要进行数据读写需要3种信息（地址信息，控制信息，数据信息
寒假第一周
S1167_11的博客
01-26 433
第一周的学习中c与c++代码都包含
寒假培训Day3上午题解1
08-03
在这个例子中，虽然使用了简单的线性搜索，但也可以选择使用`lower_bound`函数来寻找大于或等于目标值的元素的第一个位置，这在元素已经排序的情况下会更快。`lower_bound`函数的调用形式为`lower_bound(arrayBegin,...
数据结构 一元多项式运算 C++实现
04-06
4. PolyNode *Mul(PolyNode *A,PolyNode *B)：本函数的调用情况和求和函数一样，计算过程是：用第一个多项式的每一项与后一多项式相乘，结果保存到一个新的链表里面。每一项相乘之后调用加法函数进行求和，最后的...
C++参考大全.第四版.完美书签版
03-02
本人利用寒假时间，对本书的每一章节添加了详尽的书签（3级书签），并删除一些原电子书的空白页和重复页面的错误，相信这会对大家阅读这本经典著作提供一些方便。 编程大师和计算机畅销书作者Herbert Schildt对他的...
C++ 中的Lambda表达式写法
12-31
在Bing上搜索 C++ lambda ，第一条记录就是MSDN上的C++ lambda的介绍。本文也是基于这篇文章来写的。 那么接下来，我们分几个部分来介绍。 一、什么是Lambda表达式 MSDN上对lambda表达式的解释： 在 C++ 11 中，...
c++ primer plus 第16章string 类和标准模板库,string 类输入
zhyjhacker的博客
07-14 1099
c++ primer plus 第16章string 类和标准模板库,string 类输入。
c++ 生成随机字符串
m0_56306892的博客
07-15 217
以下是一个示例代码，它使用std::random_device和std::mt19937生成随机字符，并将结果存储在一个字符串中。std::uniform_int_distribution<> distribution(0, max_index - 1) 创建一个均匀分布，以确保生成的随机数在字符集的索引范围内。输出随机字符串: 在主函数中调用generateRandomString生成一个长度为1024的随机字符串，并输出结果。std::random_device rd 用于生成一个随机种子。
C语言 2个日期相关的函数
waterHBO的博客
07-15 153
读代码的过程中，遇到2个日期相关的工具函数， 记录一下。比较日期，计算日期间隔（天数)
C++ std::thread 管理线程生命周期：join 和 detach
m0_59680769的博客
07-16 977
方法用于同步主线程和子线程。也就是说，当主线程调用子线程的join方法时，主线程会被阻塞，直到子线程完成其执行。这意味着join方法确保主线程等待子线程结束，然后继续执行后续代码。t.join()方法则是让子线程在后台独立运行，与主线程分离。分离后的线程（也称为“游离线程”）不能再被join，它的资源会在该线程完成后自动释放。主线程会继续执行而不会等待该子线程。如果把std::this_thread::sleep_for(std::chrono::seconds(3));
JNI: 在Kotlin和C++之间通过JNI进行接口传递，两边参数定义映射
tyfwin的博客
07-15 1037
在Kotlin和C++之间通过JNI进行接口传递时，需要注意两边参数定义的映射关系。JNI（Java Native Interface）为Java（Kotlin也适用）与本地语言（如C/C++）之间的交互提供了桥梁。在Kotlin中定义的外部函数和C++中的实现需要通过JNI签名相互对应。
【C++】获取环境变量
Badme
07-18 39
【C++】获取环境变量
【C++进阶学习】第六弹——set和map——体会用C++来构建二叉搜索树
2301_80220607的博客
07-12 4366
【C++进阶学习】第六弹——set和map——数据结构进阶知识点，适合初学者学习！！！
【C++修炼之路 第三章】内存管理：new 与 delete
最新发布
唯有忍受别人不能忍受的，才能享受别人不能享受的
07-18 575
【含常见面试题】new & delete 的概念与用法 + 定位new表达式 + malloc/free 和 new/delete 的区别
C++ std::partial_sort_copy 用法
07-16 292
部分排序，即选出前n个最大值或者最小值，并将其保存到另外一个容器中。
寒假作业蓝桥杯c++
09-28
寒假作业蓝桥杯c是一个计算题，代码中使用了深度优先搜索（DFS）的方式来解题。通过枚举13个数字的全排列，并根据题目要求进行判断，找出符合条件的解。具体代码实现有两种方式：一种是通过递归实现的DFS，另一种是...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值