常见简单排序算法的实现

常见简单排序算法的实现

一、冒泡排序

实现思想： 依次比较相邻的两个数，将小数放在前面，大数放在后面。

void BubbleSort(int array[], int len){    bool isSwap; // the flag: break     for(int i = 1; i < len; i++){ //compare len-1 loop          isSwap = false;        for(int j = 0; j < len  - i; j++){              if(array[j] > array[j+1]){  //swap                int temp = array[j];                array[j] = array[j+1];                array[j+1] = temp;                isSwap = true;            }        }        if(!isSwap) break;    }}

分析：冒泡排序算法的时间复杂性为O(n^2），属于稳定的排序方法。

二、选择排序

实现思想：每一次从待排序的数据元素中选出最小的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

void SelectionSort(int array[], int len){    int index;    //find the minValue to ith position     for(int i = 0; i < len - 1; i++){         index = i;        for(int j = i + 1; j < len; j++){               if(array[index] > array[j]){                  index = j; //update index of the min number            }        }        if(index != i){            int temp = array[i];            array[i] = array[index];            array[index] = temp;        }    }}

分析： 选择排序算法的时间复杂性为O(n^2），属于不稳定的排序方法。

三、插入排序

实现思路： 每步将一个待排序的纪录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。

void InsertSort(int unsorted[], int len){    for(int i = 1; i < len; i++){        if(unsorted[i-1] > unsorted[i]){            int temp = unsorted[i];            int j = i;            while(unsorted[j-1] > temp && j > 0){                 //move 1 step to right                unsorted[j] = unsorted[j-1];                 j--;            }            unsorted[j] = temp;        }    }}

分析： 插入排序算法的时间复杂性为O(n^2），属于稳定的排序方法。

四、桶排序

实现思路： 简单的桶排序，适用于正整数且上界不大的数组排序。此处的映射直接是直接线性的。

#define MAX 1000 void BucketSort(int array[], int len){    int buket[MAX];    memset(buket,0,sizeof(buket));    for(int i = 0; i < len; i++){        buket[array[i]]++;    }    int j = 0;    for(int i = 0; i < MAX; i++){        while(buket[i]--){            array[j++] = i;        }    }}

分析： 这个简单的桶排序时间复杂度是O(N)，空间复杂度为O(N)。

五、基数排序

实现思路： LSD法:先从kd开始排序，再对kd-1进行排序，依次重复，直到对k1排序后便得到一个有序序列。即元素从个位排好序，然后再从十位排好序，…直到最高位排序完成。

void RadixSort(vector<int> &v, int d, int size){    int i, j, digit = 1;    queue<int> digitQueue[10]; //对应位的队列    for(i = 0; i < d; i++){        for(j = 0; j < size; j++){            digitQueue[(v[j] / digit)%10].push(v[j]);        }        j = 0;        for(int digitValue = 0; digitValue < 10; digitValue++){            while(!digitQueue[digitValue].empty()){                v[j] = digitQueue[digitValue].front();                digitQueue[digitValue].pop();                j++;            }        }        cout <<"经过第 " << i << " 次排序的结果如下:" << endl;        for(j = 0; j < size; j++){            cout << v[j] << " ";        }        cout << endl;        digit *= 10;    } }

分析： ，基数排序法的时间复杂度为O (nlog(r)m)，其中r为所采取的基数，而m为堆数。属于稳定性的排序。