排序算法

插入排序：

插入排序的核心思想是为第i个元素找到合适的位置。

在升序排序中，第i+1个元素会逐个和前i个元素相比较，若其小于第j（k<=i）个元素，则将第j个元素后移成为第j+1个元素，其继续喝第j-1个元素相比；若其小于第j个元素，则将之置于j+1个元素的位置。

这种排序比较适用于待排元素个数较少的情况，也比较适用于待排元素已经基本有序的情况。

#ifndef insertion_sort_h#define insertion_sort_h#include "printf_array.h"void insertion_sort(int *a, int n);#endif

#include "insertion_sort.h"void insertion_sort(int *a, int n){int j = 0;int key = 0;for(int i = 1; i < n; i++){key = a[i];j = i - 1;while(j >= 0 && a[j] > key){a[j + 1] = a[j];j--;}a[j + 1] = key;}}

归并排序：

这是一种典型的使用分而治之思想的排序算法。他将待排元素一分为二，分别对这两部分进行排序，然后再将已排序的两部分进行合并，这样合并后的元素就是有序的了；而一分为二的每部分元素都会按照这种思想执行下去，直到被分的元素只有一个为止。

在合并的过程中要为待合并的两部分元素分配空间，这里实际分配的空间比所需要的空间大了一个，是用了编程上的技巧来简化合并过程。

这种排序方法的执行时间是nlg（n），但是需要额外的空间代价，这种排序方法比较适合于待排元素较多，且对程序运行空间较为充足的情况。

#ifndef merge_sort_h#define merge_sort_h#include <stdlib.h>#include "printf_array.h"void real_merge(int *a, int p, int r);void merge(int *a, int p, int q, int r);void merge_sort(int *a, int n);#endif

#include "merge_sort.h"void merge_sort(int *a, int n){real_merge(a, 0, n - 1);}void real_merge(int *a, int p, int r){int q =  0 ;if(p < r){q = (p + r) / 2;real_merge(a, p, q);real_merge(a, q + 1, r);merge(a, p, q, r);}}

</pre><pre code_snippet_id="447850" snippet_file_name="blog_20140811_10_706962" name="code" class="cpp">void merge(int *a, int p, int q, int r){int n1 = q - p + 1 +1;int n2 = r - q + 1;int *L = (int *)malloc(n1* sizeof(int));int *R = (int *)malloc(n2* sizeof(int));for(int i = 0; i < n1 - 1; i++)L[i] = a[p + i];for(int i = 0; i < n2 - 1; i++)R[i] = a[q + i + 1];L[n1 - 1] = 65536;R[n2 - 1] = 65536;for(int i = 0, j = 0, k = p; k <= r; k++){if(L[i] <= R[j]){a[k] = L[i];i++;}else{a[k] = R[j];j++;}}free(L);free(R);}

选择排序：

这种排序的核心思想是为第i个位置找到合适的元素，和插入排序的思想相反。

第i个元素会逐个和后n-i个元素相比较，找出本次比较中最小的元素，将第i个元素和其交换位置。

适用于待排元素个数较少的情况。

#ifndef selection_sort_h#define selection_sort_h#include "myswap.h"#include "printf_array.h"void selection_sort(int *a,int n);#endif

#include "selection_sort.h"void selection_sort(int *a,int n){int i=0,j=0;int temp=0;int k=0;for(i=0;i<n-1;i++){temp=a[i];for(j=i+1;j<n;j++){if(temp>a[j]){k=j;temp=a[j];}}if(temp!=a[i])swap(a[i],a[k]);}}

堆排序：

最大堆的性质：节点i大于等于其左右两个子节点。

最大堆化是维护了最大堆的性质，它假设节点i的左右两个子堆都满足了最大堆的性质，对节点i的处理过程。

建立最大堆是从第n/2个元素到第一个元素逐个调用最大堆化的过程，结束后将建立一个最大堆。

堆排序首先调用建立最大堆，建立一个最大堆，然后将堆顶元素和堆中最后一个元素置换，再对堆顶元素调用最大堆化，直到堆的长度为0.

最大堆适用于找出堆中最大的m个元素问题。

其实若m的个数小于lgn，则用直接查找的方法会更快。

#ifndef HEAP_SORT_H#define HEAP_SORT_Hvoid max_heapify(int *a, int i, int heap_length);void build_max_heap(int *a, int n);void heap_sort(int *a, int n);#endif

#include "heap_sort.h"#include "myswap.h"void heap_sort(int *a, int n){int heap_length = n;build_max_heap(a, n);for(int i = n-1; i > 0; i--){swap(a[0], a[i]);heap_length--;max_heapify(a, 0, heap_length);}}void build_max_heap(int *a, int n){for(int i = (n - 1) / 2; i >= 0; i--){max_heapify(a, i, n);}}void max_heapify(int *a, int i, int heap_length){int max_index = i;int left_child_index = 2 * i + 1, right_child_index = 2 *(i + 1);if(left_child_index < heap_length && a[left_child_index] > a[i] )max_index = left_child_index;if(right_child_index < heap_length && a[right_child_index] > a[max_index])max_index = right_child_index;if(max_index  != i){swap(a[i], a[max_index]);max_heapify(a, max_index, heap_length);}}

快速排序：

快速排序的核心思想是找到指定元素的最终位置，并将小于该元素的元素置于其左边，大于该元素的元素置于其右边；两边的元素也都会按照这种思想执行下去，直到只剩下一个元素。

放置指定元素两边的元素的过程需要将所有元素分为三个区域：比指定元素小的，比指定元素大的，待划分的。

这种排序方法适用于待排元素较多，且严重无序的情况。

这种排序方法稍加修改便可作为快速找到第i小元素的方法。

#ifndef QUICK_SORT_H#define QUICK_SORT_Hvoid quick_sort(int *a, int n);void real_quick_sort(int *a, int start_index, int end_index);int randomized_partition(int *a, int start_index, int end_index);int partition(int *a, int start_index, int end_index);int ramdom(int start_index, int end_index);#endif

#include "quick_sort.h"#include "myswap.h"#include <stdlib.h>#include <time.h>void quick_sort(int *a, int n){real_quick_sort(a, 0, n-1);}void real_quick_sort(int *a, int start_index, int end_index){int pivot = 0;if(start_index < end_index){pivot = randomized_partition(a, start_index, end_index);real_quick_sort(a, start_index, pivot-1);real_quick_sort(a, pivot+1, end_index);}}int randomized_partition(int *a, int start_index, int end_index){int pivot = 0;pivot = ramdom(start_index, end_index);swap(a[pivot], a[end_index]);return partition(a, start_index, end_index);}int partition(int *a, int start_index, int end_index){int key = a[end_index];int i = start_index - 1;for(int j = i + 1; j < end_index; j++){if(a[j] <= key){i++;swap(a[i], a[j]);}}swap(a[i+1], a[end_index]);return i + 1;}int ramdom(int start_index, int end_index){srand(time(0));return rand() % (end_index - start_index) + start_index;}

计数排序：

计数排序的核心思想是找到每个元素之前的元素个数，再将它们一一列出。

1.要找出待排元素的最大元素，并创建一个比其大一的空间。

2.找出每个元素的个数。

3.找出小于等于元素x的个数。

4.依次列出元素

#ifndef COUNTING_SORT_H#define COUNTING_SORT_Hvoid counting_sort(int *a, int n);int find_max_num(int *a, int n);#endif

#include "counting_sort.h"#include <stdlib.h>void counting_sort(int *a, int n){int *b, *c;int length  = find_max_num(a, n) + 1;b = (int *)malloc(n * sizeof(int));c = (int *)malloc(length * sizeof(int));for(int i = 0; i < length; i++ ){c[i] = 0;}for(int i = 0; i < n; i++){c[a[i]]++;}for(int i = 1; i < length; i++){c[i] += c[i - 1];}while(c[0] > 0){b[c[0] - 1] = 0;c[0]--;}for(int i = 1; i < length; i++){while((c[i] - c[i - 1]) > 0){b[c[i] - 1] = i;c[i]--;}}for(int i = 0; i < n; i++){a[i] = b[i];}free(b);free(c);}int find_max_num(int *a, int n){int max_num = a[0];for(int i = 1; i < n; i++){if(max_num < a[i]){max_num = a[i];}}return max_num;}

#ifndef sort_verification_h#define sort_verification_h#include <stdio.h>#include <stdlib.h>#include <time.h>#include "printf_array.h"enum {length=8};int do_sort_verifition(int *a,int length,int order);void sort_verification(char *str, void (*sort)(int *a,int n) );#endif

#include "sort_verification.h"void sort_verification(char *str, void (*sort)(int *a,int n) ){printf("verifing %s :",str);int flag=0;srand((unsigned int)time(NULL));for(int i=0;i<100;i++){int a[length]={0};for(int i=0;i<length;i++)a[i]=rand()%100;//printf_array("before", a, length);sort(a,length);//printf_array("after", a, length);flag=do_sort_verifition(a,length,1);if(flag==0){printf("you are fail in %s\n",str);break;}}if(flag)printf("you are sucess in %s\n",str);}// order equals 1 indicate ascending should be verified int do_sort_verifition(int *a,int length,int order){if(order){for(int i=0;i<length-1;i++)if(a[i]>a[i+1])return 0;return 1;}else{for(int i=0;i<length-1;i++)if(a[i]<a[i+1])return 0;return 1;}}

#ifndef myswap_h#define myswap_hvoid swap(int &a,int &b);#endif

#include "myswap.h"void swap(int &a,int &b){int temp;temp=a;a=b;b=temp;}

#ifndef printf_array_h#define printf_array_h#include <stdio.h>void printf_array(char *str, int *a,int length);#endif

#include "printf_array.h"void printf_array(char *str, int *a,int length){printf("\n%s:", str);for(int i = 0;i < length;i++){printf("\t%d",a[i]);}printf("\n");}

#include "sort_verification.h"#include "selection_sort.h"#include "insertion_sort.h"#include "merge_sort.h"#include "heap_sort.h"#include "quick_sort.h"#include "counting_sort.h"int main(int argc, char* argv[]){sort_verification("selection_sort", selection_sort);sort_verification("insertion_sort", insertion_sort);sort_verification("merge_sort", merge_sort);sort_verification("heap_sort", heap_sort);sort_verification("quick_sort", quick_sort);sort_verification("counting_sort", counting_sort);return 0;}