基础算法-学习笔记

已于 2022-05-10 23:12:46 修改
阅读量1k 收藏
点赞数
文章标签： 算法 学习 c++ 模板方法模式
于 2022-05-06 00:02:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Peter_a/article/details/124386864
版权

文章目录

一、排序

1.快速排序

算法思想：
快速排序算法思想

快速排序模板 使用较多为面试官要求，手写快排。
代码：

//快速排序模板 面试官，手写快排
#include<iostream>
using namespace std;

const int N = 1e6 + 10;
int n;
int q[N];

void quick_sort(int q[], int l, int r) {
	if (l >= r) return;//判断边界

	int x = q[l];//随机取
	int i = l - 1;//初始位置为最右侧的元素的前面
	int j = r + 1;//初始位置为最左侧的元素的后面
	while (i < j) {
		do i++; while (q[i] < x);
		do j--; while (q[j] > x);
		if (i < j)swap(q[i], q[j]);
	}
	quick_sort(q, l, j);//这里j对应取q[l]，不能取r，否则会出现递归死循环
	quick_sort(q, j + 1, r);//同理，i对应取q[r]，不能取q[l]
}

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

	quick_sort(q, 0, n - 1);
	for (int i = 0; i < n; i++)printf("%d ", q[i]);

	return 0;
}

2.归并排序

算法思想：
在这里插入图片描述

代码如下：

#include<iostream>
using namespace std;

const int N = 1000010;
int n;
int q[N],temp[N];

//归并
void merge_sort(int q[], int l, int r) {
	if (l >= r) return;//判断边界

	int mid = (l + r)/2;

	merge_sort(q, l, mid);
	merge_sort(q, mid + 1,r);
	
	//归并过程，将两个有序的序列归并到temp中
	int k = 0;//用来表示辅助数组temp中已经合并有元素的个数
	int i = l;//指向左半边起点
	int j = mid + 1;//指向右半边起点
	
	while (i <= mid && j <= r)
	{
		if (q[i] <= q[j]) temp[k++] = q[i++];
		else temp[k++] = q[j++];
	}
	while (i <= mid) temp[k++] = q[i++];
	while (j <= r)temp[k++] = q[j++];

	for (i = l, j = 0; i <= r; i++, j++) q[i] = temp[j];//将temp结果存回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;
}

二、二分

1、整数二分

思想：
在这里插入图片描述
二分找边界：
在这里插入图片描述
注意：进行 l=mid 更新时，取mid=（l+r+1）/ 2，补上+1是防止进入死循环。

#include<iostream>
using namespace std;

const int N = 100010;
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) / 2;

			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) / 2;
				if (q[mid] <= x) l = mid;
				else r = mid - 1;
			}
			cout << l << endl;
		}
	}
	return 0;
}

2、浮点数二分

求一个浮点数的开方：

#include<iostream>
using namespace std;

int main() {
	double x;
	cin >> x;

	double l = 0, r = x;
	while (r-l>1e-8)
	{
		double mid = (l + r) / 2;
		if (mid * mid >= x) r = mid;
		else l = mid;
	}
	printf("%lf\n", l);

	return 0;
}

三、高精度

C++需要考虑的问题；在Java 和 Python中不需要考虑

四种应用场景：

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

大整数在数组中的存储形式：个位存储在前面

①加法：

#include<iostream>
#include<vector>

using namespace std;

//C = A + B  模板
vector<int> add(vector<int>& A, vector<int>& B) {
	vector<int> c;
	int t = 0; //进位
	for (int i = 0; i < A.size() || i < B.size(); i++) {

		if (i < A.size())t += A[i];
		if (i < B.size())t += B[i];//此时，t=t+A[i]+B[i]
		c.push_back(t % 10);
		t /= 10;//大于10产生进位
	}
	if (t)c.push_back(1);//判断一下，最高位是否有进位
	return c;

}
int main() {
	string a, b;
	vector<int>A, B;

	cin >> a >> b;//a="123456"
	for (int i = a.size() - 1; i >= 0; i--)A.push_back(a[i] - '0');
	for (int i = b.size() - 1; i >= 0; i--)B.push_back(b[i] - '0');

	auto c = add(A, B);  //auto代表编译器自己推断类型

	for (int i = c.size() - 1; i >= 0; i--) {
		printf("%d", c[i]);
	}
	return 0;
}

②减法：

A-B分两种情况 :
		A >= B，直接进行计算
		A < B，则计算 -（B-A)

#include<iostream>
#include<vector>

using namespace std;
//函数判断是否有A>=B
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;
	}
}
//C = A-B  模板
vector<int> sub(vector<int>& A, vector<int>& B) {
	vector<int> c;
	int t = 0;           //进位
	for (int i = 0, t = 0; i < A.size(); i++) {
		t = A[i] - t;
		if (i < B.size()) t -= B[i];
		c.push_back((t + 10 )% 10);
		if (t < 0) t = 1;
		else t = 0;
	}

	while (c.size() > 1 && c.back() == 0) c.pop_back();//去掉前导0
	return c;
}
int main() {
	string a, b;
	vector<int>A, B;

	cin >> a >> b;//a="123456"
	for (int i = a.size() - 1; i >= 0; i--)A.push_back(a[i] - '0');
	for (int i = b.size() - 1; i >= 0; i--)B.push_back(b[i] - '0');

	//先判断A、B的的大小
	if (cmp(A, B)) {
		auto c = sub(A, B);  //auto代表编译器自己推断类型
		for (int i = c.size() - 1; i >= 0; i--) {
			printf("%d", c[i]);
		}
	}
	else {
		auto c = sub(B, A);  //auto代表编译器自己推断类型
		printf("-");
		for (int i = c.size() - 1; i >= 0; i--) {
			printf("%d", c[i]);
		}
	}

	return 0;
}

③乘法：

#include<iostream>
#include<vector>

using namespace std;

//c=A*b
vector<int> mult(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;
	}
	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');
	auto c = mult(A, b);
	for (int i = c.size() - 1; i >= 0; i--)printf("%d", c[i]);

	return 0;
}

④除法：

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

//  c=A/b ,商是c，余数是r
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();//去掉前导0
	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);
	for (int i = c.size() - 1; i >= 0; i--)printf("%d", c[i]);

	cout << endl;
	cout << r << endl;

	return 0;
}

四、前缀和

在这里插入图片描述

1、一维

#include<iostream>
using namespace std;

const int N = 100010;

int k, m;
int a[N], s[N];

int main() {
	scanf("%d%d", &k, &m);
	for (int i = 1; i <= k; i++)scanf("%d", &a[i]);

	for (int i = 1; i <= k; i++)s[i] = s[i - 1] + a[i];//前缀和的初始化

	while (m--) {
		int l, r;
		scanf("%d%d", &l, &r);
		printf("%d\n", s[r] - s[l - 1]);//区间和的计算
	}

	return 0;
}

2、二维

#include<iostream>

const int N = 1010;

int m, n, q;
int a[N][N], s[N][N];

int main() {
	scanf("%d%d%d", &n, &m, &q);

	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= m; j++) {
			scanf("%d", &a[i][j]);
		}
	}
	//初始化前缀和数组
	for (int i = 1; i <= n; i++)
		for (int j = 1; j <= m; j++)
			s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + a[i][j];//求前缀和

	//询问
	while (q--) {
		int x1, y1, x2, y2;
		scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
		printf("%d\n", s[x2][y2] - s[x1 - 1][y2] - s[x2][y1 - 1] + s[x1 - 1][y1 - 1]);//算子矩阵的和
	}
	return 0;
}

五、差分

前缀和的逆运算；构造B数组，使得A数组是其前缀和，A称为前缀和；B称为差分。
在这里插入图片描述

1.一维差分

#include<iostream>

using namespace std;

const int N = 100010;

int m, n;
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++) cin >> 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];

	for (int i = 1; i <= n; i++) printf("%d ", b[i]);

	return 0;
}

//输入
//6 3
//1 2 2 1 2 1
//1 3 1
//3 5 1
//1 6 1
//输出
//3 4 5 3 4 2

2.二维差分

#include<iostream>
using namespace std;

const int N = 1010;
int n2, m2, q1;
int a[N][N];//原矩阵
int b[N][N];//差分矩阵

void insert(int x1, int y1, int x2, int y2, int c) {
	b[x1][y1] += c;
	b[x2 + 1][y1] -= c;
	b[x1][y2 + 1] -= c;
	b[x2 + 1][y2 + 1] += c;
}
int main() {

	scanf("%d%d%d", &n2, &m2, &q1);

	for (int i = 1; i <= n2; i++)
		for (int j = 1; j <= m2; j++)
			scanf("%d", &a[i][j]);

	for (int i = 1; i <= n2; i++)
		for (int j = 1; j <= m2; j++)
			insert(i, j, i, j, a[i][j]);

	while (q1--)
	{
		int x1, x2, y1, y2, c;
		cin >> x1 >> y1 >> x2 >> y2 >> c;
		insert(x1, y1, x2, y2, c);

	}

	for (int i = 1; i <= n2; i++)
		for (int j = 1; j <= m2; j++)
			b[i][j] += b[i - 1][j] + b[i][j - 1] - b[i - 1][j - 1];

	for (int i = 1; i <= n2; i++) {
		for (int j = 1; j <= m2; j++) printf("%d ", b[i][j]);
		puts("");
	}

	return 0;
}

六、双指针算法

凡是具有以下形式的算法都可以被称作双指针算法

for(i=0,j=0;j<n;i++){
	while(j<i && check(i,j)) j++;

	//每道题目的具体逻辑
}

核心思想：将下面的朴素算法优化到O（n）

for(int i=0;i<n;i++)
	for(int j=0;j>n;j++)
	O(N^2)

核心思想是利用单调性，省去多余的遍历，
将原本On²的问题化简为On，具体形式可分为：
1.双序列双指针：如归并排序
2.单序列双指针：如字符串匹配

例题：
在这里插入图片描述
在这里插入图片描述
双指针问题：解决思路可以从暴力做法进行切入

#include<iostream>
using namespace std;

const int N = 100010;

int n;
int a[N];//原来的数
int s[N];//当前j到i区间每个数出现的次数

int main() {
	cin >> n;
	for (int i = 0; i < n; i++)cin >> a[i];

	int res = 0;
	for (int i = 0, j = 0; i < n; i++) {
		s[a[i]]++;
		while (s[a[i]]>1)
		{
			s[a[j]]--;
			j++;
		}
		res = max(res, i - j + 1);
	}

	cout << res << endl;

	return 0;
}

七、位运算

1、n的二进制表示中第k位是多少？

①先把第k位移动到最后一位 n>>k
②看一下个位是多少  x&1
结合①② 得到公式：n>>k&1


#include<iostream>
using namespace std;

int main() {

	int n = 10;
		for (int k = 3; k >= 0; k--) 
			cout << (n >> k & 1);
	return 0;
}
//输出结果 1010

2、返回n的最后一位1

lowbit(x):返回x的最后一位1
若x=1010  则 lowbit(x)=10;
若x=10100 则lowbit(x)=100;

实现原理：x&-x = x&(~x+1)
负数-x,存储是补码形式，在x 的基础上取反加1

lowbit应用：统计x中1的个数

//统计二进制中1的个数
#include<iostream>
using namespace std;

int lowbit(int x) {
	return x & -x;
}
int main() {
	int n;
	cin >> n;
	while (n--) {
		int x;
		cin >> x;
		int res = 0;
		while (x) {
			x -= lowbit(x);//每次减去x的最后一位1
			res++;
		}
		cout << res << ' ';
	}

	return 0;
}

八、离散化

核心思想是将很大范围的稀疏点按次序映射到一个数组中，类似哈希，方便查询一个范围的和等操作。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

1、求区间和

在这里插入图片描述

//区间和
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

typedef pair<int, int> PII;

const int N = 300010;//数据规模是n+2m,其中n，m都小于1000000

int n, m;
int a[N], s[N];
vector<int> alls;//存储需要离散化的数据
vector<PII> add;
vector<PII> 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;
}
//unique函数实现原理：双指针思想
vector<int>::iterator unique(vector<int>& a) {
	int j = 0;
	for (int i = 0; i < a.size(); i++)
		if (!i || a[i] != a[i - 1])// 将所有满足性质的数拿出来
			a[j++] = a[i];
	//此时，a[0]-a[j-1]所有a中不重复的数

	return a.begin() + j;
}
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());
	alls.erase(unique(alls), alls.end());

	for (auto item : add) {
		int x = find(item.first);
		a[x] += item.second;
	}

	//预处理前缀和
	for (int i = 0; i <= alls.size(); i++) {
		s[i] = s[i - 1] + a[i];
	}
	//处理询问
	for (auto item : query) {
		int l = find(item.first), r = find(item.second);
		cout << s[r] - s[l - 1] << endl;
	}
	return 0;
}

2、区间合并

在这里插入图片描述

在这里插入图片描述

//区间合并：
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;

typedef pair<int, int> PII;

const int N = 100010;
int n;
vector<PII> segs;

void merge(vector<PII>& segs) {
	vector<PII> res;

	sort(segs.begin(), segs.end());//在c++中优先以左端点排序

	int st = -2e9;
	int 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() {
	cin >> n;
	for (int i = 0; i < n; i++) {
		int l, r;
		cin >> l >> r;
		segs.push_back({ l,r });
	}
	merge(segs);

	cout << segs.size() << endl;

	return 0;
}
gloomy_coder
关注
cpp-算法学习笔记
08-16
【cpp-算法学习笔记】是一份专注于C++编程语言的算法学习资源，旨在帮助开发者深入理解和掌握各种基础及高级算法。这份笔记包含了丰富的实例、解释和练习，是C/C++开发人员提升算法技能的理想教材。在C++这个强大的...
部分基础算法个人学习笔记和心得
09-16
部分基础算法个人学习笔记和心得
组合计数
weixin_42638946的博客
04-20 1033
组合计数 1. 组合计数原理 原理 组合计数包含很多内容，比如乘法原理，加法原理，组合数，排列数等。 组合计数中存在的方法： （1）递推法；对应AcWing 1307. 牡牛和牝牛； （2）隔板法；对应AcWing 1308. 方程的解； （3）加法原理、乘法原理； （4）组合数，排列数； Cab=a!b!×(a−b)!=a×(a−1)×...×(a−b+1)1×2×...×b C_a^b = \frac{a!}{b! \times (a-b)!} = \frac{a \times (a-1)
第一章：基础算法集和——八大排序中的部分(DAY 40)
学恒的博客
04-19 368
文章目录一：快速二：归并三：二分四：前缀和五：双指针六：位运算 一：快速 #include<iostream> using namespace std; const int N=1000010; int n; int q[N]; void quick_sort(int q[],int l,int r) { if(l>=r)return; int x=q[l+r>>1],i=l-1,j=r+1; while(i<j) {
第十二届蓝桥杯软件类 C/C++ A组 个人解答（基本完结）
qq_29353083的博客
04-19 3476
目录（欢迎指正）A：卡片B：直线C：货物摆放D：路径E：回路计数 A：卡片 题目 #include <iostream> using namespace std; const int N=100; int n; int st[N]; int split(int n) { while(n) { if(--st[n%10]<0) return false; n/=10; } return true; } int mai
【算法】归并排序
Black_Customer的博客
11-29 129
#include<iostream> using namespace std; const int N = 1000010; int n; int q[N],temp[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); //合并
数据结构与算法基础篇（一）链表、栈、队列、KMP
惟愿一生无悔也无憾
10-20 519
内容 1.链表与邻接表 2.栈与队列 3.kmp 一、链表 数组模拟构造 静态链表 #include<iostream> //算法 不是工程 所以就可以不怕内存泄露 using namespace std; //head 头节点的下标 //e[]值 ne[] 结点i的next指针 即i.next //idx当前待插入的位置,即当前已经用到哪个点了 const int N = 100010; int head,e[N],ne[N],idx; //初始化 用-1 表示空 所以
数据结构与算法学习笔记
热门推荐
ityqing的博客
09-25 34万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
网络安全-自学笔记
关注网络安全、云原生安全
12-01 17万+
目录 WEB（应用）安全 前端安全 xss攻击 后端安全 文件上传漏洞 WebShell 解析安全 数据安全 sql注入 通信安全 WEB（应用）安全 前端安全 xss攻击 后端安全 文件上传漏洞 WebShell 解析安全 数据安全 sql注入 网络安全-sqlmap学习笔记 通信安全 网络-http协议学习笔记（消息结构、请求方法、状态码等） ...
【计算机二级等级考试】公共基础知识-学习笔记
02-22
以上内容是对计算机二级等级考试公共基础知识部分的学习笔记，涵盖了算法与数据结构的核心概念和基础知识，包括数据结构的逻辑与物理结构、各种查找与排序技术、算法的基本特征与复杂度分析方法等。掌握这些知识点，...
算法导论 学习笔记.pdf
05-04
本资源是对《算法导论》的学习笔记，涵盖了算法的基础知识、算法分析、函数的增长、递归式等方面的内容。 一、算法基础知识 算法是指将输入转换为输出的一系列计算步骤，目的是为了有效利用计算机的有限资源。算法...
COURSERA 吴恩达老师机器学习课程笔记-机器学习笔记-[机器学习与推荐算法].pdf
09-03
在吴恩达老师的COURSERA机器学习课程中，他深入浅出地介绍了机器学习的基本概念和核心算法。课程笔记涵盖了从机器学习的介绍...这些笔记是深入理解机器学习和推荐算法的宝贵资源，适合初学者和有一定基础的学习者参考。
二叉树最小深度
2301_80161204的博客
09-27 459
25[0, 105]
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 1271
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
904. 水果成篮
最新发布
YQ20210216的博客
09-27 358
转化，找出一个最长的子数组长度，子数组中不超过两种类型的水果，要记录水果类型和水果数量，所以要使用unord_map，key来记录水果中类，valuse记录水果数量，当right开始增加的时候，将水果种类加入到哈希表中，当水果中类超过两种时，控制left使得水果种类回到两种。你想要尽可能多地收集水果。你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组。，返回你可以收集的水果的。
【优选算法】（第一篇）
weixin_73861555的博客
09-25 1089
这个⽅法是往后我们学习「快排算法」的时候，「数据划分」过程的重要⼀步。如果将快排算法拆解的话，这⼀段⼩代码就是实现快排算法的「核⼼步骤」。
代码随想录算法训练营|226.翻转二叉树 、 101. 对称二叉树、 104.二叉树的最大深度、 111.二叉树的最小深度
cccoffer的博客
09-27 392
这里只是取最小值是不正确的，因为一旦有一个节点的左或右节点出现了空，此时这个位置成为了最小值，但是不符合题意的，题意是到叶子节点的最小深度。首先交换当前节点的左右子节点，然后递归当前节点的左右子节点（相当于到了子节点还是做同样的操作），知道所有节点遍历完了，就完成了翻转，返回root即可。思路：这题的就是区分高度和深度的题目，不过也可以用求高度的方法求得（即求根节点的高度即可，这个就是用到了后序遍历），求深度就是从根节点开始遍历，直到找到最深的叶子节点即可（相当于前序遍历），这里用前序遍历的方式解题。
560. 和为 K 的子数组
mrjieke6的博客
09-24 299
子数组是数组中元素的连续非空序列。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

gloomy_coder

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

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

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

打赏作者

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

抵扣说明：

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

余额充值