9.1 C++ STL 排序、算数与集合

C++ STL(Standard Template Library)是C++标准库中的一个重要组成部分,提供了丰富的模板函数和容器,用于处理各种数据结构和算法。在STL中,排序、算数和集合算法是常用的功能,可以帮助我们对数据进行排序、统计、查找以及集合操作等。

STL提供的这些算法,能够满足各种数据处理和分析的需求。通过灵活使用这些算法,我们可以高效地对数据进行排序、查找和聚合操作,提高代码的性能和可读性。在实际编程中,根据具体问题的需求选择合适的算法,能够更好地发挥STL的优势,提高程序的效率。

9.1 堆排序算法

Sort_heap 算法函数,用于对堆容器进行排序。sort_heap的用法如下:

template<class RandomAccessIterator>
void sort_heap(RandomAccessIterator first, RandomAccessIterator last);

其中,first、last是随机访问迭代器,表示待排序的堆容器的范围。sort_heap函数将[first, last]范围的堆容器排序,并将排序后的结果存储在相同的容器中。

读者需要注意,sort_heap函数执行前,必须先使用make_heap函数对容器进行堆化,然后再利用堆排序算法对其进行排序。

sort_heap函数通过重复执行pop_heap操作来实现排序。pop_heap操作从堆顶提取元素,将该元素放到容器的末尾位置;然后重新调整剩余元素的顺序,使之形成新的堆结构。重复执行pop_heap操作,就可以将堆容器中的所有元素按照递增顺序排序。

#include <iostream>
#include <algorithm>
#include <vector>using namespace std;void MyPrint(int val){ cout << val << "  "; }int main(int argc, char* argv[])
{vector<int> var {45,76,89,32,11,23,45,9,0,3};for_each(var.begin(), var.end(), MyPrint);cout << endl;// 建立堆make_heap(var.begin(), var.end());// 如果堆建立成功,则执行排序if (is_heap(var.begin(), var.end())){// 开始对堆排序sort_heap(var.begin(), var.end());}for_each(var.begin(), var.end(), MyPrint);system("pause");return 0;
}

9.2 局部排序与复制

Partial_sort 算法函数,用于对指定区间的元素进行部分排序。partial_sort的用法如下:

template<class RandomAccessIterator>
void partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last);

其中,first、last是随机访问迭代器,表示待排序序列的范围;middle是迭代器,表示指定的部分排序位置。partial_sort函数将[first, last]范围内的元素进行部分排序,使得从[first, middle)的元素按照递增顺序排列,其余元素不保证有序。也就是说,middle之前的元素是排过序的,middle之后的元素未排序。

由于该函数使用的是堆排序算法。在实现排序功能前,partial_sort函数首先将元素按照一定规则生成部分堆,然后重复执行pop_heap操作,将堆顶元素放到middle前,重新调整剩余元素的顺序,使之形成新的堆结构。重复执行pop_heap操作,就可以将[first, middle)范围内的元素按照递增顺序排列。

该算法可实现对容器中部分元素进行排序,还可以将结果拷贝到其他容器中,如下是一个简单的局部排序与排序拷贝案例。

#include <iostream>
#include <algorithm>
#include <vector>using namespace std;void MyPrint(int val){ cout << val << "  "; }int main(int argc, char* argv[])
{int iArray[] = { 3, 4, 8, 23, 56, 3, 89, 0, 32, 6 };const int len = sizeof(iArray) / sizeof(int);// 输出排序前的顺序for_each(iArray, iArray + len, MyPrint);cout << endl;// 局部排序,将数组中的前6个元素进行排序,后面的不排列int middle = 5;  // 指定排序索引,索引从0开始partial_sort(iArray, iArray + middle, iArray + len);for_each(iArray, iArray + len, MyPrint);cout << endl;// 排序并拷贝元素,将iArray中前5个元素排序后拷贝到var中vector<int> var(6);partial_sort_copy(iArray, iArray + 5, var.begin(), var.end());for_each(iArray, iArray + 5, MyPrint);system("pause");return 0;
}

9.3 快速排序算法

Sort 算法函数,用于对序列进行排序。sort的用法如下:

template<class RandomAccessIterator>
void sort(RandomAccessIterator first, RandomAccessIterator last);

其中,first、last是随机访问迭代器,表示待排序的序列的范围。sort函数将[first, last]范围内的元素按照递增顺序排序,并将排序后的结果存储在相同的容器中。sort函数在执行前,需要保证所排序的元素类型支持<运算符。

sort函数使用的是快速排序算法,在实现排序功能前,sort函数首先会选择[first, last]范围内的一个元素作为分割基准元素,然后按照分割基准元素将范围内的元素分为两个序列,其中一个序列的元素均小于基准元素,另一个序列的元素均大于等于基准元素。然后对两个序列分别递归调用sort函数,不断进行分割和排序,直到分割出的序列长度为1,排序就完成了。

#include <iostream>
#include <algorithm>
#include <vector>
#include <functional>using namespace std;void MyPrint(int val){ cout << val << " "; }int main(int argc, char* argv[])
{// 从小到大排序int iArray[] = { 56, 43, 22, 1, 34, 7, 89, 0, 43, 56 };const int len = sizeof(iArray) / sizeof(int);sort(iArray, iArray + len);for_each(iArray, iArray + len, [](int val){cout << val << " "; });cout << endl;// 从大到小排序vector<int> var = { 45, 76, 33, 21, 7, 89, 0, 34, 5, 7 };sort(var.begin(), var.end(), greater<int>());for_each(var.begin(), var.end(), MyPrint);system("pause");return 0;
}

9.4 稳定排序算法

Stable_sort 算法函数,用于对序列进行稳定排序。stable_sort的用法如下:

template<class RandomAccessIterator>
void stable_sort(RandomAccessIterator first, RandomAccessIterator last);

其中,first、last是随机访问迭代器,表示待排序的序列的范围。stable_sort函数将[first, last]范围内的元素按照递增顺序排序,并保证相等元素的相对顺序不变,将排序后的结果存储在相同的容器中。

stable_sort函数使用的是归并排序算法,具有良好的稳定性,可以保证相等元素的相对顺序不变。在实现排序功能前,stable_sort函数首先将序列从中间分成两个子序列,然后分别对两个子序列进行排序,最后归并两个排序好的子序列,形成一个完整的排序序列。

#include <iostream>
#include <algorithm>
#include <vector>using namespace std;struct Student{int id;char *name;int score;Student(int _id, char* _name, int _score){id = _id; name = _name; score = _score;}
};void MyPrint(Student val)
{cout << val.id << val.name << val.score << endl;
}bool CompByScore(Student x, Student y)
{// 按照学生的成绩从小到大进行排序return x.score < y.score ? 1 : 0;
}int main(int argc, char* argv[])
{vector<Student> var;var.push_back(Student(1, "keey", 90));var.push_back(Student(2, "marry", 82));var.push_back(Student(3, "lisa", 70));stable_sort(var.begin(), var.end(), CompByScore);for_each(var.begin(), var.end(), MyPrint);system("pause");return 0;
}

9.5 容器归并算法

Merge 算法函数,用于将两个已排序的序列合并成一个有序序列。merge的用法如下:

template<class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator merge(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result);

其中,first1、last1、first2、last2是输入迭代器,表示待合并的两个已排序序列的范围;result是输出迭代器,表示合并后的有序序列的目标位置。merge函数将已排序的两个序列按照递增顺序合并成一个新的有序序列,输出到result所指向的迭代器位置,并将输出结果的尾后迭代器作为函数的返回值返回。

merge函数使用的是归并排序算法,在实现合并功能前,merge函数首先将输入序列分成若干个小的段,将不同段之间的元素合并成一个有序段,然后再将合并后的所有段依次合并,完成最终的排序结果。

该算法可以实现将两个具有相同升降方向的有序序列(必须有序),合并成另一个有序序列。

#include <iostream>
#include <algorithm>
#include <functional>using namespace std;void MyPrint(int val){ cout << val << " "; }int main(int argc, char* argv[])
{// 按照升序方式将两个序列合并int iArray1[3] = { 1, 2, 3 };int iArray2[7] = { 4, 5, 6, 7, 8, 9, 10 };int result[10];merge(iArray1, iArray1 + 3, iArray2, iArray2 + 7, result);for_each(result, result + 10, MyPrint);cout << endl;// 按照降序方式将两个序列合并int iArray3[5] = { 30, 20, 15, 9, 2 };int iArray4[4] = { 10, 5, 3, 1 };int result2[9];merge(iArray3, iArray3 + 5, iArray4, iArray4 + 4, result2, greater<int>());for_each(result2, result2 + 9, MyPrint);cout << endl;// 内部归并排序,这里只给出降序排列代码,升序排列与第一个案例相同int iArray5[] = { 100, 80, 60, 40, 20, 10, 90, 70, 50, 30 };const int len = sizeof(iArray5) / sizeof(int);  // 数组元素总长度int middle = 6;                                 // 选择一个切割中位数下标inplace_merge(iArray5, iArray5 + middle, iArray5 + len, greater<int>());for_each(iArray5, iArray5 + len, MyPrint);system("pause");return 0;
}

9.6 容器区间查找算法

Bound 算法函数,用于查找序列中指定值的边界位置。bound的用法如下:

template<class ForwardIterator, class T>
ForwardIterator lower_bound (ForwardIterator first, ForwardIterator last, const T& value);template<class ForwardIterator, class T>
ForwardIterator upper_bound (ForwardIterator first, ForwardIterator last, const T& value);

其中,first、last是迭代器,表示待查找的序列的范围;value是需要查找的元素的值。lower_bound函数返回指向序列中第一个不小于value的元素的迭代器,如果所有元素都小于value,则返回last;upper_bound函数返回指向序列中第一个大于value的元素的迭代器,如果所有元素都不大于value,则返回last。

读者需要注意,该函数函数执行前,需要保证所输入的序列本身已经是已排序的序列,并且元素类型支持<运算符。

bound函数使用的是二分查找算法,可以高效地找到指定值的边界位置。lower_bound函数首先将序列分成若干个小的区间,每个区间内的元素都不大于value;然后在这些区间中继续执行二分查找操作,直到定位到第一个不小于value的元素位置。upper_bound函数和lower_bound函数类似,只是在找到不小于value的元素时,继续向前遍历,直到定位到第一个大于value的元素位置。

#include <iostream>
#include <algorithm>using namespace std;int main(int argc, char* argv[])
{int iArray[] = { 3, 6, 9, 12, 13, 18, 20, 27, 55, 44};const int len = sizeof(iArray) / sizeof(int);// lower_bound 找出不小于某值的有序数组下确界元素int *result1 = lower_bound(iArray, iArray + len, 16);cout << "lower_bound = " << *result1 << endl;// upper_bound 找出大于某值的有序数组上确界元素int *result2 = upper_bound(iArray, iArray + len, 20);cout << "upper_bound = " << *result2 << endl;// equal_range 找出可插入某值的区间元素pair<int*, int*> range = equal_range(iArray, iArray + len, 5);cout << "lower_bound = " << *range.first << endl;cout << "upper_bound = " << *range.second << endl;system("pause");return 0;
}

9.7 最大值/最小值算法

min_element和max_element 算法函数,用于查找序列中的最小元素和最大元素。它们的用法如下:

template<class ForwardIterator>
ForwardIterator min_element(ForwardIterator first, ForwardIterator last);template<class ForwardIterator>
ForwardIterator max_element(ForwardIterator first, ForwardIterator last);

其中,firstlast是迭代器,表示待查找的序列的范围。min_element函数返回指向序列中最小元素的迭代器,max_element函数返回指向序列中最大元素的迭代器。

读者需要注意,min_elementmax_element函数执行前,需要保证所输入的序列本身已经是已排序的序列。另外,为了实现更高效的运行时间,C++ STL中提供了另一个函数模板来查找最大或最小值。它可以在部分或未排序的序列中查找最大或最小的元素:

template <class ForwardIterator, class Compare>
ForwardIterator min_element(ForwardIterator first, ForwardIterator last, Compare comp);template <class ForwardIterator, class Compare>
ForwardIterator max_element(ForwardIterator first, ForwardIterator last, Compare comp);

其中,comp是一个可调用函数或函数对象,用于指定元素的比较方法。min_elementmax_element函数的功能与之前相同,只是增加了一个参数comp,用于指定元素的比较方法。

总之,min_elementmax_element函数是C++ STL中非常实用的查找函数,可以方便地查找序列中的最小元素和最大元素,并支持自定义的比较方法,实现各种元素查找和排序等操作。

#include <iostream>
#include <algorithm>
#include <list>using namespace std;int main(int argc, char* argv[])
{list<int> ls = { 1, 4, 5, 6, 7, 2, 3, 4, 9, 7, 6 };// 返回链表最小元素cout << *min_element(ls.begin(), ls.end()) << endl;// 返回链表最大元素cout << *max_element(ls.begin(), ls.end()) << endl;// 剩余 max /min 比较cout << max(100, 30) << endl;cout << min(1, -10) << endl;system("pause");return 0;
}

9.8 交集/并集/差集算法

set_intersection、set_union和set_difference 算法函数,分别用于求两个集合的交集、并集和差集。它们的用法如下:

template<class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator set_intersection(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result);template<class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator set_union(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result);template<class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator set_difference(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result);

其中,first1、last1、first2、last2是输入迭代器,表示待运算的两个集合的范围;result是输出迭代器,表示运算结果的位置。set_intersection函数返回两个集合的交集,set_union函数返回两个集合的并集,set_difference函数返回两个集合的差集。这些函数将运算结果复制到由result指定的迭代器范围内,并返回一个指向输出序列尾后位置的迭代器。

读者需要注意,函数执行前,需要保证输入的两个集合已经是有序的集合,并且元素类型支持<运算符。

set_intersection、set_union和set_difference函数使用的是归并排序的思想,可以高效地计算两个集合的交集、并集和差集。具体实现方式为,从输入集合的第一个元素开始遍历,将两个集合中相同的元素复制到输出序列中(set_intersection),将所有元素(包括重复元素)复制到输出序列中(set_union),将只存在于第一个集合中的元素复制到输出序列中(set_difference)。

#include <iostream>
#include <algorithm>
#include <vector>
#include <iterator>using namespace std;int main(int argc, char* argv[])
{vector<int> var1 = { 1,2,3,4,5,23 };vector<int> var2 = { 1,2,3,4,5,6,7,8,9,10 };vector<int> vTarget;// ------------------------------------------------// 求 var1 与 var2 的交集// ------------------------------------------------// 分配最小空间vTarget.resize(min(var1.size(), var2.size()));vector<int>::iterator itEnd;itEnd = set_intersection(var1.begin(), var1.end(), var2.begin(), var2.end(), vTarget.begin());// 拷贝与打印出来copy(vTarget.begin(), itEnd, ostream_iterator<int>(cout, " "));cout << endl;// ------------------------------------------------// 求 var1 与 var2 的并集// ------------------------------------------------// 分配最大空间vTarget.resize(var1.size()+var2.size());vector<int>::iterator itEnd1;itEnd1 = set_union(var1.begin(), var1.end(), var2.begin(), var2.end(), vTarget.begin());// 拷贝与打印出来copy(vTarget.begin(), itEnd1, ostream_iterator<int>(cout, " "));cout << endl;// ------------------------------------------------// 求 var1 与 var2 的差集// ------------------------------------------------// 分配最大数组的空间vTarget.resize(max(var1.size(),var2.size()));vector<int>::iterator itEnd2;itEnd2 = set_difference(var1.begin(), var1.end(), var2.begin(), var2.end(), vTarget.begin());// 拷贝与打印出来copy(vTarget.begin(), itEnd2, ostream_iterator<int>(cout, " "));system("pause");return 0;
}

9.9 求容器上/下排列组合

next_permutation和prev_permutation算法函数,用于获取一个序列的下一个或上一个排列。它们的用法如下:

template<class BidirectionalIterator>
bool next_permutation(BidirectionalIterator first, BidirectionalIterator last);template<class BidirectionalIterator>
bool prev_permutation(BidirectionalIterator first, BidirectionalIterator last);

其中,firstlast是双向迭代器,表示待排列的序列的起始和终止位置。next_permutation函数将序列转换为下一个排列,prev_permutation函数将序列转换为上一个排列,如果没有下一个或上一个排列,则返回false,否则返回true。

next_permutation和prev_permutation函数使用的是字典序算法,即通过比较相邻的排列,从而找到下一个或上一个排列。具体实现方式为,从序列的最后一个元素开始遍历,找到第一个满足a[i]<a[i+1]的元素a[i],然后在i的右边找到最小的元素a[j],使得a[j]>a[i],将a[i]a[j]互换位置,最后将i右边的元素按升序排列,从而得到下一个排列。prev_permutation函数实现方式类似,只是将上述步骤中的<>反转即可。

该算法用于对区间元素进行组合排列,选择一个字典顺序更大或更小的排列。

#include <iostream>
#include <algorithm>using namespace std;void MyPrint(int x) { cout << x << " "; }// 排序函数
template <class BidirectionalIter>
void nextPermu_sort(BidirectionalIter first, BidirectionalIter last)
{// 利用较大的组合返回truewhile (next_permutation(first, last)){}
}int main(int argc, char* argv[])
{int iArray[] = { 3, 5, 8, 1, 8, 9, 3, 2, 1, 9 };const int len = sizeof(iArray) / sizeof(int);// 下一排列组合next_permutation(iArray, iArray + len);for_each(iArray, iArray + len, MyPrint);cout << endl;// 上一排列组合prev_permutation(iArray, iArray + len);for_each(iArray, iArray + len, MyPrint);system("pause");return 0;
}

9.10 容器元素求和算法

accumulate、inner_product和partial_sum 算法函数,分别用于计算序列中的累加和、内积和和部分和序列。它们的用法如下:

template<class InputIterator, class T>
T accumulate(InputIterator first, InputIterator last, T init);template<class InputIterator1, class InputIterator2, class T>
T inner_product(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, T init);template<class InputIterator, class OutputIterator>
OutputIterator partial_sum(InputIterator first, InputIterator last, OutputIterator result);

其中,first、last、first1、last1、first2是输入迭代器,表示待计算的序列范围;init是计算的初始值,result是输出迭代器,表示计算结果的位置。accumulate函数返回序列中元素的累加和,inner_product函数返回序列的内积和,partial_sum函数返回序列的部分和序列。这些函数将计算结果复制到由result指定的迭代器范围内,并返回一个指向输出序列尾后位置的迭代器。

需要说明的是,accumulate和inner_product函数可以接受一个自定义的二元操作符(比如加法、乘法等),从而实现各种自定义的累加和和内积和的计算。partial_sum函数不需要自定义操作符,固定使用加法运算。

accumulate、inner_product和partial_sum函数使用的都是迭代算法,在遍历序列时进行累加和、内积和和部分和的计算。具体实现方式为,遍历序列中的元素,根据特定的操作符将每个元素进行累加、相乘或相加,从而得到总体的累加和、内积和或部分和序列。

#include <iostream>
#include <numeric>
#include <algorithm>using namespace std;void MyPrint(int x) { cout << x << " "; }int multiply(int x, int y) { return x*y; }int main(int argc, char* argv[])
{// 求数组元素相加之和int iArray[5] = {1,2,3,4,5};cout << accumulate(iArray, iArray + 5, 0) << endl;// 求数组元素的内积int iArray1[3] = { 2, 5, 4 };int iArray2[3] = { 10, 6, 5 };cout << inner_product(iArray1, iArray1 + 3, iArray2, 0) << endl;// 部分元素求和int iArray3[5] = { 1, 2, 3, 4, 5 };int result[5];partial_sum(iArray3, iArray3 + 5, result);for_each(iArray3, iArray3 + 5, MyPrint);cout << endl;// 求阶乘int result1[5];partial_sum(iArray3, iArray3 + 5, result1,multiply);for_each(result1, result1 + 5, MyPrint);system("pause");return 0;
}

本文作者: 王瑞
本文链接: https://www.lyshark.com/post/bba79f2e.html
版权声明: 本博客所有文章除特别声明外,均采用 BY-NC-SA 许可协议。转载请注明出处!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/40414.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

【JVM】JVM中的分代回收

文章目录 分代收集算法什么是分代分代收集算法-工作机制MinorGC、 Mixed GC 、 FullGC的区别是什么 分代收集算法 什么是分代 在java8时&#xff0c;堆被分为了两份&#xff1a; 新生代和老年代【1&#xff1a;2】 其中&#xff1a; 对于新生代&#xff0c;内部又被分为了三…

eclipse常用设置

1、调整编辑页面字体大小 窗口 (Window)- 首选项&#xff08;Preferences&#xff09;- 常规&#xff08;General&#xff09;- 外观 (Appearence)- 颜色与字体 (Colors And Fonts)&#xff0c;在右边的对话框里选择 Java - Java Editor Text Font&#xff0c;点击出现的修改&…

【ARM 嵌入式 编译系列 3.3 -- gcc 动态库与静态库的链接方法介绍】

文章目录 1.1 GCC 链接器 LD 介绍1.1.1 GCC 链接器 LD 常用参数介绍1.2 动态库和静态库介绍1.2.1 动态库和静态库优缺点1.2.2 库文件链接方式1.2.3 ldd 工具介绍1.2.4 静态库链接时搜索路径顺序1.2.5 动态库链接时、执行时搜索路径顺序1.2.6 头文件搜索路径1.2.7 有关环境变量上…

Neo4j之Aggregation基础

在 Neo4j 中&#xff0c;聚合&#xff08;Aggregation&#xff09;是对数据进行计算、汇总和统计的过程。以下是一些使用聚合函数的常见例子&#xff0c;以及它们的解释&#xff1a; 计算节点数量&#xff1a; MATCH (p:Person) RETURN count(p) AS totalPersons;这个查询会计…

Socks5代理在多线程爬虫中的应用

在进行爬虫开发过程中&#xff0c;我们常常需要处理大量的数据&#xff0c;并执行多任务并发操作。然而&#xff0c;频繁的请求可能会引起目标网站的反爬机制&#xff0c;导致IP封禁或限制访问。为了规避这些限制&#xff0c;我们可以借助Socks5代理的强大功能&#xff0c;通过…

Nginx反向代理技巧

跨域 作为一个前端开发者来说不可避免的问题就是跨域&#xff0c;那什么是跨域呢&#xff1f; 跨域&#xff1a;指的是浏览器不能执行其他网站的脚本。它是由浏览器的同源策略造成的&#xff0c;是浏览器对javascript施加的安全限制。浏览器的同源策略是指协议&#xff0c;域名…

2011-2021年数字普惠金融指数Bartik工具变量法(含原始数据和Bartik工具变量法代码)

2011-2021年数字普惠金融指数Bartik工具变量法&#xff08;含原始数据和Bartik工具变量法代码&#xff09; 1、时间&#xff1a;2011-2020&#xff08;省级、城市&#xff09;&#xff0c;2014-2020&#xff08;区县&#xff09; 2、原始数据来源&#xff1a;北大金融研究中心…

npm的镜像源和代理的查看和修改

一、镜像源 查询当前镜像源 npm get registry 设置为淘宝镜像 npm config set registry http://registry.npm.taobao.org/ 设置回默认的官方镜像 npm config set registry https://registry.npmjs.org/ 设置electron为淘宝镜像 npm config set ELECTRON_MIRROR "h…

Redis对象类型和结构、内存回收、对象共享

对象类型和结构 在Redis中&#xff0c;无论是键key还是值value都是一个对象&#xff0c;每次对Redis数据库创建一个新的键值对时&#xff0c;就至少会创建两个对象。 常见的对象类型有&#xff1a; 字符串列表哈希集合有序集合 这些对象在Redis中统一用一个结构体redisObjec…

VS2019生成的DLL,给QT(MinGW版本)使用的小结

VS2019端&#xff1a; a 基于生成一个DLL的工程&#xff08;要注意生成是x86&#xff0c;还是x64的&#xff0c;需要和后面的QT的App工程对应&#xff09;&#xff0c;这里不多解释了&#xff0c;网上多的是&#xff1b; b 在cpp实现文件里&#xff0c;假如要导出一个这样的…

Git如何上传文件到github

Git下载网址&#xff1a; https://git-scm.com/downloads 1. 新建一个空文件夹&#xff0c;用来上传文件&#xff0c;第一次需创建&#xff0c;以后无需创建 2. 点进去空文件夹&#xff0c;鼠标右键&#xff0c;使用Git Bash Here 打开 3. 克隆远程仓库&#xff1a;git cl…

深入理解JVM——垃圾回收与内存分配机制详细讲解

所谓垃圾回收&#xff0c;也就是要回收已经“死了”的对象。 那我们如何判断哪些对象“存活”&#xff0c;哪些已经“死去”呢&#xff1f; 一、判断对象已死 1、引用计数算法 给对象中添加一个引用计数器&#xff0c;每当有一个地方引用它时&#xff0c;计数器就加一&…

解决git reset --soft HEAD^撤销commit时报错

今天在使用git回退功能的时候&#xff0c;遇到以下错误&#xff1a; 解决git reset --soft HEAD^撤销commit时报错 问题&#xff1a; 在进行完commit后&#xff0c;想要撤销该commit&#xff0c;于是使用了git reset --soft HEAD^命令&#xff0c;但是出现如下报错&#xff1…

【学习心得】安装cuda/cudann和pytorch

一、查看驱动信息 # 进入CMD输入命令 nvidia-smi 也可以右下角图标打开NVIDIA 设置进行查看 二、下载安装CUDA 1、下载 下载地址 https://developer.nvidia.com/ 2、安装 推荐自定义安装。建议只勾选Cuda&#xff0c;只安装这一个就好&#xff0c;以免报错安装失败。 3、验证…

移动端直播相关技术总结

一、直播APP原理 二、直播APP架构 三、直播APP实现流程 四、流媒体开发 流媒体模块架构 流媒体相关基础知识 帧&#xff1a;每一帧代表一幅静止的图像 GOP&#xff1a;Group of Pictures&#xff0c;画面组&#xff0c;一个GOP就是一组连续的画面&#xff0c;很多帧的集合 码率…

BC136 KiKi去重整数并排序

给定一个整数序列&#xff0c;KiKi想把其中的重复的整数去掉&#xff0c;并将去重后的序列从小到大排序输出。 输入描述 第一行&#xff0c;输入一个整数n&#xff0c;表示序列有n个整数。 第二行输入n个整数&#xff08;每个整数大于等于1&#xff0c;小于等于1000&#xf…

nodejs与前端js大文件、切片、视频流相关技术示例

nodejs服务代码 const express require("express"); const fs require("fs");const app express(); // 展示html页面 app.get("/", function (req, res) {res.sendFile(__dirname "/index.html"); });// nodejs切片读取文件示例 …

redis-配置详解(基础篇)

# 可以配置包含其他redis配置&#xff0c;可以使得配置更清晰化 # include /path/to/local.conf ################################## MODULES ##################################### # Load modules at startup. If the server is not able to load modules # it will abor…

拉丁方设计资料的方差分析(SPSS版+SAS版)

拉丁方设计&#xff08;Latin square design&#xff09;&#xff1a;实验研究中涉及一个处理因素和两个控制因素&#xff0c;每个因素的类别数或水平数相等&#xff0c;此时可采用拉丁方设计&#xff0c;将两个控制因素分别安排在拉丁方设计的行和列上。该设计类型仍为单因素方…

中电金信通过KCSP认证 云原生能力获权威认可

中电金信通过KCSP&#xff08;Kubernetes Certified Service Provider&#xff09;认证&#xff0c;正式成为CNCF&#xff08;云原生计算基金会&#xff09;官方认证的 Kubernetes 服务提供商。 Kubernetes是容器管理编排引擎&#xff0c;底层实现为容器技术&#xff0c;是云原…