Ⅰ c語言中要把三個數從大到小排列出來應該怎麼編
初學簡單版本代碼如下：
#include<stdio.h>
int main( )
{
int a, b, c;//定義三個數的變數
int t ;//定義作為交換的變數
scanf ( "%d%d%d" , &a, &b, &c ) ; //取值
if ( a < b )
{t = a; a = b; b = t ;};//如果a,b，進行交換，反之不動
if ( a < c )
{t = a; a = c; c = t ;};//同上
if ( b < c )
{t = b; b = c; c = t ;};
printf( "%-5d%-5d%-5d " , a, b, c);//輸出
}
(1)c語言中排列的方法擴展閱讀：
C語言中其他多個數排序的方法：
1、冒泡排序法
#include <stdio.h>
#define SIZE 8
void bubble_sort(int a[], int n);
void bubble_sort(int a[], int n)
{
int i, j, temp;
for (j = 0; j < n - 1; j++)
for (i = 0; i < n - 1 - j; i++)
{
if(a[i] > a[i + 1])
{
temp = a[i];
a[i] = a[i + 1];
a[i + 1] = temp;
} } }
int main()
{
int number[SIZE] = {95, 45, 15, 78, 84, 51, 24, 12};
int i;
bubble_sort(number, SIZE);
for (i = 0; i < SIZE; i++)
{
printf("%d ", number[i]);
}
}
2、選擇排序
#include<stdio.h>
void main()//主函數
{
int a[10];
int i,j,w;
printf("請輸入10個數字： ");
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])//進行比較
//比較後進行交換
{
w=a[i];
a[i]=a[j];
a[j]=w;
}
Ⅱ 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
Ⅲ c語言的兩種排序
1、選擇排序法
要求輸入10個整數，從大到小排序輸出
輸入：2 0 3 -4 8 9 5 1 7 6
輸出：9 8 7 6 5 3 2 1 0 -4
代碼：
#include<stdio.h>
int main(int argc,const char*argv[]){
int num[10],i,j,k,l,temp;
//用一個數組保存輸入的數據
for(i=0;i<=9;i++)
{
scanf("%d",&num<i>);
}
//用兩個for嵌套循環來進行數據大小比較進行排序
for(j=0;j<9;j++)
{
for(k=j+1;k<=9;k++)
{
if(num[j]<num[k])//num[j]<num[k]
{
temp=num[j];
num[j]=num[k];
num[k]=temp;
}
}
}
//用一個for循環來輸出數組中排序好的數據
for(l=0;l<=9;l++)
{
printf("%d",num[l]);
}
return 0;
}
2、冒泡排序法
要求輸入10個整數，從大到小排序輸出
輸入：2 0 3-4 8 9 5 1 7 6
輸出：9 8 7 6 5 3 2 1 0-4
代碼：
#include<stdio.h>
int main(int argc,const char*argv[]){
//用一個數組來存數據
int num[10],i,j,k,l,temp;
//用for來把數據一個一個讀取進來
for(i=0;i<=9;i++)
{
scanf("%d",&num<i>);
}
//用兩次層for循環來比較數據，進行冒泡
for(j=0;j<9;j++)
{
for(k=0;k<9-j;k++)
{
if(num[k]<num[k+1])//num[k]<num[k+1]
{
temp=num[k];
num[k]=num[k+1];
num[k+1]=temp;
}
}
}
//用一個for循環來輸出數組中排序好的數據
for(l=0;l<=9;l++)
{
printf("%d",num[l]);
}
return 0;
}
(3)c語言中排列的方法擴展閱讀：
return 0代表程序正常退出。return是C++預定義的語句，它提供了終止函數執行的一種方式。當return語句提供了一個值時，這個值就成為函數的返回值。
return語句用來結束循環，或返回一個函數的值。
1、return 0，說明程序正常退出，返回到主程序繼續往下執行。
2、return 1，說明程序異常退出，返回主調函數來處理，繼續往下執行。return 0或return 1對程序執行的順序沒有影響，只是大家習慣於使用return(0)退出子程序而已。
Ⅳ c語言排序的方法
排序主要分為以下幾種。
1.冒泡排序:通過循環比較前後數的大小進行交換。最後使得數組有序。
2.快速排序:首先將第一個數作為一個基準，然後循環，將前半部分大於該數的與後半部分小於該數的進行交換，使得以該數為分界線，前面的小於該數，後面的大於該數，然後分前後兩部分繼續。
Ⅳ C語言中將三個數字進行排序的幾種寫法
方法1：用3個變數存放3個數字，按從大到小的順序排：
int a,b,c,tmp;
printf("請輸入3個數字：");
scanf("%d%d%d",&a,&b,&c);
if(a<b)//如果a比b小，交換a和b的值，使a存放大的數字
{
tmp=a;
a=b;
b=tmp;
}
if(a<c)//如果a比c小，交換a和c的值，使a存放大的數字
{
tmp=a;
a=c;
c=tmp;
}
if(b<c)//如果b比c小，交換b和c的值，使b存放大的數字
{
tmp=b;
b=c;
c=tmp;
}
printf("按照從大到小的順序為：%d,%d,%d ",a,b,c);
方法2：用數組存放3個變數，用冒泡排序的方法進行排序
int i=0,j=0,tmp=0,a[3];
printf("請輸入3個數字：");
for(i=0;i<3;i++)
scanf("%d",&a[i]);
for(i=0;i<2;i++)
for(j=0;j<2-i;j++)
if(a[i]<a[i+1])//按照從大到小排列
{
tmp=a[i];
a[i]=a[i+1];
a[i+1]=tmp;
}
printf("按照從大到小的順序為：");
for(i=0;i<3;i++)
printf("%d ",&a[i]);
printf(" ");
Ⅵ C語言數組排序方法
選擇排序的原理是，每次從待排序數字中挑選出最大（最小）數字，放在有序序列的末尾。實際操作中，只需要在這個數組中將挑出來的數字與前面的數字交換即可。例如：4
1 5
2 3找到最小的1，1和4交換1
4 5
2
3找到最小的2，2和4交換1
2
5
4
3找到最小的3，3和5交換1
2
3
4
5找到最小的4，4和4交換（不交換也可）可見，選擇排序需要一個雙重循環來完成，因此它的復雜度是O(n^2)在數據量比較大時，不建議使用這種排序方法。 其他排序方法有很多，你甚至可以自己根據不同數據規模設計不同的排序方法。比較常見的有冒泡排序，插入排序（這兩種和選擇排序一樣，都是O(n^2)），二分法插入排序（降低了一些復雜度，但是涉及到大規模數據移動，效率依然不高），快速排序（平均復雜度O(nlogn)，但是不穩定，最壞情況O(n^2)），隨機化快速排序（很大程度上避免了最壞情況的出現），堆排序（O(nlogn)，編程復雜度高），基數排序（理論復雜度O(n)，實際要比這個慢。甚至能應付字元串排序，但是編程復雜度高，牽扯到其他數據結構），桶排序（O(n)，編程簡單，效率高，但是應付的數據范圍不能太大，受到內存大小的限制）。 平時比較常用的就是快速排序，程序簡單，效率也可以接受。 這是我了解的一些東西，希望對你有幫助。
Ⅶ c語言排序方法有哪幾種
C，語言常用的排序方法有很多種。比如說冒泡排序，直接交換排序，直接選擇排序，直接插入排序，二分插入排序，快速排序，歸並排序，二叉排序樹排序，小學生排序，等等。
Ⅷ C語言冒泡排序法是什麼
冒泡排序法，是C語言常用的排序演算法之一，意思是對一組數字進行從大到小或者從小到大排序的一種演算法。
具體方法是：
相鄰數值兩兩交換。從第一個數值開始，如果相鄰兩個數的排列順序與我們的期望不同，則將兩個數的位置進行交換（對調）；如果其與我們的期望一致，則不用交換。重復這樣的過程，一直到最後沒有數值需要交換，則排序完成。
C語言常見的排序演算法：
1、冒泡排序
基本思想：比較相鄰的兩個數，如果前者比後者大，則進行交換。每一輪排序結束，選出一個未排序中最大的數放到數組後面。
2、快速排序
基本思想:選取一個基準元素，通常為數組最後一個元素（或者第一個元素）。從前向後遍歷數組，當遇到小於基準元素的元素時，把它和左邊第一個大於基準元素的元素進行交換。在利用分治策略從已經分好的兩組中分別進行以上步驟，直到排序完成。
3、直接插入排序
基本思想：和交換排序不同的是它不用進行交換操作，而是用一個臨時變數存儲當前值。當前面的元素比後面大時，先把後面的元素存入臨時變數，前面元素的值放到後面元素位置，再到最後把其值插入到合適的數組位置。
4、直接選擇排序
基本思想：依次選出數組最小的數放到數組的前面。首先從數組的第二個元素開始往後遍歷，找出最小的數放到第一個位置。再從剩下數組中找出最小的數放到第二個位置。以此類推，直到數組有序。
以上內容參考 網路-排序演算法、網路-c語言冒泡排序
Ⅸ C語言N名同學,排成一排,有多少中排列方法
這個問題需要拆解成兩個部分解決：
1.n個同學排成一排的數學解
2.將上面數學解或者數學過程轉化為程序代碼
於是：
對於第1部分：
這個是一個全排列問題，解為n的階乘，表示為：n！=1*2*3...*n
如果沒學過，稍微解釋一下為什麼：
n個人排一排，那麼顯然肯定是n個位置，我們順序來看，第一個位置：可以隨便放n個人中任何一個，所以n種可能；第二個位置：前面已經放了一個人，也就總共只有n-1個人了，所以只能n-1種可能...到最後一個位置，只剩下最後一個人了，所以只有最後1種可能；
那麼上面乘起來就是n！種情況了
於是第二個部分，實現n！
顯然需要遞歸或者循環，看學過哪個吧～
下面只寫核心部分，聲明就略了
result表示結果，建議考慮用long或者更大位數的，階乘很可怕，結果數值很大
循環(for為例)：
for(int i=1;i<=n;i++){
result*=i;
}
遞歸
主函數調用：Func(n);
函數聲明：
long Func(int value){
if(value==1)
return 1;
else
return value*Func(value-1);
}
Ⅹ C語言排序有哪些方法 詳細點
我博客里收藏的，粘給你 排序有哪幾種好方法（ 1 ）<from csdn>2009-12-03 19:26 排序小結 排序演算法是一種基本並且常用的演算法。由於實際工作中處理的數量巨大，所以排序演算法 對演算法本身的速度要求很高。 而一般我們所謂的演算法的性能主要是指演算法的復雜度，一般用O方法來表示。在後面我將 給出詳細的說明。 對於排序的演算法我想先做一點簡單的介紹，也是給這篇文章理一個提綱。 我將按照演算法的復雜度，從簡單到難來分析演算法。 第一部分是簡單排序演算法，後面你將看到他們的共同點是演算法復雜度為O(N*N)（因為沒有 使用word,所以無法打出上標和下標）。 第二部分是高級排序演算法，復雜度為O(Log2(N))。這里我們只介紹一種演算法。另外還有幾種 演算法因為涉及樹與堆的概念，所以這里不於討論。 第三部分類似動腦筋。這里的兩種演算法並不是最好的（甚至有最慢的），但是演算法本身比較 奇特，值得參考（編程的角度）。同時也可以讓我們從另外的角度來認識這個問題。 第四部分是我送給大家的一個餐後的甜點——一個基於模板的通用快速排序。由於是模板函數 可以對任何數據類型排序（抱歉，裡面使用了一些論壇專家的呢稱）。 現在，讓我們開始吧： 一、簡單排序演算法 由於程序比較簡單，所以沒有加什麼注釋。所有的程序都給出了完整的運行代碼，並在我的VC環境 下運行通過。因為沒有涉及MFC和WINDOWS的內容，所以在BORLAND C++的平台上應該也不會有什麼 問題的。在代碼的後面給出了運行過程示意，希望對理解有幫助。 1.冒泡法： 這是最原始，也是眾所周知的最慢的演算法了。他的名字的由來因為它的工作看來象是冒泡： #include <iostream.h> void BubbleSort(int* pData,int Count) { int iTemp; for(int i=1;i<Count;i++) { for(int j=Count-1;j>=i;j--) { if(pData[j]<pData[j-1]) { iTemp = pData[j-1]; pData[j-1] = pData[j]; pData[j] = iTemp; } } } } void main() { int data[] = {10,9,8,7,6,5,4}; BubbleSort(data,7); for (int i=0;i<7;i++) cout<<data[i]<<" "; cout<<"\n"; } 倒序(最糟情況) 第一輪：10,9,8,7->10,9,7,8->10,7,9,8->7,10,9,8(交換3次) 第二輪：7,10,9,8->7,10,8,9->7,8,10,9(交換2次) 第一輪：7,8,10,9->7,8,9,10(交換1次) 循環次數：6次 交換次數：6次 其他： 第一輪：8,10,7,9->8,10,7,9->8,7,10,9->7,8,10,9(交換2次) 第二輪：7,8,10,9->7,8,10,9->7,8,10,9(交換0次) 第一輪：7,8,10,9->7,8,9,10(交換1次) 循環次數：6次 交換次數：3次 上面我們給出了程序段，現在我們分析它：這里，影響我們演算法性能的主要部分是循環和交換， 顯然，次數越多，性能就越差。從上面的程序我們可以看出循環的次數是固定的，為1+2+...+n-1。 寫成公式就是1/2*(n-1)*n。 現在注意，我們給出O方法的定義： 若存在一常量K和起點n0，使當n>=n0時，有f(n)<=K*g(n),則f(n) = O(g(n))。（呵呵，不要說沒 學好數學呀，對於編程數學是非常重要的！！！） 現在我們來看1/2*(n-1)*n，當K=1/2，n0=1，g(n)=n*n時，1/2*(n-1)*n<=1/2*n*n=K*g(n)。所以f(n) =O(g(n))=O(n*n)。所以我們程序循環的復雜度為O(n*n)。 再看交換。從程序後面所跟的表可以看到，兩種情況的循環相同，交換不同。其實交換本身同數據源的 有序程度有極大的關系，當數據處於倒序的情況時，交換次數同循環一樣（每次循環判斷都會交換）， 復雜度為O(n*n)。當數據為正序，將不會有交換。復雜度為O(0)。亂序時處於中間狀態。正是由於這樣的 原因，我們通常都是通過循環次數來對比演算法。 2.交換法： 交換法的程序最清晰簡單，每次用當前的元素一一的同其後的元素比較並交換。 #include <iostream.h> void ExchangeSort(int* pData,int Count) { int iTemp; for(int i=0;i<Count-1;i++) { for(int j=i+1;j<Count;j++) { if(pData[j]<pData[i]) { iTemp = pData[i]; pData[i] = pData[j]; pData[j] = iTemp; } } } } void main() { int data[] = {10,9,8,7,6,5,4}; ExchangeSort(data,7); for (int i=0;i<7;i++) cout<<data[i]<<" "; cout<<"\n"; } 倒序(最糟情況) 第一輪：10,9,8,7->9,10,8,7->8,10,9,7->7,10,9,8(交換3次) 第二輪：7,10,9,8->7,9,10,8->7,8,10,9(交換2次) 第一輪：7,8,10,9->7,8,9,10(交換1次) 循環次數：6次 交換次數：6次 其他： 第一輪：8,10,7,9->8,10,7,9->7,10,8,9->7,10,8,9(交換1次) 第二輪：7,10,8,9->7,8,10,9->7,8,10,9(交換1次) 第一輪：7,8,10,9->7,8,9,10(交換1次) 循環次數：6次 交換次數：3次 從運行的表格來看，交換幾乎和冒泡一樣糟。事實確實如此。循環次數和冒泡一樣 也是1/2*(n-1)*n，所以演算法的復雜度仍然是O(n*n)。由於我們無法給出所有的情況，所以 只能直接告訴大家他們在交換上面也是一樣的糟糕（在某些情況下稍好，在某些情況下稍差）。 3.選擇法： 現在我們終於可以看到一點希望：選擇法，這種方法提高了一點性能（某些情況下） 這種方法類似我們人為的排序習慣：從數據中選擇最小的同第一個值交換，在從省下的部分中 選擇最小的與第二個交換，這樣往復下去。 #include <iostream.h> void SelectSort(int* pData,int Count) { int iTemp; int iPos; for(int i=0;i<Count-1;i++) { iTemp = pData[i]; iPos = i; for(int j=i+1;j<Count;j++) { if(pData[j]<iTemp) { iTemp = pData[j]; iPos = j; } } pData[iPos] = pData[i]; pData[i] = iTemp; } } void main() { int data[] = {10,9,8,7,6,5,4}; SelectSort(data,7); for (int i=0;i<7;i++) cout<<data[i]<<" "; cout<<"\n"; } 倒序(最糟情況) 第一輪：10,9,8,7->(iTemp=9)10,9,8,7->(iTemp=8)10,9,8,7->(iTemp=7)7,9,8,10(交換1次) 第二輪：7,9,8,10->7,9,8,10(iTemp=8)->(iTemp=8)7,8,9,10(交換1次) 第一輪：7,8,9,10->(iTemp=9)7,8,9,10(交換0次) 循環次數：6次 交換次數：2次 其他： 第一輪：8,10,7,9->(iTemp=8)8,10,7,9->(iTemp=7)8,10,7,9->(iTemp=7)7,10,8,9(交換1次) 第二輪：7,10,8,9->(iTemp=8)7,10,8,9->(iTemp=8)7,8,10,9(交換1次) 第一輪：7,8,10,9->(iTemp=9)7,8,9,10(交換1次) 循環次數：6次 交換次數：3次 遺憾的是演算法需要的循環次數依然是1/2*(n-1)*n。所以演算法復雜度為O(n*n)。 我們來看他的交換。由於每次外層循環只產生一次交換（只有一個最小值）。所以f(n)<=n 所以我們有f(n)=O(n)。所以，在數據較亂的時候，可以減少一定的交換次數。 4.插入法： 插入法較為復雜，它的基本工作原理是抽出牌，在前面的牌中尋找相應的位置插入，然後繼續下一張 #include <iostream.h> void InsertSort(int* pData,int Count) { int iTemp; int iPos; for(int i=1;i<Count;i++) { iTemp = pData[i]; iPos = i-1; while((iPos>=0) && (iTemp<pData[iPos])) { pData[iPos+1] = pData[iPos]; iPos--; } pData[iPos+1] = iTemp; } } void main() { int data[] = {10,9,8,7,6,5,4}; InsertSort(data,7); for (int i=0;i<7;i++) cout<<data[i]<<" "; cout<<"\n"; } 倒序(最糟情況) 第一輪：10,9,8,7->9,10,8,7(交換1次)(循環1次) 第二輪：9,10,8,7->8,9,10,7(交換1次)(循環2次) 第一輪：8,9,10,7->7,8,9,10(交換1次)(循環3次) 循環次數：6次 交換次數：3次 其他： 第一輪：8,10,7,9->8,10,7,9(交換0次)(循環1次) 第二輪：8,10,7,9->7,8,10,9(交換1次)(循環2次) 第一輪：7,8,10,9->7,8,9,10(交換1次)(循環1次) 循環次數：4次 交換次數：2次 上面結尾的行為分析事實上造成了一種假象，讓我們認為這種演算法是簡單演算法中最好的，其實不是， 因為其循環次數雖然並不固定，我們仍可以使用O方法。從上面的結果可以看出，循環的次數f(n)<= 1/2*n*(n-1)<=1/2*n*n。所以其復雜度仍為O(n*n)（這里說明一下，其實如果不是為了展示這些簡單 排序的不同，交換次數仍然可以這樣推導）。現在看交換，從外觀上看，交換次數是O(n)（推導類似 選擇法），但我們每次 要進行與內層循環相同次數的『=』操作。正常的一次交換我們需要三次『=』 而這里顯然多了一些，所以我們浪費了時間。 最終，我個人認為，在簡單排序演算法中，選擇法是最好的。