Csort算法
选择排序
#include<iostream>
usingnamespacestd;
voidselect_sort(intarr[],intnum);
voidoutput_array(intarr[],intnum);
intmain()
{
inta[10];
for(inti=0;i<10;i++)
{
cin>>a[i];
}
select_sort(a,10);
output_array(a,10);
return0;
}
voidselect_sort(intarray[],intn)//形参array是数组名
{
inti,j,k,t;
for(i=0;i<n-1;i++)
{
k=i;//先设第i个就为最小
for(j=i+1;j<n;j++)
if(array[j]<array[k])
k=j;//通过循环，得到k为最小
t=array[k];//交换a[i]和a[k]
array[k]=array[i];
array[i]=t;
}
return;
}
voidoutput_array(intarr[],intnum)
{
inti;
for(i=0;i<num;i++)
{
cout<<arr[i];
cout<<endl;
}
return;
}
2.冒泡排序
#include<stdio.h>
intmain()
{
inti,j,a[10],t;
for(i=0;i<10;i++)
scanf("%d",&a[i]);
for(i=0;i<10;i++)
for(j=i+1;j<10;j++)
if(a[i]>a[j])
{
t=a[j];
a[j]=a[i];
a[i]=t;
}
for(i=0;i<10;i++)
printf("%d",a[i]);
return0;
}
3.堆排序
#include<iostream>
usingnamespacestd;
voidpaii(inta[20],inti,intm)
{
intk,t;
t=a[i];
k=2*i+1;
while(k<m)
{
if((k<m-1)&&(a[k]<a[k+1]))
k++;
if(t<a[k])
{
a[i]=a[k];
i=k;
k=2*i+1;
}
elsebreak;
}
a[i]=t;
}
voidipai(inta[20],intn)
{
inti,k;
for(i=n/2-1;i>=0;i--)
paii(a,i,n);
for(i=n-1;i>=1;i--)
{
k=a[0];
a[0]=a[i];
a[i]=k;
paii(a,0,i);
}}
intmain()
{
inta[10],i;
for(i=0;i<10;i++)
cin>>a[i];
ipai(a,10);
for(i=0;i<10;i++)
cout<<a[i]<<endl;
}
4.快速排序
#include<iostream>
usingnamespacestd;
voidQuicksort(inta[],intlow,inthigh)
{
if(low>=high)
{
return;
}
intfirst=low;
intlast=high;
intkey=a[first];
while(first<last)
{
while(first<last&&a[last]>=key)
--last;
a[first]=a[last];
while(first<last&&a[first]<=key)
++first;
a[last]=a[first];
}
a[first]=key;
Quicksort(a,low,first-1);
Quicksort(a,last+1,high);
}
intmain()
{
inti,a[100],x,n=0;
while(cin>>x)
{
a[n]=x;
n++;
}
n--;
Quicksort(a,0,n);
for(i=0;i<=n;i++)
cout<<a[i]<<"";
cout<<endl;
return0;
}
5. 基数排序
#include<stdio.h>
#include<stdlib.h>
intmain(){
intdata[10]={73,22,93,43,55,14,82,65,39,81};//对十个数进行排序
inttemp[10][10]={0};//构造一个临时二维数组，其值为0
intorder[10]={0};//构造一维数组，其值为0
inti,j,k,n,lsd;
k=0;n=1;
for(i=0;i<10;i++)printf("%d",data[i]);//在排序前，对这10个数打印一遍
putchar(' ');
while(n<=10){
for(i=0;i<10;i++){
lsd=((data[i]/n)%10);//lsd先对个位取余，然后再对十位取余，注意循环
temp[lsd][order[lsd]]=data[i];//temp[3][0]=73,temp[2][0]=22,temp[3][1]=93,temp[3][2]=43,⋯⋯
order[lsd]++;//需要区分的是lsd和order[lsd]，这两个不是一样的概念嗷
}
printf(" 重新排列:");
for(i=0;i<10;i++){
if(order[i]!=0)
for(j=0;j<order[i];j++){
data[k]=temp[i][j];
printf("%d",data[k]);
k++;
}
order[i]=0;
}
n*=10;//第二次用十位
k=0;
}
putchar(' ');
printf(" 排序后:");
for(i=0;i<10;i++)printf("%d",data[i]);
return0;
}
6.希尔排序
#include<iostream>
usingnamespacestd;
voidshell_sort(inta[],intn);
intmain()
{
intn,a[10000];
cin>>n;
for(inty=0;y<n;y++)
cin>>a[y];
shell_sort(a,n);
for(inti=0;i<n;i++)
cout<<a[i]<<"";
cout<<endl;
}
voidshell_sort(inta[],intn)
{
intgap,k,temp;//定义增量；
for(gap=3;gap>0;gap--)//设置初始增量，递减；
{
for(inti=0;i<gap;i++)//按增量分组；
{
for(intj=i+gap;j<n;j=j+gap)//每组分别比较大小；
{
if(a[j]<a[j-gap])
{
temp=a[j];
k=j-gap;
while(k>=0&&a[k]>temp)
{
a[k+gap]=a[k];
k=k-gap;
}
a[k+gap]=temp;
}
}
}
}
}
7.归并排序
#include<iostream>
usingnamespacestd;
voidMergeSort(intp[],ints,intm,intt)
{
intq[100];//q[100]用来存放排好的序列
inti=s;
intj=m+1;
intk=s;
while(i<=m&&j<=t)
{
if(p[i]<=p[j])
q[k++]=p[i++];
else
q[k++]=p[j++];
}
if(i<=m)
while(i<=m)
q[k++]=p[i++];
elsewhile(j<=t)
q[k++]=p[j++];
for(intn=s;n<=t;n++)
p[n]=q[n];
}
voidMerge(intp[],ints,intt)
{
if(s<t)
{
intm=(s+t)/2;//将数组分成两半
Merge(p,s,m);//递归拆分左数组
Merge(p,m+1,t);//递归拆分右数组
MergeSort(p,s,m,t);//合并数组
}
}
intmain()
{
intn;
intp[100];
cin>>n;
for(inti=0;i<n;i++)
cin>>p[i];
Merge(p,0,n-1);
for(intj=0;j<n;j++)
cout<<p[j]<<"";
cout<<endl;
return0;
}
排序方法基本就这些，还有双向冒泡这种拓展的排序方法，还有直接排序如桶排序
⑵ C++sort和qsort排序的时间复杂度分别为多少
C中的qsort()采用的是快排算法，C++的sort()则是改进的快排算法。两者的时间复杂度都是nlogn，但是实际应用中，sort()一般要快些，建议使用sort()。
⑶ C语言程序设计sort功能
最简单的冒泡排序
冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。
它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端，故名.
冒泡排序算法的运作如下：（从后往前）
1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最3.后的元素应该会是最大的数。
4.针对所有的元素重复以上的步骤，除了最后一个。
5.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
#include<stdio.h>
#defineSIZE10
voidbubble_sort(inta[],intn);
voidbubble_sort(inta[],intn)
{
inti,j,temp;
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
{
if(a[i]<a[j])//注意排序是小的冒起来,大的往下,即大的在前,小的在后
{
temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
}
intmain()
{
intnumber[SIZE]={1,2,3,4,5,6,7,8,9,10};
inti;
bubble_sort(&number[3],5);//注意,排序范围是从4-8
for(i=0;i<SIZE;i++)
{
printf("%d",number[i]);//结果是C
}
printf(" ");
}
⑷ 关于快速排序C语言算法
//一点小问题而已，已为你改好
#include <stdio.h>
void Quick_sort (int s[], int l, int r )
{
if(l<r)
{
int i=l,j=r,x=s[l];
while(i<j)
{
while(i<j&&s[j]>=x)
{j--;}//从右向左找第一个小于x的数
if(i<j)
{s[i++]=s[j];}
while(i<j&&s[i]<=x)
{i++;}//从左到右找第一个大于等于x的数
if(i<j)
{s[j--]=s[i];}
}
s[i]=x;
Quick_sort(s,l,i-1);//递归
Quick_sort(s,i+1,r);
}
}
int main()
{
int arr[7] = { 1,9,7,6,5,35,15 };
int i;
printf("之前的数组：");
for (i = 0; i < 7; i++) printf("%3d", arr[i]);
printf("\n");
Quick_sort(arr, 0, 6);
printf("排序之后的数组：");
for (i = 0; i < 7; i++) printf("%3d", arr[i]);
printf("\n");
return 0;
}
⑸ C语言编程创建自定义函数sort()，sort函数中实现选择法升序排序，主函数输出排序后的数组元素
#include<stdio.h>
//选择排序算法,升序
voidsort(int*arr,intn)
{
inti,j,k;
inttmp;
for(i=0;i<n-1;i++)
{
k=i;//开始一趟选择排序，假定第i个元素是后面n-i+1个未排序的元素中最小的元素
for(j=i+1;j<n;j++)
{
if(arr[k]>arr[j])//如果发现比当前最小元素还小的元素，则更新记录最小元素的下标k
k=j;
}
//如果最小元素的下标不是后面n-i+1的未排序序列的第一个元素,则需要交换第i个元素和后面找到的最小元素的位置
if(k!=i)
{
tmp=arr[k];
arr[k]=arr[i];
arr[i]=tmp;
}
}
}
intmain()
{
inta[10]={-5,-9,-8,3,9,2,-28,101,-395,0};
inti;
sort(a,10);
for(i=0;i<10;i++)
printf("%d",a[i]);
printf(" ");
return0;
}
//运行结果
F:c_work>a.exe
-395-28-9-8-50239101
⑹ C语言. .编写一个Sort函数，完成对整型数组元素升序排列。
#include<stdio.h>
voidsort(inta[],intn){//选择排序
inti,j,k,t;
for(i=0;i<n-1;++i){
k=i;
for(j=k+1;j<n;++j){
if(a[k]>a[j])k=j;
}
if(k!=i){
t=a[i];
a[i]=a[k];
a[k]=t;
}
}
}
intmain(){
inta[]={21,16,30,21,8,19,33,26,28,27,24,50,13,12};
inti,n=sizeof(a)/sizeof(a[0]);
printf("排序前:
");
for(i=0;i<n;++i)
printf("%d",a[i]);
printf("
");
sort(a,n);
printf("排序后:
");
for(i=0;i<n;++i)
printf("%d",a[i]);
printf("
");
return0;
}
⑺ c语言排序算法
#include<stdio.h>
#defineN100000//定义最多输入的数据
intsort(int*a,intn){
inti,j,m;
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
if(a[i]>a[j]){
m=a[i];a[i]=a[j];a[j]=m;
}
return0;
}
intmain(){
inta[N];
inti=0,n,ii;
while(1){
//printf("输入n ");
scanf("%d",&n);
a[i++]=n;
if(n==0)break;
ii=i;
for(;i<n+ii;i++)
scanf("%d",&a[i]);
}
i=0;
while(a[i]!=0){
sort(a+i+1,a[i]);
for(n=1;n<=a[i];n++)
printf("%d",a[i+n]);
printf(" ");
i=i+a[i]+1;
}
}
⑻ C语言结构体sort排序
结构体的排序算法和整型数组排序并没很大区别。
if(...) 其中就比较两个结构体的出生年月，如果不满足要求就交换，交换记得交换整个结构体变量，不要只交换出生年月
⑼ c++STL泛型编程sort算法问题
你是指的是在sort泛型算法中带的参数有个谓词吧。谓词相当于sort中的1个参数，但是谓词本身是个函数，你这里的是个返回bool类型的函数，这个函数有2个参数，分别是对形参a和b的const引用，然后比较a和b是否相等，如果a不等于b，那么return a>b 返回的是表达式a>b的值，如果a比b大，值的true，否则值为false ，else return a>b 这里就是a==b的情况下才走到这里，肯定返回false了
在sort算法里调用如下，比如定义了1个int的vector容器
vector<int> ivec;
sort(ivec.begin(),ivec.end(),Comp);
这里记住Comp后面不能带参数了，直接写函数名字即可，在排序的时候就会根据函数的返回结果为true的进行排序，也就是说从大到小排序。
⑽ C语言的快速排序的算法是什么啊
快速排序（Quicksort）是对冒泡排序的一种改进。由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 算法过程设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。 一趟快速排序的算法是： 1）设置两个变量I、J，排序开始的时候：I=0，J=N-1； 2）以第一个数组元素作为关键数据，赋值给key，即 key=A[0]； 3）从J开始向前搜索，即由后开始向前搜索（J=J-1），找到第一个小于key的值A[J]，并与key交换； 4）从I开始向后搜索，即由前开始向后搜索（I=I+1），找到第一个大于key的A[I]，与key交换； 5）重复第3、4、5步，直到 I=J； (3,4步是在程序中没找到时候j=j-1，i=i+1，直至找到为止。找到并交换的时候i， j指针位置不变。另外当i=j这过程一定正好是i+或j-完成的最后另循环结束。) 例如：待排序的数组A的值分别是：（初始关键数据：X=49） 注意关键X永远不变，永远是和X进行比较，无论在什么位子，最后的目的就是把X放在中间，小的放前面大的放后面。 A[0] A[1] A[2] A[3] A[4] A[5] A[6]： 49 38 65 97 76 13 27 进行第一次交换后：27 38 65 97 76 13 49 ( 按照算法的第三步从后面开始找) 进行第二次交换后：27 38 49 97 76 13 65 ( 按照算法的第四步从前面开始找>X的值，65>49,两者交换，此时：I=3 ) 进行第三次交换后：27 38 13 97 76 49 65 ( 按照算法的第五步将又一次执行算法的第三步从后开始找 进行第四次交换后：27 38 13 49 76 97 65 ( 按照算法的第四步从前面开始找大于X的值，97>49,两者交换，此时：I=4,J=6 ) 此时再执行第三步的时候就发现I=J，从而结束一趟快速排序，那么经过一趟快速排序之后的结果是：27 38 13 49 76 97 65，即所有大于49的数全部在49的后面，所有小于49的数全部在49的前面。 快速排序就是递归调用此过程——在以49为中点分割这个数据序列，分别对前面一部分和后面一部分进行类似的快速排序，从而完成全部数据序列的快速排序，最后把此数据序列变成一个有序的序列，根据这种思想对于上述数组A的快速排序的全过程如图6所示： 初始状态 {49 38 65 97 76 13 27} 进行一次快速排序之后划分为 {27 38 13} 49 {76 97 65} 分别对前后两部分进行快速排序 {27 38 13} 经第三步和第四步交换后变成 {13 27 38} 完成排序。 {76 97 65} 经第三步和第四步交换后变成 {65 76 97} 完成排序。