本文目錄一覽：
使用C語言編程實現排序算法
#includestdio.h
main()
{
struct
{
char mz[5];
int sd;
char sbing[5];
int xs;
}a[100],k;
int i,b,j;
printf(“請輸入球員數量\n”);
scanf(“%d”,b);
for(i=0;ib;i++)
{printf(“請輸入第%d個球員的信息\n”,i+1);
printf(“名字:”); scanf(“%s”,a[i].mz);
printf(“速度(數字):”); scanf(“%d”,a[i].sd);
printf(“傷病情況:”); scanf(“%s”,a[i].sbing);
printf(“薪水(數字:”); scanf(“%d”,a[i].xs);}
for(j=0;jb;j++)
for(i=j+1;ib;i++)
if(a[j].sda[i].sd)
{ k=a[i];
a[i]=a[j];
a[j]=k;}
if(a[j].sd==a[i].sd)
if (a[j].xsa[i].xs)
{ k=a[i];
a[i]=a[j];
a[j]=k;}
for(j=0;jb;j++)
printf(“名字:%s 速度: %d 傷病: %s 薪水: %d\n”,a[j].mz,a[j].sd,a[j].sbing,a[j].xs);
}
如有不滿請回復
C語言實現文件排序
常見排序算法（冒泡，選擇，快速）的C語言實現
要實現這幾種算法的關鍵是要熟悉算法的思想。簡單的說，冒泡排序，就如名字說的，每經過一輪排序，將最大的數沉到最底部。選擇排序的思想是將整個數列，分為有序區和無序區。每輪排序，將無序區里的最小數移入到有序區。快速排序的思想是以一個數為中心，通常這個數是該數列第一個數，將整個數列分為兩個部分，一個部分是大於這個數的區域，一個部分是小於這個數的區域。然後再對這兩個部分的數列分別排序。如果將數列分為兩個部分是通過，一方面從後向前的搜索，另一方面從前向後的搜索來實現的。具體的參考後面的來自百度百科的文檔。
從這幾個簡單的排序算法上看，有幾個特點：
冒泡排序是最簡單的，也是最穩定的算法。
選擇排序不太穩定，但是效率上較冒泡還是有較大的提升。其實在分析的過程中就能發現，選擇排序和冒泡排序相比，中間少了很多的交換過程，和比較的次數，這個應該是時間較少的原因。選擇排序能夠滿足一般的使用。當比較的數超過以萬為單位時，選擇排序也還是要一點時間的。
快速排序據說是最快的。這個可以從思想上看的出來。，當記錄較多的時候，快速排序的比較循環次數比上面2個都要少。但是在具體的實現過程中，並不見得如此。這是因為遞歸效率的低下導致的。當然，估計在實際使用過的過程，快速排序估計都會使用非遞歸操作棧的方式來實現。那樣應該會效率高傷不少。估計我會在後期出一個快速排序的非遞歸實現來真正比較它們3個性能。在下面的程序中，可以通過調高N的數字就能看的出來冒泡排序和選擇排序性能的差異。在N較小，大概幾百的時候，是看不出來的。N較大的的時候，比如N=1000或者N=10000的時候，快速排序的遞歸實現就會卡死在那裡了，出不了結果。
以下是具體的代碼：
/*
** 常見排序算法比較
*/
#include stdio.h
#include stdlib.h
#include time.h
#include windows.h
#define N 10
#define Demo 1
void BubbleSort(int arr[], int n);
void SelectSort(int arr[], int n);
void QuickSort(int arr[], int n);
void PrintArray(int arr[], int n);
void GenerateArray(int arr[], int n);
int main(int argc, char *argv[])
{
int arr[N];
GenerateArray(arr, N);
#if Demo
printf(“Before the bubble sort————————\n”);
PrintArray(arr, N);
#endif
printf(“Start Bubble sort———————-\n”);
clock_t start_time1=clock(); //開始計時
BubbleSort(arr, N);
clock_t end_time1=clock(); // 結束計時
printf(“Running time is: %lf ms\n”, (double)(end_time1-start_time1)/CLOCKS_PER_SEC*1000); //輸出運行時間
#if Demo
printf(“After the bubble sort————————\n”);
PrintArray(arr, N);
#endif
printf(“———————————————————–\n”);
sleep(1000); // 單位是毫秒即千分之一秒
GenerateArray(arr, N);
#if Demo
printf(“Before the selection sort————————\n”);
PrintArray(arr, N);
#endif
printf(“Start selection sort———————-\n”);
clock_t start_time2=clock(); //開始計時
SelectSort(arr, N);
clock_t end_time2=clock(); // 結束計時
printf(“Running time is: %lf ms\n”, (double)(end_time2-start_time2)/CLOCKS_PER_SEC*1000); //輸出運行時間
#if Demo
printf(“After the selection sort————————\n”);
PrintArray(arr, N);
#endif
printf(“———————————————————–\n”);
sleep(1000); // 單位是毫秒即千分之一秒
GenerateArray(arr, N);
#if Demo
printf(“Before the quick sort————————\n”);
PrintArray(arr, N);
#endif
printf(“Start quick sort———————-\n”);
clock_t start_time3=clock(); //開始計時
QuickSort(arr, N);
clock_t end_time3=clock(); // 結束計時
printf(“Running time is: %lf ms\n”, (double)(end_time3-start_time3)/CLOCKS_PER_SEC*1000); //輸出運行時間
#if Demo
printf(“After the quick sort————————\n”);
PrintArray(arr, N);
#endif
system(“PAUSE”);
return 0;
}
// 產生隨機列表
void GenerateArray(int arr[], int n)
{
int i;
srand((unsigned)time(0));
for(i = 0; i N; i++)
{
arr[i] = rand(); // 生成隨機數 範圍在0-32767之間
}
}
// 打印列表
void PrintArray(int arr[], int n)
{
int i = 0;
for(i = 0; i n; i++)
printf(“%6d”, arr[i]);
printf(“\n”);
}
// 經典冒泡排序
void BubbleSort(int arr[], int n)
{
int i = 0, j =0;
for(i = 0; i n; i++)
for(j = 0; j n – 1 – i; j++)
{
if(arr[j] arr[j + 1])
{
arr[j] = arr[j] ^ arr[j+1];
arr[j+1] = arr[j] ^ arr[j+1];
arr[j] = arr[j] ^ arr[j+1];
}
}
}
// 快速排序的遞歸實現
void QuickSort(int arr[], int n)
{
if(n = 1)
return;
int i =0 , j = n – 1;
int key = arr[0];
int index = 0;
while(i j)
{
// 從後向前搜索
while(j i arr[j] key)
j–;
if(j == i)
break;
else
{
//交換 a[j] a[i]
arr[j] = arr[j] ^arr[i];
arr[i] = arr[j] ^arr[i];
arr[j] = arr[j] ^arr[i];
index = j;
}
// 從前向後搜索
while(i j arr[i] key)
i++;
if(i == j)
break;
else
{
// 交換 a[i] a[j]
arr[j] = arr[j] ^arr[i];
arr[i] = arr[j] ^arr[i];
arr[j] = arr[j] ^arr[i];
index = i;
}
}
QuickSort(arr, index);
QuickSort(arr + index + 1, n – 1 – index);
}
// 選擇排序
void SelectSort(int arr[], int n)
{
int i, j;
int min;
for(i = 0; i n – 1; i++)
{
int index = 0;
min = arr[i];
for(j = i + 1; j n; j++) //找出 i+1 – n 無序區的最小者與arr[i]交換
{
if(arr[j] min)
{
min = arr[j];
index = j;
}
}
if(index != 0) //表明無序區有比arr[i]小的元素
{
arr[i] = arr[i]^arr[index];
arr[index] = arr[i]^arr[index];
arr[i] = arr[i]^arr[index];
}
}
}
程序里有幾點注意的地方：
一，在程序里，交換2個數，我使用了異或來處理。這個可以根據個人喜好。為了避免產生臨時變量，可以使用如下幾種方式來交換2個數：
a=a^b;
b=a^b;
a=a^b;
或者
a=a+b;
b=a-b;
a=a-b;
使用第二種也挺好的。第一種異或的方式，只適用於，2個數都為int型的，a,b可以正可以負，這個沒有關係，但是必須是int類型。
二， sleep()函數是包含在windows.h裏面的，要加入 #include window.h
三， 關於隨機數生成的2個函數 srand()種子發生器函數，還有rand()隨機數生成器函數，自己可以參考相關文檔。
四， Demo宏來控制是演示還是比較性能用的。當把N調整的很小，比如10的時候，可以設置Demo為1，那樣就能打印數組了，可以看到比較前後的情況。當把N調整到很大比如10000的時候，就把Demo設置為0，那樣就不打印數組，直接比較性能。
具體的算法文檔參考下面的：
冒泡排序
基本概念
冒泡排序（BubbleSort）的基本概念是：依次比較相鄰的兩個數，將小數放在前面，大數放在後面。即在第一趟：首先比較第1個和第2個數，將小數放前，大數放後。然後比較第2個數和第3個數，將小數放前，大數放後，如此繼續，直至比較最後兩個數，將小數放前，大數放後。至此第一趟結束，將最大的數放到了最後。在第二趟：仍從第一對數開始比較（因為可能由於第2個數和第3個數的交換，使得第1個數不再小於第2個數），將小數放前，大數放後，一直比較到倒數第二個數（倒數第一的位置上已經是最大的），第二趟結束，在倒數第二的位置上得到一個新的最大數（其實在整個數列中是第二大的數）。如此下去，重複以上過程，直至最終完成排序。
由於在排序過程中總是小數往前放，大數往後放，相當於氣泡往上升，所以稱作冒泡排序。
用二重循環實現，外循環變量設為i，內循環變量設為j。外循環重複9次，內循環依次重複9，8，…，1次。每次進行比較的兩個元素都是與內循環j有關的，它們可以分別用a[j]和a[j+1]標識，i的值依次為1,2,…,9，對於每一個i, j的值依次為1,2,…10-i。
產生
在許多程序設計中，我們需要將一個數列進行排序，以方便統計，而冒泡排序一直由於其簡潔的思想方法而倍受青睞。
排序過程
設想被排序的數組R［1..N］垂直豎立，將每個數據元素看作有重量的氣泡，根據輕氣泡不能在重氣泡之下的原則，從下往上掃描數組R，凡掃描到違反本原則的輕氣泡，就使其向上”漂浮”，如此反覆進行，直至最後任何兩個氣泡都是輕者在上，重者在下為止。
算法示例
A[0] 、 A[1]、 A[2]、 A[3]、 A[4]、 A[5]、 A[6]：
49 38 65 97 76 13 27
第一趟冒泡排序過程
38 49 65 97 76 13 27
38 49 65 97 76 13 27
38 49 65 97 76 13 27
38 49 65 76 97 13 27
38 49 65 76 13 97 27
38 49 65 76 13 27 97 – 這是第一趟冒泡排序完的結果
第二趟也是重複上面的過程，只不過不需要比較最後那個數97，因為它已經是最大的
38 49 65 13 27 76 97 – 這是結果
第三趟繼續重複，但是不需要比較倒數2個數了
38 49 13 27 65 76 97
….
選擇排序
基本思想
n個記錄的文件的直接選擇排序可經過n-1趟直接選擇排序得到有序結果：
①初始狀態：無序區為R[1..n]，有序區為空。
②第1趟排序
在無序區R[1..n]中選出關鍵字最小的記錄R[k]，將它與無序區的第1個記錄R[1]交換，使R[1..1]和R[2..n]分別變為記錄個數增加1個的新有序區和記錄個數減少1個的新無序區。
……
③第i趟排序
第i趟排序開始時，當前有序區和無序區分別為R[1..i-1]和R(1≤i≤n-1)。該趟排序從當前無序區中選出關鍵字最小的記錄 R[k]，將它與無序區的第1個記錄R交換，使R[1..i]和R分別變為記錄個數增加1個的新有序區和記錄個數減少1個的新無序區。
這樣，n個記錄的文件的直接選擇排序可經過n-1趟直接選擇排序得到有序結果。
常見的選擇排序細分為簡單選擇排序、樹形選擇排序（錦標賽排序）、堆排序。上述算法僅是簡單選擇排序的步驟。
排序過程
A[0] 、 A[1]、 A[2]、 A[3]、 A[4]、 A[5]、 A[6]：
49 38 65 97 76 13 27
第一趟排序後 13 ［38 65 97 76 49 27]
第二趟排序後 13 27 ［65 97 76 49 38]
第三趟排序後 13 27 38 [97 76 49 65]
第四趟排序後 13 27 38 49 [76 97 65]
第五趟排序後 13 27 38 49 65 [97 76]
第六趟排序後 13 27 38 49 65 76 [97]
最後排序結果 13 27 38 49 49 65 76 97
快速排序算法
算法過程
設要排序的數組是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]，並與A[I]交換；
4）從I開始向後搜索，即由前開始向後搜索（I=I+1），找到第一個大於key的A[I]，與A[J]交換；
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的值，6549,兩者交換，此時：I=3 )
進行第三次交換後： 27 38 13 97 76 49 65
( 按照算法的第五步將又一次執行算法的第三步從後開始找
進行第四次交換後： 27 38 13 49 76 97 65
( 按照算法的第四步從前面開始找大於X的值，9749,兩者交換，此時：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} 完成排序。
程序設計中有哪些排序算法？用C語言分別怎樣實現？
冒泡排序法，折半查找法。折半是有一定的順序的中找，利用折半減少查找次數。
、沒優化的冒泡我就不說了，優化的說是拿第一個元素跟後面的一個個比較，大的或小的放到第一個，這樣第一次比較出來的就是最大的或最小的，然後第二個在跟後面的元素一個個比較，找出第二大或第二小，依此到完，用到二個FOR循環。
用C語言編程實現快速排序算法
給個快速排序你參考參考
/********************** 快速排序 ****************************
基本思想：在待排序的n個記錄中任取一個記錄（通常取第一個記錄），
以該記錄為基準，將當前的無序區劃分為左右兩個較小的無
序子區，使左邊的記錄均小於基準值，右邊的記錄均大於或
等於基準值，基準值位於兩個無序區的中間位置（即該記錄
最終的排序位置）。之後，分別對兩個無序區進行上述的劃
分過程，直到無序區所有記錄都排序完畢。
*************************************************************/
/*************************************************************
函數名稱：static void swap(int *a, int *b)
參 數：int *a—整型指針
int *b—整型指針
功 能：交換兩個整數的位置
返 回 值：無
說 明：static關鍵字指明了該函數只能在本文件中使用
**************************************************************/
static void swap(int *a, int *b)
{
int temp = *a;
*a = *b;
*b = temp;
}
int quickSortNum = 0; // 快速排序算法所需的趟數
/*************************************************************
函數名稱：static int partition(int a[], int low, int high)
參 數：int a[]—待排序的數據
int low—無序區的下限值
int high—無序區的上限值
功 能：完成一趟快速排序
返 回 值：基準值的最終排序位置
說 明：static關鍵字指明了該函數只能在本文件中使用
**************************************************************/
static int partition(int a[], int low, int high)
{
int privotKey = a[low]; //基準元素
while(low high)
{ //從表的兩端交替地向中間掃描
while(low high a[high] = privotKey) // 找到第一個小於privotKey的值
high–; //從high所指位置向前搜索，至多到low+1位置
swap(a[low], a[high]); // 將比基準元素小的交換到低端
while(low high a[low] = privotKey) // 找到第一個大於privotKey的值
low++; //從low所指位置向後搜索，至多到high-1位置
swap(a[low], a[high]); // 將比基準元素大的交換到高端
}
quickSortNum++; // 快速排序趟數加1
return low; // 返回基準值所在的位置
}
/*************************************************************
函數名稱：void QuickSort(int a[], int low, int high)
參 數：int a[]—待排序的數據
int low—無序區的下限值
int high—無序區的上限值
功 能：完成快速排序算法，並將排序完成的數據存放在數組a中
返 回 值：無
說 明：使用遞歸方式完成
**************************************************************/
void QuickSort(int a[], int low, int high)
{
if(low high)
{
int privotLoc = partition(a, low, high); // 將表一分為二
QuickSort(a, low, privotLoc-1); // 遞歸對低子表遞歸排序
QuickSort(a, privotLoc+1, high); // 遞歸對高子表遞歸排序
}
}
原創文章，作者：VBED，如若轉載，請註明出處：https://www.506064.com/zh-hk/n/133780.html
微信掃一掃 
支付寶掃一掃 