常用算法模板库C++.docx

常用算法模板库C++.docx

《常用算法模板库C++.docx》由会员分享，可在线阅读，更多相关《常用算法模板库C++.docx（74页珍藏版）》请在冰豆网上搜索。

常用算法模板库C++

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（Mid

if（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（i

if（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（x

if（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;

}

elsereturn1;

}

template

intStackClass:

:

GetTop（DataType&Data）

{

if（!

Empty（））

{

Data=Top->Pre->Data;

return0;

}

elsereturn1;

}

template

intStackClass:

:

Size（）

{

BodyNodeStruct*Temp=&Bottom;

intCount=0;

while（Temp!

=Top）

{

Count++;

Temp=Temp->Next;

}

returnCount;

}

template

voidStackClass:

:

Clear（）

{

DataTypeTemp;

while（!

Empty（））Pop（Temp）;

}

template

StackClass:

:

~StackClass（）

{

Clear（）;

}

4.2表达式求值

/*

函数功能：

计算四则运算表达式的值。

函数原形：

longEvaluate（stringExp）;

参数：

stringExp：

欲求值的四则运算表达式。

返回值：

long型，表达式的值。

备注：

需包含。

*/

longEvaluate（stringExp）

{

S