STL常用算法总结（上）

最新推荐文章于 2024-10-02 23:40:03 发布
最新推荐文章于 2024-10-02 23:40:03 发布
阅读量644 收藏
点赞数
文章标签： 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cslx97/article/details/123148871
版权

STL中常用算法可大致分为四类：
非变异算法：不直接修改所操作的容器内容的算法。
变异算法：可以修改容器内容的算法。
排序算法：包括对序列进行排序和合并的算法、搜索算法以及有序序列上的集合操作。
数值算法：对容器内容进行数值计算。

1.查找算法
包含在头文件中，用来提供元素排序策略。

注意：_InIt _First和_FwdIt _First分别代表InputIterator和ForwardIterator，表示输入迭代器和前向迭代器。

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>  

using namespace std;

int main(int argc, char* argv[])
{
	int iarr[] = { 0, 1, 2, 3, 4, 5, 6, 6, 6, 7, 8 };
	vector<int> iv(iarr, iarr + sizeof(iarr) / sizeof(int));

	/*** adjacent_find: 在iterator对标识元素范围内，查找一对相邻重复元素 ***/
	cout << "adjacent_find: ";
	cout << *adjacent_find(iv.begin(), iv.end()) << endl;

	/*** count: 利用等于操作符，把标志范围内的元素与输入值比较，返回相等元素个数。 ***/
	// 原型： count(_InIt _First, _InIt _Last, const _Ty& _Val)
	cout << "count(==7): ";
	cout << count(iv.begin(), iv.end(), 6) << endl;// 统计6的个数

	/*** count_if: 利用输入的操作符，对标志范围内的元素进行操作，返回结果为true的个数。 ***/
	// 原型： count_if(_InIt _First, _InIt _Last, _Pr _Pred)
	// 统计小于7的元素的个数 :9个
	cout << "count_if(<7): ";
	cout << count_if(iv.begin(), iv.end(), bind2nd(less<int>(), 7)) << endl;

	/*** binary_search: 在有序序列中查找value，找到返回true。 ***/
	// 原型： bool binary_search(_FwdIt _First, _FwdIt _Last, const _Ty& _Val)
	cout << "binary_search: ";
	cout << binary_search(iv.begin(), iv.end(), 4) << endl; // 找到返回true

	/*** equal_range: 功能类似equal，返回一对iterator，第一个表示lower_bound，第二个表示upper_bound。 ***/
	// 原型： equal_range(_FwdIt _First, _FwdIt _Last, const _Ty& _Val)
	pair<vector<int>::iterator, vector<int>::iterator> pairIte;
	pairIte = equal_range(iv.begin(), iv.end(), 3);
	cout << "pairIte.first:" << *(pairIte.first) << endl;// lowerbound 3   
	cout << "pairIte.second:" << *(pairIte.second) << endl; // upperbound 4

	/*** find: 利用底层元素的等于操作符，对指定范围内的元素与输入值进行比较。 ***/
	// 原型： _InIt find(_InIt _First, _InIt _Last, const _Ty& _Val)
	cout << "find: ";
	cout << *find(iv.begin(), iv.end(), 4) << endl; // 返回元素为4的元素的下标位置

	/*** find_if: 使用输入的函数代替等于操作符执行find。 ***/
	// 原型： _InIt find_if(_InIt _First, _InIt _Last, _Pr _Pred)
	cout << "find_if: " << *find_if(iv.begin(), iv.end(), bind2nd(greater<int>(), 2)) << endl; // 返回大于2的第一个元素的位置：3 

	/*** search: 给出两个范围，返回一个ForwardIterator，查找成功指向第一个范围内第一次出现子序列的位置。 ***/
	// 原型： _FwdIt1 search(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2)
	// 在iv中查找 子序列 2 3 第一次出现的位置的元素   
	int iarr3[3] = { 2, 3 };
	vector<int> iv3(iarr3, iarr3 + 2);
	cout << "search: " << *search(iv.begin(), iv.end(), iv3.begin(), iv3.end()) << endl;

	/*** search_n: 在指定范围内查找val出现n次的子序列。 ***/
	// 原型： _FwdIt1 search_n(_FwdIt1 _First1, _FwdIt1 _Last1, _Diff2 _Count, const _Ty& _Val)
	// 在iv中查找 2个6 出现的第一个位置的元素   
	cout << "search_n: " << *search_n(iv.begin(), iv.end(), 2, 6) << endl;

	return 0;
}

在这里插入图片描述
2.排序算法
包含在头文件中，用来判断容器中是否包含某个值。

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional> // 定义了greater<int>()

using namespace std;

// 要注意的技巧
template <class T>
struct display
{
	void operator()(const T& x) const
	{
		cout << x << " ";
	}
};

// 如果想从大到小排序，可以采用先排序后反转的方式，也可以采用下面方法:
// 自定义从大到小的比较器，用来改变排序方式
bool Comp(const int& a, const int& b) {
	return a > b;
}

int main(int argc, char* argv[])
{
	int iarr1[] = { 0, 1, 2, 3, 4, 5, 6, 6, 6, 7, 8 };
	vector<int> iv1(iarr1, iarr1 + sizeof(iarr1) / sizeof(int));
	vector<int> iv2(iarr1 + 4, iarr1 + 8); // 4 5 6 6
	vector<int> iv3(15);

	/*** merge: 合并两个有序序列，存放到另一个序列 ***/
	// iv1和iv2合并到iv3中（合并后会自动排序）
	merge(iv1.begin(), iv1.end(), iv2.begin(), iv2.end(), iv3.begin());
	cout << "merge合并后: ";
	for_each(iv3.begin(), iv3.end(), display<int>());
	cout << endl;

	/*** random_shuffle: 对指定范围内的元素随机调整次序。 ***/
	int iarr2[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
	vector<int> iv4(iarr2, iarr2 + sizeof(iarr2) / sizeof(int));
	// 打乱顺序  
	random_shuffle(iv4.begin(), iv4.end());
	cout << "random_shuffle打乱后: ";
	for_each(iv4.begin(), iv4.end(), display<int>());
	cout << endl;

	/*** nth_element: 将范围内的序列重新排序。 ***/
	// 将小于iv.begin+5的放到左边   
	nth_element(iv4.begin(), iv4.begin() + 5, iv4.end());
	cout << "nth_element重新排序后: ";
	for_each(iv4.begin(), iv4.end(), display<int>());
	cout << endl;

	/*** reverse: 将指定范围内元素重新反序排序。 ***/
	reverse(iv4.begin(), iv4.begin());
	cout << "reverse翻转后: ";
	for_each(iv4.begin(), iv4.end(), display<int>());
	cout << endl;

	/*** sort: 以升序重新排列指定范围内的元素。 ***/
	// sort(iv4.begin(), iv4.end(), Comp); // 也可以使用自定义Comp()函数
	sort(iv4.begin(), iv4.end(), greater<int>());
	cout << "sort排序（倒序）: ";
	for_each(iv4.begin(), iv4.end(), display<int>());
	cout << endl;

	/*** stable_sort: 与sort类似，不过保留相等元素之间的顺序关系。 ***/
	int iarr3[] = { 0, 1, 2, 3, 3, 4, 4, 5, 6 };
	vector<int> iv5(iarr3, iarr3 + sizeof(iarr3) / sizeof(int));
	stable_sort(iv5.begin(), iv5.end(), greater<int>());
	cout << "stable_sort排序（倒序）: ";
	for_each(iv5.begin(), iv5.end(), display<int>());
	cout << endl;

	return 0;
}

在这里插入图片描述

3.删除和替换算法
包含在头文件中，实现删除和替换功能。

#include "stdafx.h"
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional> // 定义了greater<int>()

using namespace std;

template <class T>
struct display
{
	void operator()(const T&x) const
	{
		cout << x << " ";
	}
};

int main(int argc, char* argv[])
{
	int iarr1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
	vector<int> iv1(iarr1, iarr1 + sizeof(iarr1) / sizeof(int));
	vector<int> iv2(9);

	/*** copy: 复制序列 ***/
	//  原型： _OutIt copy(_InIt _First, _InIt _Last,_OutIt _Dest)
	copy(iv1.begin(), iv1.end(), iv2.begin());
	cout << "copy(iv2): ";
	for_each(iv2.begin(), iv2.end(), display<int>());
	cout << endl;

	/*** copy_backward: 与copy相同，不过元素是以相反顺序被拷贝。 ***/
	//  原型： _BidIt2 copy_backward(_BidIt1 _First, _BidIt1 _Last,_BidIt2 _Dest)
	copy_backward(iv1.begin(), iv1.end(), iv2.rend());
	cout << "copy_backward(iv2): ";
	for_each(iv2.begin(), iv2.end(), display<int>());
	cout << endl;

	/*** remove: 删除指定范围内所有等于指定元素的元素。 ***/
	//  原型： _FwdIt remove(_FwdIt _First, _FwdIt _Last, const _Ty& _Val)
	remove(iv1.begin(), iv1.end(), 5); // 删除元素5
	cout << "remove(iv1): ";
	for_each(iv1.begin(), iv1.end(), display<int>());
	cout << endl;

	/*** remove_copy: 将所有不匹配元素复制到一个制定容器，返回OutputIterator指向被拷贝的末元素的下一个位置。 ***/
	//  原型： 	_OutIt remove_copy(_InIt _First, _InIt _Last,_OutIt _Dest, const _Ty& _Val)
	vector<int> iv3(8);
	remove_copy(iv1.begin(), iv1.end(), iv3.begin(), 4); // 去除4 然后将一个容器的元素复制到另一个容器
	cout << "remove_copy(iv3): ";
	for_each(iv3.begin(), iv3.end(), display<int>());
	cout << endl;

	/*** remove_if: 删除指定范围内输入操作结果为true的所有元素。 ***/
	//  原型： _FwdIt remove_if(_FwdIt _First, _FwdIt _Last, _Pr _Pred)
	remove_if(iv3.begin(), iv3.end(), bind2nd(less<int>(), 6)); //  将小于6的元素 "删除"
	cout << "remove_if(iv3): ";
	for_each(iv3.begin(), iv3.end(), display<int>());
	cout << endl;

	/*** remove_copy_if: 将所有不匹配元素拷贝到一个指定容器。 ***/
	// 原型： _OutIt remove_copy_if(_InIt _First, _InIt _Last,_OutIt _Dest, _Pr _Pred)
	//  将iv1中小于6的元素 "删除"后，剩下的元素再复制给iv3
	remove_copy_if(iv1.begin(), iv1.end(), iv2.begin(), bind2nd(less<int>(), 4));
	cout << "remove_if(iv2): ";
	for_each(iv2.begin(), iv2.end(), display<int>());
	cout << endl;

	return 0;
}

在这里插入图片描述

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional> // 定义了greater<int>()

using namespace std;

template <class T>
struct display
{
	void operator()(const T&x) const
	{
		cout << x << " ";
	}
};

int main(int argc, char* argv[])
{
	int iarr[] = { 8, 10, 7, 8, 6, 6, 7, 8, 6, 7, 8 };
	vector<int> iv(iarr, iarr + sizeof(iarr) / sizeof(int));

	/*** replace: 将指定范围内所有等于vold的元素都用vnew代替。 ***/
	//  原型： void replace(_FwdIt _First, _FwdIt _Last, const _Ty& _Oldval, const _Ty& _Newval)
	// 将容器中6 替换为 3   
	replace(iv.begin(), iv.end(), 6, 3);
	cout << "replace(iv): ";
	for_each(iv.begin(), iv.end(), display<int>()); // 由于_X是static 所以接着 增长
	cout << endl; // iv:8 10 7 8 3 3 7 8 3 7 8   

	/*** replace_copy: 与replace类似，不过将结果写入另一个容器。 ***/
	//  原型： _OutIt replace_copy(_InIt _First, _InIt _Last, _OutIt _Dest, const _Ty& _Oldval, const _Ty& _Newval)
	vector<int> iv2(12);
	// 将容器中3 替换为 5，并将结果写入另一个容器。  
	replace_copy(iv.begin(), iv.end(), iv2.begin(), 3, 5);
	cout << "replace_copy(iv2): ";
	for_each(iv2.begin(), iv2.end(), display<int>());  
	cout << endl; // iv2:8 10 7 8 5 5 7 8 5 7 8 0（最后y一个残留元素）   

	/*** replace_if: 将指定范围内所有操作结果为true的元素用新值代替。 ***/
	//  原型： void replace_if(_FwdIt _First, _FwdIt _Last, _Pr _Pred, const _Ty& _Val)
	// 将容器中小于 5 替换为 2   
	replace_if(iv.begin(), iv.end(), bind2nd(less<int>(), 5), 2);
	cout << "replace_copy(iv): ";
	for_each(iv.begin(), iv.end(), display<int>());   
	cout << endl; // iv:8 10 7 8 2 5 7 8 2 7 8   

	/*** replace_copy_if: 与replace_if，不过将结果写入另一个容器。 ***/
	//  原型： _OutIt replace_copy_if(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred, const _Ty& _Val)
	// 将容器中小于 5 替换为 2，并将结果写入另一个容器。  
	replace_copy_if(iv.begin(), iv.end(), iv2.begin(), bind2nd(equal_to<int>(), 8), 9);
	cout << "replace_copy_if(iv2): ";
	for_each(iv2.begin(), iv2.end(), display<int>()); 
	cout << endl; // iv2:9 10 7 8 2 5 7 9 2 7 8 0(最后一个残留元素)

	int iarr3[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, };
	vector<int> iv3(iarr3, iarr3 + sizeof(iarr3) / sizeof(int));
	int iarr4[] = { 8, 10, 7, 8, 6, 6, 7, 8, 6, };
	vector<int> iv4(iarr4, iarr4 + sizeof(iarr4) / sizeof(int));

	/*** swap: 交换存储在两个对象中的值。 ***/
	//  原型： _OutIt replace_copy_if(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred, const _Ty& _Val)
	// 将两个容器中的第一个元素交换  
	swap(*iv3.begin(), *iv4.begin());
	cout << "swap(iv3): ";
	for_each(iv3.begin(), iv3.end(), display<int>());  
	cout << endl;

	/*** swap_range: 将指定范围内的元素与另一个序列元素值进行交换。 ***/
	//  原型： _FwdIt2 swap_ranges(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _Dest)
	// 将两个容器中的全部元素进行交换  
	swap_ranges(iv4.begin(), iv4.end(), iv3.begin());
	cout << "swap_range(iv3): ";
	for_each(iv3.begin(), iv3.end(), display<int>());
	cout << endl;

	/*** unique: 清除序列中相邻的重复元素，和remove类似，它也不能真正删除元素。 ***/
	//  原型： _FwdIt unique(_FwdIt _First, _FwdIt _Last, _Pr _Pred) 
	unique(iv3.begin(), iv3.end());
	cout << "unique(iv3): ";
	for_each(iv3.begin(), iv3.end(), display<int>());
	cout << endl;

	/*** unique_copy: 与unique类似，不过把结果输出到另一个容器。 ***/
	//  原型： _OutIt unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred)
	unique_copy(iv3.begin(), iv3.end(), iv4.begin());
	cout << "unique_copy(iv4): ";
	for_each(iv4.begin(), iv4.end(), display<int>());
	cout << endl;

	return 0;
}

在这里插入图片描述
4.排列组合算法
包含在头文件中，用来提供计算给定集合按一定顺序的所有可能排列组合。

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

template <class T>
struct display
{
	void operator()(const T&x) const
	{
		cout << x << " ";
	}
};

int main(int argc, char* argv[])
{
	int iarr[] = { 12, 17, 20, 22, 23, 30, 33, 40 };
	vector<int> iv(iarr, iarr + sizeof(iarr) / sizeof(int));

	/*** next_permutation: 取出当前范围内的排列，并重新排序为下一个字典序排列。***/
	//  原型： bool next_permutation(_BidIt _First, _BidIt _Last)
	// 生成下一个排列组合（字典序）   
	next_permutation(iv.begin(), iv.end());
	for_each(iv.begin(), iv.end(), display<int>());
	cout << endl;

	/*** prev_permutation: 取出指定范围内的序列并将它重新排序为上一个字典序排列。 ***/
	//  原型： bool prev_permutation(_BidIt _First, _BidIt _Last)
	prev_permutation(iv.begin(), iv.end());
	for_each(iv.begin(), iv.end(), display<int>());
	cout << endl;

	return 0;
}

在这里插入图片描述

ekkoxxxx
关注
java 可变参数列表 数组_第5章-- 初始化与清理 _Java,初始化数组,可变参数列表,枚举类型初始化 | 边城网事...
weixin_33291014的博客
02-16 107
import java.util.Arrays;/*** 1. 定义一个数组 int[] iArr; // 这时数组还没有初始化,不能使用* 2. 在定义时,初始一个数组 int iArr = new int[5]; //初始化为5个元素数组,为[0,0,0,0,0]* 3. 在定义时初始化一个数组 int iArr2 = {1,2,3,4,5};* 上面这种方式只能在定义时可以,假如int...
IAR使用教程
热门推荐
linxi8693的博客
05-30 4万+
转载至：https://www.cnblogs.com/nanase/p/9028351.html 面向尚未熟悉且初次使用该软件的新手（比如我。。。） 1、建立新工作区 　　File-->>New Workspace 2、建立新项目 　　1) Project-->>Create New Project... 　　2) 选择如下模板： ...
stl clocklist 查找元素_C++ STL 常用算法总结
weixin_39856265的博客
11-27 281
一、概述 STL算法部分主要由头文件,,组成。要使用 STL中的算法函数必须包含头文件 ，对于数值算法须包含 ， 中则定义了一些模板类，用来声明函数对象。二、常用算法介绍STL 中算法大致分为四类：非可变序列算法：指不直接修改其所操作的容器内容的算法。可变序列算法：指可以修改它们所操作的容器内容的算法。排序算法：包括对序列进行排序和合并的算法、搜索算法以及有序序列上的集...
C++ STL常用算法 学习总结
weixin_45231931的博客
02-17 533
end1 容器1结束迭代器 beg2 容器2开始迭代器 end2 容器2结束迭代器 dest 目标容器开始迭代器。beg1 容器1开始迭代器，end1 容器1结束迭代器，beg2 容器2开始迭代器，end2 容器2结束迭代器。beg 开始迭代器，end 结束迭代器，oldvalue 旧元素，newvalue 新元素。beg 开始迭代器，end 结束迭代器，_Pred 谓词，newvalue 替换的新元素。查找指定元素，找到返回指定元素的迭代器，找不到返回结束迭代器end()
C++ STL常用算法
会思想的苇草i的博客
01-14 463
C++标准模板库（STL）是C++编程中不可或缺的部分，它提供了丰富的数据结构和算法。本文将带你初识C++ STL，包括容器（如vector、list、map等）、算法（如排序、查找、遍历等）以及迭代器等内容。我们将对每种容器和算法进行简要介绍，并给出示例代码加深理解。通过本文的阅读，读者将能够初步掌握C++ STL的基本用法，为日后的程序设计打下坚实的基础。
STL常用算法总结
qq_36534594的博客
03-22 547
常用遍历算法 头文件：<algorithm> <functional> <numeric> <algorithm>是所有STL文件中最大的一个，范围涉及比较、交换、查找、遍历操作、复制、修改等等 <functional>体积很小，只包含几个在序列上面进行简单数学运算的模板函数 <numeric>定义了一些模板类，用以声明函数对象 常用遍历算法 1. for_each//遍历容器 2. transform //搬运容器到另一个容器中
STL常见算法总结
sinat_31608641的博客
11-19 4273
一、各种常见算法的用法 accumlate ： iterator 对标志的序列中的元素之和，加到一个由 init 指定的初始值上。重载的版本不再做加法，而是传进来的二元操作符被应用到元素上。adjacent_different ：创建一个新序列，该序列的每个新值都代表了当前元素与上一个元素的差。重载版本用指定的二元操作计算相邻元素的差。adjacent_find ：在 iterator 对标志的元素范围内，查找一对相邻的重复元素，如果找到返回一个 ForwardIterator ，指向这对元素的第一
stl常用算法总结
Cristiano_san的博客
10-26 1058
stl的算法简单概念 算法（algorithm）是用模板技术实现的适用于各种容器的通用程序。算法常常通过迭代器间接地操作容器元素，而且通常会返回迭代器作为算法运算的结果。 STL大约提供了70个算法，每个算法都是一个模板函数或者一组模板函数，能够在许多不同类型的容器上进行操作，各个容器则可能包含着不同类型的数据元素。STL中的算法覆盖了在容器上实施的各种常见操作，如遍历、排序、检索、插入及删除元素等操作 1、find/count算法 find用于查找指定数据在某个区间中是否存在，该函数返回等于指定值的第一个
c++模板stl常用算法
09-01
### C++模板STL常用算法 #### 前言 C++是一种强大的编程语言，它支持多种编程范式，包括面向对象编程、泛型编程等。其中，泛型编程是通过模板来实现的，模板允许程序员编写能处理多种类型数据的代码。标准模板库...
常用的STL查找算法
01-01
查找少不了循环遍历，在这里总结下常用的STL查找算法； 查找有三种，即点线面： 点就是查找目标为单个元素； 线就是查找目标为区间； 面就是查找目标为集合； 针对每个类别的查找，默认的比较函数是相等，为了...
C++STL库常用库函数总结
07-08
以下是对C++ STL库中常用库函数的详细总结： 1. **vector** - `size()`：返回向量中元素的数量。 - `empty()`：检查向量是否为空。 - `clear()`：清空向量的所有元素。 - `front()` / `back()`：访问第一个和...
STL常用算法
KevinJune的博客
06-11 2148
概述：○算法主要是由头文件组成○是所有STL头文件中最大的一个，范围涉及到比较、交换、查找、遍历操作、复制、修改等等○体积很小，只包括几个再序列上面进行简单数学运算的模板函数○定义了一些模板类，用以声明函数对象学习目标：○掌握常用的遍历算法算法简介：○for_each //遍历容器○transform //搬运容器到另一个容器中.........
STL【算法】| 常用算法大集合
weixin_45926547的博客
03-08 1852
文章目录一、简介1.1 类别1.1.1 _if结尾1.1.2 _copy尾词1.1.3 算法类别二、非变动性算法2.1 简介2.2 常见算法2.2.1 元素计数2.2.2 最大值和最小值2.2.3 搜寻元素三、变动性算法3.1 简介3.2 常用3.3 移除性算法四、变序性算法五、排序算法六、已序区间算法七、数值算法 一、简介 STL算法都被设计用来处理一个或多个迭代器区间；多数情况下只需提供起点即可； STL算法采用覆盖模式而非安插模式； 1.1 类别 1.1.1 _if结尾 当此类算法有两种形式
C++进阶学习--STL常用算法总结
文艺小少年的博客
02-23 270
目录 一、引言 二、迭代器 ------> 2.1、访问顺序/操作算法 ------> 2.2、读写元素 三、STL常用容器 ------> 3.1、序列容器 ------------> 3.1.1、vector 一、引言 前一章大致介绍了在STL中常用的几种容器类，本章来介绍下STL中常用的算法 https://www.cnblogs.com/hustsss/p/11177040.html https://blog.csdn.net/wdl20170204/article/deta
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
m0_57859086的博客
10-01 1205
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
【理论科学与实践技术】数学与经济管理中的学科与实用算法
最新发布
wnm23的专栏
10-02 783
在现代商业环境中，数学与经济管理的结合为企业提供了强大的决策支持。本文将介绍几个主要学科，包括数学基础、经济学模型、管理学及风险管理，并探讨相关的实用算法和这些算法在中国及全球知名企业中的实际应用。
【韩顺平Java笔记】第6章：数组、排序和查找
随手写写
10-02 776
排序是将多个数据，依指定的顺序进行排列的过程。
理解与应用：STL常用算法及MD5与RSA加密
"STL常用算法.doc" 本文主要讨论的是信息安全中的两种常见加密算法：MD5和RSA，它们在数据保护和网络安全中扮演着重要角色。 首先，MD5（Message-Digest Algorithm 5）是一种广泛使用的哈希函数，它将任意长度的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值