c/c++排序算法-選擇排序

簡單的選擇排序

基本思想

在要排序的一組數中，選出最小（或者最大）的一個數與第1個位置的數交換；然後在剩下的數當中再找最小（或者最大）的與第2個位置的數交換，依次類推，直到第n-1個元素（倒數第二個數）和第n個元素（最後一個數）比較爲止。

#include <stdio.h>

void printfarr(int *buf, unsigned int len,int count)
{
    if (buf == NULL)
    {
        return;
    }
    printf("%d:",count);
    unsigned int i = 0;
    for (i = 0;i < len;i++)
    {
        printf("%d ", buf[i]);
    }
    printf("\n");
}

unsigned int SelectSmall(int *arr,unsigned int len,unsigned int n)
{
    int min = arr[n];
    unsigned int index = n;
    for(unsigned int i = n;i < len;i++)
    {
        if(min > arr[i])
        {
            min = arr[i];
            index = i;
        }
    }
    return index;
}


void SimpleSelectSort(int *arr,unsigned int len)
{
    int count = 0;
    for(unsigned int i = 0;i < len;i++)
    {
        unsigned int key = SelectSmall(arr,len,i);
        if(arr[i] > arr[key])
        {
            //異或法實現兩個數交換
            arr[key] = arr[key] ^ arr[i];
            arr[i] = arr[i] ^ arr[key];
            arr[key] = arr[key] ^ arr[i];
            count++;
            printfarr(arr, len,count);
        }
    }
}

int main()
{
    int arr[] = {9,8,2,6,4,0,3,14,1,7,5,11,10,16,13,15,18};
    SimpleSelectSort(arr,sizeof(arr)/sizeof (arr[0]));
    return 0;
}

運行結果：
1:0 8 2 6 4 9 3 14 1 7 5 11 10 16 13 15 18
2:0 1 2 6 4 9 3 14 8 7 5 11 10 16 13 15 18
3:0 1 2 3 4 9 6 14 8 7 5 11 10 16 13 15 18
4:0 1 2 3 4 5 6 14 8 7 9 11 10 16 13 15 18
5:0 1 2 3 4 5 6 7 8 14 9 11 10 16 13 15 18
6:0 1 2 3 4 5 6 7 8 9 14 11 10 16 13 15 18
7:0 1 2 3 4 5 6 7 8 9 10 11 14 16 13 15 18
8:0 1 2 3 4 5 6 7 8 9 10 11 13 16 14 15 18
9:0 1 2 3 4 5 6 7 8 9 10 11 13 14 16 15 18
10:0 1 2 3 4 5 6 7 8 9 10 11 13 14 15 16 18

操作方法：

第一趟，從n 個記錄中找出關鍵碼最小的記錄與第一個記錄交換；
第二趟，從第二個記錄開始的n-1 個記錄中再選出關鍵碼最小的記錄與第二個記錄交換；
以此類推…
第i 趟，則從第i 個記錄開始的n-i+1 個記錄中選出關鍵碼最小的記錄與第i 個記錄交換，
直到整個序列按關鍵碼有序。

時間複雜度分析

簡單選擇排序是一個穩定的排序算法，它最大的特點就是交換移動數據次數相當少，無論最好最差的情況，其比較次數都是一樣的多，第 $i$ 趟排序需要進行 $n-i$ 次關鍵字的比較，
$\sum_{i=1}^{n-1} (n - i) = (n-1) + (n-2) + (n-3) + …… + 1 = \frac{n(n - 1)}{2}$
交換次數最好的時候是 $0$ 次，最差的時候是 $\frac{n}{2}$ 次，總的時間複雜度是$O(n^2)$

二元選擇排序（簡單選擇排序的改進版）

簡單選擇排序，每趟循環只能確定一個元素排序後的定位。我們可以考慮改進爲每趟循環確定兩個元素（當前趟最大和最小記錄）的位置,從而減少排序所需的循環次數。改進後對n個數據進行排序，最多隻需進行[n/2]趟循環即可。具體實現如下：

#include <stdio.h>

struct arrIndex{
    unsigned int minIndex;
    unsigned int maxIndex;
};

void printfarr(int *buf, unsigned int len,int count)
{
    if (buf == NULL)
    {
        return;
    }
    printf("%d:",count);
    unsigned int i = 0;
    for (i = 0;i < len;i++)
    {
        printf("%d ", buf[i]);
    }
    printf("\n");
}

void SelectSmall(int *arr,unsigned int len,unsigned int n,struct arrIndex *index_t)
{
    int min = arr[n];
    int max = arr[n];
    index_t->maxIndex = n;
    index_t->minIndex = n;
    for(unsigned int i = n;i < len;i++)
    {
        if(min > arr[i])
        {
            min = arr[i];
            index_t->minIndex = i;
            continue;
        }
        if(max < arr[i])
        {
            max = arr[i];
            index_t->maxIndex = i;
        }
    }
}


void SelectSort(int *arr,unsigned int len)
{
    int count = 0;
    unsigned key = len;
    struct arrIndex index_t;
    for(unsigned int i = 0;i <= len/2;i++)
    {
        SelectSmall(arr,key,i,&index_t);
        key = key - 1;
        printfarr(arr, len,count);
        printf("min = %d,max = %d\n",arr[index_t.minIndex],arr[index_t.maxIndex]);
        if(arr[index_t.minIndex] == arr[index_t.maxIndex])
        {
            break;
        }
        if(arr[i] > arr[index_t.minIndex])
        {
            //異或法實現兩個數交換
            arr[index_t.minIndex] = arr[index_t.minIndex] ^ arr[i];
            arr[i] = arr[i] ^ arr[index_t.minIndex];
            arr[index_t.minIndex] = arr[index_t.minIndex] ^ arr[i];
        }
        if(arr[len - i - 1] < arr[index_t.maxIndex])
        {
            //異或法實現兩個數交換
            arr[index_t.maxIndex] = arr[index_t.maxIndex] ^ arr[len - i - 1];
            arr[len - i - 1] = arr[len - i - 1] ^ arr[index_t.maxIndex];
            arr[index_t.maxIndex] = arr[index_t.maxIndex] ^ arr[len - i - 1];
        }
        count++;
    }
}

int main()
{
    int arr[] = {9,8,2,6,4,0,3,14,1,7,5,11,10,16,13,15,18};
    SelectSort(arr,sizeof(arr)/sizeof (arr[0]));
    return 0;
}

運行結果：
0:9 8 2 6 4 0 3 14 1 7 5 11 10 16 13 15 18
min = 0,max = 18
1:0 8 2 6 4 9 3 14 1 7 5 11 10 16 13 15 18
min = 1,max = 16
2:0 1 2 6 4 9 3 14 8 7 5 11 10 15 13 16 18
min = 2,max = 15
3:0 1 2 6 4 9 3 14 8 7 5 11 10 13 15 16 18
min = 3,max = 14
4:0 1 2 3 4 9 6 13 8 7 5 11 10 14 15 16 18
min = 4,max = 13
5:0 1 2 3 4 9 6 10 8 7 5 11 13 14 15 16 18
min = 5,max = 11
6:0 1 2 3 4 5 6 10 8 7 9 11 13 14 15 16 18
min = 6,max = 10
7:0 1 2 3 4 5 6 9 8 7 10 11 13 14 15 16 18
min = 7,max = 9
8:0 1 2 3 4 5 6 7 8 9 10 11 13 14 15 16 18
min = 8,max = 8