選擇排序演算法

『壹』 c語言選擇法排序

#include<stdio.h>

#defineM 5

void main()

{

int b[M],i,j,t,k;

for(i=0;i<M;i++)

scanf("%d",&b[i]);

for(i=0;i<M-1;i++)

{

for(k=i,j=i+1;j<M;j++)

if(b[k]<b[j])

k=j;

if(i!=k)

{

t=b[i];

b[i]=b[k];

b[k]=t;

}

}

for(i=0;i<M;i++)

printf("%d ",b[i]);

}

錯在大括弧位置加錯了。

代碼：

#include<stdio.h>

void SelectionSort(int *num,int n)

{

int i = 0;

int min = 0;

int j = 0;

int tmp = 0;

for(i = 0;i < n-1;i++)

{

min = i;//每次講min置成無序組起始位置元素下標

for(j = i;j < n;j++)//遍歷無序組，找到最小元素。

{

if(num[min]>num[j])

{

min = j;

}

}

if(min != i)//如果最小元素不是無序組起始位置元素，則與起始元素交換位置

{

tmp = num[min];

num[min] = num[i];

num[i] = tmp;

}

}

}

（此處空一行）

int main()

{

int num[6] = {5,4,3,2,9,1};

int i = 0;

SelectionSort(num,6);//這里需要將數列元素個數傳入。有心者可用sizeof在函數內求得元素個數。

for(i = 0;i < 6;i++)

{

printf("%d ",num[i]);

}

return 0;

}

『貳』 選擇排序法

這是冒泡法吧

粘些資料給你：
冒泡排序和選擇排序是排序演算法中比較簡單和容易實現的演算法。冒泡排序的思想為：每一次排序過程，通過相鄰元素的交換，將當前沒有排好序中的最大（小）移到數組的最右（左）端。而選擇排序的思想也很直觀：每一次排序過程，我們獲取當前沒有排好序中的最大（小）的元素和數組最右（左）端的元素交換，循環這個過程即可實現對整個數組排序。
還有「
http://www.d2school.com/bcyl/bhcpp/newls/ls18.htm#18.2
還有
一、簡單排序演算法
由於程序比較簡單，所以沒有加什麼注釋。所有的程序都給出了完整的運行代碼，並在我的VC環境
下運行通過。因為沒有涉及MFC和WINDOWS的內容，所以在BORLAND C++的平台上應該也不會有什麼
問題的。在代碼的後面給出了運行過程示意，希望對理解有幫助。

1.冒泡法：
這是最原始，也是眾所周知的最慢的演算法了。他的名字的由來因為它的工作看來象是冒泡：
#include

void BubbleSort(int* pData,int Count)
{
int iTemp;
for(int i=1;i {
for(int j=Count-1;j>=i;j--)
{
if(pData[j] {
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<}

倒序(最糟情況)
第一輪：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
void SelectSort(int* pData,int Count)
{
int iTemp;
int iPos;
for(int i=0;i {
iTemp = pData[i];
iPos = i;
for(int j=i+1;j {
if(pData[j] {
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<}
倒序(最糟情況)
第一輪：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)。所以，在數據較亂的時候，可以減少一定的交換次數。
最終，我個人認為，在簡單排序演算法中，選擇法是最好的。
還有：http://it2.chinahw.net/ioi/Article/program/suanfa/200604/139.html

『叄』 直接選擇排序演算法問題

加不加都一樣，加這個語句，上面的for循環後R[m]是最小的了，如果R[i]不是最小的， 即m!=i，所以要交換，交換後R[i]最小，如果R[i]本是最小的，通過if(m!=i) 語句可以不執行直接執行下面的語句，不執行交換的

『肆』 選擇排序演算法的思想是什麼

次序關系，採用分治策略，可在最壞的情況下用O(log n)完成搜索任務。它的基本思想是，將n個元素分成個數大致相同的兩半，取a[n/2]與欲查找的x作比較，如果x=a[n/2]則找到x，演算法終止。如果x<a[n/2]，則我們只要在數組a的左半部繼續搜索x（這里假設數組元素呈升序排列）。如果x>a[n/2]，則我們只要在數組a的右半部繼續搜索x。二分搜索法的應用極其廣泛，而且它的思想易於理解，但是要寫一個正確的二分搜索演算法也不是一件簡單的事。第一個二分搜索演算法早在1946年就出現了，但是第一個完全正確的二分搜索演算法直到1962年才出現。Bentley在他的著作《Writing Correct Programs》中寫道，90%的計算機專家不能在2小時內寫出完全正確的二分搜索演算法。問題的關鍵在於准確地制定各次查找范圍的邊界以及終止條件的確定，正確地歸納奇偶數的各種情況，其實整理後可以發現它的具體演算法是很直觀的，我們可用C++描述如下：

template<class Type>

int BinarySearch(Type a[],const Type& x,int n)

{

int left=0;

int right=n-1;

while(left<=right){

int middle=(left+right)/2;

if (x==a[middle]) return middle;

if (x>a[middle]) left=middle+1;

else right=middle-1;

}

return -1;

}

模板函數BinarySearch在a[0]<=a[1]<=...<=a[n-1]共n個升序排列的元素中搜索x,找到x時返回其在數組中的位置，否則返回-1。容易看出，每執行一次while循環，待搜索數組的大小減少一半,因此整個演算法在最壞情況下的時間復雜度為O(log n)。在數據量很大的時候，它的線性查找在時間復雜度上的優劣一目瞭然。
選擇排序
基本思想是：每次選出第i小的記錄，放在第i個位置（i的起點是0，按此說法，第0小的記錄實際上就是最小的，有點別扭，不管這么多了）。當i＝N－1時就排完了。

直接選擇排序
直選排序簡單的再現了選擇排序的基本思想，第一次尋找最小元素的代價是O(n)，如果不做某種特殊處理，每次都使用最簡單的尋找方法，自然的整個排序的時間復雜度就是O(n2)了。

冒泡法
為了在a[1]中得到最大值，我們將a[1]與它後面的元素a[2]，a[3]，...，a[10]進行比較。首先比較a[1]與a[2]，如果a[1]<a[2]，則將a[1]與a[2]交換，否則不交換。這樣在a[1]中得到的是a[1]與a[2]中的大數。然後將a[1]與a[3]比較，如果a[1]<a[3]，則將a[1]與a[3]交換，否則不交換。這樣在a[1]中得到的是a[1]，a[2]，a[3]中的最大值，...。如此繼續，最後a[1]與a[10]比較，如果a[1]<a[10]，則將a[1]與a[10]交換，否則不交換。這樣在a[1]中得到的數就是數組a的最大值（一共進行了9次比較）。

為了在a[2]中得到次大值，應將a[2]與它後面的元素a[3]，a[4]，...，a[10]進行比較。這樣經過8次比較，在a[2]是將得到次大值。

如此繼續，直到最後a[9]與a[10]比較，將大數放於a[9]，小數放於a[10]，全部排序到此結束。
從上面可以看出，對於10個數，需進行9趟比較，每一趟的比較次數是不一樣的。第一趟需比較9次，第二趟比較8次，...，最後一趟比較1次。

以上數組元素的排序，用二重循環實現，外循環變數設為i，內循環變數設為j。外循環重復9次，內循環依次重復9，8，...，1次。每次進行比較的兩個元素，第一個元素與外循環i有關的，用a[i]標識，第二個元素是與內循環j有關的，用a[j]標識，i的值依次為1,2,...,9，對於每一個i, j的值依次為i+1,i+2,...。

『伍』 選擇排序演算法與冒泡排序演算法有何異同啊

區別在於：在交換的方式上

冒泡演算法，每次比較如果發現較小的元素在後面，就交換兩個相鄰的元素。

而選擇排序演算法的改進在於：先並不急於調換位置，先從A[1]開始逐個檢查，看哪個數最小就記下該數所在的位置P，等一躺掃描完畢，再把A[P]和A[1]對調，這時A[1]到A[10]中最小的數據就換到了最前面的位置。

所以，選擇排序每掃描一遍數組，只需要一次真正的交換，而冒泡可能需要很多次。比較的次數一樣的。

例如：1 2 3 4我們分別用a[0],a[1],a[2],a[3]存儲。假設從大到小排序

選擇排序，是a[0]和a[1],a[2],a[3]依次比較，遇到小的就交換，這樣一次下來，最大的被保存在了a[0].下次排序就從a[1]開始重復以上步驟。

冒泡排序，是a[0]和a[1]比較，小的就交換。然後a[1]和a[2]比較，小的交換。然後a[2]和a[3]比較小的就交換。這樣一次下來，最大的被保存在a[0]。下次排序從a[1]開始重復以上步驟。

雖然差不多，但是請注意：兩者的比較方法是右差別的，一個事依次比下來，一個是倆倆比較。

(5)選擇排序演算法擴展閱讀：

冒泡排序的基本思想是將數組中的每個相鄰元素進行兩兩比較，按照小元素在前（或大元素在前）的原則確定是否進行交換。這樣每一輪執行之後，最大（或最小）的元素就會被交換到了最後一位。

同樣的過程會依次進行，直到所有元素都被排列成預期的順序為止。這個過程是不是很像是水中的起泡一個個冒起來的過程.

選擇排序(select sort):每一趟從待排序的數據元素中選出最小（或最大）的一個元素，順序放在已排好序的數列的最後，直到全部待排序的數據元素排完。 選擇排序是不穩定的排序方法。

『陸』 選擇排序演算法的思想是什麼

選擇排序=選擇最小放前面

『柒』 VB 關於選擇排序演算法

'在窗體上增加控制項command1,label1，然後復制以下代碼

Option Explicit
Dim a(9) As Long
Private Sub Command1_Click()
Dim i As Long, l As Long, n As Long
Dim j As Long, s As String
For i = 0 To 9 '使用選擇排序法排序，每次選擇最小的數值。
For l = i To 9
If a(i) > a(l) Then
n = a(i)
a(i) = a(l)
a(l) = n
End If
Next l
Print a(i)
s = ""
For j = 0 To 9
s = s & a(j) & vbNewLine
Next
MsgBox s, vbInformation, "階段排序情況"
Next i
End Sub
Private Sub Form_Load()
a(0) = 564 '給數組a中個數組元素賦值。
a(1) = 78
a(2) = 45
a(3) = 456412
a(4) = 456
a(5) = 1
a(6) = 45 + 79
a(7) = 12
a(8) = 1 * 966
a(9) = 65 / 5
Dim i As Long
For i = 0 To 9
Label1.Caption = Label1.Caption & "第" & CStr(i + 1) & "是：" & CStr(a(i)) & " "
Next i
End Sub

『捌』 求 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;

}

『玖』 選擇排序演算法

#include<stdio.h>
int main(){
int n,k,i,j,m;
int a[100];

scanf("%d",&n);
for(i=0;i<n;i++){
scanf("%d",&a[i]);
}
for(i=0;i<n-1;i++){
for(j=i+1;j<n;j++){
if(a[i]>a[j]){
k=a[j];
a[j]=a[i];
a[i]=k;
}
}
}
for(i=0;i<n;i++){
printf("%d ",a[i]);
}

return 1;
}