c++ 算法学习

最新推荐文章于 2024-11-11 22:06:28 发布
原创 最新推荐文章于 2024-11-11 22:06:28 发布 · 2.7k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#音视频 #opencv #计算机视觉

这篇博客展示了C++中模板函数的用法，包括普通模板、引用参数模板以及计算数组长度。此外，还介绍了各种算法实现，如：求和、乘积、排序、查找、重排等，并用STL算法进行了比较。最后，文章讨论了如何在有序数组中插入元素、原地重排数组以及计数排序和冒泡排序的优化。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.2 函数与参数
CMakeLists.txt


cmake_minimum_required(VERSION 3.1)
project(test)
add_executable(test main.cpp)



#include <iostream>
using namespace std;
int abc(int a,int b,int c)
{
	return a + b * c;
}

int main()
{
	int a = 1,b = 2,c = 3;
	std::cout<<abc(a,b,c)<<std::endl; //1+2*3 = 7
	return 0;
}



Scanning dependencies of target test
[ 50%] Building CXX object CMakeFiles/test.dir/main.cpp.o
[100%] Linking CXX executable test
[100%] Built target test
xz@xiaqiu:~/study/algorithm/c++/1/build$ ./test 
7
xz@xiaqiu:~/study/algorithm/c++/1/build$

模板函数


#include <iostream>
using namespace std;

template <class T>
T abc(T a,T b,T c)
{
	return a + b * c;
}

int main()
{
	int i1 = 1,i2 = 2,i3 = 3;
	double d1 = 1.0,d2 = 2.0,d3 = 3.0;
	std::cout<<abc(i1,i2,i3)<<std::endl;
	std::cout<<abc(d1,d2,d3)<<std::endl;
	return 0;
}



xz@xiaqiu:~/study/algorithm/c++/1/build$ ./test 
7
7
xz@xiaqiu:~/study/algorithm/c++/1/build$

引用参数


#include <iostream>
using namespace std;

template<class T>
T abc(const T& a,const T& b, const T& c)
{
	return a + b * c;
}

int main()
{
	float f1 = 1,f2 = 2, f3 = 3;
	cout<<abc(f1,f2,f3)<<endl;
	return 0;
}



#include <iostream>
using namespace std;

template <class Ta ,class Tb,class Tc>
Ta abc(const Ta& a,const Tb& b, const Tc& c)
{
	return a + b * c;
}

int main()
{
	double d = 1.3; int i = 2 ;float f = 3.0;
	cout<<abc(d , i , f)<<endl;
	return 0;
}



xz@xiaqiu:~/study/algorithm/c++/1/build$ make
Scanning dependencies of target test
[ 50%] Building CXX object CMakeFiles/test.dir/main3.cpp.o
[100%] Linking CXX executable test
[100%] Built target test
xz@xiaqiu:~/study/algorithm/c++/1/build$ ./test 
7.3
xz@xiaqiu:~/study/algorithm/c++/1/build$

计算数组的个数


#include <iostream>
struct St
{
	int a;
	int b;
};

template <typename T>
size_t count(const T& a)
{
	return sizeof(a) / sizeof(a[0]);
}

template <typename T, size_t N>
size_t count1(const T(&a)[N])
{
	return N;
}

int main()
{
	int i[10];
	double d[10];
	St st[10];
	std::cout<<count(i)<<std::endl;
	std::cout<<count(d)<<std::endl;
	std::cout<<count(st)<<std::endl;

	std::cout<<count1(i)<<std::endl;
	std::cout<<count1(d)<<std::endl;
	std::cout<<count1(st)<<std::endl;


	return 0;
}

模板fill


#include <iostream>
using namespace std;

template <typename T,size_t N>
void fill(T(&a)[N],T&& val)
{
	for(int i = 0;i < N;i++)
	{
		a[i] = val;
	}
}

int main()
{
	int array[10];
	fill(array,12);
	for(auto value : array)
	{
		std::cout<<value<<" ";
	}
	cout<<endl;
	return 0;
}

inner_product


#include <iostream>

template <typename T,size_t N>
T inner_product(T(&a)[N],T(&b)[N])
{
	T ret = {};
	for(int i = 0;i < N;i++)
	{
		ret += a[i] * b[i];
	}
	return ret;
}

int main()
{
	int a[] = {1,1,1,1,1};
	int b[] = {2,2,2,2,2}; 
	std::cout<<inner_product(a,b);
	std::cout<<std::endl;
	return 0;
}

iota


#include <iostream>

template <typename T,size_t N>
void iota(T(&a)[N],const T& value)
{
	for(int i = 0;i < N;i++)
		a[i] += value;
}

int main()
{
	int a[] = {1,2,3,4};
	iota(a,10);
	for(auto value : a)
	{
		std::cout<<value<<" ";
	}
	std::cout<<std::endl;
	return 0;
}

is_sorted


#include <iostream>
template <typename T,size_t N>
bool is_sorted(T(&a)[N])
{
	int toLow = 0;
	int toHigh = 0;
	for(int i = 0; i < N-1;i++)
	{
		if(a[i]>a[i+1])
		{
			toLow++;
		}
		else if(a[i]<a[i+1])
		{
			toHigh++;
		}
	}

	if(toLow == N-1 || toHigh == N-1 ||(toLow == 0 && toHigh == 0))
	{
		return true;
	}
	else
	{
		return false;
	}
}

int main()
{
	int a[] = {1,2,3,4,5,6};
	int b[] = {2,3,4,5,2};
	int c[] = {9,6,5,3,2,1};
	std::cout<<is_sorted(a)<<std::endl;
	std::cout<<is_sorted(b)<<std::endl;
	std::cout<<is_sorted(c)<<std::endl;
	return 0;
}

mismatch


#include <iostream>
using namespace std;

template <typename T,size_t N1,size_t N2>
int mismatch(const T(&a)[N1],const T(&b)[N2])
{
	int len = N1 > N2? N2 : N1;
	for(int i = 0;i < len;i++)
	{
		if(a[i] != b[i])
		{
			return i;
		}
	}
	return len;
}


int main()
{
	int a[] = {1,2,3,4,5};
	int b[] = {1,2,3,2};
	int c[] = {1,2};
	std::cout<<mismatch(a,b)<<std::endl;
	std::cout<<mismatch(a,c)<<std::endl;
	return 0;
}

抛出异常


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

int abc(int a,int b,int c)
{
	if(a <= 0 || b <= 0 || c <= 0)
		throw std::logic_error("All parameters shold be >0");
	return a + b * c;
}

int main()
{
	try{
		cout<<abc(1,0,2)<<endl;
		cout<<abc(1,2,2)<<endl;
	}
	catch(exception& e)
	{
		cout<<e.what()<<endl;
		return 1;
	}
	return 0;
}

sum求和


#include <iostream>
template <class T,size_t N>
T sum(T(&a)[N])
{
	//返回数值数组元素a[0:n-1]的和
	T theSum = 0;
	for(int i = 0; i < N;i++)
	{
		theSum += a[i];
	}
	return theSum;
}

int main()
{
	double d[] = {1.2,2.,3.,4.,5.};
	int i[] = {2,3,4,5};
	std::cout<<sum(d)<<std::endl;
	std::cout<<sum(i)<<std::endl;
	return 0;
}

使用递归函数求和


#include <iostream>

template<class T>
T rsubm(T a[],int n)
{
	//返回数值数组元素a[0:n-1]的和
	if(n>0)
		return rsubm(a,n-1) + a[n-1];
	return 0;
}

int main()
{
	double d[] = {1.2,2.,3.,4.,5.};
	int i[] = {2,3,4,5};
	std::cout<<rsubm(d,5)<<std::endl;
	std::cout<<rsubm(i,4)<<std::endl;
	return 0;
}

使用递归函数生成排列


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

template<class T>
void permutations(T list[],int k,int m)
{
	//生成 list[k:m] 的所有排列
	if(k == m)
	{
		//list[k:m] 仅有一个排列，输出它
		copy(list,list+m+1,ostream_iterator<T>(cout," "));
		cout<<endl;
	}
	else
	{
		for(int i = k;i <= m;i++)
		{
			swap(list[k],list[i]);
			permutations(list,k+1,m);
			swap(list[k],list[i]);
		}
	}
}

int main()
{
	int a[] = {1,2,3,4};
	permutations(a,0,3);
	return 0;
}

std::accumulate


#include <iostream>
#include <numeric>

template<class T>
T sum(T a[],int n)
{
	//返回数组a[0:n-1]的累计和
	T theSum = 0;
	return std::accumulate(a, a+n, theSum);
}

int main()
{
	int a[] = {1,2,3,4,5};
	std::cout<<sum(a,5)<<std::endl; //15
	return 0;
}

std::accumulate 乘积


#include <iostream>
#include <numeric>

template<class T>
T product(T a[],int n)
{
	//返回数组 ar[0:n-1] 的累计和
	T theProduct = 1;
	return std::accumulate(a,a+n,theProduct,std::multiplies<T>());
}

int main()
{
	int a[] = {1,2,3,4,5};
	std::cout<<product(a,5)<<std::endl; //120
	return 0;
}

STL 算法 copy 和 next_permutation


//使用 STL 算法 next_permutation 求排列
#include <iostream>
#include <algorithm>
#include <numeric>
#include <iterator>
using namespace std;

template<class T>
void permutations(T list[],int k,int m)
{
	//生成 1ist[k:m] 的所有排列
	//假设k <= m
	//将排列逐个输出
	do{
		copy(list,list+m+1,ostream_iterator<T>(cout," "));
		cout<<endl;
	}while(next_permutation(list,list+m+1));
}


int main()
{
	char a[] = {'a','b','c','d'};
	permutations(a,0,3);
	return 0;
}



xz@xiaqiu:~/study/algorithm/c++/1/build$ ./test 
a b c d 
a b d c 
a c b d 
a c d b 
a d b c 
a d c b 
b a c d 
b a d c 
b c a d 
b c d a 
b d a c 
b d c a 
c a b d 
c a d b 
c b a d 
c b d a 
c d a b 
c d b a 
d a b c 
d a c b 
d b a c 
d b c a 
d c a b 
d c b a 
xz@xiaqiu:~/study/algorithm/c++/1/build$

计数排序


#include <iostream>

template<class T>
void rearrange(T a[], int n, int r[])
{
	//使用一个附加数组 u，将元素排序
	T *u = new T[n]; //创建附加数组

	//把a中元素移到u中正确位置
	for(int i = 0;i < n;i++)
		u[r[i]] = a[i];

	//把u 中元素移回 a
	for(int i = 0;i < n;i++)
	{
		a[i] = u[i];
	}
	delete []u;
}


int main()
{
	int a[] = {4,3,9,3,7};
	int n[] = {2,0,4,1,3};
	rearrange(a,5,n);
	for(auto val : a)
	{
		std::cout<<val<<" "; //3 3 4 7 9
	}
	std::cout<<std::endl; 
	return 0;
}

选择排序 ( selection sort )


#include <iostream>
using namespace std;

template <class T>
int indexOfMax(T a[],int n)
{
	//查找数组 a[0:n-1] 的最大元素
	if(n <= 0)
	{
		cerr<<"n must be > 0";
		return -1;
	}

	int indexOfMax = 0;
	for(int i = 1;i < n;i++)
		if(a[indexOfMax] < a[i])
			indexOfMax = i;
	return indexOfMax;
}

template <class T>
void selectionSort(T a[],int n)
{
	//给数组 a[0:n-1] 的 个元素排序
	for(int size = n;size>1;size--)
	{
		int j = indexOfMax(a,size);
		swap(a[j],a[size - 1]);
	}
}

int main()
{
	int a[] = {2,4,4,5,2,3,1,2,34,4};
	selectionSort(a,10);
	for(auto value:a)
	{
		std::cout<<value<<" ";
	} //1 2 2 2 3 4 4 4 5 34 
	std::cout<<std::endl;
	return 0;
}

冒泡排序 ( bubble sort )


#include <iostream>
#include <algorithm>

//一次冒泡过程
template<class T>
void bubble(T a[], int n)
{
	//把a[0:n-1]中最大元素移到右边
	for(int i = 0;i < n - 1;i++)
	{
		if(a[i] > a[i+1]) std::swap(a[i],a[i+1]);
	}
}

//冒泡排序
template<class T>
void bubbleSort(T a[],int n)
{
	// 对数组元素 a[0:n - 1] 使用冒泡排序
	for(int i = n;i>1;i--)
		bubble(a,i);
}

int main()
{
	int a[] = {3,2,1,3,54,6};
	bubbleSort(a,6);
	for(auto value:a)
	{
		std::cout<<value<<" "; //1 2 3 3 6 54 
	}
	std::cout<<std::endl;
}

//在一个有序数组中插入一个元素


#include <iostream>
using namespace std;

template<class T>
void insert(T a[],int &n,const T& x)
{
	///把 x插入有序数组ar[0:n-1]
	//// 假设数组 a 的容量大于 n
	int i;
	for(i = n-1;i>=0 && x < a[i]; i--)
		a[i+1] = a[i];
	a[i+1] = x;
	n++;
}

int main()
{
	int len = 5;
	int a[len] = {1,3,4,5,6};
	insert(a,len,2);
	for(int i = 0;i < len;i++)
	{
		std::cout<<a[i]<<" "; //1 2 3 4 5 6
	}
	std::cout<<std::endl;
}

原地重排数组元素


#include <iostream>
#include <algorithm>

template<class T>
void rearrange(T a[], int n,int r[])
{
	//原地重排数组元素使之有序
	for(int i = 0; i<n;i++)
	{
		//把正确的元素移到a[i]
		while(r[i] != i)
		{
			int t = r[i];
			std::swap(a[i],a[t]);
			std::swap(r[i],r[t]);
		}
	}
}

int main()
{
	int a[] = {4,3,9,3,7};
	int n[] = {2,0,4,1,3};
	rearrange(a,5,n);
	for(auto val : a)
	{
		std::cout<<val<<" "; //3 3 4 7 9
	}
	std::cout<<std::endl; 
	return 0;
}

及时终止的选择排序


#include <iostream>
using namespace std;

template<class T>
void selectionSort(T a[],int n)
{
	//及时终止的选择排序
	bool sorted = false;
	for(int size = n; !sorted && (size > 1);size--)
	{
		int indexOfMax = 0;
		sorted = true;
		///查找最大元素
		for(int i = 1;i < size; i++)
		{
			if(a[indexOfMax] <= a[i]) 
				indexOfMax = i;
			else
				sorted = false; //无序
		}
		swap(a[indexOfMax],a[size-1]);
	}
}

int main()
{
	int a[] = {1,2,3,21,2,3,1};
	selectionSort(a,7);
	for(auto value : a)
	{
		std::cout<<value<<" "; //1 1 2 2 3 3 21 
	}
	std::cout<<std::endl;
	return 0;
}

及时终止冒泡排序


#include <iostream>
using namespace std;

template<class T>
bool bubble(T a[],int n)
{
	//把数组 a[0:n-1] 中的最大元素移到最右端
	bool swapped = false;// 目前为止未交换
	for(int i = 0; i < n-1;i++)
	{
		if(a[i] > a[i+1])
		{
			swap(a[i],a[i+1]);
			swapped = true; //交换
		}
	}
	return swapped;
}

template<class T>
void bubbleSort(T a[], int n)
{
	//及时终止冒泡排序
	for(int i = n; i > 1 && bubble(a,i); i--);
}

int main()
{
	int a[] = {1,2,3,21,2,3,1};
	bubbleSort(a,7);
	for(auto value : a)
	{
		std::cout<<value<<" "; //1 1 2 2 3 3 21 
	}
	std::cout<<std::endl;
	return 0;
}

插入排序


#include <iostream>
#include <algorithm>

using namespace std;

template<class T>
void insert(T a[],int n,const T& x)
{
	//把 x插入有序数组a[0:n-1]
	int i;
	for(i = n-1;i>=0 && x < a[i];i--)
		a[i+1] = a[i];
	a[i+1] = x;
}

template<class T>
void insertionSort(T a[],int n)
{
	//对数组a[0:n-1]实施插入排序
	for(int i = 1; i<n;i++)
	{
		T t = a[i];
		insert(a,i,t);
	}
}


int main()
{
	int a[] = {1,2,3,21,2,3,1};
	insertionSort(a,7);
	for(auto value : a)
	{
		std::cout<<value<<" "; //1 1 2 2 3 3 21 
	}
	std::cout<<std::endl;
	return 0;
}

程序步数


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

int stepCount = 0;

template<class T>
T sum(T a[],int n)
{
	//返回数值数组元素a[0:n-1] 的和
	T theSum = 0; 
	stepCount++; //theSum = 0 是一个程序步
	for(int i = 0;i<n;i++)
	{
		stepCount++;//for 循环的每一次条件判断是一个程序步
		theSum += a[i];
		stepCount++;//theSum += a[i] 是一个程序步
	}
	stepCount++;
	stepCount++;//for 循环语句的最后一次条件判断是一个程序步
				//return theSum 是一个程序步
	return theSum;
}

int main()
{
	int a[] = {1,2,3,21,2,3,1};
	std::cout<<sum(a,7)<<" "<<stepCount; //33 17
	std::cout<<std::endl;
	return 0;
}
C++算法学习(动态规划算法)
weixin_45743162的博客
12-12 567
动态规划算法1、目标2、方法3、过程4、例题（1）[力扣:5. 最长回文子串](https://leetcode-cn.com/problems/longest-palindromic-substring/) 1、目标 是求解决策过程最优化的过程。 2、方法 把原问题分解成子问题进行求解，也就是分治的思想。 3、过程 主要分四步： 划分子问题：把一个大问题分解为小问题 状态表示：如何处理小问题。 状态转移：也就是父问题如何推导出子问题。 确定边界：确定初始状态是什么？最小的子问题？最终状态又是什么。 4
C++算法学习(栈)
weixin_45743162的博客
02-03 630
目录什么是栈？实践题目[155. 最小栈](https://leetcode-cn.com/problems/min-stack/) 什么是栈？ 是一个运算受限制的线性表，只能在表尾进行插入和删除，也就是先进后出，后进先出。(新手检验搜一本算法图解，讲的很明白) 实践题目 155. 最小栈 struct Node{ int val; int min; Node *next; }; //建立结构体，写入题目要求的功能 class MinStack { priva
C++算法学习1
weixin_43839485的博客
05-13 290
表，栈和队列 表（在C++标准模版库） 1.vector（可增长的数组实现）常量时间内可索引，插入/删除代价昂贵 2.list（双向链表实现）插入/删除代价小，不容易索引 vector和list 的方法： int size() const; 返回容器中元素个数 void clear() bool empty() void push_back(const Object &x); 在表的末尾添...
C++算法学习——经典的抽象设计——charstack（2）
redAnt的博客
06-05 1031
虽然利用vector来实现charstack很简单。但是更重要的是，依靠Vector类使得更难分析CharStack类的性能，因为Vector类隐藏了这么多的复杂性。因为你还不知道Vector类的详细情况如何，你不知道在push和pop方法需要的情况下添加或删除元素涉及多少工作。接下来，我们要论的的主要目的是分析数据表示如何影响算法的效率。如果所有成本都可见，那么这种分析就更容易实现。所以我们以后要
C++基础算法学习
sinat_33511478的博客
10-05 233
基础算法 1、二分法 在包含size个元素的，从小到大排序的int数组a里查找元素p，如果找到，返回元素下标，如果找不到，返回-1. #include<iostream> using namespace std; int BinarySearch(int a[], int size, int p) { int L = 0; int R = size - 1; while (L <= R) { int mid = L + (R - L) / 2; if (p == a[mid
C++算法学习入门书，方便大家学习
07-11
C++算法学习入门书，方便大家学习
我做了个C++算法学习网站，从语法到算法再到数据结构，全方位为算法竞赛小伙伴护航
bigbigli的博客
07-02 1985
最近半个月，我做了个《C++算法宝典》并更新了40多篇教程，目前还在更新中，内容从语法到算法和数据结构，全方位为算法竞赛小伙伴护航。
PID c++算法学习和实现
weixin_37781153的博客
07-17 1779
原理 原理图：
小学生C++学习资料集-2022.07.11(B).pdf
07-11
总体而言，《小学生C++学习资料集-2022.07.11(B).pdf》为小学生们提供了一个全面的学习方案，内容涵盖了C++的基础知识、算法设计、编程思想和设计、学习资源和推荐以及信奥和竞赛相关信息，旨在帮助学生全面掌握C++...
黑马扫地僧C\C++\数据结构\算法\设计模式讲义.rar
06-03
《黑马扫地僧C/C++\数据结构\算法\设计模式讲义》是一份全面且深入的编程学习资源，特别适合那些希望通过自学提升C/C++技能的开发者。这份讲义结合了理论与实践，旨在帮助读者掌握编程语言的基础，深化对数据结构的...
c++算法入门学习
02-15
c++条件下写的常见的应用算法学习代码，引用于leetcode
算法学习代码实现_C++
11-06
在学习算法过程中自己的代码实现，与大家分享交流。版权所有:miracledan
C++算法的学习入门
adkinsy的博客
11-07 774
字典数 非递归运算方式 对于数字1、2、3......n的排列，不同排列的先后关系是从左到右逐个比较对应的数字的先后来决定的。例如对于5个数字的排列 12354和12345，排列12345在前，排列12354在后。按照这样的规定，5个数字的所有的排列中最前面的是12345，最后面的是 54321。 例如给定的数，为21543，从右向左，找到一个右边的数比它大的数s[k]<s[k+1],...
C++算法学习3
weixin_43839485的博客
05-18 220
剑指offer数据结构题1 1.寻找数组中相同的数字 1.把数字交换到和他的值相等的下标中 2.如果一个数字和与其值相等的下标中存储的数字相等，证明有重复 //找出数组中重复的数字： bool duplicate(int numbers[] , int length , int *duplication) { if(numbers == nullptr||length <= 0) ...
算法学习第一弹——C++基础
最新发布
黑不拉几的小白兔和你一起努力
11-11 1482
对于算法学习中，为了使算法更加容易成型，会很常用到STL库，这个也是C++中区别于C很大的一个板块，所以我们在正式开始学习算法之前先简单说一说C++的语法和STL库。
c++算法入门教程(1)
有求必应，有问必答（只要是我能解决的）
01-20 1578
C++是一种功能强大且广泛应用的编程语言，对于想要深入学习编程和算法的人来说，掌握C++是一个重要的里程碑。本文将带你逐步了解C++编程的基础知识，帮助你快速入门。
C++学习(函数和算法)
violet的博客
02-27 495
#include<iostream> using namespace std; #include<string> #include<vector> #include<map> #include<ctime> #include<algorithm> #include<functional> /*案例-员工分组 公司今天招聘了十个员工(ABCDEFGHIJK) ,10名员工进入公司之后，需要指派员工在那个部门工作 员工的信.
C++ 排序算法学习模板
wwxy1995的博客
02-16 240
SortTestHelper.h中给出了生成随机数组以及测试和计时函数 #pragma once #include &lt;iostream&gt; #include &lt;string&gt; #include &lt;ctime&gt; #include &lt;cassert&gt; using namespace std; namespace SorttestHelper { ...
C++常见算法大全（自用）
ylh的博客
08-27 7045
集合算法主要是集合上的一些运算，例如集合加法：并集，集合的减法：差集，还有交集。stable_partition: 范围排序，保存原容器顺序。partial_sort_copy:范围排序外加复制操作。next_permutation:下一个排序序列的组合。prev_permutation:上一个排序序列的组合。stable_sort: 排序，保存原容器数据顺序。remove_copy_if:条件删除拷贝到新容器。replace_copy_if:条件替换，结果另存。......
C++算法学习与代码实现交流
标题中的“算法学习代码实现_C++”指出了本文档的核心内容是关于算法的学习与实现，并且特别强调了编程语言的选择是C++。算法作为计算机科学的基石，无论在理论研究还是在软件开发中都占据着至关重要的位置。学习...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值