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} 完成排序。