c++常用算法模板库.docx
《c++常用算法模板库.docx》由会员分享，可在线阅读，更多相关《c++常用算法模板库.docx（76页珍藏版）》请在冰豆网上搜索。
c++常用算法模板库
常用算法模板库（C++）
目录1
1排序算法3
1.1冒泡排序3
1.2选择排序4
1.3插入排序5
1.4快速排序6
1.5哈希排序8
2数学问题8
2.1求最大公约数最小公倍数8
2.2求素数9
2.2.1穷举法9
2.2.2筛法10
2.3排列组合10
2.3.1排列数10
2.3.2组合数11
2.3.3全排列算法12
2.3.4从n个数中选m个的组合13
2.4进制转换14
2.4.1十进制转N进制14
2.4.2N进制转十进制14
3查找15
3.1二分查找15
4栈16
4.1栈的定义16
4.2表达式求值19
5队列21
5.1队列的定义21
6串24
6.1基本操作24
6.1.1赋值24
6.1.2比较大小（字典顺序）24
6.2模式匹配25
6.2.1一般匹配算法25
6.2.2KMP算法26
7树27
7.1二叉树的定义27
7.2根据先序序列和中序序列建立二叉树31
7.3二叉排序树32
7.4建立哈夫曼树32
7.5树的定义34
8图38
8.1图的定义38
8.2图的最短路径43
8.2.1Dijkstra算法43
8.2.2Floyd算法44
8.3最小生成树44
8.3.1prim算法44
8.3.2Kruskal算法45
8.4拓扑排序46
8.5关键路径47
9高精度计算48
9.1加法48
9.2减法49
9.3乘法50
1排序算法
1.1冒泡排序
/*
函数功能：
对数组中的某一部分进行冒泡排序。
函数原形：
voidBubSort（DataTypea[],intl,intr,boolUp=true）;
参数：
DataTypea[]：
欲排序的数组；
intl：
有序序列在数组中的起始位置；
intr：
有序序列在数组中的结束位置；
boolUp：
true按升序排列，false按降序排列。
返回值：
无。
备注：
无。
*/
template
voidBubSort（DataTypea[],intl,intr,boolUp=true）
{
inti,j;
DataTypek;
if（Up）
{
for（i=l;i<=r-1;i++）
for（j=r;j>=i+1;j--）
if（a[j-1]>a[j]）
{
k=a[j-1];
a[j-1]=a[j];
a[j]=k;
}
}
else
for（i=l;i<=r-1;i++）
for（j=r;j>=i+1;j--）
if（a[j-1]{
k=a[j-1];
a[j-1]=a[j];
a[j]=k;
}
}
1.2选择排序
/*
函数功能：
对数组中的某一部分进行选择排序。
函数原形：
voidSelectSort（DataTypea[],intl,intr,boolUp=true）;
参数：
DataTypea[]：
欲排序的数组；
intl：
有序序列在数组中的起始位置；
intr：
有序序列在数组中的结束位置；
boolUp：
true按升序排列，false按降序排列。
返回值：
无。
备注：
无。
*/
/*普通版*/
template
voidSelectSort（DataTypea[],intl,intr,boolUp=true）
{
inti,j;
DataTypek;
if（Up）
{
for（i=l;i<=r-1;i++）
for（j=i+1;j<=r;j++）
if（a[i]>a[j]）
{
k=a[i];
a[i]=a[j];
a[j]=k;
}
}
else
for（i=l;i<=r-1;i++）
for（j=i+1;j<=r;j++）
if（a[i]{
k=a[i];
a[i]=a[j];
a[j]=k;
}
}
/*优化版*/
template
voidSelectSort（DataTypea[],intl,intr,boolUp=true）
{
inti,j,k;
DataTypex;
if（Up）
{
for（i=l;i<=r-1;i++）
{
k=i;
for（j=i+1;j<=r;j++）
if（a[j]x=a[i];
a[i]=a[k];
a[k]=x;
}
}
else
for（i=l;i<=r-1;i++）
{
k=i;
for（j=i+1;j<=r;j++）
if（a[j]>a[k]）k=j;
x=a[i];
a[i]=a[k];
a[k]=x;
}
}
1.3插入排序
/*
函数功能：
向有序数组中插如元素，并使插入新元素后仍然有序。
函数原形：
voidInsertSort（DataTypes[],int&Count,DataTypex,boolUp=true）;
参数：
DataTypes[]：
欲插入元素的有序序列；
int&Count：
有序序列中现有元素个数；
DataTypex：
欲插入的元素；
boolUp：
true按升序排列，false按降序排列。
返回值：
无。
备注：
无。
*/
template
voidInsertSort（DataTypes[],int&Count,DataTypex,boolUp=true）
{
inti,k=-1;
if（Up）
{
for（i=0;i<=Count-1;i++）
if（x{
k=i;
break;
}
}
else
for（i=0;i<=Count-1;i++）
if（x>s[i]）
{
k=i;
break;
}
if（k==-1）s[++Count-1]=x;
else
{
for（i=Count-1;i>=k;i--）s[i+1]=s[i];
s[k]=x;
Count++;
}
}
1.4快速排序
/*
函数功能：
对数组中的某一部分进行快速排序。
函数原形：
voidQuickSort（DataTypea[],intl,intr,boolUp=true）;
参数：
DataTypea[]：
欲排序的数组；
intl：
有序序列在数组中的起始位置；
intr：
有序序列在数组中的结束位置；
boolUp：
true按升序排列，false按降序排列。
返回值：
无。
备注：
无。
*/
template
voidQuickSort（DataTypea[],intl,intr,boolUp=true）
{
inti,j;
DataTypeMid,k;
i=l;
j=r;
Mid=a[（l+r）/2];
if（Up）
{
do
{
while（a[i]while（Midif（i<=j）
{
k=a[i];
a[i]=a[j];
a[j]=k;
++i;
--j;
}
}while（i<=j）;
}
else
do
{
while（a[i]>Mid）++i;
while（Mid>a[j]）--j;
if（i<=j）
{
k=a[i];
a[i]=a[j];
a[j]=k;
++i;
--j;
}
}while（i<=j）;
if（iif（l}
1.5哈希排序
/*
函数功能：
对数组中的某一部分进行哈希排序。
函数原形：
voidQuickSort（DataTypea[],intl,intr,boolUp=true）;
参数：
DataTypea[]：
欲排序的数组；
intl：
有序序列在数组中的起始位置；
intr：
有序序列在数组中的结束位置；
boolUp：
true按升序排列，false按降序排列。
返回值：
无。
备注：
只能对0~32767范围内的整数排序。
*/
voidHashSort（inta[],intl,intr,boolUp=true）
{
inti,j,k,Hash[32767]={0};
for（i=l;i<=r;i++）Hash[a[i]]++;
k=l;
if（Up）
{
for（i=0;i<=32767-1;i++）
{
for（j=1;j<=Hash[i];j++）a[k++]=i;
if（k>r）break;
}
}
else
for（i=32767-1;i>=0;i--）
{
for（j=1;j<=Hash[i];j++）a[k++]=i;
if（k>r）break;
}
}
2数学问题
2.1求最大公约数最小公倍数
/*
函数功能：
求两数的最大公约数。
函数原形：
intGCD（intm,intn）;
参数：
intm,intn：
求这两个数的最大公约数。
返回值：
int型，m、n的最大公约数。
备注：
最小公倍数=m*n/GCD（m,n）。
*/
intGCD（intm,intn）
{
intTemp,x,y;
x=m;
y=n;
Temp=x%y;
while（Temp!
=0）
{
x=y;
y=Temp;
Temp=x%y;
}
returny;
}
2.2求素数
2.2.1穷举法
/*
函数功能：
判断一个数是否是素数。
函数原形：
boolPrime（intx）;
参数：
intx：
欲判断的数。
返回值：
bool型，返回true表示x是素数，返回false表示x不是素数。
备注：
需包含头文件。
*/
boolPrime（intx）
{
inti;
x=abs（x）;
if（x<=1）returnfalse;
for（i=2;i<=int（sqrt（float（x）））;i++）
if（x%i==0）returnfalse;
returntrue;
}
2.2.2筛法
/*
函数功能：
判断小于等于n的数是否是素数。
函数原形：
voidPrime（boolHash[],intn）;
参数：
boolHash[]：
最终结果，Hash[i]=true表示i是素数，否则表示i不是素数；
intn：
判断范围。
返回值：
无。
备注：
无。
*/
voidPrime（boolHash[],intn）
{
inti,k;
Hash[0]=false;
Hash[1]=false;
for（i=2;i<=n;i++）Hash[i]=true;
i=2;
while（i<=n/2）
{
k=i;
while（k+i<=n）
{
k=k+i;
Hash[k]=false;
}
i++;
while（Hash[i]==false&&i}
}
2.3排列组合
2.3.1排列数
/*
函数功能：
排列数公式A（m,n）。
函数原形：
intA（intm,intn）;
参数：
intm,intn：
排列数公式的两个参数。
返回值：
int型，排列数。
备注：
无。
*/
intA（intm,intn）
{
inti,Ans;
Ans=1;
for（i=1;i<=m;i++）
{
Ans=Ans*n;
n--;
}
returnAns;
}
2.3.2组合数
/*
函数功能：
组合数公式C（m,n）。
函数原形：
intC（intm,intn）;
参数：
intm,intn：
组合数公式的两个参数。
返回值：
int型，组合数。
备注：
无。
*/
intC（intm,intn）
{
inti,Ans;
Ans=1;
for（i=1;i<=m;i++）
{
Ans=Ans*n;
n--;
}
for（i=2;i<=m;i++）Ans=Ans/i;
returnAns;
}
2.3.3全排列算法
/*
函数功能：
输出n的全排列。
函数原形：
voidArrange（intn）;
参数：
intn：
全排列元素个数。
返回值：
无。
备注：
无。
*/
voidSwap（int&a,int&b）
{
intk;
k=a;
a=b;
b=k;
}
voidInverse（intNum[],intl,intr）
{
inti,Count;
Count=（r-l+1）/2;
for（i=1;i<=Count;i++）Swap（Num[l++],Num[r--]）;
}
voidArrange（intn）
{
int*Num=newint[n+1];
chari,x,y;
Num[0]=0;
for（i=1;i<=n;i++）//输出原始序列
{
Num[i]=i;
cout<}
cout<<'\n';
do
{
for（i=1;i<=n;i++）
if（Num[i]>Num[i-1]）x=i;
for（i=x;i<=n;i++）
if（Num[i]>Num[x-1]）y=i;
if（x>1）
{
Swap（Num[x-1],Num[y]）;//交换Num[x-1]和Num[y]
Inverse（Num,x,n）;//对num[x]~num[n]作逆序处理
for（i=1;i<=n;i++）cout<cout<<'\n';
}
}while（x!
=1）;
delete[]Num;
}
2.3.4从n个数中选m个的组合
/*
函数功能：
输出n选m的组合方案。
函数原形：
voidCombination（intm,intn）;
参数：
intm：
欲选出的元素个数；
intn：
元素总个数。
返回值：
无。
备注：
无。
*/
voidCombination（intm,intn）
{
int*a=newint[n+1],i,j;
a[0]=1;
for（i=1;i<=m;i++）a[i]=i;
while（a[0]==1）
{
for（i=1;i<=m;i++）cout<cout<<'\n';
j=m;
while（a[j]==n-m+j&&j>0）j--;
a[j]++;
for（i=j+1;i<=n;i++）a[i]=a[i-1]+1;
}
delete[]a;
}
2.4进制转换
2.4.1十进制转N进制
/*
函数功能：
将一个十进制数转换成一个N进制数。
函数原形：
stringDecToN（DataTypex,intn）;
参数：
DataTypex：
欲转换的数；
intn：
返回结果的进制。
返回值：
string类对象，转换结果。
备注：
需包含。
*/
template
stringDecToN（DataTypex,intn）
{
stringAns;
intCount,i,j=0,a[64];
Count=0;
if（x==0）
{
Ans[0]='0';
Ans[1]='\0';
}
else
{
while（x>0）
{
a[Count++]=x%n;
x=x/n;
}
for（i=Count-1;i>=0;i--）
if（a[i]<10）Ans.append（1,a[i]+'0'）;
elseAns.append（1,a[i]+'A'-10）;
}
returnAns;
}
2.4.2N进制转十进制
/*
函数功能：
将一个N进制数转换成一个十进制数。
函数原形：
longNToDec（stringx,intn）;
参数：
stringx：
欲转换的数；
intn：
被转换数的进制。
返回值：
long型，转换结果。
备注：
需包含、。
*/
longNToDec（stringx,intn）
{
inta[32],y,Count,i,j;
longAns;
Ans=0;
for（i=0;i<=（int）x.length（）-1;i++）
if（'0'<=x[i]&&x[i]<='9'）a[i]=x[i]-'0';
elsea[i]=toupper（x[i]）-'A'+10;
Count=0;
for（i=（int）x.length（）-1;i>=0;i--）
{
y=1;
for（j=1;j<=Count;j++）y=y*n;
Count++;
Ans=Ans+y*a[i];
}
returnAns;
}
3查找
3.1二分查找
/*
函数功能：
查找指定元素在数组中的位置。
函数原形：
intBinarySearch（DataTypea[],DataTypex,intl,intr）;
参数：
DataTypea[]：
目标数组；
DataTypex：
待查找的元素；
intl：
数组下标上限；
intr：
数组下标下限。
返回值：
int型，元素x在数组a中的下标。
备注：
无。
*/
template
intBinarySearch（DataTypea[],DataTypex,intl,intr）
{
intMid;
while（l<=r）
{
Mid=（l+r）/2;
if（x==a[Mid]）returnMid;
else
{
if（xif（x>a[Mid]）l=Mid+1;
}
}
return-1;
}
4栈
4.1栈的定义
template
classStackClass
{
private:
structBodyNodeStruct
{
DataTypeData;
BodyNodeStruct*Pre,*Next;
}Bottom,*Top;
public:
StackClass（）;//构造函数，创建一个空栈
boolEmpty（）;//判断栈是否为空，若为空则返回true，否则返回false
intPush（DataTypeData）;//将Data压栈，如果压栈成功则返回0，否则返回1
intPop（DataType&Data）;//弹出栈顶元素，保存在Data中，若栈不为空则返回0，否则返回1
intGetTop（DataType&Data）;//读取栈顶元素，保存在Data中，若栈不为空则返回0，否则返回1
intSize（）;//返回栈中元素个数
voidClear（）;//清空栈
~StackClass（）;//析构函数
};
template
StackClass:
:
StackClass（）
{
Top=&Bottom;
Top->Pre=NULL;
Top->Next=NULL;
}
template
boolStackClass:
:
Empty（）
{
if（Top==&Bottom）returntrue;
elsereturnfalse;
}
template
intStackClass:
:
Push（DataTypeData）
{
BodyNodeStruct*Temp=newBodyNodeStruct;
if（Temp!
=NULL）
{
Temp->Pre=Top;
Temp->Next=NULL;
Top->Next=Temp;
Top->Data=Data;
Top=Temp;
return0;
}
elsereturn1;
}
template
intStackClass:
:
Pop（DataType&Data）
{
if（!
Empty（））
{
Top=Top->Pre;
Data=Top->Data;
deleteTop->Next;
Top->Next=NULL;
return0;
升级会员 