c簡單選擇排序演算法

㈠ C語言編程:選擇法排序

選擇排序是一種簡單直觀的排序演算法。

工作原理：

每一次從待排序的數據元素中選出最小（或最大）的一個元素，存放在序列的起始位置，直到全部待排序的數據元素排完。

性能：

選擇排序是不穩定的排序方法（比如序列[5， 5， 3]第一次就將第一個[5]與[3]交換，導致第一個5挪動到第二個5後面）。

選擇排序的時間復雜度是O(n^2)

思想：

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(i..n）。該趟排序從當前無序區中選出關鍵字最小的記錄 R[k]，將它與無序區的第1個記錄R交換，使R[1..i]和R分別變為記錄個數增加1個的新有序區和記錄個數減少1個的新無序區。

C語言版代碼：

#include<stdio.h>
#include<math.h>

#defineMAX_SIZE101
#defineSWAP(x,y,t)((t)=(x),(x)=(y),(y)=(t))

voidsort(int[],int);/*selectionsort*/

intmain()
{
inti,n;
intlist[MAX_SIZE];
printf(":");
scanf_s("%d",&n);
if(n<1||n>MAX_SIZE){
fprintf(stderr,"Impropervalueofn
");
exit(1);
}
for(i=0;i<n;i++){/*randomlygeneratenumbers*/
list[i]=rand()*1000;
printf("%d",list[i]);
}
sort(list,n);
printf("
Sortedarray:
");
for(i=0;i<n;i++)/*printoutsortednumbers*/
printf("%d",list[i]);
printf("
");
return0;
}
voidsort(intlist[],intn)
{
inti,j,min,temp;
for(i=0;i<n-1;i++){
min=i;
for(j=i+1;j<n;j++)
if(list[j]<list[min])
min=j;
SWAP(list[i],list[min],temp);
}
}

㈡ C語言選擇排序法有哪些

1、穩定排序和非穩定排序
簡單地說就是所有相等的數經過某種排序方法後，仍能保持它們在排序之前的相對次序，我
們就
說這種排序方法是穩定的。反之，就是非穩定的。
比如：一組數排序前是a1,a2,a3,a4,a5，其中a2=a4，經過某種排序後為a1,a2,a4,a3,a5，
則我們說這種排序是穩定的，因為a2排序前在a4的前面，排序後它還是在a4的前面。假如變
成a1,a4,
a2,a3,a5就不是穩定的了。
2、內排序和外排序
在排序過程中，所有需要排序的數都在內存，並在內存中調整它們的存儲順序，稱為內排序；
在排序過程中，只有部分數被調入內存，並藉助內存調整數在外存中的存放順序排序方法稱
為外排序。
3、演算法的時間復雜度和空間復雜度
所謂演算法的時間復雜度，是指執行演算法所需要的計算工作量。
一個演算法的空間復雜度，一般是指執行這個演算法所需要的內存空間。
======================================================================
==========
*/
/*
================================================
功能：選擇排序
輸入：數組名稱（也就是數組首地址）、數組中元素個數
================================================
*/
/*
====================================================
演算法思想簡單描述：
在要排序的一組數中，選出最小的一個數與第一個位置的數交換；
然後在剩下的數當中再找最小的與第二個位置的數交換，如此循環
到倒數第二個數和最後一個數比較為止。
選擇排序是不穩定的。演算法復雜度O(n2)--[n的平方]
=====================================================
*/
voidselect_sort(int*x,intn)
{
inti,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的平方]
=====================================================
*/
voidinsert_sort(int*x,intn)
{
inti,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的平方]
=====================================================
*/
voidbubble_sort(int*x,intn)
{
intj,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。
希爾排序是不穩定的。
=====================================================
*/
voidshell_sort(int*x,intn)
{
inth,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)
=====================================================
*/
voidquick_sort(int*x,intlow,inthigh)
{
inti,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); /*對基準點右邊的數再執行快速排序*/
}
}
/*
================================================
功能：堆排序
輸入：數組名稱（也就是數組首地址）、數組中元素個數
================================================

㈢ C語言選擇排序法

這是選擇排序。先用a[0]與a[1]比較，當a[0]<a[1]時並不交換，而用k記下來現在a[0]最小……這樣一趟比較完後a[k]就是整個數組中最小的元素，把它與a[0]交換；第二趟，從a[1]開始重復前面的操作，那麼最後a[1]就是剩下的n-1個元素中最小的……看a[0]、a[1]已經由小到大排好了，當做完n-1趟時不就把整個數組都排好了嗎？注意：t=array[k];array[k]=array[i];array[i]=t;不是for(j=i+1;j<n;j++)的循環體，要等它循環完了後才執行一次。

㈣ 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;

}

}

}

㈤ c語言 選擇法排序

void sa(int array[],int n)
{
int i,j,k,temp;
for(i=0;i<10;i++)
{
k=i; //保存i的值，用k來進行循環排序
for(j=i+1;j<n;j++) //將第i個元素後面的元素與第i個元素進行比較
if(array[j]<array[k]) //如果第k=i個元素後面的元素小於i號元素，交換兩個元素的標號， 這樣就將最小元素的標號放到最前面
k=j; //交換標號
temp=array[k]; //循環結束後，交換兩個標號下的元素的值
array[k]=array[i];
array[i]=temp;
}
}
這個程序實現的是由小到大的排序。第二個循環裡面，就是i號元素後面最小的元素對應的標號放到k中，在交換當前元素與k號元素中的值，實現由大到小排序

㈥ C語言演算法設計，選擇排序

排序如下：

voidSelectSort(RecordTyper[],intlength)/*對記錄數組r做簡單選擇排序，length為待排序記錄的個數*/

{inttemp;for(i=0;i<length-1;i++)//n-1趟排序{intindex=i；//假設index處對應的數組元素是最小的for(intj=i+1;j<length;j++)//查找最小記錄的位置if(r[j].key<r[index].key)index=j;if(index!=i)//若無序區第一個元素不是無序區中最小元素，則進行交換{temp=r[i];r[i]=r[index];r[index]=temp;}}}

初始序列：{49 27 65 97 76 12 38}第1趟：12與49交換：12{27 65 97 76 49 38}第2趟：27不動：12 27{65 97 76 49 38}第3趟：65與38交換：12 27 38{97 76 49 65}第4趟：97與49交換：12 27 38 49{76 97 65}第5趟：76與65交換：12 27 38 49 65{97 76}第6趟：97與76交換：12 27 38 49 65 76 97 完成

選擇排序法 是對 定位比較交換法（也就是冒泡排序法） 的一種改進。選擇排序的基本思想是：每一趟在n-i+1（i=1，2，…n-1）個記錄中選取關鍵字最小的記錄作為有序序列中第i個記錄。基於此思想的演算法主要有簡單選擇排序、樹型選擇排序和堆排序。

簡單選擇排序的基本思想：第1趟，在待排序記錄r[1]~r[n]中選出最小的記錄，將它與r[1]交換；第2趟，在待排序記錄r[2]~r[n]中選出最小的記錄，將它與r[2]交換；以此類推，第i趟在待排序記錄r[i]~r[n]中選出最小的記錄，將它與r[i]交換，使有序序列不斷增長直到全部排序完畢。

拓展資料

下面也寫個例子：

由大到小時：

intmain(void){inta[10];inti,j,t,k;for(i=0;i<10;i++)scanf("%d",&a[i]);/*輸入10個數，比武報名，報名費用10000￥^_^*/for(i=0;i<9;i++)/*10個數，所以只需比9次*/{k=i;/*裁判AND記者實時追蹤報道比賽情況*/for(j=i+1;j<10;j++)if(a[k]<a[j])k=j;/*使a[k]始終表示已比較的數中的最大數*/if（k！=i）{t=a[i];a[i]=a[k];a[k]=t;}/*t發放獎品*/}for(i=0;i<10;i++)printf("%4d",a[i]);/*顯示排序後的結果*/return0;}

由小到大時：

intmain(void){inta[10];inti,j,t,k;for(i=0;i<10;i++)scanf("%d",&a[i]);/*輸入10個數，比武報名，報名費用10000￥^_^*/for(i=0;i<9;i++){k=i;/*裁判AND記者實時追蹤報道比賽情況*/for(j=i+1;j<10;j++)if(a[k]>a[j])k=j;if（k！=i）{t=a[i];a[i]=a[k];a[k]=t;}/*t發放獎品*/}for(i=0;i<=9;i++)printf("%4d",a[i]);/*顯示排序後的結果*/return0;}

㈦ C語言中選擇排序法具體是怎樣的

選擇排序的基本思想是:每一趟在n-i+1(i=1，2，…n-1)個記錄中選取關鍵字最小的記錄作為有序序列中第i個記錄。基於此思想的演算法主要有簡單選擇排序、樹型選擇排序和堆排序。
簡單選擇排序的基本思想:第1趟，在待排序記錄r[1]~r[n]中選出最小的記錄，將它與r[1]交換;第2趟，在待排序記錄r[2]~r[n]中選出最小的記錄，將它與r[2]交換;以此類推，第i趟在待排序記錄r[i]~r[n]中選出最小的記錄，將它與r[i]交換，使有序序列不斷增長直到全部排序完畢。