幾種簡單排序演算法

標籤：style   blog   http   color   os   ar   for   sp   div   

最簡單的排序演算法——冒泡排序:

 1 void bubble_sort(int *arr, int len) 2 { 3    int up, down; 4    for(up = 0; up != len; ++ up) 5    { 6        for(down = 0; down != len - up - 1; ++ down) 7        { 8            if(arr[down] > arr[down + 1]) 9                swap(arr[down], arr[down + 1]);10        }11    }12 }

View Code

還有一種思路，就是從頭排到尾，再從尾排到前，這樣的做法與上面的做法時間複雜度是一樣的，在這裡就不予以實現了。

 

當數組元素不多時，較快捷的排序演算法就是——插入排序，實現代碼如下:

void insert_sort(int *arr, int len){    int pos, index, key;    for(pos = 1; pos != len; ++ pos)    {        key = arr[pos];        for(index = pos - 1; index >= 0; -- index)        {            if(arr[index] > key)                arr[index + 1] = arr[index];            else                break;        }        arr[index + 1] = key;    }}

View Code

插入排序是將數組從開頭開始變成一小段有序序列，再將下一個元素插入適當的位置，使數組變為一個長度加1的有序序列，這樣做便無需每次都遍曆一邊整個數組了。

同樣的情況下，另一種較快捷的排序演算法是——選擇排序，實現代碼如下:

void select_sort(int *arr, int len){    int index, pos, min;    for(pos = 0; pos != len; ++ pos)    {        min = pos;        for(index = pos + 1; index != len; ++ index)        {            if(arr[min] > arr[index])                min = index;        }        if(min != pos)            swap(arr[min], arr[pos]);    }}

View Code

選擇排序較快捷的地方是:無需每次都交換元素，這樣為系統節省了一部分交換元素的步驟。

 

在數組元素較多時，快速排序就是一種不錯的選擇。

第一種實現代碼如下:

static int func1(int *arr, int low, int high)       //普通方法{    int key = arr[low];    while(low < high)    {        while(low < high && arr[high] >= key)            -- high;        if(low >= high)            break;        else            swap(arr[high], arr[low]);        while(low < high && arr[low] <= key)            ++ low;        if(low < high)            swap(arr[high], arr[low]);    }    return low;}void quick_sort(int *arr, int len){    if(len <= 10)        insert_sort(arr, len);    else    {        int index = func1(arr, 0, len - 1);        quick_sort(arr, index + 1);        quick_sort(arr + index + 1, len - index - 2);    }}

View Code

該種實現，主要是依靠遞迴方法，每次將數組分成兩部分，前面的部分都比中間元素小，後面的部分都比中間元素大，這樣，遞迴到最後，這個數組便成為一個有序序列。

第二種實現代碼如下:

static int func2(int *arr, int low, int high)       //快慢指標{    int fast = low + 1, last = low;    int key = arr[low];    for(; fast <= high; ++ fast)    {        if(arr[fast] < key)        {            swap(arr[last + 1], arr[fast]);            ++ last;        }    }    swap(arr[low], arr[last]);    return last;}void quick_sort(int *arr, int len){    if(len <= 10)        insert_sort(arr, len);    else    {        int index = func2(arr, 0, len - 1);        quick_sort(arr, index + 1);        quick_sort(arr + index + 1, len - index - 2);    }}

View Code

該種是先，主要是依靠快慢指標的方法，每次快指標的元素比key小時，將快指標與慢指標的下一個元素交換，這樣，快指標指向的元素始終都比key大，慢指標指向的元素，始終都比key小，最後再將arr[low]與慢指標交換，這樣，key又一次變成了中間值，思路與普通方法一樣，實現方法有一些改進。

 

 

堆排序，就是每一次將數組建立成堆，這樣最大的元素始終在最前面，然後我們將該元素與相應的後面元素交換，即可得到有序序列。

堆排序實現代碼如下:

static void func(int *arr, int low, int high){    int index;    int key = arr[low];    for(index = 2 * low + 1; index <= high; index = 2 * index + 1)    {        if(index < high && arr[index] < arr[index + 1])            ++ index;        if(key > arr[index])            break;        arr[low] = arr[index];        low = index;    }    arr[low] = key;}void heap_sort(int *arr, int len){    if(len <= 10)        insert_sort(arr, len);    else    {        int index;        for(index = (len - 2) / 2; index >= 0; -- index)            func(arr, index, len - 1);        for(index = len - 1; index > 0; -- index)        {            swap(arr[0], arr[index]);            func(arr, 0, index - 1);        }    }}

View Code

建立成堆的方法，就是將元素下標每次乘2，得到最低層的值，將低層中較大的值與父值比較，若比父值大，則將該值賦給父值，否則退出，將key儲存的父值賦到當前下標的元素。

由於演算法部分有些地方比較難以理解，所以目前只能簡單寫出這幾種演算法，當然也可能有不完善的地方，以後會慢慢改進。

幾種簡單排序演算法