数据结构基本算法大全.docx
《数据结构基本算法大全.docx》由会员分享,可在线阅读,更多相关《数据结构基本算法大全.docx(12页珍藏版)》请在冰点文库上搜索。
数据结构基本算法大全
/***冒泡算法思想:
两个泡泡,大的在后面,小的在后面***/
#include
voidbubble(inta[],intn)
{
inttemp=0;
intlastexchange=0;/***传递边界***/
intborder=n-1;
for(inti=0;i{boolsort=true;for(intj=0;j{if(a[j]>a[j+1]){temp=a[j];a[j]=a[j+1];a[j+1]=temp;sort=false;/***两两交换,还得工作***/lastexchange=j;/***新的边界,解决了不在遍历全部元素,而是从最后交换那个位置开始***/border=lastexchange;/***给它新的边界***/用里if(sort)/***sort==trune才做,每一轮循环如果有交换面的false,如果哪一次循环一次都没有交换那么就不会执行交换,外面的true,就退出循环***/{break;}}}intmain(){inta[10],i;printf("请输入10个整数:\n");for(i=0;i<10;i++){scanf("%d",&a[i]);}bubble(a,10);printf("bubble后:\n");for(i=0;i<10;i++)printf("%4d",a[i]);printf("\n");}/***插入排序思想:把它看作摸牌过程。首先手里面有一张牌,所以i=1;摸第二张牌时和手里牌比较,比第一张牌小则往前,摸第二张牌,和前面两张牌比较,比他们都小则移动到最前面,剩下两张牌向后移动。***/#includevoidinsert(inta[],intn){inttemp,i,j;for(i=1;i{temp=a[i];j=i-1;while(j>=0&&tempa[j+1]=a[j--];/***利用j--先用后赋值的力量***/a[j+1]=temp;/***此时j--赋值了***/}}}main(){inti,a[10];printf("请输入10个整数\n");for(i=0;i<10;i++){scanf("%d",&a[i]);}printf("thearrayis:\n");for(i=0;i<10;i++){printf("%-4d",a[i]);}insert(a,10);printf("排序后:\n");for(i=0;i<10;i++)printf("%-4d",a[i]);printf("\n");}/*顺序查找思想:把查找的数从头至尾***/#includeintfind(int*ListSep,intListLength,intKeydata){inttemp=0;intlength=ListLength;for(inti=0;i{if(ListSep[i]==Keydata)returni;}return0;}intmain(){intTestData[5]={34,67,1,47,8};intreData=find(TestData,5,47);printf("reData:%d\n",reData);return0;}/***算法思想:分而治之,挖坑填数。初始i=0;j=9;x=a[i]=?由于已经将a[0]中的数保存在x中,可以理解成在数组a[0]上挖了一个坑,可以将其它数据填充到这里***/#includevoidquick(inta[],intl,intr){if(l{inti=l,j=r,x=a[l];/***l,r的生存期是大if结束***/while(i{while(i=x)/*这里的while循环,当找到a[j]相当于从右往左推进,找到后停下退出***/j--;if(i好了,j都已经指了第一个元素的位置,这时if就不用执行了***/a[i++]=a[j];/***i++,这里的值还是当前的,下面的i,就是赋值后的值***/}while(i***/i++;if(i{a[j--]=a[i];}}a[i]=x;/***把第一个坑的元素储存起来最后放到该放的位置***/quick(a,l,i-1);/***左边新组***//***此时那个标杆在中间,就不去动它了,它左边比他小,右边比它大***/quick(a,i+1,r);/***右边新组***/}}intmain(){inta[10],i;printf("pleseinputtennumber:\n");for(i=0;i<10;i++){scanf("%d",&a[i]);}quick(a,0,9);printf("快速排序的结果:\n");for(i=0;i<10;i++){printf("%4d",a[i]);}printf("\n");}/***选择排序思想:从头扫至尾,找到最小的元素,和第一个元素交换,接着找第二个小的放到第二个位置***/#includevoidselect(inta[],intn){for(inti=0;iintindex=i;intj;for(j=i+1;j{if(a[j]{index=j;}}inttemp=a[index];/***这里的index就是j的值,也就是最小元素的下标***/a[index]=a[i];a[i]=temp;}}intmain(){inta[10],i;printf("请输入10个整数:\n");for(i=0;i<10;i++)scanf("%d",&a[i]);}select(a,10);printf("afterselection:\n");for(i=0;i<10;i++){printf("%4d",a[i]);}printf("\n");}/***希尔排序思想:插入排序特殊情况,和升级版。分成一半一半的插***/#include#definemax100voidshell(inta[],intn){inti,j,k,temp,gap;/***这里gap=1是可以分到一个元素一组,然后比较***/for(intgap=n/2;gap>=1;gap/=2)/***这里的for循环功能是分组,gap/=2和i++一样,先用再赋值,下面都是这样***for(inti=0;i{for(j=i+gap;j{if(a[j-gap]>a[j]){temp=a[j];for(k=j-gap;k>=0&&a[k]>temp;k-=gap)/*ror,为了向左交换,这里的一个前提a[k]>temp,满足才能往左边进行交换*/a[k+gap]=a[k];/***此时k还是j-gap的值***//***要先把这个for循环搞完,在弄a[k+gap]=a[k]***/a[k+gap]=temp;/***此时k的值就是k-=gap的值***/}}}intmain(){inta[max],n,q;printf("输入数据个数\n");scanf("%d",&n);printf("输入数组元素值:\n");for(inti=0;iscanf("%d",&a[i]);shell(a,8);for(inti=0;i<8;i++)printf("%4d",a[i]);printf("\n");scanf("%d",&q);return0;}/***二分查找思想:用给定值K先与中间的结点的关键字比较,中间结点把线形表分成两个子表,若相等则查找成功;若不相等,再根据K与该中间结点关键字的比较结果确定下一步查找哪个子表,这样递归进行,直到查找到或查找结束发现表中没有这样的结点***//*前提是有序顺序存储*/#includeintbinsearch(int*Sep,intsepLength,intkeydata){intlow=0,mid,high=sepLength-1;while(low<=high)//防止一个元素都没有{mid=(low+high)/2;if(keydata{mdihigh=mid-1;//是mid-1,因为mid已经比较过了,左边,继续细分}elseif(keydata>Sep[mid]){low=mid+1;}else//说明已经找到了,不满足if,elseif说明keydata=sep[mid]{returnmid;}return-1;//查找失败,或一个元素都没有}intmain(){inta[]={1,2,3,4,5,6,7,8,9};intlocation;inttarget=4;location=binsearch(a,9,target);printf("%d\n",location);return0;/*基于结构体栈的实现思路:top始终指向一个待插入的位置push操作:1.写入数据2.top++3.前提:栈非满pop操作:1.top--2.弹出数据3.前提:栈非空*/#includetypedefstruct_stackcharmem[1024];inttop;}stack;intisFull(stack*ps)//判满{returnps->top==1024;}intisEmpty(stack*ps)//判空{returnps->top==0;}voidpush(stack*ps,charch)//压栈{ps->mem[ps->top]=ch;(ps->top)++;}charpop(stack*ps)//出栈{--(ps->top);returnps->mem[ps->top];intmain(){stacks={{0},0};//栈初始化for(charch='a';ch<='z';ch++){if(!isFull(&s)){push(&s,ch);}}while(!isEmpty(&s)){putchar(pop(&s));puts("");//换行}return0;
boolsort=true;
for(intj=0;j{if(a[j]>a[j+1]){temp=a[j];a[j]=a[j+1];a[j+1]=temp;sort=false;/***两两交换,还得工作***/lastexchange=j;/***新的边界,解决了不在遍历全部元素,而是从最后交换那个位置开始***/border=lastexchange;/***给它新的边界***/用里if(sort)/***sort==trune才做,每一轮循环如果有交换面的false,如果哪一次循环一次都没有交换那么就不会执行交换,外面的true,就退出循环***/{break;}}}intmain(){inta[10],i;printf("请输入10个整数:\n");for(i=0;i<10;i++){scanf("%d",&a[i]);}bubble(a,10);printf("bubble后:\n");for(i=0;i<10;i++)printf("%4d",a[i]);printf("\n");}/***插入排序思想:把它看作摸牌过程。首先手里面有一张牌,所以i=1;摸第二张牌时和手里牌比较,比第一张牌小则往前,摸第二张牌,和前面两张牌比较,比他们都小则移动到最前面,剩下两张牌向后移动。***/#includevoidinsert(inta[],intn){inttemp,i,j;for(i=1;i{temp=a[i];j=i-1;while(j>=0&&tempa[j+1]=a[j--];/***利用j--先用后赋值的力量***/a[j+1]=temp;/***此时j--赋值了***/}}}main(){inti,a[10];printf("请输入10个整数\n");for(i=0;i<10;i++){scanf("%d",&a[i]);}printf("thearrayis:\n");for(i=0;i<10;i++){printf("%-4d",a[i]);}insert(a,10);printf("排序后:\n");for(i=0;i<10;i++)printf("%-4d",a[i]);printf("\n");}/*顺序查找思想:把查找的数从头至尾***/#includeintfind(int*ListSep,intListLength,intKeydata){inttemp=0;intlength=ListLength;for(inti=0;i{if(ListSep[i]==Keydata)returni;}return0;}intmain(){intTestData[5]={34,67,1,47,8};intreData=find(TestData,5,47);printf("reData:%d\n",reData);return0;}/***算法思想:分而治之,挖坑填数。初始i=0;j=9;x=a[i]=?由于已经将a[0]中的数保存在x中,可以理解成在数组a[0]上挖了一个坑,可以将其它数据填充到这里***/#includevoidquick(inta[],intl,intr){if(l{inti=l,j=r,x=a[l];/***l,r的生存期是大if结束***/while(i{while(i=x)/*这里的while循环,当找到a[j]相当于从右往左推进,找到后停下退出***/j--;if(i好了,j都已经指了第一个元素的位置,这时if就不用执行了***/a[i++]=a[j];/***i++,这里的值还是当前的,下面的i,就是赋值后的值***/}while(i***/i++;if(i{a[j--]=a[i];}}a[i]=x;/***把第一个坑的元素储存起来最后放到该放的位置***/quick(a,l,i-1);/***左边新组***//***此时那个标杆在中间,就不去动它了,它左边比他小,右边比它大***/quick(a,i+1,r);/***右边新组***/}}intmain(){inta[10],i;printf("pleseinputtennumber:\n");for(i=0;i<10;i++){scanf("%d",&a[i]);}quick(a,0,9);printf("快速排序的结果:\n");for(i=0;i<10;i++){printf("%4d",a[i]);}printf("\n");}/***选择排序思想:从头扫至尾,找到最小的元素,和第一个元素交换,接着找第二个小的放到第二个位置***/#includevoidselect(inta[],intn){for(inti=0;iintindex=i;intj;for(j=i+1;j{if(a[j]{index=j;}}inttemp=a[index];/***这里的index就是j的值,也就是最小元素的下标***/a[index]=a[i];a[i]=temp;}}intmain(){inta[10],i;printf("请输入10个整数:\n");for(i=0;i<10;i++)scanf("%d",&a[i]);}select(a,10);printf("afterselection:\n");for(i=0;i<10;i++){printf("%4d",a[i]);}printf("\n");}/***希尔排序思想:插入排序特殊情况,和升级版。分成一半一半的插***/#include#definemax100voidshell(inta[],intn){inti,j,k,temp,gap;/***这里gap=1是可以分到一个元素一组,然后比较***/for(intgap=n/2;gap>=1;gap/=2)/***这里的for循环功能是分组,gap/=2和i++一样,先用再赋值,下面都是这样***for(inti=0;i{for(j=i+gap;j{if(a[j-gap]>a[j]){temp=a[j];for(k=j-gap;k>=0&&a[k]>temp;k-=gap)/*ror,为了向左交换,这里的一个前提a[k]>temp,满足才能往左边进行交换*/a[k+gap]=a[k];/***此时k还是j-gap的值***//***要先把这个for循环搞完,在弄a[k+gap]=a[k]***/a[k+gap]=temp;/***此时k的值就是k-=gap的值***/}}}intmain(){inta[max],n,q;printf("输入数据个数\n");scanf("%d",&n);printf("输入数组元素值:\n");for(inti=0;iscanf("%d",&a[i]);shell(a,8);for(inti=0;i<8;i++)printf("%4d",a[i]);printf("\n");scanf("%d",&q);return0;}/***二分查找思想:用给定值K先与中间的结点的关键字比较,中间结点把线形表分成两个子表,若相等则查找成功;若不相等,再根据K与该中间结点关键字的比较结果确定下一步查找哪个子表,这样递归进行,直到查找到或查找结束发现表中没有这样的结点***//*前提是有序顺序存储*/#includeintbinsearch(int*Sep,intsepLength,intkeydata){intlow=0,mid,high=sepLength-1;while(low<=high)//防止一个元素都没有{mid=(low+high)/2;if(keydata{mdihigh=mid-1;//是mid-1,因为mid已经比较过了,左边,继续细分}elseif(keydata>Sep[mid]){low=mid+1;}else//说明已经找到了,不满足if,elseif说明keydata=sep[mid]{returnmid;}return-1;//查找失败,或一个元素都没有}intmain(){inta[]={1,2,3,4,5,6,7,8,9};intlocation;inttarget=4;location=binsearch(a,9,target);printf("%d\n",location);return0;/*基于结构体栈的实现思路:top始终指向一个待插入的位置push操作:1.写入数据2.top++3.前提:栈非满pop操作:1.top--2.弹出数据3.前提:栈非空*/#includetypedefstruct_stackcharmem[1024];inttop;}stack;intisFull(stack*ps)//判满{returnps->top==1024;}intisEmpty(stack*ps)//判空{returnps->top==0;}voidpush(stack*ps,charch)//压栈{ps->mem[ps->top]=ch;(ps->top)++;}charpop(stack*ps)//出栈{--(ps->top);returnps->mem[ps->top];intmain(){stacks={{0},0};//栈初始化for(charch='a';ch<='z';ch++){if(!isFull(&s)){push(&s,ch);}}while(!isEmpty(&s)){putchar(pop(&s));puts("");//换行}return0;
if(a[j]>a[j+1])
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
sort=false;/***两两交换,还得工作***/
lastexchange=j;/***新的边界,解决了不在遍历全部元素,而是从最后交换那个位置开始***/
border=lastexchange;/***给它新的边界***/
用里
if(sort)/***sort==trune才做,每一轮循环如果有交换面的false,如果哪一次循环一次都没有交换那么就不会执行交换,外面的true,就退出循环***/
{break;
}
intmain()
inta[10],i;
printf("请输入10个整数:
\n");
for(i=0;i<10;i++)
scanf("%d",&a[i]);
bubble(a,10);
printf("bubble后:
printf("%4d",a[i]);
printf("\n");
/***插入排序思想:
把它看作摸牌过程。
首先手里面有一张牌,所以i=1;摸第二张牌时和手里牌比较,比第一张牌小则往前,摸第二张牌,和前面两张牌比较,比他们都小则移动到最前面,剩下两张牌向后移动。
***/
voidinsert(inta[],intn)
inttemp,i,j;
for(i=1;i{temp=a[i];j=i-1;while(j>=0&&tempa[j+1]=a[j--];/***利用j--先用后赋值的力量***/a[j+1]=temp;/***此时j--赋值了***/}}}main(){inti,a[10];printf("请输入10个整数\n");for(i=0;i<10;i++){scanf("%d",&a[i]);}printf("thearrayis:\n");for(i=0;i<10;i++){printf("%-4d",a[i]);}insert(a,10);printf("排序后:\n");for(i=0;i<10;i++)printf("%-4d",a[i]);printf("\n");}/*顺序查找思想:把查找的数从头至尾***/#includeintfind(int*ListSep,intListLength,intKeydata){inttemp=0;intlength=ListLength;for(inti=0;i{if(ListSep[i]==Keydata)returni;}return0;}intmain(){intTestData[5]={34,67,1,47,8};intreData=find(TestData,5,47);printf("reData:%d\n",reData);return0;}/***算法思想:分而治之,挖坑填数。初始i=0;j=9;x=a[i]=?由于已经将a[0]中的数保存在x中,可以理解成在数组a[0]上挖了一个坑,可以将其它数据填充到这里***/#includevoidquick(inta[],intl,intr){if(l{inti=l,j=r,x=a[l];/***l,r的生存期是大if结束***/while(i{while(i=x)/*这里的while循环,当找到a[j]相当于从右往左推进,找到后停下退出***/j--;if(i好了,j都已经指了第一个元素的位置,这时if就不用执行了***/a[i++]=a[j];/***i++,这里的值还是当前的,下面的i,就是赋值后的值***/}while(i***/i++;if(i{a[j--]=a[i];}}a[i]=x;/***把第一个坑的元素储存起来最后放到该放的位置***/quick(a,l,i-1);/***左边新组***//***此时那个标杆在中间,就不去动它了,它左边比他小,右边比它大***/quick(a,i+1,r);/***右边新组***/}}intmain(){inta[10],i;printf("pleseinputtennumber:\n");for(i=0;i<10;i++){scanf("%d",&a[i]);}quick(a,0,9);printf("快速排序的结果:\n");for(i=0;i<10;i++){printf("%4d",a[i]);}printf("\n");}/***选择排序思想:从头扫至尾,找到最小的元素,和第一个元素交换,接着找第二个小的放到第二个位置***/#includevoidselect(inta[],intn){for(inti=0;iintindex=i;intj;for(j=i+1;j{if(a[j]{index=j;}}inttemp=a[index];/***这里的index就是j的值,也就是最小元素的下标***/a[index]=a[i];a[i]=temp;}}intmain(){inta[10],i;printf("请输入10个整数:\n");for(i=0;i<10;i++)scanf("%d",&a[i]);}select(a,10);printf("afterselection:\n");for(i=0;i<10;i++){printf("%4d",a[i]);}printf("\n");}/***希尔排序思想:插入排序特殊情况,和升级版。分成一半一半的插***/#include#definemax100voidshell(inta[],intn){inti,j,k,temp,gap;/***这里gap=1是可以分到一个元素一组,然后比较***/for(intgap=n/2;gap>=1;gap/=2)/***这里的for循环功能是分组,gap/=2和i++一样,先用再赋值,下面都是这样***for(inti=0;i{for(j=i+gap;j{if(a[j-gap]>a[j]){temp=a[j];for(k=j-gap;k>=0&&a[k]>temp;k-=gap)/*ror,为了向左交换,这里的一个前提a[k]>temp,满足才能往左边进行交换*/a[k+gap]=a[k];/***此时k还是j-gap的值***//***要先把这个for循环搞完,在弄a[k+gap]=a[k]***/a[k+gap]=temp;/***此时k的值就是k-=gap的值***/}}}intmain(){inta[max],n,q;printf("输入数据个数\n");scanf("%d",&n);printf("输入数组元素值:\n");for(inti=0;iscanf("%d",&a[i]);shell(a,8);for(inti=0;i<8;i++)printf("%4d",a[i]);printf("\n");scanf("%d",&q);return0;}/***二分查找思想:用给定值K先与中间的结点的关键字比较,中间结点把线形表分成两个子表,若相等则查找成功;若不相等,再根据K与该中间结点关键字的比较结果确定下一步查找哪个子表,这样递归进行,直到查找到或查找结束发现表中没有这样的结点***//*前提是有序顺序存储*/#includeintbinsearch(int*Sep,intsepLength,intkeydata){intlow=0,mid,high=sepLength-1;while(low<=high)//防止一个元素都没有{mid=(low+high)/2;if(keydata{mdihigh=mid-1;//是mid-1,因为mid已经比较过了,左边,继续细分}elseif(keydata>Sep[mid]){low=mid+1;}else//说明已经找到了,不满足if,elseif说明keydata=sep[mid]{returnmid;}return-1;//查找失败,或一个元素都没有}intmain(){inta[]={1,2,3,4,5,6,7,8,9};intlocation;inttarget=4;location=binsearch(a,9,target);printf("%d\n",location);return0;/*基于结构体栈的实现思路:top始终指向一个待插入的位置push操作:1.写入数据2.top++3.前提:栈非满pop操作:1.top--2.弹出数据3.前提:栈非空*/#includetypedefstruct_stackcharmem[1024];inttop;}stack;intisFull(stack*ps)//判满{returnps->top==1024;}intisEmpty(stack*ps)//判空{returnps->top==0;}voidpush(stack*ps,charch)//压栈{ps->mem[ps->top]=ch;(ps->top)++;}charpop(stack*ps)//出栈{--(ps->top);returnps->mem[ps->top];intmain(){stacks={{0},0};//栈初始化for(charch='a';ch<='z';ch++){if(!isFull(&s)){push(&s,ch);}}while(!isEmpty(&s)){putchar(pop(&s));puts("");//换行}return0;
temp=a[i];
j=i-1;
while(j>=0&&tempa[j+1]=a[j--];/***利用j--先用后赋值的力量***/a[j+1]=temp;/***此时j--赋值了***/}}}main(){inti,a[10];printf("请输入10个整数\n");for(i=0;i<10;i++){scanf("%d",&a[i]);}printf("thearrayis:\n");for(i=0;i<10;i++){printf("%-4d",a[i]);}insert(a,10);printf("排序后:\n");for(i=0;i<10;i++)printf("%-4d",a[i]);printf("\n");}/*顺序查找思想:把查找的数从头至尾***/#includeintfind(int*ListSep,intListLength,intKeydata){inttemp=0;intlength=ListLength;for(inti=0;i{if(ListSep[i]==Keydata)returni;}return0;}intmain(){intTestData[5]={34,67,1,47,8};intreData=find(TestData,5,47);printf("reData:%d\n",reData);return0;}/***算法思想:分而治之,挖坑填数。初始i=0;j=9;x=a[i]=?由于已经将a[0]中的数保存在x中,可以理解成在数组a[0]上挖了一个坑,可以将其它数据填充到这里***/#includevoidquick(inta[],intl,intr){if(l{inti=l,j=r,x=a[l];/***l,r的生存期是大if结束***/while(i{while(i=x)/*这里的while循环,当找到a[j]相当于从右往左推进,找到后停下退出***/j--;if(i好了,j都已经指了第一个元素的位置,这时if就不用执行了***/a[i++]=a[j];/***i++,这里的值还是当前的,下面的i,就是赋值后的值***/}while(i***/i++;if(i{a[j--]=a[i];}}a[i]=x;/***把第一个坑的元素储存起来最后放到该放的位置***/quick(a,l,i-1);/***左边新组***//***此时那个标杆在中间,就不去动它了,它左边比他小,右边比它大***/quick(a,i+1,r);/***右边新组***/}}intmain(){inta[10],i;printf("pleseinputtennumber:\n");for(i=0;i<10;i++){scanf("%d",&a[i]);}quick(a,0,9);printf("快速排序的结果:\n");for(i=0;i<10;i++){printf("%4d",a[i]);}printf("\n");}/***选择排序思想:从头扫至尾,找到最小的元素,和第一个元素交换,接着找第二个小的放到第二个位置***/#includevoidselect(inta[],intn){for(inti=0;iintindex=i;intj;for(j=i+1;j{if(a[j]{index=j;}}inttemp=a[index];/***这里的index就是j的值,也就是最小元素的下标***/a[index]=a[i];a[i]=temp;}}intmain(){inta[10],i;printf("请输入10个整数:\n");for(i=0;i<10;i++)scanf("%d",&a[i]);}select(a,10);printf("afterselection:\n");for(i=0;i<10;i++){printf("%4d",a[i]);}printf("\n");}/***希尔排序思想:插入排序特殊情况,和升级版。分成一半一半的插***/#include#definemax100voidshell(inta[],intn){inti,j,k,temp,gap;/***这里gap=1是可以分到一个元素一组,然后比较***/for(intgap=n/2;gap>=1;gap/=2)/***这里的for循环功能是分组,gap/=2和i++一样,先用再赋值,下面都是这样***for(inti=0;i{for(j=i+gap;j{if(a[j-gap]>a[j]){temp=a[j];for(k=j-gap;k>=0&&a[k]>temp;k-=gap)/*ror,为了向左交换,这里的一个前提a[k]>temp,满足才能往左边进行交换*/a[k+gap]=a[k];/***此时k还是j-gap的值***//***要先把这个for循环搞完,在弄a[k+gap]=a[k]***/a[k+gap]=temp;/***此时k的值就是k-=gap的值***/}}}intmain(){inta[max],n,q;printf("输入数据个数\n");scanf("%d",&n);printf("输入数组元素值:\n");for(inti=0;iscanf("%d",&a[i]);shell(a,8);for(inti=0;i<8;i++)printf("%4d",a[i]);printf("\n");scanf("%d",&q);return0;}/***二分查找思想:用给定值K先与中间的结点的关键字比较,中间结点把线形表分成两个子表,若相等则查找成功;若不相等,再根据K与该中间结点关键字的比较结果确定下一步查找哪个子表,这样递归进行,直到查找到或查找结束发现表中没有这样的结点***//*前提是有序顺序存储*/#includeintbinsearch(int*Sep,intsepLength,intkeydata){intlow=0,mid,high=sepLength-1;while(low<=high)//防止一个元素都没有{mid=(low+high)/2;if(keydata{mdihigh=mid-1;//是mid-1,因为mid已经比较过了,左边,继续细分}elseif(keydata>Sep[mid]){low=mid+1;}else//说明已经找到了,不满足if,elseif说明keydata=sep[mid]{returnmid;}return-1;//查找失败,或一个元素都没有}intmain(){inta[]={1,2,3,4,5,6,7,8,9};intlocation;inttarget=4;location=binsearch(a,9,target);printf("%d\n",location);return0;/*基于结构体栈的实现思路:top始终指向一个待插入的位置push操作:1.写入数据2.top++3.前提:栈非满pop操作:1.top--2.弹出数据3.前提:栈非空*/#includetypedefstruct_stackcharmem[1024];inttop;}stack;intisFull(stack*ps)//判满{returnps->top==1024;}intisEmpty(stack*ps)//判空{returnps->top==0;}voidpush(stack*ps,charch)//压栈{ps->mem[ps->top]=ch;(ps->top)++;}charpop(stack*ps)//出栈{--(ps->top);returnps->mem[ps->top];intmain(){stacks={{0},0};//栈初始化for(charch='a';ch<='z';ch++){if(!isFull(&s)){push(&s,ch);}}while(!isEmpty(&s)){putchar(pop(&s));puts("");//换行}return0;
a[j+1]=a[j--];/***利用j--先用后赋值的力量***/a[j+1]=temp;/***此时j--赋值了***/
main()
inti,a[10];
printf("请输入10个整数\n");
printf("thearrayis:
printf("%-4d",a[i]);
insert(a,10);
printf("排序后:
/*顺序查找思想:
把查找的数从头至尾***/
intfind(int*ListSep,intListLength,intKeydata){
intlength=ListLength;
for(inti=0;i{if(ListSep[i]==Keydata)returni;}return0;}intmain(){intTestData[5]={34,67,1,47,8};intreData=find(TestData,5,47);printf("reData:%d\n",reData);return0;}/***算法思想:分而治之,挖坑填数。初始i=0;j=9;x=a[i]=?由于已经将a[0]中的数保存在x中,可以理解成在数组a[0]上挖了一个坑,可以将其它数据填充到这里***/#includevoidquick(inta[],intl,intr){if(l{inti=l,j=r,x=a[l];/***l,r的生存期是大if结束***/while(i{while(i=x)/*这里的while循环,当找到a[j]相当于从右往左推进,找到后停下退出***/j--;if(i好了,j都已经指了第一个元素的位置,这时if就不用执行了***/a[i++]=a[j];/***i++,这里的值还是当前的,下面的i,就是赋值后的值***/}while(i***/i++;if(i{a[j--]=a[i];}}a[i]=x;/***把第一个坑的元素储存起来最后放到该放的位置***/quick(a,l,i-1);/***左边新组***//***此时那个标杆在中间,就不去动它了,它左边比他小,右边比它大***/quick(a,i+1,r);/***右边新组***/}}intmain(){inta[10],i;printf("pleseinputtennumber:\n");for(i=0;i<10;i++){scanf("%d",&a[i]);}quick(a,0,9);printf("快速排序的结果:\n");for(i=0;i<10;i++){printf("%4d",a[i]);}printf("\n");}/***选择排序思想:从头扫至尾,找到最小的元素,和第一个元素交换,接着找第二个小的放到第二个位置***/#includevoidselect(inta[],intn){for(inti=0;iintindex=i;intj;for(j=i+1;j{if(a[j]{index=j;}}inttemp=a[index];/***这里的index就是j的值,也就是最小元素的下标***/a[index]=a[i];a[i]=temp;}}intmain(){inta[10],i;printf("请输入10个整数:\n");for(i=0;i<10;i++)scanf("%d",&a[i]);}select(a,10);printf("afterselection:\n");for(i=0;i<10;i++){printf("%4d",a[i]);}printf("\n");}/***希尔排序思想:插入排序特殊情况,和升级版。分成一半一半的插***/#include#definemax100voidshell(inta[],intn){inti,j,k,temp,gap;/***这里gap=1是可以分到一个元素一组,然后比较***/for(intgap=n/2;gap>=1;gap/=2)/***这里的for循环功能是分组,gap/=2和i++一样,先用再赋值,下面都是这样***for(inti=0;i{for(j=i+gap;j{if(a[j-gap]>a[j]){temp=a[j];for(k=j-gap;k>=0&&a[k]>temp;k-=gap)/*ror,为了向左交换,这里的一个前提a[k]>temp,满足才能往左边进行交换*/a[k+gap]=a[k];/***此时k还是j-gap的值***//***要先把这个for循环搞完,在弄a[k+gap]=a[k]***/a[k+gap]=temp;/***此时k的值就是k-=gap的值***/}}}intmain(){inta[max],n,q;printf("输入数据个数\n");scanf("%d",&n);printf("输入数组元素值:\n");for(inti=0;iscanf("%d",&a[i]);shell(a,8);for(inti=0;i<8;i++)printf("%4d",a[i]);printf("\n");scanf("%d",&q);return0;}/***二分查找思想:用给定值K先与中间的结点的关键字比较,中间结点把线形表分成两个子表,若相等则查找成功;若不相等,再根据K与该中间结点关键字的比较结果确定下一步查找哪个子表,这样递归进行,直到查找到或查找结束发现表中没有这样的结点***//*前提是有序顺序存储*/#includeintbinsearch(int*Sep,intsepLength,intkeydata){intlow=0,mid,high=sepLength-1;while(low<=high)//防止一个元素都没有{mid=(low+high)/2;if(keydata{mdihigh=mid-1;//是mid-1,因为mid已经比较过了,左边,继续细分}elseif(keydata>Sep[mid]){low=mid+1;}else//说明已经找到了,不满足if,elseif说明keydata=sep[mid]{returnmid;}return-1;//查找失败,或一个元素都没有}intmain(){inta[]={1,2,3,4,5,6,7,8,9};intlocation;inttarget=4;location=binsearch(a,9,target);printf("%d\n",location);return0;/*基于结构体栈的实现思路:top始终指向一个待插入的位置push操作:1.写入数据2.top++3.前提:栈非满pop操作:1.top--2.弹出数据3.前提:栈非空*/#includetypedefstruct_stackcharmem[1024];inttop;}stack;intisFull(stack*ps)//判满{returnps->top==1024;}intisEmpty(stack*ps)//判空{returnps->top==0;}voidpush(stack*ps,charch)//压栈{ps->mem[ps->top]=ch;(ps->top)++;}charpop(stack*ps)//出栈{--(ps->top);returnps->mem[ps->top];intmain(){stacks={{0},0};//栈初始化for(charch='a';ch<='z';ch++){if(!isFull(&s)){push(&s,ch);}}while(!isEmpty(&s)){putchar(pop(&s));puts("");//换行}return0;
if(ListSep[i]==Keydata)returni;
return0;
intTestData[5]={34,67,1,47,8};
intreData=find(TestData,5,47);
printf("reData:
%d\n",reData);
/***算法思想:
分而治之,挖坑填数。
初始i=0;j=9;x=a[i]=?
由于已经将a[0]中的数保存在x中,可以理解成在数组a[0]上挖了一个坑,可以将其它数据填充到这里***/
voidquick(inta[],intl,intr)
if(l{inti=l,j=r,x=a[l];/***l,r的生存期是大if结束***/while(i{while(i=x)/*这里的while循环,当找到a[j]相当于从右往左推进,找到后停下退出***/j--;if(i好了,j都已经指了第一个元素的位置,这时if就不用执行了***/a[i++]=a[j];/***i++,这里的值还是当前的,下面的i,就是赋值后的值***/}while(i***/i++;if(i{a[j--]=a[i];}}a[i]=x;/***把第一个坑的元素储存起来最后放到该放的位置***/quick(a,l,i-1);/***左边新组***//***此时那个标杆在中间,就不去动它了,它左边比他小,右边比它大***/quick(a,i+1,r);/***右边新组***/}}intmain(){inta[10],i;printf("pleseinputtennumber:\n");for(i=0;i<10;i++){scanf("%d",&a[i]);}quick(a,0,9);printf("快速排序的结果:\n");for(i=0;i<10;i++){printf("%4d",a[i]);}printf("\n");}/***选择排序思想:从头扫至尾,找到最小的元素,和第一个元素交换,接着找第二个小的放到第二个位置***/#includevoidselect(inta[],intn){for(inti=0;iintindex=i;intj;for(j=i+1;j{if(a[j]{index=j;}}inttemp=a[index];/***这里的index就是j的值,也就是最小元素的下标***/a[index]=a[i];a[i]=temp;}}intmain(){inta[10],i;printf("请输入10个整数:\n");for(i=0;i<10;i++)scanf("%d",&a[i]);}select(a,10);printf("afterselection:\n");for(i=0;i<10;i++){printf("%4d",a[i]);}printf("\n");}/***希尔排序思想:插入排序特殊情况,和升级版。分成一半一半的插***/#include#definemax100voidshell(inta[],intn){inti,j,k,temp,gap;/***这里gap=1是可以分到一个元素一组,然后比较***/for(intgap=n/2;gap>=1;gap/=2)/***这里的for循环功能是分组,gap/=2和i++一样,先用再赋值,下面都是这样***for(inti=0;i{for(j=i+gap;j{if(a[j-gap]>a[j]){temp=a[j];for(k=j-gap;k>=0&&a[k]>temp;k-=gap)/*ror,为了向左交换,这里的一个前提a[k]>temp,满足才能往左边进行交换*/a[k+gap]=a[k];/***此时k还是j-gap的值***//***要先把这个for循环搞完,在弄a[k+gap]=a[k]***/a[k+gap]=temp;/***此时k的值就是k-=gap的值***/}}}intmain(){inta[max],n,q;printf("输入数据个数\n");scanf("%d",&n);printf("输入数组元素值:\n");for(inti=0;iscanf("%d",&a[i]);shell(a,8);for(inti=0;i<8;i++)printf("%4d",a[i]);printf("\n");scanf("%d",&q);return0;}/***二分查找思想:用给定值K先与中间的结点的关键字比较,中间结点把线形表分成两个子表,若相等则查找成功;若不相等,再根据K与该中间结点关键字的比较结果确定下一步查找哪个子表,这样递归进行,直到查找到或查找结束发现表中没有这样的结点***//*前提是有序顺序存储*/#includeintbinsearch(int*Sep,intsepLength,intkeydata){intlow=0,mid,high=sepLength-1;while(low<=high)//防止一个元素都没有{mid=(low+high)/2;if(keydata{mdihigh=mid-1;//是mid-1,因为mid已经比较过了,左边,继续细分}elseif(keydata>Sep[mid]){low=mid+1;}else//说明已经找到了,不满足if,elseif说明keydata=sep[mid]{returnmid;}return-1;//查找失败,或一个元素都没有}intmain(){inta[]={1,2,3,4,5,6,7,8,9};intlocation;inttarget=4;location=binsearch(a,9,target);printf("%d\n",location);return0;/*基于结构体栈的实现思路:top始终指向一个待插入的位置push操作:1.写入数据2.top++3.前提:栈非满pop操作:1.top--2.弹出数据3.前提:栈非空*/#includetypedefstruct_stackcharmem[1024];inttop;}stack;intisFull(stack*ps)//判满{returnps->top==1024;}intisEmpty(stack*ps)//判空{returnps->top==0;}voidpush(stack*ps,charch)//压栈{ps->mem[ps->top]=ch;(ps->top)++;}charpop(stack*ps)//出栈{--(ps->top);returnps->mem[ps->top];intmain(){stacks={{0},0};//栈初始化for(charch='a';ch<='z';ch++){if(!isFull(&s)){push(&s,ch);}}while(!isEmpty(&s)){putchar(pop(&s));puts("");//换行}return0;
inti=l,j=r,x=a[l];/***l,r的生存期是大if结束***/
while(i{while(i=x)/*这里的while循环,当找到a[j]相当于从右往左推进,找到后停下退出***/j--;if(i好了,j都已经指了第一个元素的位置,这时if就不用执行了***/a[i++]=a[j];/***i++,这里的值还是当前的,下面的i,就是赋值后的值***/}while(i***/i++;if(i{a[j--]=a[i];}}a[i]=x;/***把第一个坑的元素储存起来最后放到该放的位置***/quick(a,l,i-1);/***左边新组***//***此时那个标杆在中间,就不去动它了,它左边比他小,右边比它大***/quick(a,i+1,r);/***右边新组***/}}intmain(){inta[10],i;printf("pleseinputtennumber:\n");for(i=0;i<10;i++){scanf("%d",&a[i]);}quick(a,0,9);printf("快速排序的结果:\n");for(i=0;i<10;i++){printf("%4d",a[i]);}printf("\n");}/***选择排序思想:从头扫至尾,找到最小的元素,和第一个元素交换,接着找第二个小的放到第二个位置***/#includevoidselect(inta[],intn){for(inti=0;iintindex=i;intj;for(j=i+1;j{if(a[j]{index=j;}}inttemp=a[index];/***这里的index就是j的值,也就是最小元素的下标***/a[index]=a[i];a[i]=temp;}}intmain(){inta[10],i;printf("请输入10个整数:\n");for(i=0;i<10;i++)scanf("%d",&a[i]);}select(a,10);printf("afterselection:\n");for(i=0;i<10;i++){printf("%4d",a[i]);}printf("\n");}/***希尔排序思想:插入排序特殊情况,和升级版。分成一半一半的插***/#include#definemax100voidshell(inta[],intn){inti,j,k,temp,gap;/***这里gap=1是可以分到一个元素一组,然后比较***/for(intgap=n/2;gap>=1;gap/=2)/***这里的for循环功能是分组,gap/=2和i++一样,先用再赋值,下面都是这样***for(inti=0;i{for(j=i+gap;j{if(a[j-gap]>a[j]){temp=a[j];for(k=j-gap;k>=0&&a[k]>temp;k-=gap)/*ror,为了向左交换,这里的一个前提a[k]>temp,满足才能往左边进行交换*/a[k+gap]=a[k];/***此时k还是j-gap的值***//***要先把这个for循环搞完,在弄a[k+gap]=a[k]***/a[k+gap]=temp;/***此时k的值就是k-=gap的值***/}}}intmain(){inta[max],n,q;printf("输入数据个数\n");scanf("%d",&n);printf("输入数组元素值:\n");for(inti=0;iscanf("%d",&a[i]);shell(a,8);for(inti=0;i<8;i++)printf("%4d",a[i]);printf("\n");scanf("%d",&q);return0;}/***二分查找思想:用给定值K先与中间的结点的关键字比较,中间结点把线形表分成两个子表,若相等则查找成功;若不相等,再根据K与该中间结点关键字的比较结果确定下一步查找哪个子表,这样递归进行,直到查找到或查找结束发现表中没有这样的结点***//*前提是有序顺序存储*/#includeintbinsearch(int*Sep,intsepLength,intkeydata){intlow=0,mid,high=sepLength-1;while(low<=high)//防止一个元素都没有{mid=(low+high)/2;if(keydata{mdihigh=mid-1;//是mid-1,因为mid已经比较过了,左边,继续细分}elseif(keydata>Sep[mid]){low=mid+1;}else//说明已经找到了,不满足if,elseif说明keydata=sep[mid]{returnmid;}return-1;//查找失败,或一个元素都没有}intmain(){inta[]={1,2,3,4,5,6,7,8,9};intlocation;inttarget=4;location=binsearch(a,9,target);printf("%d\n",location);return0;/*基于结构体栈的实现思路:top始终指向一个待插入的位置push操作:1.写入数据2.top++3.前提:栈非满pop操作:1.top--2.弹出数据3.前提:栈非空*/#includetypedefstruct_stackcharmem[1024];inttop;}stack;intisFull(stack*ps)//判满{returnps->top==1024;}intisEmpty(stack*ps)//判空{returnps->top==0;}voidpush(stack*ps,charch)//压栈{ps->mem[ps->top]=ch;(ps->top)++;}charpop(stack*ps)//出栈{--(ps->top);returnps->mem[ps->top];intmain(){stacks={{0},0};//栈初始化for(charch='a';ch<='z';ch++){if(!isFull(&s)){push(&s,ch);}}while(!isEmpty(&s)){putchar(pop(&s));puts("");//换行}return0;
while(i=x)/*这里的while循环,当找到a[j]相当于从右往左推进,找到后停下退出***/j--;if(i好了,j都已经指了第一个元素的位置,这时if就不用执行了***/a[i++]=a[j];/***i++,这里的值还是当前的,下面的i,就是赋值后的值***/}while(i***/i++;if(i{a[j--]=a[i];}}a[i]=x;/***把第一个坑的元素储存起来最后放到该放的位置***/quick(a,l,i-1);/***左边新组***//***此时那个标杆在中间,就不去动它了,它左边比他小,右边比它大***/quick(a,i+1,r);/***右边新组***/}}intmain(){inta[10],i;printf("pleseinputtennumber:\n");for(i=0;i<10;i++){scanf("%d",&a[i]);}quick(a,0,9);printf("快速排序的结果:\n");for(i=0;i<10;i++){printf("%4d",a[i]);}printf("\n");}/***选择排序思想:从头扫至尾,找到最小的元素,和第一个元素交换,接着找第二个小的放到第二个位置***/#includevoidselect(inta[],intn){for(inti=0;iintindex=i;intj;for(j=i+1;j{if(a[j]{index=j;}}inttemp=a[index];/***这里的index就是j的值,也就是最小元素的下标***/a[index]=a[i];a[i]=temp;}}intmain(){inta[10],i;printf("请输入10个整数:\n");for(i=0;i<10;i++)scanf("%d",&a[i]);}select(a,10);printf("afterselection:\n");for(i=0;i<10;i++){printf("%4d",a[i]);}printf("\n");}/***希尔排序思想:插入排序特殊情况,和升级版。分成一半一半的插***/#include#definemax100voidshell(inta[],intn){inti,j,k,temp,gap;/***这里gap=1是可以分到一个元素一组,然后比较***/for(intgap=n/2;gap>=1;gap/=2)/***这里的for循环功能是分组,gap/=2和i++一样,先用再赋值,下面都是这样***for(inti=0;i{for(j=i+gap;j{if(a[j-gap]>a[j]){temp=a[j];for(k=j-gap;k>=0&&a[k]>temp;k-=gap)/*ror,为了向左交换,这里的一个前提a[k]>temp,满足才能往左边进行交换*/a[k+gap]=a[k];/***此时k还是j-gap的值***//***要先把这个for循环搞完,在弄a[k+gap]=a[k]***/a[k+gap]=temp;/***此时k的值就是k-=gap的值***/}}}intmain(){inta[max],n,q;printf("输入数据个数\n");scanf("%d",&n);printf("输入数组元素值:\n");for(inti=0;iscanf("%d",&a[i]);shell(a,8);for(inti=0;i<8;i++)printf("%4d",a[i]);printf("\n");scanf("%d",&q);return0;}/***二分查找思想:用给定值K先与中间的结点的关键字比较,中间结点把线形表分成两个子表,若相等则查找成功;若不相等,再根据K与该中间结点关键字的比较结果确定下一步查找哪个子表,这样递归进行,直到查找到或查找结束发现表中没有这样的结点***//*前提是有序顺序存储*/#includeintbinsearch(int*Sep,intsepLength,intkeydata){intlow=0,mid,high=sepLength-1;while(low<=high)//防止一个元素都没有{mid=(low+high)/2;if(keydata{mdihigh=mid-1;//是mid-1,因为mid已经比较过了,左边,继续细分}elseif(keydata>Sep[mid]){low=mid+1;}else//说明已经找到了,不满足if,elseif说明keydata=sep[mid]{returnmid;}return-1;//查找失败,或一个元素都没有}intmain(){inta[]={1,2,3,4,5,6,7,8,9};intlocation;inttarget=4;location=binsearch(a,9,target);printf("%d\n",location);return0;/*基于结构体栈的实现思路:top始终指向一个待插入的位置push操作:1.写入数据2.top++3.前提:栈非满pop操作:1.top--2.弹出数据3.前提:栈非空*/#includetypedefstruct_stackcharmem[1024];inttop;}stack;intisFull(stack*ps)//判满{returnps->top==1024;}intisEmpty(stack*ps)//判空{returnps->top==0;}voidpush(stack*ps,charch)//压栈{ps->mem[ps->top]=ch;(ps->top)++;}charpop(stack*ps)//出栈{--(ps->top);returnps->mem[ps->top];intmain(){stacks={{0},0};//栈初始化for(charch='a';ch<='z';ch++){if(!isFull(&s)){push(&s,ch);}}while(!isEmpty(&s)){putchar(pop(&s));puts("");//换行}return0;
相当于从右往左推进,找到后停下退出***/
j--;
if(i好了,j都已经指了第一个元素的位置,这时if就不用执行了***/a[i++]=a[j];/***i++,这里的值还是当前的,下面的i,就是赋值后的值***/}while(i***/i++;if(i{a[j--]=a[i];}}a[i]=x;/***把第一个坑的元素储存起来最后放到该放的位置***/quick(a,l,i-1);/***左边新组***//***此时那个标杆在中间,就不去动它了,它左边比他小,右边比它大***/quick(a,i+1,r);/***右边新组***/}}intmain(){inta[10],i;printf("pleseinputtennumber:\n");for(i=0;i<10;i++){scanf("%d",&a[i]);}quick(a,0,9);printf("快速排序的结果:\n");for(i=0;i<10;i++){printf("%4d",a[i]);}printf("\n");}/***选择排序思想:从头扫至尾,找到最小的元素,和第一个元素交换,接着找第二个小的放到第二个位置***/#includevoidselect(inta[],intn){for(inti=0;iintindex=i;intj;for(j=i+1;j{if(a[j]{index=j;}}inttemp=a[index];/***这里的index就是j的值,也就是最小元素的下标***/a[index]=a[i];a[i]=temp;}}intmain(){inta[10],i;printf("请输入10个整数:\n");for(i=0;i<10;i++)scanf("%d",&a[i]);}select(a,10);printf("afterselection:\n");for(i=0;i<10;i++){printf("%4d",a[i]);}printf("\n");}/***希尔排序思想:插入排序特殊情况,和升级版。分成一半一半的插***/#include#definemax100voidshell(inta[],intn){inti,j,k,temp,gap;/***这里gap=1是可以分到一个元素一组,然后比较***/for(intgap=n/2;gap>=1;gap/=2)/***这里的for循环功能是分组,gap/=2和i++一样,先用再赋值,下面都是这样***for(inti=0;i{for(j=i+gap;j{if(a[j-gap]>a[j]){temp=a[j];for(k=j-gap;k>=0&&a[k]>temp;k-=gap)/*ror,为了向左交换,这里的一个前提a[k]>temp,满足才能往左边进行交换*/a[k+gap]=a[k];/***此时k还是j-gap的值***//***要先把这个for循环搞完,在弄a[k+gap]=a[k]***/a[k+gap]=temp;/***此时k的值就是k-=gap的值***/}}}intmain(){inta[max],n,q;printf("输入数据个数\n");scanf("%d",&n);printf("输入数组元素值:\n");for(inti=0;iscanf("%d",&a[i]);shell(a,8);for(inti=0;i<8;i++)printf("%4d",a[i]);printf("\n");scanf("%d",&q);return0;}/***二分查找思想:用给定值K先与中间的结点的关键字比较,中间结点把线形表分成两个子表,若相等则查找成功;若不相等,再根据K与该中间结点关键字的比较结果确定下一步查找哪个子表,这样递归进行,直到查找到或查找结束发现表中没有这样的结点***//*前提是有序顺序存储*/#includeintbinsearch(int*Sep,intsepLength,intkeydata){intlow=0,mid,high=sepLength-1;while(low<=high)//防止一个元素都没有{mid=(low+high)/2;if(keydata{mdihigh=mid-1;//是mid-1,因为mid已经比较过了,左边,继续细分}elseif(keydata>Sep[mid]){low=mid+1;}else//说明已经找到了,不满足if,elseif说明keydata=sep[mid]{returnmid;}return-1;//查找失败,或一个元素都没有}intmain(){inta[]={1,2,3,4,5,6,7,8,9};intlocation;inttarget=4;location=binsearch(a,9,target);printf("%d\n",location);return0;/*基于结构体栈的实现思路:top始终指向一个待插入的位置push操作:1.写入数据2.top++3.前提:栈非满pop操作:1.top--2.弹出数据3.前提:栈非空*/#includetypedefstruct_stackcharmem[1024];inttop;}stack;intisFull(stack*ps)//判满{returnps->top==1024;}intisEmpty(stack*ps)//判空{returnps->top==0;}voidpush(stack*ps,charch)//压栈{ps->mem[ps->top]=ch;(ps->top)++;}charpop(stack*ps)//出栈{--(ps->top);returnps->mem[ps->top];intmain(){stacks={{0},0};//栈初始化for(charch='a';ch<='z';ch++){if(!isFull(&s)){push(&s,ch);}}while(!isEmpty(&s)){putchar(pop(&s));puts("");//换行}return0;
好了,j都已经指了第一个元素的位置,这时if就不用执行了***/
a[i++]=a[j];/***i++,这里的值还是当前的,下面的i,就是赋值后的值***/
while(i***/i++;if(i{a[j--]=a[i];}}a[i]=x;/***把第一个坑的元素储存起来最后放到该放的位置***/quick(a,l,i-1);/***左边新组***//***此时那个标杆在中间,就不去动它了,它左边比他小,右边比它大***/quick(a,i+1,r);/***右边新组***/}}intmain(){inta[10],i;printf("pleseinputtennumber:\n");for(i=0;i<10;i++){scanf("%d",&a[i]);}quick(a,0,9);printf("快速排序的结果:\n");for(i=0;i<10;i++){printf("%4d",a[i]);}printf("\n");}/***选择排序思想:从头扫至尾,找到最小的元素,和第一个元素交换,接着找第二个小的放到第二个位置***/#includevoidselect(inta[],intn){for(inti=0;iintindex=i;intj;for(j=i+1;j{if(a[j]{index=j;}}inttemp=a[index];/***这里的index就是j的值,也就是最小元素的下标***/a[index]=a[i];a[i]=temp;}}intmain(){inta[10],i;printf("请输入10个整数:\n");for(i=0;i<10;i++)scanf("%d",&a[i]);}select(a,10);printf("afterselection:\n");for(i=0;i<10;i++){printf("%4d",a[i]);}printf("\n");}/***希尔排序思想:插入排序特殊情况,和升级版。分成一半一半的插***/#include#definemax100voidshell(inta[],intn){inti,j,k,temp,gap;/***这里gap=1是可以分到一个元素一组,然后比较***/for(intgap=n/2;gap>=1;gap/=2)/***这里的for循环功能是分组,gap/=2和i++一样,先用再赋值,下面都是这样***for(inti=0;i{for(j=i+gap;j{if(a[j-gap]>a[j]){temp=a[j];for(k=j-gap;k>=0&&a[k]>temp;k-=gap)/*ror,为了向左交换,这里的一个前提a[k]>temp,满足才能往左边进行交换*/a[k+gap]=a[k];/***此时k还是j-gap的值***//***要先把这个for循环搞完,在弄a[k+gap]=a[k]***/a[k+gap]=temp;/***此时k的值就是k-=gap的值***/}}}intmain(){inta[max],n,q;printf("输入数据个数\n");scanf("%d",&n);printf("输入数组元素值:\n");for(inti=0;iscanf("%d",&a[i]);shell(a,8);for(inti=0;i<8;i++)printf("%4d",a[i]);printf("\n");scanf("%d",&q);return0;}/***二分查找思想:用给定值K先与中间的结点的关键字比较,中间结点把线形表分成两个子表,若相等则查找成功;若不相等,再根据K与该中间结点关键字的比较结果确定下一步查找哪个子表,这样递归进行,直到查找到或查找结束发现表中没有这样的结点***//*前提是有序顺序存储*/#includeintbinsearch(int*Sep,intsepLength,intkeydata){intlow=0,mid,high=sepLength-1;while(low<=high)//防止一个元素都没有{mid=(low+high)/2;if(keydata{mdihigh=mid-1;//是mid-1,因为mid已经比较过了,左边,继续细分}elseif(keydata>Sep[mid]){low=mid+1;}else//说明已经找到了,不满足if,elseif说明keydata=sep[mid]{returnmid;}return-1;//查找失败,或一个元素都没有}intmain(){inta[]={1,2,3,4,5,6,7,8,9};intlocation;inttarget=4;location=binsearch(a,9,target);printf("%d\n",location);return0;/*基于结构体栈的实现思路:top始终指向一个待插入的位置push操作:1.写入数据2.top++3.前提:栈非满pop操作:1.top--2.弹出数据3.前提:栈非空*/#includetypedefstruct_stackcharmem[1024];inttop;}stack;intisFull(stack*ps)//判满{returnps->top==1024;}intisEmpty(stack*ps)//判空{returnps->top==0;}voidpush(stack*ps,charch)//压栈{ps->mem[ps->top]=ch;(ps->top)++;}charpop(stack*ps)//出栈{--(ps->top);returnps->mem[ps->top];intmain(){stacks={{0},0};//栈初始化for(charch='a';ch<='z';ch++){if(!isFull(&s)){push(&s,ch);}}while(!isEmpty(&s)){putchar(pop(&s));puts("");//换行}return0;
***/i++;
if(i{a[j--]=a[i];}}a[i]=x;/***把第一个坑的元素储存起来最后放到该放的位置***/quick(a,l,i-1);/***左边新组***//***此时那个标杆在中间,就不去动它了,它左边比他小,右边比它大***/quick(a,i+1,r);/***右边新组***/}}intmain(){inta[10],i;printf("pleseinputtennumber:\n");for(i=0;i<10;i++){scanf("%d",&a[i]);}quick(a,0,9);printf("快速排序的结果:\n");for(i=0;i<10;i++){printf("%4d",a[i]);}printf("\n");}/***选择排序思想:从头扫至尾,找到最小的元素,和第一个元素交换,接着找第二个小的放到第二个位置***/#includevoidselect(inta[],intn){for(inti=0;iintindex=i;intj;for(j=i+1;j{if(a[j]{index=j;}}inttemp=a[index];/***这里的index就是j的值,也就是最小元素的下标***/a[index]=a[i];a[i]=temp;}}intmain(){inta[10],i;printf("请输入10个整数:\n");for(i=0;i<10;i++)scanf("%d",&a[i]);}select(a,10);printf("afterselection:\n");for(i=0;i<10;i++){printf("%4d",a[i]);}printf("\n");}/***希尔排序思想:插入排序特殊情况,和升级版。分成一半一半的插***/#include#definemax100voidshell(inta[],intn){inti,j,k,temp,gap;/***这里gap=1是可以分到一个元素一组,然后比较***/for(intgap=n/2;gap>=1;gap/=2)/***这里的for循环功能是分组,gap/=2和i++一样,先用再赋值,下面都是这样***for(inti=0;i{for(j=i+gap;j{if(a[j-gap]>a[j]){temp=a[j];for(k=j-gap;k>=0&&a[k]>temp;k-=gap)/*ror,为了向左交换,这里的一个前提a[k]>temp,满足才能往左边进行交换*/a[k+gap]=a[k];/***此时k还是j-gap的值***//***要先把这个for循环搞完,在弄a[k+gap]=a[k]***/a[k+gap]=temp;/***此时k的值就是k-=gap的值***/}}}intmain(){inta[max],n,q;printf("输入数据个数\n");scanf("%d",&n);printf("输入数组元素值:\n");for(inti=0;iscanf("%d",&a[i]);shell(a,8);for(inti=0;i<8;i++)printf("%4d",a[i]);printf("\n");scanf("%d",&q);return0;}/***二分查找思想:用给定值K先与中间的结点的关键字比较,中间结点把线形表分成两个子表,若相等则查找成功;若不相等,再根据K与该中间结点关键字的比较结果确定下一步查找哪个子表,这样递归进行,直到查找到或查找结束发现表中没有这样的结点***//*前提是有序顺序存储*/#includeintbinsearch(int*Sep,intsepLength,intkeydata){intlow=0,mid,high=sepLength-1;while(low<=high)//防止一个元素都没有{mid=(low+high)/2;if(keydata{mdihigh=mid-1;//是mid-1,因为mid已经比较过了,左边,继续细分}elseif(keydata>Sep[mid]){low=mid+1;}else//说明已经找到了,不满足if,elseif说明keydata=sep[mid]{returnmid;}return-1;//查找失败,或一个元素都没有}intmain(){inta[]={1,2,3,4,5,6,7,8,9};intlocation;inttarget=4;location=binsearch(a,9,target);printf("%d\n",location);return0;/*基于结构体栈的实现思路:top始终指向一个待插入的位置push操作:1.写入数据2.top++3.前提:栈非满pop操作:1.top--2.弹出数据3.前提:栈非空*/#includetypedefstruct_stackcharmem[1024];inttop;}stack;intisFull(stack*ps)//判满{returnps->top==1024;}intisEmpty(stack*ps)//判空{returnps->top==0;}voidpush(stack*ps,charch)//压栈{ps->mem[ps->top]=ch;(ps->top)++;}charpop(stack*ps)//出栈{--(ps->top);returnps->mem[ps->top];intmain(){stacks={{0},0};//栈初始化for(charch='a';ch<='z';ch++){if(!isFull(&s)){push(&s,ch);}}while(!isEmpty(&s)){putchar(pop(&s));puts("");//换行}return0;
a[j--]=a[i];
a[i]=x;/***把第一个坑的元素储存起来最后放到该放的位
置***/
quick(a,l,i-1);/***左边新组***/
/***此时那个标杆在中间,就不去动它了,它左边比他小,右边比它大***/
quick(a,i+1,r);/***右边新组***/
printf("pleseinputtennumber:
quick(a,0,9);
printf("快速排序的结果:
/***选择排序思想:
从头扫至尾,找到最小的元素,和第一个元素交换,接着找第二个小的放到第二个位置***/
voidselect(inta[],intn)
for(inti=0;iintindex=i;intj;for(j=i+1;j{if(a[j]{index=j;}}inttemp=a[index];/***这里的index就是j的值,也就是最小元素的下标***/a[index]=a[i];a[i]=temp;}}intmain(){inta[10],i;printf("请输入10个整数:\n");for(i=0;i<10;i++)scanf("%d",&a[i]);}select(a,10);printf("afterselection:\n");for(i=0;i<10;i++){printf("%4d",a[i]);}printf("\n");}/***希尔排序思想:插入排序特殊情况,和升级版。分成一半一半的插***/#include#definemax100voidshell(inta[],intn){inti,j,k,temp,gap;/***这里gap=1是可以分到一个元素一组,然后比较***/for(intgap=n/2;gap>=1;gap/=2)/***这里的for循环功能是分组,gap/=2和i++一样,先用再赋值,下面都是这样***for(inti=0;i{for(j=i+gap;j{if(a[j-gap]>a[j]){temp=a[j];for(k=j-gap;k>=0&&a[k]>temp;k-=gap)/*ror,为了向左交换,这里的一个前提a[k]>temp,满足才能往左边进行交换*/a[k+gap]=a[k];/***此时k还是j-gap的值***//***要先把这个for循环搞完,在弄a[k+gap]=a[k]***/a[k+gap]=temp;/***此时k的值就是k-=gap的值***/}}}intmain(){inta[max],n,q;printf("输入数据个数\n");scanf("%d",&n);printf("输入数组元素值:\n");for(inti=0;iscanf("%d",&a[i]);shell(a,8);for(inti=0;i<8;i++)printf("%4d",a[i]);printf("\n");scanf("%d",&q);return0;}/***二分查找思想:用给定值K先与中间的结点的关键字比较,中间结点把线形表分成两个子表,若相等则查找成功;若不相等,再根据K与该中间结点关键字的比较结果确定下一步查找哪个子表,这样递归进行,直到查找到或查找结束发现表中没有这样的结点***//*前提是有序顺序存储*/#includeintbinsearch(int*Sep,intsepLength,intkeydata){intlow=0,mid,high=sepLength-1;while(low<=high)//防止一个元素都没有{mid=(low+high)/2;if(keydata{mdihigh=mid-1;//是mid-1,因为mid已经比较过了,左边,继续细分}elseif(keydata>Sep[mid]){low=mid+1;}else//说明已经找到了,不满足if,elseif说明keydata=sep[mid]{returnmid;}return-1;//查找失败,或一个元素都没有}intmain(){inta[]={1,2,3,4,5,6,7,8,9};intlocation;inttarget=4;location=binsearch(a,9,target);printf("%d\n",location);return0;/*基于结构体栈的实现思路:top始终指向一个待插入的位置push操作:1.写入数据2.top++3.前提:栈非满pop操作:1.top--2.弹出数据3.前提:栈非空*/#includetypedefstruct_stackcharmem[1024];inttop;}stack;intisFull(stack*ps)//判满{returnps->top==1024;}intisEmpty(stack*ps)//判空{returnps->top==0;}voidpush(stack*ps,charch)//压栈{ps->mem[ps->top]=ch;(ps->top)++;}charpop(stack*ps)//出栈{--(ps->top);returnps->mem[ps->top];intmain(){stacks={{0},0};//栈初始化for(charch='a';ch<='z';ch++){if(!isFull(&s)){push(&s,ch);}}while(!isEmpty(&s)){putchar(pop(&s));puts("");//换行}return0;
intindex=i;
intj;
for(j=i+1;j{if(a[j]{index=j;}}inttemp=a[index];/***这里的index就是j的值,也就是最小元素的下标***/a[index]=a[i];a[i]=temp;}}intmain(){inta[10],i;printf("请输入10个整数:\n");for(i=0;i<10;i++)scanf("%d",&a[i]);}select(a,10);printf("afterselection:\n");for(i=0;i<10;i++){printf("%4d",a[i]);}printf("\n");}/***希尔排序思想:插入排序特殊情况,和升级版。分成一半一半的插***/#include#definemax100voidshell(inta[],intn){inti,j,k,temp,gap;/***这里gap=1是可以分到一个元素一组,然后比较***/for(intgap=n/2;gap>=1;gap/=2)/***这里的for循环功能是分组,gap/=2和i++一样,先用再赋值,下面都是这样***for(inti=0;i{for(j=i+gap;j{if(a[j-gap]>a[j]){temp=a[j];for(k=j-gap;k>=0&&a[k]>temp;k-=gap)/*ror,为了向左交换,这里的一个前提a[k]>temp,满足才能往左边进行交换*/a[k+gap]=a[k];/***此时k还是j-gap的值***//***要先把这个for循环搞完,在弄a[k+gap]=a[k]***/a[k+gap]=temp;/***此时k的值就是k-=gap的值***/}}}intmain(){inta[max],n,q;printf("输入数据个数\n");scanf("%d",&n);printf("输入数组元素值:\n");for(inti=0;iscanf("%d",&a[i]);shell(a,8);for(inti=0;i<8;i++)printf("%4d",a[i]);printf("\n");scanf("%d",&q);return0;}/***二分查找思想:用给定值K先与中间的结点的关键字比较,中间结点把线形表分成两个子表,若相等则查找成功;若不相等,再根据K与该中间结点关键字的比较结果确定下一步查找哪个子表,这样递归进行,直到查找到或查找结束发现表中没有这样的结点***//*前提是有序顺序存储*/#includeintbinsearch(int*Sep,intsepLength,intkeydata){intlow=0,mid,high=sepLength-1;while(low<=high)//防止一个元素都没有{mid=(low+high)/2;if(keydata{mdihigh=mid-1;//是mid-1,因为mid已经比较过了,左边,继续细分}elseif(keydata>Sep[mid]){low=mid+1;}else//说明已经找到了,不满足if,elseif说明keydata=sep[mid]{returnmid;}return-1;//查找失败,或一个元素都没有}intmain(){inta[]={1,2,3,4,5,6,7,8,9};intlocation;inttarget=4;location=binsearch(a,9,target);printf("%d\n",location);return0;/*基于结构体栈的实现思路:top始终指向一个待插入的位置push操作:1.写入数据2.top++3.前提:栈非满pop操作:1.top--2.弹出数据3.前提:栈非空*/#includetypedefstruct_stackcharmem[1024];inttop;}stack;intisFull(stack*ps)//判满{returnps->top==1024;}intisEmpty(stack*ps)//判空{returnps->top==0;}voidpush(stack*ps,charch)//压栈{ps->mem[ps->top]=ch;(ps->top)++;}charpop(stack*ps)//出栈{--(ps->top);returnps->mem[ps->top];intmain(){stacks={{0},0};//栈初始化for(charch='a';ch<='z';ch++){if(!isFull(&s)){push(&s,ch);}}while(!isEmpty(&s)){putchar(pop(&s));puts("");//换行}return0;
if(a[j]{index=j;}}inttemp=a[index];/***这里的index就是j的值,也就是最小元素的下标***/a[index]=a[i];a[i]=temp;}}intmain(){inta[10],i;printf("请输入10个整数:\n");for(i=0;i<10;i++)scanf("%d",&a[i]);}select(a,10);printf("afterselection:\n");for(i=0;i<10;i++){printf("%4d",a[i]);}printf("\n");}/***希尔排序思想:插入排序特殊情况,和升级版。分成一半一半的插***/#include#definemax100voidshell(inta[],intn){inti,j,k,temp,gap;/***这里gap=1是可以分到一个元素一组,然后比较***/for(intgap=n/2;gap>=1;gap/=2)/***这里的for循环功能是分组,gap/=2和i++一样,先用再赋值,下面都是这样***for(inti=0;i{for(j=i+gap;j{if(a[j-gap]>a[j]){temp=a[j];for(k=j-gap;k>=0&&a[k]>temp;k-=gap)/*ror,为了向左交换,这里的一个前提a[k]>temp,满足才能往左边进行交换*/a[k+gap]=a[k];/***此时k还是j-gap的值***//***要先把这个for循环搞完,在弄a[k+gap]=a[k]***/a[k+gap]=temp;/***此时k的值就是k-=gap的值***/}}}intmain(){inta[max],n,q;printf("输入数据个数\n");scanf("%d",&n);printf("输入数组元素值:\n");for(inti=0;iscanf("%d",&a[i]);shell(a,8);for(inti=0;i<8;i++)printf("%4d",a[i]);printf("\n");scanf("%d",&q);return0;}/***二分查找思想:用给定值K先与中间的结点的关键字比较,中间结点把线形表分成两个子表,若相等则查找成功;若不相等,再根据K与该中间结点关键字的比较结果确定下一步查找哪个子表,这样递归进行,直到查找到或查找结束发现表中没有这样的结点***//*前提是有序顺序存储*/#includeintbinsearch(int*Sep,intsepLength,intkeydata){intlow=0,mid,high=sepLength-1;while(low<=high)//防止一个元素都没有{mid=(low+high)/2;if(keydata{mdihigh=mid-1;//是mid-1,因为mid已经比较过了,左边,继续细分}elseif(keydata>Sep[mid]){low=mid+1;}else//说明已经找到了,不满足if,elseif说明keydata=sep[mid]{returnmid;}return-1;//查找失败,或一个元素都没有}intmain(){inta[]={1,2,3,4,5,6,7,8,9};intlocation;inttarget=4;location=binsearch(a,9,target);printf("%d\n",location);return0;/*基于结构体栈的实现思路:top始终指向一个待插入的位置push操作:1.写入数据2.top++3.前提:栈非满pop操作:1.top--2.弹出数据3.前提:栈非空*/#includetypedefstruct_stackcharmem[1024];inttop;}stack;intisFull(stack*ps)//判满{returnps->top==1024;}intisEmpty(stack*ps)//判空{returnps->top==0;}voidpush(stack*ps,charch)//压栈{ps->mem[ps->top]=ch;(ps->top)++;}charpop(stack*ps)//出栈{--(ps->top);returnps->mem[ps->top];intmain(){stacks={{0},0};//栈初始化for(charch='a';ch<='z';ch++){if(!isFull(&s)){push(&s,ch);}}while(!isEmpty(&s)){putchar(pop(&s));puts("");//换行}return0;
index=j;
inttemp=a[index];/***这里的index就是j的值,也就是最小元素的下标***/
a[index]=a[i];
a[i]=temp;
select(a,10);
printf("afterselection:
/***希尔排序思想:
插入排序特殊情况,和升级版。
分成一半一半的插***/
#definemax100
voidshell(inta[],intn)
inti,j,k,temp,gap;/***这里gap=1是可以分到一个元素一组,然后比较***/
for(intgap=n/2;gap>=1;gap/=2)/***这里的for循环功能是分组,
gap/=2和i++一样,先用再赋值,下面都是这样***
for(inti=0;i{for(j=i+gap;j{if(a[j-gap]>a[j]){temp=a[j];for(k=j-gap;k>=0&&a[k]>temp;k-=gap)/*ror,为了向左交换,这里的一个前提a[k]>temp,满足才能往左边进行交换*/a[k+gap]=a[k];/***此时k还是j-gap的值***//***要先把这个for循环搞完,在弄a[k+gap]=a[k]***/a[k+gap]=temp;/***此时k的值就是k-=gap的值***/}}}intmain(){inta[max],n,q;printf("输入数据个数\n");scanf("%d",&n);printf("输入数组元素值:\n");for(inti=0;iscanf("%d",&a[i]);shell(a,8);for(inti=0;i<8;i++)printf("%4d",a[i]);printf("\n");scanf("%d",&q);return0;}/***二分查找思想:用给定值K先与中间的结点的关键字比较,中间结点把线形表分成两个子表,若相等则查找成功;若不相等,再根据K与该中间结点关键字的比较结果确定下一步查找哪个子表,这样递归进行,直到查找到或查找结束发现表中没有这样的结点***//*前提是有序顺序存储*/#includeintbinsearch(int*Sep,intsepLength,intkeydata){intlow=0,mid,high=sepLength-1;while(low<=high)//防止一个元素都没有{mid=(low+high)/2;if(keydata{mdihigh=mid-1;//是mid-1,因为mid已经比较过了,左边,继续细分}elseif(keydata>Sep[mid]){low=mid+1;}else//说明已经找到了,不满足if,elseif说明keydata=sep[mid]{returnmid;}return-1;//查找失败,或一个元素都没有}intmain(){inta[]={1,2,3,4,5,6,7,8,9};intlocation;inttarget=4;location=binsearch(a,9,target);printf("%d\n",location);return0;/*基于结构体栈的实现思路:top始终指向一个待插入的位置push操作:1.写入数据2.top++3.前提:栈非满pop操作:1.top--2.弹出数据3.前提:栈非空*/#includetypedefstruct_stackcharmem[1024];inttop;}stack;intisFull(stack*ps)//判满{returnps->top==1024;}intisEmpty(stack*ps)//判空{returnps->top==0;}voidpush(stack*ps,charch)//压栈{ps->mem[ps->top]=ch;(ps->top)++;}charpop(stack*ps)//出栈{--(ps->top);returnps->mem[ps->top];intmain(){stacks={{0},0};//栈初始化for(charch='a';ch<='z';ch++){if(!isFull(&s)){push(&s,ch);}}while(!isEmpty(&s)){putchar(pop(&s));puts("");//换行}return0;
for(j=i+gap;j{if(a[j-gap]>a[j]){temp=a[j];for(k=j-gap;k>=0&&a[k]>temp;k-=gap)/*ror,为了向左交换,这里的一个前提a[k]>temp,满足才能往左边进行交换*/a[k+gap]=a[k];/***此时k还是j-gap的值***//***要先把这个for循环搞完,在弄a[k+gap]=a[k]***/a[k+gap]=temp;/***此时k的值就是k-=gap的值***/}}}intmain(){inta[max],n,q;printf("输入数据个数\n");scanf("%d",&n);printf("输入数组元素值:\n");for(inti=0;iscanf("%d",&a[i]);shell(a,8);for(inti=0;i<8;i++)printf("%4d",a[i]);printf("\n");scanf("%d",&q);return0;}/***二分查找思想:用给定值K先与中间的结点的关键字比较,中间结点把线形表分成两个子表,若相等则查找成功;若不相等,再根据K与该中间结点关键字的比较结果确定下一步查找哪个子表,这样递归进行,直到查找到或查找结束发现表中没有这样的结点***//*前提是有序顺序存储*/#includeintbinsearch(int*Sep,intsepLength,intkeydata){intlow=0,mid,high=sepLength-1;while(low<=high)//防止一个元素都没有{mid=(low+high)/2;if(keydata{mdihigh=mid-1;//是mid-1,因为mid已经比较过了,左边,继续细分}elseif(keydata>Sep[mid]){low=mid+1;}else//说明已经找到了,不满足if,elseif说明keydata=sep[mid]{returnmid;}return-1;//查找失败,或一个元素都没有}intmain(){inta[]={1,2,3,4,5,6,7,8,9};intlocation;inttarget=4;location=binsearch(a,9,target);printf("%d\n",location);return0;/*基于结构体栈的实现思路:top始终指向一个待插入的位置push操作:1.写入数据2.top++3.前提:栈非满pop操作:1.top--2.弹出数据3.前提:栈非空*/#includetypedefstruct_stackcharmem[1024];inttop;}stack;intisFull(stack*ps)//判满{returnps->top==1024;}intisEmpty(stack*ps)//判空{returnps->top==0;}voidpush(stack*ps,charch)//压栈{ps->mem[ps->top]=ch;(ps->top)++;}charpop(stack*ps)//出栈{--(ps->top);returnps->mem[ps->top];intmain(){stacks={{0},0};//栈初始化for(charch='a';ch<='z';ch++){if(!isFull(&s)){push(&s,ch);}}while(!isEmpty(&s)){putchar(pop(&s));puts("");//换行}return0;
if(a[j-gap]>a[j])
for(k=j-gap;k>=0&&a[k]>temp;k-=gap)/*ror,为了向左交换,这里的一个前提a[k]>temp,满足才能往左边进行交换*/
a[k+gap]=a[k];/***此时k还是j-gap的值***//***要先把这个for循环搞完,在弄a[k+gap]=a[k]***/
a[k+gap]=temp;/***此时k的值就是k-=gap的值
inta[max],n,q;
printf("输入数据个数\n");
scanf("%d",&n);
printf("输入数组元素值:
for(inti=0;iscanf("%d",&a[i]);shell(a,8);for(inti=0;i<8;i++)printf("%4d",a[i]);printf("\n");scanf("%d",&q);return0;}/***二分查找思想:用给定值K先与中间的结点的关键字比较,中间结点把线形表分成两个子表,若相等则查找成功;若不相等,再根据K与该中间结点关键字的比较结果确定下一步查找哪个子表,这样递归进行,直到查找到或查找结束发现表中没有这样的结点***//*前提是有序顺序存储*/#includeintbinsearch(int*Sep,intsepLength,intkeydata){intlow=0,mid,high=sepLength-1;while(low<=high)//防止一个元素都没有{mid=(low+high)/2;if(keydata{mdihigh=mid-1;//是mid-1,因为mid已经比较过了,左边,继续细分}elseif(keydata>Sep[mid]){low=mid+1;}else//说明已经找到了,不满足if,elseif说明keydata=sep[mid]{returnmid;}return-1;//查找失败,或一个元素都没有}intmain(){inta[]={1,2,3,4,5,6,7,8,9};intlocation;inttarget=4;location=binsearch(a,9,target);printf("%d\n",location);return0;/*基于结构体栈的实现思路:top始终指向一个待插入的位置push操作:1.写入数据2.top++3.前提:栈非满pop操作:1.top--2.弹出数据3.前提:栈非空*/#includetypedefstruct_stackcharmem[1024];inttop;}stack;intisFull(stack*ps)//判满{returnps->top==1024;}intisEmpty(stack*ps)//判空{returnps->top==0;}voidpush(stack*ps,charch)//压栈{ps->mem[ps->top]=ch;(ps->top)++;}charpop(stack*ps)//出栈{--(ps->top);returnps->mem[ps->top];intmain(){stacks={{0},0};//栈初始化for(charch='a';ch<='z';ch++){if(!isFull(&s)){push(&s,ch);}}while(!isEmpty(&s)){putchar(pop(&s));puts("");//换行}return0;
shell(a,8);
for(inti=0;i<8;i++)
scanf("%d",&q);
/***二分查找思想:
用给定值K先与中间的结点的关键字比较,中间结点把线形表分成两个子表,若相等则查找成功;若不相等,再根据K与该中间结点关键字的比较结果确定下一步查找哪个子表,这样递归进行,直到查找到或查找结束发现表中没有这样的结点***/
/*前提是有序顺序存储*/#include
intbinsearch(int*Sep,intsepLength,intkeydata)
intlow=0,mid,high=sepLength-1;
while(low<=high)//防止一个元素都没有{
mid=(low+high)/2;
if(keydata{mdihigh=mid-1;//是mid-1,因为mid已经比较过了,左边,继续细分}elseif(keydata>Sep[mid]){low=mid+1;}else//说明已经找到了,不满足if,elseif说明keydata=sep[mid]{returnmid;}return-1;//查找失败,或一个元素都没有}intmain(){inta[]={1,2,3,4,5,6,7,8,9};intlocation;inttarget=4;location=binsearch(a,9,target);printf("%d\n",location);return0;/*基于结构体栈的实现思路:top始终指向一个待插入的位置push操作:1.写入数据2.top++3.前提:栈非满pop操作:1.top--2.弹出数据3.前提:栈非空*/#includetypedefstruct_stackcharmem[1024];inttop;}stack;intisFull(stack*ps)//判满{returnps->top==1024;}intisEmpty(stack*ps)//判空{returnps->top==0;}voidpush(stack*ps,charch)//压栈{ps->mem[ps->top]=ch;(ps->top)++;}charpop(stack*ps)//出栈{--(ps->top);returnps->mem[ps->top];intmain(){stacks={{0},0};//栈初始化for(charch='a';ch<='z';ch++){if(!isFull(&s)){push(&s,ch);}}while(!isEmpty(&s)){putchar(pop(&s));puts("");//换行}return0;
mdi
high=mid-1;//是mid-1,因为mid已经比较过了,左边,继续细分
elseif(keydata>Sep[mid])
low=mid+1;
else//说明已经找到了,不满足if,elseif说明keydata=sep[mid]
returnmid;
return-1;//查找失败,或一个元素都没有
inta[]={1,2,3,4,5,6,7,8,9};
intlocation;
inttarget=4;location=binsearch(a,9,target);printf("%d\n",location);
/*基于结构体栈的实现
思路:
top始终指向一个待插入的位置
push操作:
1.写入数据2.top++3.前提:
栈非满pop操作:
1.top--2.弹出数据3.前提:
栈非空*/#include
typedefstruct_stack
charmem[1024];
inttop;
}stack;
intisFull(stack*ps)//判满
returnps->top==1024;
intisEmpty(stack*ps)//判空
returnps->top==0;
voidpush(stack*ps,charch)//压栈
ps->mem[ps->top]=ch;
(ps->top)++;
charpop(stack*ps)//出栈{
--(ps->top);
returnps->mem[ps->top];
stacks={{0},0};//栈初始化
for(charch='a';ch<='z';ch++){
if(!
isFull(&s))
push(&s,ch);
while(!
isEmpty(&s))
putchar(pop(&s));
puts("");//换行
copyright@ 2008-2023 冰点文库 网站版权所有
经营许可证编号:鄂ICP备19020893号-2