C/C++ 入门核心算法大局观：堆

最新推荐文章于 2021-11-13 17:21:08 发布
最新推荐文章于 2021-11-13 17:21:08 发布
阅读量451 收藏 4
点赞数 2
分类专栏： 算法 文章标签： 二叉树 算法 数据结构 堆
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cpp_learner/article/details/105599877
版权

观看本系列博文提醒：

  1. 你将学会堆的原理 和 算法实现；
  2. 一个企业级应用：堆实现优先队列；
  3. 还有堆排序；
  4. 最后还有一道检测是否掌握堆算法的作业。

堆的原理精讲

堆是算法中一种特别的树状数据结构，堆是一棵完全二叉树。但他又和二叉树有区别。

（不懂二叉树？没关系，下面我也会有简单的介绍，在后续的博文中会有详细讲解，敬请期待！）

什么是二叉树呢？
在这里插入图片描述
如上图就是一个简单的二叉树。也是一个堆。对就是基于二叉树实现的。

上图中，95就是二叉树的根，而93，87，82，78等，是二叉树的茎，而最后一行灰色的数字是二叉树的叶。

何为二叉树，即他的根或者茎最多只能有两个子节点。且只有一个根。

好了，二叉树就先了解到这里，下面我们开始讲一下堆的原理。

堆分为最大堆和最小堆。

最大堆的特点：
1. 每个节点最多可以有两个节点；
2. 根节点的键值是所有堆节点键值中最大者，且每个节点的值都比起孩子的值要大；
3. 除了根节点没有兄弟节点，最后一个左子节点可以没有兄弟节点，其他节点必须有兄弟节点。
在这里插入图片描述
如上图中，图一和图二是最大堆，而图三和图四不是最大堆。因为他不符合上面三条最大堆的原理。

最小堆和最大堆的原理是相反的，所以我们这里都是以最大堆为例解说。

看图识堆：
在这里插入图片描述

堆是你见过的最有个性的树！它是用数组表示的树。

i的左子节点：2 * i + 1
i的右子节点：2 * i + 2
i的父节点：（i - 1) / 2

请记住这三条公式，再堆的算法实现中用经常用到！

为什么说堆是最后个性的数？请看下图。
在这里插入图片描述
堆的存储方式完全都可以使用数组的方式。
这里更有利于我们操作堆，既可以得到最大的数目，也可以再最大数目出堆时，更快速的找到第二大的数目。
这也是最大堆为什么要迎合上面那三条原理的原因，如果最大堆不符合上面那三条原理，那么我们那些公式就无法使用了。（如果不信，大家可以使用公式计算一下，i 是下标）

到这里兴许大家已经对堆有了一定的了解，那么该如何在一堆混乱的数据中建堆呢？如下图。
在这里插入图片描述
如何从灰色的二叉树中变成堆呢？

  1. 首先我们需要找到最后一个结点的父结点如图(a),我们找到的结点是 87,然后找出该结点的最大子节点与自己比较,若该子节点比自身大,则将两个结点交换. 图(a)中,87 比左子节点 95 小,则交换之.如图(b)所示
    在这里插入图片描述
    这里呢95没有兄弟节点，所以可以直接与87进行比较，如果有的话，得先和兄弟节点比较，选出最大的节点再与父节点比较。

  2. .我们移动到前一个父结点 93,如图©所示.同理做第一步的比较操作，结果不需要交换。
    在这里插入图片描述

3.继续移动结点到前一个父结点 82,如图(d)所示,82 小于右子节点 95，则 82 与 95 交换,如图(e)所示，82 交换后，其值小于左子节点，不符合最大堆的特点，故需要继续向下调整，如图(f)所示
在这里插入图片描述

4.所有节点交换完毕,最大堆构建完成。

好了建堆的原理讲完了，我们来看一下代码是怎么样实现的吧。

首先我们得先定义堆：
涉及到堆得长度，我们还得定义一个宏

#define DEFAULT_CAPCITY 128

typedef struct _Heap {
	int* arr;		// 存储堆元素的数组
	int size;		// 当前已存储的元素个数
	int capacity;	// 当前以存储的容量
}Heap;

之后呢？我们还需要定义几个函数来完成堆的初始化和建堆的工作。

bool initHeap(Heap &heap, int *orginal, int size);	// 初始化堆
static void buildHeap(Heap &heap);	// 建堆
static void adjustDown(Heap &heap, int index);	// 父茎的下移

函数的具体实现：

bool initHeap(Heap &heap, int *orginal, int size) {	// 参数二：待成堆的数组；参数三：数组的个数
	int capacity = DEFAULT_CAPCITY > size ? DEFAULT_CAPCITY : size;	// 确定堆元素的存储容量

	heap.arr = new int[capacity];	// 分配内存
	if (!heap.arr) return false;	// 如果内存分配失败

	heap.capacity = capacity;	// 数据赋值
	heap.size = 0;				

	if (size > 0) {	// 判断数组是否有数据
		memcpy(heap.arr, orginal, size * sizeof(int));	// 内存拷贝
		heap.size = size;
		buildHeap(heap);	// 建堆
	}

	return true;
}


/*  从最后一个父节点（size/2-1的位置）逐个往前调整所有父节点（直到根节点），
确保每一个父节点都是要给最大堆，最后整体上形成一个最大堆 */
void buildHeap(Heap &heap) {
	for (int i = heap.size / 2 - 1; i >= 0; i--) {
		adjustDown(heap, i);	// 堆里面的数据排序
	}
}

// 将当前的节点和子节点调整成最大堆
void adjustDown(Heap &heap, int index) {	// 参数二：待调整的父节点下标
	int cur = heap.arr[index];	// 将待调整节点赋值给cur
	int parent, child;	// parent：充当父节点的下标；child：充当左或右子节点的下标

	/*  判断是否存在大于当前节点的子节点，如果不存在，则堆本身是平衡的，不需要调整；
	如果存在，则将最大的子节点与之交换，交换后，如果这个子节点还有子节点，则需要继续
	按照同样的步骤对这个子节点进行调整。*/
	for (parent = index; (parent * 2 + 1) < heap.size; parent = child) {
		child = parent * 2 + 1;	// 计算出当前节点的左子节点的下标

		// 取两个子节点中的最大的节点
		if ((child + 1) < heap.size && (heap.arr[child] < heap.arr[child + 1])) {
			child += 1;		// 不管有没有右子节点，都可以计算出最大的子节点下标位置
		}

		// 判断最大的子节点是否大于当前的父节点
		if (cur > heap.arr[child]) {
			break;
		} else {
			// 子节点和父节点交换值
			heap.arr[parent] = heap.arr[child];	
			heap.arr[child] = cur;
		}
	}
}

代码中都有详细的注释解析。

堆建好后，我们得试试插入元素了。

将数字 99 插入到上面大顶堆中的过程如下:

  1. 原始的堆,如图 a
    在这里插入图片描述
    对应的数组：{95, 93, 87, 92, 86, 82}

  2. 将新进的元素插入到大顶堆的尾部,如下图 b 所示:
    在这里插入图片描述
    对应的数组：{95, 93, 87, 92, 86, 82, 99}

  3. 此时最大堆已经被破坏，需要重新调整, 因加入的节点比父节点大，则新节点跟父节点调换即可,如图 c所示；调整后，新节点如果比新的父节点小，则已经调整到位，如果比新的父节点大，则需要和父节点重新进
    行交换，如图 d, 至此，最大堆调整完成。
    在这里插入图片描述

这样就完成了堆元素的插入了。
原理也讲完了，我们来看一下代码实现：

同样，需要建立几个实现的函数。

bool insert(Heap& heap, int value);	// 插入元素
static void adjustUp(Heap& heap, int index);	// 父茎的上移

具体函数实现：

// 将当前的节点和父节点调整成最大堆
void adjustUp(Heap& heap, int index) {
	if (index < 0 || index >= heap.size) {
		cout << "index参数不合法！" << endl;
		return;
	}

	while (index > 0) {
		int temp = heap.arr[index];
		int parent = (index - 1) / 2;	// 计算出父节点下标

		if (parent >= 0) {	// 如果索引没有出界就执行想要的操作
			if (temp > heap.arr[parent]) {
				heap.arr[index] = heap.arr[parent];
				heap.arr[parent] = temp;
				index = parent;	// 交换后，index下标被更新
			} else {	// 如果已经比父亲小，直接结束循环
				break;
			}
		} else {
			break;
		}
	}
}

// 最大堆尾部插入节点，同时保证最大堆的特性
bool insert(Heap& heap, int value) {	// 参数二：待插入的值
	if (heap.size == heap.capacity) {
		cout << "堆以满！" << endl;
		return false;
	}

	int index = heap.size;
	heap.arr[heap.size] = value;	// 将元素插入堆的最后一个位置
	heap.size += 1;
	adjustUp(heap, index);		// 实现插入元素的上移
}

代码中都有详细注释，请耐心观看。

我们已经知道该怎么插入元素了，那么该如何删除堆顶的元素呢？
如果我们将堆顶的元素删除，那么顶部有一个空的节点，怎么处理？

处理方法很简单：
当插入节点的时候，我们将新的值插入数组的尾部。现在我们来做相反的事情：我们取出数组中的最后一个元素，将它放到堆的顶部，然后再修复堆属性。
在这里插入图片描述
替换后，我们只需要使用初始化堆时用过的函数来将堆重新排序一遍就行了。

我们需要使用到的新函数：

bool popHeap(Heap &heap, int &value);	// 删除最大的元素

还有前面已经定义好的函数：

static void adjustDown(Heap &heap, int index);	// 父茎的下移

函数实现：

// 堆中最大元素出堆
bool popHeap(Heap &heap, int &value) {
	if (heap.size < 1) {
		cout << "堆为空!" << endl;
		return false;
	}

	value = heap.arr[0];
	heap.arr[0] = heap.arr[heap.size - 1];	// 将最后一个值覆盖第一个值
	heap.size -= 1;	// 长度减一

	adjustDown(heap, 0);	// 重新调整最大堆
	return true;
}

调整完成后，又是一个全新的最大堆。

全部代码：

#include <iostream>
#include <Windows.h>

using namespace std;

#define DEFAULT_CAPCITY 128

typedef struct _Heap {
	int* arr;		// 存储堆元素的数组
	int size;		// 当前已存储的元素个数
	int capacity;	// 当前以存储的容量
}Heap;

bool initHeap(Heap &heap, int *orginal, int size);	// 初始化堆
static void buildHeap(Heap &heap);	// 建堆
static void adjustDown(Heap &heap, int index);	// 父茎的下移

bool insert(Heap& heap, int value);	// 插入元素
static void adjustUp(Heap& heap, int index);	// 父茎的上移

bool popHeap(Heap &heap, int &value);	// 删除最大的元素

bool initHeap(Heap &heap, int *orginal, int size) {	// 参数二：待成堆的数组；参数三：数组的个数
	int capacity = DEFAULT_CAPCITY > size ? DEFAULT_CAPCITY : size;	// 确定堆元素的存储容量

	heap.arr = new int[capacity];	// 分配内存
	if (!heap.arr) return false;	// 如果内存分配失败

	heap.capacity = capacity;	// 数据赋值
	heap.size = 0;				

	// 方式二
	if (size > 0) {	// 判断数组是否有数据
		memcpy(heap.arr, orginal, size * sizeof(int));	// 内存拷贝
		heap.size = size;
		buildHeap(heap);	// 建堆
	}

	
	// 方式一
	/*for (int i = 0; i < size; i++) {
		insert(heap, orginal[i]);
	}*/

	return true;
}


/*  从最后一个父节点（size/2-1的位置）逐个往前调整所有父节点（直到根节点），
确保每一个父节点都是要给最大堆，最后整体上形成一个最大堆 */
void buildHeap(Heap &heap) {
	for (int i = heap.size / 2 - 1; i >= 0; i--) {
		adjustDown(heap, i);	// 堆里面的数据排序
	}
}

// 将当前的节点和子节点调整成最大堆
void adjustDown(Heap &heap, int index) {	// 参数二：待调整的父节点下标
	int cur = heap.arr[index];	// 将待调整节点赋值给cur
	int parent, child;	// parent：充当父节点的下标；child：充当左或右子节点的下标

	/*  判断是否存在大于当前节点的子节点，如果不存在，则堆本身是平衡的，不需要调整；
	如果存在，则将最大的子节点与之交换，交换后，如果这个子节点还有子节点，则需要继续
	按照同样的步骤对这个子节点进行调整。*/
	for (parent = index; (parent * 2 + 1) < heap.size; parent = child) {
		child = parent * 2 + 1;	// 计算出当前节点的左子节点的下标

		// 取两个子节点中的最大的节点
		if ((child + 1) < heap.size && (heap.arr[child] < heap.arr[child + 1])) {
			child += 1;		// 不管有没有右子节点，都可以计算出最大的子节点下标位置
		}

		// 判断最大的子节点是否大于当前的父节点
		if (cur > heap.arr[child]) {
			break;
		} else {
			// 子节点和父节点交换值
			heap.arr[parent] = heap.arr[child];	
			heap.arr[child] = cur;
		}
	}
}

// 将当前的节点和父节点调整成最大堆
void adjustUp(Heap& heap, int index) {
	if (index < 0 || index >= heap.size) {
		cout << "index参数不合法！" << endl;
		return;
	}

	while (index > 0) {
		int temp = heap.arr[index];
		int parent = (index - 1) / 2;	// 计算出父节点下标

		if (parent >= 0) {	// 如果索引没有出界就执行想要的操作
			if (temp > heap.arr[parent]) {
				heap.arr[index] = heap.arr[parent];
				heap.arr[parent] = temp;
				index = parent;	// 交换后，index下标被更新
			} else {	// 如果已经比父亲小，直接结束循环
				break;
			}
		} else {
			break;
		}
	}
}

// 最大堆尾部插入节点，同时保证最大堆的特性
bool insert(Heap& heap, int value) {	// 参数二：待插入的值
	if (heap.size == heap.capacity) {
		cout << "堆以满！" << endl;
		return false;
	}

	int index = heap.size;
	heap.arr[heap.size] = value;	// 将元素插入堆的最后一个位置
	heap.size += 1;
	adjustUp(heap, index);		// 实现插入元素的上移
}

// 堆中最大元素出堆
bool popHeap(Heap &heap, int &value) {
	if (heap.size < 1) {
		cout << "堆为空!" << endl;
		return false;
	}

	value = heap.arr[0];
	heap.arr[0] = heap.arr[heap.size - 1];	// 将最后一个值覆盖第一个值
	heap.size -= 1;	// 长度减一

	adjustDown(heap, 0);	// 重新调整最大堆
	return true;
}



int main(void) {
	Heap hp;
	int origVals[] = { 1, 2, 3, 87, 93, 82, 92, 86, 95 };

	if (!initHeap(hp, origVals, sizeof(origVals) / sizeof(origVals[0]))) {
		cout << "初始化堆失败！" << endl;
		exit(-1);
	}
	
	cout << "初始化堆后：" << endl;
	for (int i = 0; i < hp.size; i++) {
		cout << hp.arr[i] << " ";
	}
	cout << endl << endl;

	cout << "插入新的元素99后：" << endl;
	insert(hp, 99);
	for (int i = 0; i < hp.size; i++) {
		cout << hp.arr[i] << " ";
	}
	cout << endl << endl;

	// 出堆
	cout << "全部元素出堆：" << endl;
	while (1) {
		int value = 0;
		if (popHeap(hp, value)) {
			cout << value << ",";
		} else {
			break;
		}
	}
	
	system("pause");
	return 0;
}

运行截图：
在这里插入图片描述

好了到了这里，堆的原理 和 算法实现已经差不多讲完了，不知道大家有没有学到呢？
堆是很抽象的，所以请大家耐心慢慢看，慢慢理解。

由于一篇博文太长了，所以后续的企业级应用和作业我将留到后续的博文中讲解！

自此！

cpp_learners
关注
专栏目录
2021最稳C/C++学习路线
C语言与CPP编程的博客
08-20 8676
大家好，我是唐唐。此篇文章关于 C/C++/Linux后端开发的全路线。前言于我而言，最开始学习就是 C++，除了计算机专业，其他专业可能学习的第一门编程语言为 C 语言，还是谭浩强爷爷那...
C++资源之不完全导引（完整版）
程序猿老樊的博客
06-30 1338
1，前言 　　无数次听到“我要开始学习C++!”的呐喊，无数次听到“C++太复杂了，我真的 学不会”的无奈。Stan Lippman先生曾在《C++ Primer》一书中指出“C++是最为难 学的高级程序设计语言之一”，人们常将“之一”去掉以表达自己对C++的敬畏。诚 然，C++程序设计语言对于学习者的确有很多难以逾越的鸿沟，体系结构的庞大，应 接不暇并不断扩充的特性……除此之外，参考资
一些经典算法的c/c++实现
10-23
算法主要包括一些经典排序算法的实现，图和树的遍历实现还有杨辉三角和背包问题。
C/C++_七大核心算法_冒泡排序
weifc-wei 的博客
05-12 399
冒泡排序 每当皇帝选妃时，首席太监小桂子总是忍不住在旁边偷窥这些候选的美女，有一次他发现做 为伴读小书童的你居然犯了个常人都可以轻易看出的错误，有几位候选的美女站成如下一排： 当我们采用前面的选择排序时，我们仍然要将候选者遍历 5 遍，才能完成最终的排序，但其 实，本身这些美女出了第一个外，已经很有序了，我们只需要把第一个和第二个交换，然后又和 第三个交换，如此循环，直到和最后一个交换后，整个数组基本就有序了！ 当然，并不是每次都这么幸运，像下面的情况就会更复杂一些，一趟并不能完全解决问题， 我们需要多
开发人的大局观
云计算?
01-12 226
开发人的大局观 ---希望每个立志成为系统分析员的程序员看一看 就象ken_qian所说的，“出了国门，大家都在变。”短短半年间，自己确实在观念上改变了许多。 回想起来，以前在国内自己只是一部不停运作的编程机器，整天写code,写code,写code,写code！ 一旦灵感一来，就想方设法地把所想的写出来，根本就没有考虑到编程以外的事情，结果，光是写出来的souce code足用...
10个重要的算法C语言实现源代码
code life
02-09 582
包括拉格朗日，牛顿插值，高斯，龙贝格，牛顿迭代，牛顿-科特斯，雅克比，秦九昭，幂法，高斯塞德尔 。都是经典的数学算法，希望能开托您的思路。转自kunli.info 1.拉格朗日插值多项式 ，用于离散数据的拟合 C/C++ code #include stdio.h> #include conio.h> #include alloc.h> float lagrange(float
C/C++ 入门核心算法大局观：堆排序
cpp_learner的博客
04-18 360
观看本系列博文提醒： 你将学会堆的原理 和 算法实现； 一个企业级应用：堆实现优先队列； 还有堆排序； 最后还有一道检测是否掌握堆算法的作业。 这已经是本系列博文的第三篇了，还没看过第二篇博文：C/C++ 入门核心算法：堆的企业级应用 之 堆实现优先队列 的朋友可以点击下面链接去了解一下。 https://editor.csdn.net/md/?articleId=105602667 我们下...
万字长文带来2021最稳C/C++学习路线
L的存在的博客
08-22 1364
大家好，我是蓝蓝。 封面自己画的，应该还算比较可爱的吧，复古类型的可爱啦。为什么是森林呢，嗯~~周末看了书《挪威的森林》，其中有句话是 如果你掉进了黑暗里，你能做的，不过是静心等待，直到你的双眼适应黑暗。此篇文章关于 C/C++/Linux后端开发的全路线。 文章已开源到 我的Github，欢迎Star。 前言 于我而言，最开始学习就是 C++，除了计算机专业，其他专业可能学习的第一门编程语言为 C 语言，还是谭浩强爷爷那本，当时想着有点 C 基础，无外乎就是 C 语言的升级版，于是开启了 C+
c++ library and resource List （zz）
Peter Wu
12-06 2152
一些类库和资源(zz)Friday, 14. April 2006, 07:43:33C++ 　1，前言　　无数次听到“我要开始学习C++!”的呐喊，无数次听到“C++太复杂了，我真的学不会”的无奈。Stan Lippman先生曾在《C++ Primer》一书中指出“C++是最为难学的高级程序设计语言之一”，人们常将“之一”去掉以表达自己对C++
为有机会进大厂，程序员必须掌握的核心算法有哪些？
热门推荐
帅地
12-26 70万+
由于我之前一直强调数据结构以及算法学习的重要性，所以就有一些读者经常问我，数据结构与算法应该要学习到哪个程度呢？，说实话，这个问题我不知道要怎么回答你，主要取决于你想学习到哪些程度，不过针对这个问题，我稍微总结一下我学过的算法知识点，以及我觉得值得学习的算法。这些算法与数据结构的学习大多数是零散的，并没有一本把他们全部覆盖的书籍。下面是我觉得值得学习的一些算法以及数据结构，当然，我也会整理一些看过...
STL-常用算法
m0_56783154的博客
08-01 218
STL-常用算法 概述： 算法主要是由头文件<algorithm> functional numeric组成 <algorithm>是所有STL头文件中最大的一个，范围涉及到比较、交换、查找、遍历、复制、修改等等 <numeric>体积很小，只包括几个在序列上面进行简单数学运算的模板函数 <functional>定义了一些模板类，用以声明函数对象 1. 常用遍历算法 算法简介： for_each //遍历容器 transform //搬运容器到另一个
图核心算法（c++）
crazyfox的博客
08-04 258
1. 图的遍历 leetcode207 这道题对应拓扑排序，有向图是否有环的问题 1.1 BFS（广度优先搜索） 第一次做法 class Solution { public: bool canFinish(int numCourses, vector<vector<int>>& prerequisites) { // 0.初始化准备 unordered_set<int> temp; vector&
基本算法思想（1）利用分治算法处一隅而观全局（C)
肇秋贰拾捌的博客
11-13 1484
善用算法是培养程序设计逻辑很重要的步骤，许多实际的问题都可用多个可行的算法来解决，本章重点向大家介绍了分治法在解决问题上的重大作用。 文章目录????分治法???? 了解时间复杂度✨ 分治法正在磨刀——二分查找✨分治法向你重拳出击——归并排序✨分治法对你进行了降维打击——汉诺塔问题????写在结尾 ????分治法 定义：分治法也被称为分而治之法，是一种很重要的算法，我们可以利用分治法来逐一拆解复杂的问题，核心思想是将一个难以解决的大问题依照相同的概念分割成两个或更多的子问题，以便各个击破。 应用：分治法
用c++实现游戏2048---核心算法
Hanpu_Liang的博客
07-24 2347
用c++实现2048—核心算法 写在前面 这一篇主要讲如何相应操纵者给出的指令，对地图进行相应的操作。 这里我最开始的思路很简单，就是将地图的移动方式分为四种，即上(w)下(s)左(a)右(d)。 但是如果分为四个函数的话，那就太繁琐了，复用性太差，相同的代码复制四次只修改一点，十分难看，所以通过思考将四个移动方式合并成为一个移动方式就是本篇所要思考的内容。 根据指令移动地图 ...
C++核心准则SF.5: .cpp文件必须包含定义它接口的.h文件
面向对象思考
12-16 578
SF.5: A.cppfile must include the.hfile(s) that defines its interface SF.5: .cpp文件必须包含定义它接口的.h文件 Reason（原因） This enables the compiler to do an early consistency check. 这样可以让编译器尽早进行一致性检查。 Example, bad（反面示例） // foo.h: void foo(int); int bar(l...
如何有效的写算法题
程序员吴师兄的博客
04-26 1431
刷 LeetCode 的大局观目前主流的刷题流派有两种，一种【龟系】，一种【兔系】。“龟系”刷法的精髓就是每个题目都做干净。不满足于一种解法，各种解法都写一写。这种流派适...
C++三大特性，七项原则
qq_43685242的博客
08-07 778
1. C++面向对象三大特性 1. 封装 封装：把客观事物抽象为类，并且类可以把自己的数据和方法只让可信的类或对象操作，对不可信的进行信息隐藏。 类将成员变量封装在类的内部，根据需求设置访问权限，通过成员函数管理内部状态。 2. 多态 多态简单讲可以概括为“一种接口，多种方法”，多种形态，程序在运行过 程才决定要调用的函数，是核心概念。 ps：重载，重写，重定义的区别： 重载，同一作用域的同名函数 1.同一个作用域 2.参数个数，参数顺序，参数类型不同 3.和函数返回值，没有关系 4.const也可以作为
标准PID核心算法（c语言）详解（二）
Q_xr
04-25 4071
            在上一篇文章中介绍了PID算法是什么，以及PID的位置式和增量式。这篇文章将解释如何在程序中实现位置式和增量式。位置式核心算法    程序是通过公式推写出来的，所以先把PID的位置式列出来    找出需要定义的变量，为程序编写做好准备。需要定义的变量有：u_1 , kp , ts , ti , td ,   e_1 ,  e_2 ,  up_1 , ui_1 , ud_1 ...
C/C++实现高精度算法详解：加法与乘幂
"本文主要探讨了C/C++中实现高精度算法的方法，通过实例代码详细讲解了高精度加法的实现过程。文章适用于学习或工作中需要处理大整数运算的读者。" 在C/C++编程中，处理大整数运算时，标准的数据类型如int、long ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

cpp_learners

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

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

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

打赏作者

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

抵扣说明：

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

余额充值