模板Word文件下载.docx
《模板Word文件下载.docx》由会员分享，可在线阅读，更多相关《模板Word文件下载.docx（21页珍藏版）》请在冰点文库上搜索。
0:
if（last==2）next=z[s[0]]<
z[width+s[1]]?
1;
/*topringof'
to'
pegmustbelargerandaneven'
distance'
away*/if（（z[next*width+s[next]]）>
（z[last*width+s[last]]）||（（z[last*width+s[last]]-z[next*width+s[next]]）%2==0））
last=3-next-last;
from%dto%d\n"
next+1,last+1）;
s[next]=s[next]-1;
s[last]=s[last]+1;
/*movefrom'
next'
to'
last'
peg*/
z[last*width+s[last]]=z[next*width+s[next]+1];
}
冒泡法改进
/*冒泡法是数据排序的一种基本算法,它的基本方法是:
相邻两元素进行比较,如有需要则进行交换,
每完成一次循环就将最小元素排在最后（如从大到小排序）,下一次循环是将其他的数进行类似操作?
如将N个数按从大到小排序,TurboC语言程序函数
如下:
*/
voidsort（inta[],intn）;
main（）
inta[100],i,j,n;
/*输入数组元素的个数及各元素的值*/
scanf（＂%d＂,&
n）;
for（i=0;
i<
n;
i++）scanf（＂%d＂,&
a[i]）;
sort（a,n）;
i++）printf（＂%d＂,a[i]）;
sort（inta[],intn）
{
inti,j,t;
for（i=n-2;
i>
=0;
i--）
for（j=0;
j<
i;
j++）
if（a[j]<
a[j+1]）
t=a[j];
a[j]=a[j+1];
a[j+1]=t;
}
/*N个元素需比较N*（N-1）/2次,效率较差?
其实,可根据每一次循环比较中的情
况改进之?
[改进一]:
若某次循环中没有数据交换过,则可认为数据已经有序了,
不必再进行循环了,可在程序中设一变量Flag用来标识有无数据交换?
sort（inta[],intn）
{
inti,j,t,flag;
for（i=n-2;
0;
flag=0;
for（j=0;
if（a[j]<
a[j+1]）
{
t=a[j];
a[j]=a[j+1];
a[j+1]=t;
flag=1;
}
if（flag==0）break;
/*[改进二]:
如果在一次循环中,最后的某些元素没有交换过,则说明后面这些元
素的顺序已排序,下次循环可不对其进行比较?
本方法主要考虑要排序的数组元素的范
围,而不是每一轮排序都将数组元素的范围减少1?
*/
sort（inta[],intn）
inti,j,t,k,flag;
flag=n-1;
while（flag>
0）
k=0;
j++）
if（a[j]<
{
t=a[j];
a[j]=a[j+1];
a[j+1]=t;
k=j;
}
flag=k;
/*此处不填flag=flag-1;
各种排序
#include<
stdlib.h>
structnode
intkey;
}r[20];
structrnode
intpoint;
};
voidprint（structnodea[20],intn）;
intcreat（）;
voidshell（structnodea[20],intn）;
inthoare（structnodea[20],intl,inth）;
voidquick1（structnodea[20],intn）;
voidquick2（structnodea[20],intl,inth）;
voidheap（structnodea[20],inti,intm）;
voidheapsort（structnodea[20],intn）;
voidmerges（structnodea[20],structnodea2[20],inth1,intmid,inth2）;
voidmergepass（structnodea[20],structnodea2[20],intl,intn）;
voidmergesort（structnodea[20],intn）;
intyx（intm,inti）;
intradixsort（structrnodea[20],intn）;
intnum,l,h,c;
structrnodes[20];
c=1;
while（c!
=0）
printf（"
主菜单\n"
1输入关键字，以-9999表示结束。
\n"
2希尔排序\n"
3非递归的快速排序\n"
4递归的快速排序\n"
5堆排序\n"
6归并排序\n"
7基数排序\n"
输入选择（1--7,0表示结束）:
scanf（"
c）;
switch（c）
case1:
num=creat（）;
print（r,num）;
break;
case2:
shell（r,num）;
case3:
quick1（r,num）;
case4:
l=0;
h=num-1;
quick2（r,l,h）;
printf（"
outputquick2sortresult:
print（r,num）;
case5:
heapsort（r,num）;
case6:
mergesort（r,num）;
case7:
radixsort（s,num）;
}
}//mainend
voidprint（structnodea[20],intn）
inti;
for（i=0;
i<
n;
i++）
%5d"
a[i].key）;
}//printend
intcreat（）
inti,n;
n=0;
inputkeys"
i）;
while（i!
=-9999）
r[n].key=i;
n++;
return（n）;
}//creatend
voidshell（structnodea[20],intn）//希尔排序
inti,j,k;
for（i=n;
i>
=1;
i--）
a[i].key=a[i-1].key;
k=n/2;
while（k>
=1）
for（i=k+1;
=n;
a[0].key=a[i].key;
j=i-k;
while（（a[j].key>
a[0].key）&
&
（j>
=0））
a[j+k].key=a[j].key;
j=j-k;
}
a[j+k]=a[0];
k=k/2;
a[i].key=a[i+1].key;
输出希尔排序的结果:
}//shellend
////////////////////快速排序///////////////////////////
inthoare（structnodea[20],intl,inth）//分区处理函数
inti,j;
structnodex;
i=l;
j=h;
x.key=a[i].key;
do
while（（i<
j）&
（a[j].key>
=x.key））
j--;
if（i<
j）
a[i].key=a[j].key;
i++;
（a[i].key<
a[j].key=a[i].key;
}while（i<
j）;
a[i].key=x.key;
return（i）;
}//hoareend
voidquick1（structnodea[20],intn）
inti,l,h,tag,top;
ints[20][2];
l=0;
h=n-1;
tag=1;
top=0;
while（l<
h）
i=hoare（a,l,h）;
top++;
s[top][0]=i+1;
s[top][1]=h;
h=h-1;
if（top==0）
tag=0;
else
l=s[top][0];
h=s[top][1];
top--;
}while（tag==1）;
输出非递归快速排序结果:
}//quickend
voidquick2（structnodea[20],intl,inth）//递归的快速排序
if（l<
i=hoare（a,l,h）;
quick2（a,l,i-1）;
quick2（a,i+1,h）;
}//quick2end
////////////////////快速排序结束////////////////////////
////////////////////堆排序函数//////////////////////////
voidheap（structnodea[20],inti,intm）//调整堆的函数
intj;
j=2*i;
while（j<
=m）
if（j<
m）
if（a[j].key>
a[j+1].key）
j++;
if（a[j].key<
x.key）
i=j;
j=2*i;
j=m+1;
}//heapend
voidheapsort（structnodea[20],intn）//堆排序的主体函数
inti,v;
for（i=n/2;
heap（a,i,n）;
输出堆排序结果:
for（v=n;
v>
=2;
v--）
a[1].key）;
x.key=a[1].key;
a[1].key=a[v].key;
a[v].key=x.key;
heap（a,1,v-1）;
}//heapsortend
/////////////////堆排序函数结束///////////////////
//////////////////归并函数////////////////////////
voidmerges（structnodea[20],structnodea2[20],inth1,intmid,inth2）
//归并排序的核心算法
i=h1;
j=mid+1;
k=h1-1;
while（（i<
=mid）&
（j<
=h2））
k=k+1;
if（a[i].key<
=a[j].key）
a2[k].key=a[i].key;
a2[k].key=a[j].key;
j++;
while（i<
=mid）
k++;
a2[k].key=a[i].key;
i++;
=h2）
a2[k].key=a[j].key;
}//mergesend
voidmergepass（structnodea[20],structnodea2[20],intl,intn）
//一趟归并
intj,i,h1,mid,h2;
i=0;
while（（n-i）>
=2*l）
h1=i;
mid=h1+l-1;
h2=i+2*l-1;
merges（a,a2,h1,mid,h2）;
i=i+2*l;
if（（n-i）<
=l）
for（j=i;
j<
j++）
a2[j].key=a[j].key;
h2=n-1;
}//mergepassend
voidmergesort（structnodea[20],intn）
intl;
structnodea2[20];
l=1;
while（l<
n）
mergepass（a,a2,l,n）;
l=2*l;
mergepass（a2,a,l,n）;
输出归并排序的结果:
}//mergesortend
///////////////归并函数结束///////////////
///////////////基数排序///////////////////
intyx（intm,inti）//分离关键字倒数第i位有效数字的算法
intx;
switch（i）
case1:
x=m%10;
case2:
x=（m%100）/10;
case3:
x=（m%1000）/100;
case4:
x=（m%10000）/1000;
return（x）;
}//yxend
intradixsort（structrnodea[20],intn）
intf[11],e[11],i,j,k,l,p,d,t;
for（i=1;
a[i].key=r[i-1].key;
a[i].point=i+1;
a[n].point=0;
p=1;
输出关键字有效位数d\n"
d）;
输出基数排序的结果:
=d;
for（j=0;
=10;
f[j]=0;
e[j]=0;
while（p!
k=yx（a[p].key,i）;
if（f[k]==0）
f[k]=p;
e[k]=p;
else
l=e[k];
a[l].point=p;
p=a[p].point;
j=0;
while（f[j]==0）
p=f[j];
t=e[j];
while（j<
10）
while（（j<
10）&
（f[j]==0））
if（f[j]!
a[t].point=f[j];
t=e[j];
a[t].point=0;
t=p;
while（t!
a[t].key）;
t=a[t].point;
return（p）;
多位阶乘
intdata[40];
intdigit;
inti,j,r,k;
intn;
=40;
i++）/*将数组初始值设为0*/
data[i]=0;
data[0]=1;
data[1]=1;
digit=1;
Enteranumberwhatyouwanttocalculus:
for（j=1;
=digit;
j++）/*每位上等乘上阶数digit决定有几位*/
data[j]*=i;
if（data[j]>
for（r=1;
r<
r++）
if（data[digit]>
digit++;
data[r+1]+=data[r]/10;
data[r]=data[r]%10;
%d!
="
i）;
for（k=digit;
k>
k--）
data[k]）;
getch（）;
/*最大公约数，最小公倍数*/
inthcf（inta,intb）
intr=0;
while（b!
r=a%b;
a=b;
b=r;
return（a）;
}
lcd（intu,intv,inth）
return（u*v/h）;
intu,v,h,l;
%d%d"
u,&
v）;
h=hcf（u,v）;
H.C.F=%d\n"
h）;
l=lcd（u,v,h）;
L.C.D=%d\n"
l）;
升级会员 