A. c語言編程： 將一組數按從大到小的順序排序
#include <stdio.h>
main()
{
int x;
printf("請輸入要排序數字個數:");
scanf("%d",&x);
int i,j,k,a,b,num[x];
printf("輸入數據:");
for(i=0;i<x;i++)
scanf("%d",&num[i]);
for(j=0;j<x;j++)
{
for(k=j+1;k<x;k++)
if(num[k]>num[j])
{
a=num[j];
num[j]=num[k];
num[k]=a;
}
}
for(b=0;b<x;b++)
printf("%d ",num[b]);
return 0;
}
(1)c語言從大到小排怎麼排擴展閱讀：
include用法：
#include命令預處理命令的一種，預處理命令可以將別的源代碼內容插入到所指定的位置；可以標識出只有在特定條件下才會被編譯的某一段程序代碼；可以定義類似標識符功能的宏，在編譯時，預處理器會用別的文本取代該宏。
插入頭文件的內容
#include命令告訴預處理器將指定頭文件的內容插入到預處理器命令的相應位置。有兩種方式可以指定插入頭文件：
1、#include<文件名>
2、#include"文件名"
如果需要包含標准庫頭文件或者實現版本所提供的頭文件，應該使用第一種格式。如下例所示：
#include<math.h>//一些數學函數的原型，以及相關的類型和宏
如果需要包含針對程序所開發的源文件，則應該使用第二種格式。
採用#include命令所插入的文件，通常文件擴展名是.h，文件包括函數原型、宏定義和類型定義。只要使用#include命令，這些定義就可被任何源文件使用。
B. 求C語言將數組元素大小排序！！
C語言將數組元素大小排序方法：
以下使用的是冒泡排序法實線數組從小到大排序。
思想：每次相鄰兩個數比較，若升序，則將大的數放到後面，一次循環過後，就會將最大的數放在最後。
10、2、3、4、5、6、9、8、7、1是輸入的待排序的數列，經過第一次排序，將最大的,10放在最後，第二次排序，將剩下的2、3、4、5、6、9、8、7、1進行冒泡，將當前最大的9放在倒數第二的位置，以此類推。
以下是具體代碼：
#include <stdio.h>
int main(){
int nums[10] = {10, 2, 3, 4, 5, 6, 9, 8, 7, 1};
int i, j, temp, isSorted;
//優化演算法：最多進行 n-1 輪比較
for(i=0; i<10-1; i++){
isSorted = 1; //假設剩下的元素已經排序好了
for(j=0; j<10-1-i; j++){
if(nums[j] > nums[j+1]){
temp = nums[j];
nums[j] = nums[j+1];
nums[j+1] = temp;
isSorted = 0; //一旦需要交換數組元素，就說明剩下的元素沒有排序好
}
}
if(isSorted) break; //如果沒有發生交換，說明剩下的元素已經排序好了
}
for(i=0; i<10; i++){
printf("%d ", nums[i]);
}
printf(" ");
return 0;
}
(2)c語言從大到小排怎麼排擴展閱讀：
其他將數組從小到大排序的演算法
以下使用的是選擇排序法實現數組從小到大排序。
思想：從第一個數開始，每次和後面剩餘的數進行比較，若升序，則如果後邊的數比當前數字小，進行交換，和後面的所有的數比較、交換後，就會將當前的最小值放在當前的位置
輸入的序列為10、2、3、4、5、6、9、8、7、1進行一次排序後將最小的數放在了第一位(a[0]與它後面的所有數進行比較，若a[0]比後面的數大，進行交換)，以此類推。
以下是具體代碼：
#include <stdio.h>
int main(void){
int a[1001];
int n,i,j,t;
scanf("%d",&n);//n為要排序的數的個數
//輸入需要排序的數
for(i=0;i<n;++i)
scanf("%d",a+i);
//接下來進行排序
for(i=0;i<n-1;++i)//因為每次需要和a[i]後面的數進行比較,所以到a[n-2](倒數第2個元素)就行
{
for(j=i+1;j<n;++j)//j從i後一個開始,a[i]與a[j]進行比較
{
if(a[i]>a[j])//a[i]為當前值,若是比後面的a[j]大,進行交換
{
t=a[i];
a[i]=a[j];
a[j]=t;
}
}//每排序一次,就會將a[i](包括a[i])之後的最小值放在a[i]的位置
for(j=0;j<n;++j)
printf("%-5d",a[j]);
printf(" ");
}
return 0;
}
C. C語言~十個數字從小到大怎麼排列~從大到小呢~
//要求任意輸入10個數，然後按從小到大順序輸出
#include <stdio.h>
int main()
{
int a[10];
int i,j;
int temp;
printf("請輸入10個整數：");
for(i=0;i<10;i++)
{
scanf("%d",&a[i]);
}
for(i=0;i<9;i++)
{
for(j=0;j<9-i;j++)
{
if(a[j]>a[j+1])
{
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
printf("排列後順序為：");
for(i=0;i<10;i++)
{
printf("%d ",a[i]);
}
printf("
");
return 0;
}
D. C語言如何輸入十個數，按從大到小順序排列！
用選擇排序法編寫c語言，實現從鍵盤上輸入10個數，按從大到小的順序排序輸出。代碼如下：
#include<stdio.h>
int main()
{
int i,j,a[10],t;
printf("輸入數");
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[i];
a[i] = a[j];
a[j] = t;
}
}
printf("從大到小");
for (i = 0; i < 10; i++)
printf("%2d", a[i]);
return 0;
}
(4)c語言從大到小排怎麼排擴展閱讀：
代碼還可以設計，如下：
#include<stdio.h>
int main()
{
int a[10],i,j,t;//定義數組;
for(i=0;i<10;i++){
scanf("%d",&a[i]);//給數組賦值;
}
for(i=0;i<9;i++)//10個數，進行9輪比較;
for(j=0;j<10-i;j++){//第一個數比較9次，依次遞減;
if(a[j]>a[j+1]) {//交換值;
t=a[j];
a[j]=a[j+1];
a[j+1]=t;
}
}
for(i=0;i<10;i++){
printf("%d ",a[i]);//輸出數組的值;
}
return 0;
}
}
printf("the sorted numbers: ");
for(i=0;i<10;i++)
printf(" %d",a[i]);
printf(" ");
}
E. 輸入3個整數abc，怎麼用C語言從大到小排列輸出
詳細如下：
# include<stdio.h>
int main (void)
{ int a,b,c,t;
printf("請輸入三個任意整數行茄： ");
scanf("%d %d %d",&a, &b, &c);
if(a<b)
{ t = a;
a = b;
b = t;
}
if(a<c)
{
t = a;
a = c;
c = t;
}
if(b<c)
{
t = b;
b = c;
c = t;
}
printf("最大值：%d 最小值：%d %d",a,c);
}
希望能幫到你。
F. 怎樣用C語言對一串整行數從大到小排序
方法太多了，當然各種時間排序的時間復雜度和空間復雜度不同、穩定性也不同。最簡單的我覺得就是冒泡排序了，也最形像。/*
================================================
功能：選擇排序
輸入：數組名稱（也就是數組首地址）、數組中元素個數
================================================
*/
/*
====================================================
演算法思想簡單描述： 在要排序的一組數中，選出最小的一個數與第一個位置的數交換；
然後在剩下的數當中再找最小的與第二個位置的數交換，如此循環
到倒數第二個數和最後一個數比較為止。 選擇排序是不穩定的。演算法復雜度O(n2)--[n的平方]
=====================================================
*/
void select_sort(int *x, int n)
{
int i, j, min, t; for (i=0; i<n-1; i++) /*要選擇的次數：0~n-2共n-1次*/
{
min = i; /*假設當前下標為i的數最小，比較後再調整*/
for (j=i+1; j<n; j++)/*循環找出最小的數的下標是哪個*/
{
if (*(x+j) < *(x+min))
{
min = j; /*如果後面的數比前面的小，則記下它的下標*/
}
}
if (min != i) /*如果min在循環中改變了，就需要交換數據*/
{
t = *(x+i);
*(x+i) = *(x+min);
*(x+min) = t;
}
}
}
/*
================================================
功能：直接插入排序
輸入：數組名稱（也就是數組首地址）、數組中元素個數
================================================
*/
/*
====================================================
演算法思想簡單描述： 在要排序的一組數中，假設前面(n-1) [n>=2] 個數已經是排
好順序的，現在要把第n個數插到前面的有序數中，使得這n個數
也是排好順序的。如此反復循環，直到全部排好順序。
直接插入排序是穩定的。演算法時間復雜度O(n2)--[n的平方]
=====================================================
*/
void insert_sort(int *x, int n)
{
int i, j, t; for (i=1; i<n; i++) /*要選擇的次數：1~n-1共n-1次*/
{
/*
暫存下標為i的數。注意：下標從1開始，原因就是開始時
第一個數即下標為0的數，前面沒有任何數，單單一個，認為
它是排好順序的。
*/
t=*(x+i);
for (j=i-1; j>=0 && t<*(x+j); j--) /*注意：j=i-1，j--，這里就是下標為i的數，在它前面有序列中找插入位置。*/
{
*(x+j+1) = *(x+j); /*如果滿足條件就往後挪。最壞的情況就是t比下標為0的數都小，它要放在最前面，j==-1，退出循環*/
} *(x+j+1) = t; /*找到下標為i的數的放置位置*/
}
}
/*
================================================
功能：冒泡排序
輸入：數組名稱（也就是數組首地址）、數組中元素個數
================================================
*/
/*
====================================================
演算法思想簡單描述： 在要排序的一組數中，對當前還未排好序的范圍內的全部數，自上
而下對相鄰的兩個數依次進行比較和調整，讓較大的數往下沉，較
小的往上冒。即：每當兩相鄰的數比較後發現它們的排序與排序要
求相反時，就將它們互換。
下面是一種改進的冒泡演算法，它記錄了每一遍掃描後最後下沉數的
位置k，這樣可以減少外層循環掃描的次數。 冒泡排序是穩定的。演算法時間復雜度O(n2)--[n的平方]
=====================================================
*/void bubble_sort(int *x, int n)
{
int j, k, h, t;
for (h=n-1; h>0; h=k) /*循環到沒有比較范圍*/
{
for (j=0, k=0; j<h; j++) /*每次預置k=0，循環掃描後更新k*/
{
if (*(x+j) > *(x+j+1)) /*大的放在後面，小的放到前面*/
{
t = *(x+j);
*(x+j) = *(x+j+1);
*(x+j+1) = t; /*完成交換*/
k = j; /*保存最後下沉的位置。這樣k後面的都是排序排好了的。*/
}
}
}
}
/*
================================================
功能：希爾排序
輸入：數組名稱（也就是數組首地址）、數組中元素個數
================================================
*/
/*
====================================================
演算法思想簡單描述：
在直接插入排序演算法中，每次插入一個數，使有序序列只增加1個節點，
並且對插入下一個數沒有提供任何幫助。如果比較相隔較遠距離（稱為
增量）的數，使得數移動時能跨過多個元素，則進行一次比較就可能消除
多個元素交換。D.L.shell於1959年在以他名字命名的排序演算法中實現
了這一思想。演算法先將要排序的一組數按某個增量d分成若干組，每組中
記錄的下標相差d.對每組中全部元素進行排序，然後再用一個較小的增量
對它進行，在每組中再進行排序。當增量減到1時，整個要排序的數被分成
一組，排序完成。
下面的函數是一個希爾排序演算法的一個實現，初次取序列的一半為增量，
以後每次減半，直到增量為1。 希爾排序是不穩定的。
=====================================================
*/
void shell_sort(int *x, int n)
{
int h, j, k, t; for (h=n/2; h>0; h=h/2) /*控制增量*/
{
for (j=h; j<n; j++) /*這個實際上就是上面的直接插入排序*/
{
t = *(x+j);
for (k=j-h; (k>=0 && t<*(x+k)); k-=h)
{
*(x+k+h) = *(x+k);
}
*(x+k+h) = t;
}
}
}/*
================================================
功能：快速排序
輸入：數組名稱（也就是數組首地址）、數組中起止元素的下標
================================================
*/
/*
====================================================
演算法思想簡單描述： 快速排序是對冒泡排序的一種本質改進。它的基本思想是通過一趟
掃描後，使得排序序列的長度能大幅度地減少。在冒泡排序中，一次
掃描只能確保最大數值的數移到正確位置，而待排序序列的長度可能只
減少1。快速排序通過一趟掃描，就能確保某個數（以它為基準點吧）
的左邊各數都比它小，右邊各數都比它大。然後又用同樣的方法處理
它左右兩邊的數，直到基準點的左右只有一個元素為止。它是由
C.A.R.Hoare於1962年提出的。
顯然快速排序可以用遞歸實現，當然也可以用棧化解遞歸實現。下面的
函數是用遞歸實現的，有興趣的朋友可以改成非遞歸的。 快速排序是不穩定的。最理想情況演算法時間復雜度O(nlog2n)，最壞O(n2)
=====================================================
*/
void quick_sort(int *x, int low, int high)
{
int i, j, t; if (low < high) /*要排序的元素起止下標，保證小的放在左邊，大的放在右邊。這里以下標為low的元素為基準點*/
{
i = low;
j = high;
t = *(x+low); /*暫存基準點的數*/ while (i<j) /*循環掃描*/
{
while (i<j && *(x+j)>t) /*在右邊的只要比基準點大仍放在右邊*/
{
j--; /*前移一個位置*/
} if (i<j)
{
*(x+i) = *(x+j); /*上面的循環退出：即出現比基準點小的數，替換基準點的數*/
i++; /*後移一個位置，並以此為基準點*/
} while (i<j && *(x+i)<=t) /*在左邊的只要小於等於基準點仍放在左邊*/
{
i++; /*後移一個位置*/
} if (i<j)
{
*(x+j) = *(x+i); /*上面的循環退出：即出現比基準點大的數，放到右邊*/
j--; /*前移一個位置*/
}
} *(x+i) = t; /*一遍掃描完後，放到適當位置*/
quick_sort(x,low,i-1); /*對基準點左邊的數再執行快速排序*/
quick_sort(x,i+1,high); /*對基準點右邊的數再執行快速排序*/
}
}
/*
================================================
功能：堆排序
輸入：數組名稱（也就是數組首地址）、數組中元素個數
================================================
*/
/*
====================================================
演算法思想簡單描述： 堆排序是一種樹形選擇排序，是對直接選擇排序的有效改進。
堆的定義如下：具有n個元素的序列（h1,h2,...,hn),當且僅當
滿足（hi>=h2i,hi>=2i+1）或（hi<=h2i,hi<=2i+1）(i=1,2,...,n/2)
時稱之為堆。在這里只討論滿足前者條件的堆。 由堆的定義可以看出，堆頂元素（即第一個元素）必為最大項。完全二叉樹可以
很直觀地表示堆的結構。堆頂為根，其它為左子樹、右子樹。
初始時把要排序的數的序列看作是一棵順序存儲的二叉樹，調整它們的存儲順序，
使之成為一個堆，這時堆的根節點的數最大。然後將根節點與堆的最後一個節點
交換。然後對前面(n-1)個數重新調整使之成為堆。依此類推，直到只有兩個節點
的堆，並對它們作交換，最後得到有n個節點的有序序列。 從演算法描述來看，堆排序需要兩個過程，一是建立堆，二是堆頂與堆的最後一個元素
交換位置。所以堆排序有兩個函數組成。一是建堆的滲透函數，二是反復調用滲透函數
實現排序的函數。 堆排序是不穩定的。演算法時間復雜度O(nlog2n)。*/
/*
功能：滲透建堆
輸入：數組名稱（也就是數組首地址）、參與建堆元素的個數、從第幾個元素開始
*/
void sift(int *x, int n, int s)
{
int t, k, j; t = *(x+s); /*暫存開始元素*/
k = s; /*開始元素下標*/
j = 2*k + 1; /*右子樹元素下標*/ while (j<n)
{
if (j<n-1 && *(x+j) < *(x+j+1))/*判斷是否滿足堆的條件：滿足就繼續下一輪比較，否則調整。*/
{
j++;
} if (t<*(x+j)) /*調整*/
{
*(x+k) = *(x+j);
k = j; /*調整後，開始元素也隨之調整*/
j = 2*k + 1;
}
else /*沒有需要調整了，已經是個堆了，退出循環。*/
{
break;
}
}
*(x+k) = t; /*開始元素放到它正確位置*/
}
/*
功能：堆排序
輸入：數組名稱（也就是數組首地址）、數組中元素個數
*/
void heap_sort(int *x, int n)
{
int i, k, t;
int *p; for (i=n/2-1; i>=0; i--)
{
sift(x,n,i); /*初始建堆*/
}
for (k=n-1; k>=1; k--)
{
t = *(x+0); /*堆頂放到最後*/
*(x+0) = *(x+k);
*(x+k) = t;
sift(x,k,0); /*剩下的數再建堆*/
}
}
void main()
{
#define MAX 4
int *p, i, a[MAX];
/*錄入測試數據*/
p = a;
printf("Input %d number for sorting :\n",MAX);
for (i=0; i<MAX; i++)
{
scanf("%d",p++);
}
printf("\n"); /*測試選擇排序*/
p = a;
select_sort(p,MAX);
/**/
/*測試直接插入排序*/ /*
p = a;
insert_sort(p,MAX);
*/
/*測試冒泡排序*/ /*
p = a;
insert_sort(p,MAX);
*/ /*測試快速排序*/ /*
p = a;
quick_sort(p,0,MAX-1);
*/ /*測試堆排序*/ /*
p = a;
heap_sort(p,MAX);
*/ for (p=a, i=0; i<MAX; i++)
{
printf("%d ",*p++);
}
printf("\n");
system("pause");
}
G. C語言如何用選擇法排序任意輸入十個數（從大到小、從小到大）
#include
<stdio.h>
main(void)
{
int
i,j,a[10],p=0,t=0,temp;
printf("請輸入原數組：\n");
for(j=0;j<10;j++)
scanf("%d",&a[j]);
temp=a[0];
for(j=0;j<9;j++)
{
t=j;
temp=a[j];
for(i=j+1;i<10;i++)
if(temp>a[i])
//這是由小到大排序
如果是大到小則改為
if(temp<a[i])
{temp=a[i];p=i;}
{temp=a[p];a[p]=a[t];a[t]=temp;}
}
printf("排序後的數組為：\n");
for(j=0;j<10;j++)
printf("%d
",a[j]);
}
H. C語言如何輸入十個數，按從大到小順序排列！
代碼如圖所示：
#include<stdio.h>
int main()
{
int i,j,a[10],t;
printf("請輸入十個數：");
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[i];
a[i] = a[j];
a[j] = t;
}
}
printf("從大到小排序後：");
for (i = 0; i < 10; i++)
printf("%2d", a[i]);
return 0;
}
(8)c語言從大到小排怎麼排擴展閱讀
C語言順序排列題的其他解法
#include <stdio.h>
int main()
{
int a[10];
int i,j;
int temp;
printf("請輸入10個整數：");
for(i=0;i<10;i++)
{
scanf("%d",&a[i]);
}
for(i=0;i<9;i++)
{
for(j=0;j<9-i;j++)
{
if(a[j]>a[j+1])
{
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
printf("排列後順序為：");
for(i=0;i<10;i++)
{
printf("%d ",a[i]);
}
printf(" ");
return 0;
}
I. C語言：輸入10個數依次從大到小排序！
用數組來存放十個數字，使用「冒泡排序」來實現排序。10個數字需進行9輪掃描，每次掃描時比較相鄰的二個數，如它們不符合要求的大小關系，就交換它們的位置。第一輪掃描結束時，最大的數就「沉」到最後。於是第二的范圍就少了一個數。再進行第二兩棲型、第三輪，…——直到第9輪就完成了。最後輸出結果。
#include<stdio.h>
int
main()
{
int
a[10],i,j,t;
printf("請輸入10個整數:\n");
for(i=0;i<10;i++)
scanf("%d",&a[i]);
for(i=0;i<9;i++)
for(j=0;j<9-i;j++)
if(a[j]>a[j+1])
{
t=a[j];
a[j]=a[j+1];
a[j+1]=t;
}
printf("排序以後的數:\n");
for(i=0;i<10;i++)
printf("%d
",a[i]);
printf("\n");
system("pause");
return
0;
}
如果要從大到小排，只要把上面的交換條件
if(a[j]>a[j+1])換為
if(a[j]<a[j+1])就可以了。
J. 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);//輸出
}
(10)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;
}