A. c語言 冒泡排序法的代碼
#include<stdio.h>
void main()
{
int a[10];
int i,j,t;
printf("input 10 numbers: ");
for(i=0;i<10;i++)
scanf("%d",&a[i]);
for(j=0;j<9;j++) /*進行9次循環 實現9趟比較*/
for(i=0;i<9-j;i++) /*在每一趟中進行9-j次比較*/
if(a[i]>a[i+1]) /*相鄰兩個數比較,想降序只要改成a[i]<a[i+1]*/
{
t=a[i];
a[i]=a[i+1];
a[i+1]=t;
}
printf("the sorted numbers: ");
for(i=0;i<10;i++)
printf(" %d",a[i]);
}
(1)c語言排序演算法擴展閱讀：
冒泡排序演算法的運作
1、比較相鄰的元素。如果第一個比第二個大（小），就交換他們兩個。
2、對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。這步做完後，最後的元素會是最大（小）的數。
3、針對所有的元素重復以上的步驟，除了最後已經選出的元素（有序）。
4、持續每次對越來越少的元素（無序元素）重復上面的步驟，直到沒有任何一對數字需要比較，則序列最終有序。
簡單的表示
#include <stdio.h>
void swap(int *i, int *j)
{
int temp = *i;
*i = *j;
*j = temp;
}
int main()
{
int a[10] = {2,1,4,5,6,9,7,8,7,7};
int i,j;
for (i = 0; i < 10; i++)
{
for (j = 9; j > i; j--)//從後往前冒泡
{
if (a[j] < a[j-1])
{
swap(&a[j], &a[j-1]);
}
}
}
for (i = 0; i < 10; i++)
{
printf("%d ", a[i]);
}
return 0;
}
參考資料來源：冒泡排序-網路
B. 求 c語言選擇排序法和 冒泡排序法代碼！
選擇排序：
void select_sort(int a[],int n) //傳入數組的要排序的元素個數
{int i,j,min,t;
for(i=0;i<n-1;i++)
{ min=i; //min:當前最小值下標
for(j=i+1;j<n;j++) //掃描餘下的部分
if(a[min]>a[j]) //若有其它元素更小，就記錄其下標
min=j;
if(min!=i) //保若最小值不在排序區首位，就換到首位
{t=a[min]; a[min]=a[i]; a[i]=t;}
}
}
冒泡排序：
void bubble_sort(int a[], int n) //傳入數組的要排序的元素個數
{ int i, j, t;
for (j=0; j<n-1; j++) //n個元素比較n-1輪
for (i= 0; i<n-1-j;i++) //比較相信的兩個數
if(a[i]>a[i+1]) //若大小順序不符，就交換
{t=a[i]; a[i]=a[i+1]; a[i+1]=t;
}
C. c語言排序演算法
對每一個國家名字字元串按字典序排序，從頭開始，比較每一個字母的大小，比如：
abc,
abd,
aaa,
bac，aaaa，5個國家，排序後
aaa,
aaaa,
abc,
abd,
bac
D. c語言排序法
這是簡單選擇排序。但你圖中的是未經優化的，因為移動次數和比較次數的時間復雜度都是O(n²)，而優化了的選擇排序的移動次數的時間復雜度最優可以達到O(n)
如下圖參考自《數據結構(C語言版)》——清華大學出版社
如圖，如有疑問或不明白請追問哦！
E. c語言中排序方法
1、冒泡排序（最常用）
冒泡排序是最簡單的排序方法：原理是：從左到右，相鄰元素進行比較。每次比較一輪，就會找到序列中最大的一個或最小的一個。這個數就會從序列的最右邊冒出來。（注意每一輪都是從a[0]開始比較的）
以從小到大排序為例，第一輪比較後，所有數中最大的那個數就會浮到最右邊；第二輪比較後，所有數中第二大的那個數就會浮到倒數第二個位置……就這樣一輪一輪地比較，最後實現從小到大排序。
2、雞尾酒排序
雞尾酒排序又稱雙向冒泡排序、雞尾酒攪拌排序、攪拌排序、漣漪排序、來回排序或快樂小時排序, 是冒泡排序的一種變形。該演算法與冒泡排序的不同處在於排序時是以雙向在序列中進行排序。
原理：數組中的數字本是無規律的排放，先找到最小的數字，把他放到第一位，然後找到最大的數字放到最後一位。然後再找到第二小的數字放到第二位，再找到第二大的數字放到倒數第二位。以此類推，直到完成排序。
3、選擇排序
思路是設有10個元素a[1]-a[10]，將a[1]與a[2]-a[10]比較，若a[1]比a[2]-a[10]都小，則不進行交換。若a[2]-a[10]中有一個以上比a[1]小，則將其中最大的一個與a[1]交換，此時a[1]就存放了10個數中最小的一個。同理，第二輪拿a[2]與a[3]-a[10]比較，a[2]存放a[2]-a[10]中最小的數，以此類推。
4、插入排序
插入排序是在一個已經有序的小序列的基礎上，一次插入一個元素*
一般來說，插入排序都採用in-place在數組上實現。
具體演算法描述如下：
⒈ 從第一個元素開始，該元素可以認為已經被排序
⒉ 取出下一個元素，在已經排序的元素序列中從後向前掃描
⒊ 如果該元素（已排序）大於新元素，將該元素移到下一位置
⒋ 重復步驟3，直到找到已排序的元素小於或者等於新元素的位置
⒌ 將新元素插入到下一位置中
⒍ 重復步驟2~5
F. c語言排序方法有哪幾種
C，語言常用的排序方法有很多種。比如說冒泡排序，直接交換排序，直接選擇排序，直接插入排序，二分插入排序，快速排序，歸並排序，二叉排序樹排序，小學生排序，等等。
G. 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;
}
}
H. c語言三種排序
常用的c語言排序演算法主要有三種即冒泡法排序、選擇法排序、插入法排序。
一、冒泡排序冒泡排序：
是從第一個數開始，依次往後比較，在滿足判斷條件下進行交換。代碼實現（以降序排序為例）
#include<stdio.h>
int main()
{
int array[10] = { 6,9,7,8,5,3,4,0,1,2 };
int temp;
for (int i = 0; i < 10; i++)
{//循環次數
for (int j = 0; j <10 - i-1; j++)
{
if (array[j] < array[j+1])
{//前面一個數比後面的數大時發生交換 temp = array[j];
array[j] = array[j+1];
array[j + 1] = temp;
}
}
} //列印數組 for (int i = 0; i < 10; i++) printf("%2d", array[i]); return 0;}}
二、選擇排序以升序排序為例：
就是在指定下標的數組元素往後（指定下標的元素往往是從第一個元素開始，然後依次往後），找出除指定下標元素外的值與指定元素進行對比，滿足條件就進行交換。與冒泡排序的區別可以理解為冒泡排序是相鄰的兩個值對比，而選擇排序是遍歷數組，找出數組元素與指定的數組元素進行對比。（以升序為例）
#include<stdio.h>
int main()
{
int array[10] = { 6,9,7,8,5,3,4,0,1,2 };
int temp, index;
for (int i = 0; i < 9; i++) {
index = i;
for (int j = i; j < 10; j++)
{
if (array[j] < array[index])
index = j;
}
if(i != index)
{
temp = array[i];
array[i] = array[index];
array[index] = temp;
}
for(int i=0;i<10:i++)
printf("%2d"array[i]）
return 0；
}
三、快速排序
是通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然後再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。
void QuickSort(int* arr, int size)
{
int temp, i, j;
for(i = 1; i <size; i++)
for(j=i; j>0; j--)
{
if(arr[j] <arr[j-1])
{
temp = arr[j];
arr[j]=arr[j-1];
arr[j-1]=temp;
}
}
}
I. C語言排序演算法一共多少種
選擇排序
#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;
}
排序方法基本就這些，還有雙向冒泡這種拓展的排序方法，還有直接排序如桶排序
J. C語言冒泡排序法是什麼
冒泡排序法，是C語言常用的排序演算法之一，意思是對一組數字進行從大到小或者從小到大排序的一種演算法。
具體方法是：
相鄰數值兩兩交換。從第一個數值開始，如果相鄰兩個數的排列順序與我們的期望不同，則將兩個數的位置進行交換（對調）；如果其與我們的期望一致，則不用交換。重復這樣的過程，一直到最後沒有數值需要交換，則排序完成。
C語言常見的排序演算法：
1、冒泡排序
基本思想：比較相鄰的兩個數，如果前者比後者大，則進行交換。每一輪排序結束，選出一個未排序中最大的數放到數組後面。
2、快速排序
基本思想:選取一個基準元素，通常為數組最後一個元素（或者第一個元素）。從前向後遍歷數組，當遇到小於基準元素的元素時，把它和左邊第一個大於基準元素的元素進行交換。在利用分治策略從已經分好的兩組中分別進行以上步驟，直到排序完成。
3、直接插入排序
基本思想：和交換排序不同的是它不用進行交換操作，而是用一個臨時變數存儲當前值。當前面的元素比後面大時，先把後面的元素存入臨時變數，前面元素的值放到後面元素位置，再到最後把其值插入到合適的數組位置。
4、直接選擇排序
基本思想：依次選出數組最小的數放到數組的前面。首先從數組的第二個元素開始往後遍歷，找出最小的數放到第一個位置。再從剩下數組中找出最小的數放到第二個位置。以此類推，直到數組有序。
以上內容參考 網路-排序演算法、網路-c語言冒泡排序