1. void insertion_sort(int array[], int first, int last)
2. {
3. int i,j;
4. int temp;
5. for (i = first+1; i<=last;i++)
6. {
7. temp = array[i];
8. j=i-1;
9. //与已排序的数逐一比较，大于temp时，该数后移
10. while((j>=first) && (array[j] > temp))  //当first=0，j循环到-1时，由于[[短路求值]]，不会运算array[-1]
11. {
12. array[j+1] = array[j];
13. j--;
14. }
15. array[j+1] = temp;      //被排序数放到正确的位置
16. }
17. }

1. template<typename T>
2. struct list_node
3. {
4. struct list_node<T> *next;
5. T value;
6. };
7. template<typename T>
8. struct _list
9. {
10. struct list_node<T> *head;
11. int size;
12. };
13. template<typename T>
14. void SortLink(struct _list<T> * link) {
15. struct list_node<T> *pHead,*pRear,*p,*tp;
16. if (!link) return;
17. for (pHead=link->head,pRear=0;pHead;pHead=pHead->next) {
18. for (tp=pHead,p=pHead->next;p;tp=p,p=p->next)
19. if (pHead->value>=p->value)
20. tp->next=p->next,p->next=pHead,pHead=p,p=tp;
21. if (!pRear) link->head=pHead;
22. else pRear->next=pHead;
23. pRear=pHead;
24. }
25. }

1. void BinInsertSort(int a[], int n)
2. {
3. int key, left, right, middle;
4. for (int i=1; i<n; i++)
5. {
6. key = a[i];
7. left = 0;
8. right = i-1;
9. while (left<=right)
10. {
11. middle = (left+right)/2;
12. if (a[middle]>key)
13. right = middle-1;
14. else
15. left = middle+1;
16. }
17. for(int j=i-1; j>=left; j--)
18. {
19. a[j+1] = a[j];
20. }
21. a[left] = key;
22. }
23. }

1. #include <stdio.h>
2. int main()
3. {
4. const int n = 5;
5. int i, j, temp;
6. int gap = 0;
7. int a[] = {5, 4, 3, 2, 1};
8. while (gap<=n)
9. {
10. gap = gap * 3 + 1;
11. }
12. while (gap > 0)
13. {
14. for ( i = gap; i < n; i++ )
15. {
16. j = i - gap;
17. temp = a[i];
18. while (( j >= 0 ) && ( a[j] > temp ))
19. {
20. a[j + gap] = a[j];
21. j = j - gap;
22. }
23. a[j + gap] = temp;
24. }
25. gap = ( gap - 1 ) / 3;
26. }
27. }

1. void selection_sort(int *a, int len)
2. {
3. register int i, j, min, t;
4. for(i = 0; i < len - 1; i ++)
5. {
6. min = i;
7. //查找最小值
8. for(j = i + 1; j < len; j ++)
9. if(a[min] > a[j])
10. min = j;
11. //交换
12. if(min != i)
13. {
14. t = a[min];
15. a[min] = a[i];
16. a[i] = t;
17. }
18. }
19. }

1. #include <stdio.h>
2. void bubbleSort(int arr[], int count)
3. {
4. int i = count, j;
5. int temp;
6. while(i > 0)
7. {
8. for(j = 0; j < i - 1; j++)
9. {
10. if(arr[j] > arr[j + 1])
11. {   temp = arr[j];
12. arr[j] = arr[j + 1];
13. arr[j + 1] = temp;
14. }
15. }
16. i--;
17. }
18. }
19. int main()
20. {
21. //测试数据
22. int arr[] = {5, 4, 1, 3, 6};
23. //冒泡排序
24. bubbleSort(arr, 5);
25. //打印排序结果
26. int i;
27. for(i = 0; i < 5; i++)
28. printf("%4d", arr[i]);
29. }

1. #include <stdio.h>
2. #include <string.h>
3. //题目以及要求：把一个字符串的大写字母放到字符串的后面，
4. //各个字符的相对位置不变，不能申请额外的空间。
5. //判断是不是大写字母
6. int isUpperAlpha(char c){
7. if(c >= 'A' && c <= 'Z'){
8. return 1;
9. }
10. return 0;
11. }
12. //交换两个字母
13. void swap(char *a, char *b){
14. char temp = *a;
15. *a = *b;
16. *b = temp;
17. }
18. char * mySort(char *arr, int len){
19. if(arr == NULL || len <= 0){
20. return NULL;
21. }
22. int i = 0, j = 0, k = 0;
23. for(i = 0; i < len; i++){
24. for(j = len - 1 - i; j >= 0; j--){
25. if(isUpperAlpha(arr[j])){
26. for(k = j; k < len - i - 1; k++){
27. swap(&arr[k], &arr[k + 1]);
28. }
29. break;
30. }
31. //遍历完了字符数组，但是没发现大写字母，所以没必要再遍历下去
32. if(j == 0 && !isUpperAlpha(arr[j])){
33. //结束;
34. return arr;
35. }
36. }
37. }
38. //over:
39. return arr;
40. }
41. int main(){
42. char arr[] = "aaaaaaaaaaaaaaaaaaaaaaaAbcAdeBbDc";
43. printf("%s\n", mySort(arr, strlen(arr)));
44. return 0;
45. }

1. #include <stdio.h>
2. #include <string.h>
3. //判断是不是大写字母
4. int isUpperAlpha(char c){
5. if(c >= 'A' && c <= 'Z'){
6. return 1;
7. }
8. return 0;
9. }
10. //交换两个字母
11. void swap(char *a, char *b){
12. char temp = *a;
13. *a = *b;
14. *b = temp;
15. }
16. char * Reorder(char *arr, int len){
17. if(arr == NULL || len <= 0){
18. return NULL;
19. }
20. int *p1 = arr;
21. int *p2 = arr;
22. While(p1<arr+len && p2<arr+len){
23. While( isUpperAlpha(*p1) ){
24. P1++;
25. }
26. While( !isUpperAlpha(*p2) ){
27. P2++;
28. }
29. swap(p1, p2)
30. }
31. //结束
32. return arr;
33. }
34. int main(){
35. char arr[] = "aaaaaaaaaaaaaaaaaaaaaaaAbcAdeBbDc";
36. printf("%s\n", Reorder(arr, strlen(arr)));
37. return 0;
38. }

1. void CocktailSort(int *a,int nsize)
2. {
3. int tail=nsize-1;
4. for (int i=0;i<tail;)
5. {
6. for (int j=tail;j>i;--j) //第一轮，先将最小的数据排到前面
7. {
8. if (a[j]<a[j-1])
9. {
10. int temp=a[j];
11. a[j]=a[j-1];
12. a[j-1]=temp;
13. }
14. }
15. ++i;                    //原来i处数据已排好序，加1
16. for (j=i;j<tail;++j)    //第二轮，将最大的数据排到后面
17. {
18. if (a[j]>a[j+1])
19. {
20. int temp=a[j];
21. a[j]=a[j+1];
22. a[j+1]=temp;
23. }
24. }
25. tail--;                 //原tail处数据也已排好序，将其减1
26. }
27. }

1. /**************************************************
2. 函数功能：对数组快速排序
3. 函数参数：指向整型数组arr的首指针arr；
4. 整型变量left和right左右边界的下标
5. 函数返回值：空
6. /**************************************************/
7. void QuickSort(int *arr, int left, int right)
8. {
9. int i,j;
10. if(left<right)
11. {
12. i=left;j=right;
13. arr[0]=arr[i]; //准备以本次最左边的元素值为标准进行划分，先保存其值
14. do
15. {
16. while(arr[j]>arr[0] && i<j)
17. j--;        //从右向左找第1个小于标准值的位置j
18. if(i<j)                               //找到了，位置为j
19. {
20. arr[i] = arr[j];
21. i++;
22. }           //将第j个元素置于左端并重置i
23. while(arr[i]<arr[0] && i<j)
24. i++;      //从左向右找第1个大于标准值的位置i
25. if(i<j)                       //找到了，位置为i
26. {
27. arr[j] = arr[i];
28. j--;
29. }           //将第i个元素置于右端并重置j
30. }while(i!=j);
31. arr[i] = arr[0];         //将标准值放入它的最终位置,本次划分结束
32. quicksort(arr, left, i-1);     //对标准值左半部递归调用本函数
33. quicksort(arr, i+1, right);    //对标准值右半部递归调用本函数
34. }
35. }

1. //使用引用，完成两数交换
2. void Swap(int& a , int& b)
3. {
4. int temp = a;
5. a = b;
6. b = temp;
7. }
8. //取区间内随机数的函数
9. int Rand(int low, int high)
10. {
11. int size = hgh - low + 1;
12. return  low + rand()%size;
13. }
14. //快排的partition算法，这里的基准数是随机选取的
15. int RandPartition(int* data, int low , int high)
16. {
17. swap(data[rand(low,high)], data[low]);//
18. int key = data[low];
19. int i = low;
20. for(int j=low+1; j<=high; j++)
21. {
22. if(data[j]<=key)
23. {
24. i = i+1;
25. swap(data[i], data[j]);
26. }
27. }
28. swap(data[i],data[low]);
29. return i;
30. }
31. //递归完成快速排序
32. void QuickSort(int* data, int low, int high)
33. {
34. if(low<high)
35. {
36. int k = RandPartition(data,low,high);
37. QuickSort(data,low,k-1);
38. QuickSort(data,k+1,high);
39. }
40. }

1. void GetLeastNumbers_by_partition(int* input, int n, int* output, int k)
2. {
3. if(input == NULL || output == NULL || k > n || n <= 0 || k <= 0)
4. return;
5. int start = 0;
6. int end = n - 1;
7. int index = Partition(input, n, start, end);
8. while(index != k - 1)
9. {
10. if(index > k - 1)
11. {
12. end = index - 1;
13. index = Partition(input, n, start, end);
14. }
15. else
16. {
17. start = index + 1;
18. index = Partition(input, n, start, end);
19. }
20. }
21. for(int i = 0; i < k; ++i)
22. output[i] = input[i];
23. }

1. bool g_bInputInvalid = false;
2. bool CheckInvalidArray(int* numbers, int length)
3. {
4. g_bInputInvalid = false;
5. if(numbers == NULL && length <= 0)
6. g_bInputInvalid = true;
7. return g_bInputInvalid;
8. }
9. bool CheckMoreThanHalf(int* numbers, int length, int number)
10. {
11. int times = 0;
12. for(int i = 0; i < length; ++i)
13. {
14. if(numbers[i] == number)
15. times++;
16. }
17. bool isMoreThanHalf = true;
18. if(times * 2 <= length)
19. {
20. g_bInputInvalid = true;
21. isMoreThanHalf = false;
22. }
23. return isMoreThanHalf;
24. }
25. int MoreThanHalfNum_Solution1(int* numbers, int length)
26. {
27. if(CheckInvalidArray(numbers, length))
28. return 0;
29. int middle = length >> 1;
30. int start = 0;
31. int end = length - 1;
32. int index = Partition(numbers, length, start, end);
33. while(index != middle)
34. {
35. if(index > middle)
36. {
37. end = index - 1;
38. index = Partition(numbers, length, start, end);
39. }
40. else
41. {
42. start = index + 1;
43. index = Partition(numbers, length, start, end);
44. }
45. }
46. int result = numbers[middle];
47. if(!CheckMoreThanHalf(numbers, length, result))
48. result = 0;
49. return result;
50. }

1. #include <iostream>
2. using namespace std;
3. void Proc( char *str )
4. {
5. int i = 0;
6. int j = 0;
7. //移动指针i, 使其指向第一个大写字母
8. while( str[i] != '\0' && str[i] >= 'a' && str[i] <= 'z' ) i++;
9. if( str[i] != '\0' )
10. {
11. //指针j遍历未处理的部分，找到第一个小写字母
12. for( j=i; str[j] != '\0'; j++ )
13. {
14. if( str[j] >= 'a' && str[j] <= 'z' )
15. {
16. char tmp = str[i];
17. str[i] = str[j];
18. str[j] = tmp;
19. i++;
20. }
21. }
22. }
23. }
24. int main()
25. {
26. char data[] = "SONGjianGoodBest";
27. Proc( data );
28. return 0;
29. }

1. #include <cstdio>
2. #include <cstdlib>
3. #include <cmath>
4. using namespace std;
5. int parent(int);
6. int left(int);
7. int right(int);
8. void HeapAdjust(int [], int, int);
9. void BuildHeap(int [], int);
10. void print(int [], int);
11. void HeapSort(int [], int);
12. /*返回父节点*/
13. int parent(int i)
14. {
15. return (int)floor((i - 1) / 2);
16. }
17. /*返回左孩子节点*/
18. int left(int i)
19. {
20. return (2 * i + 1);
21. }
22. /*返回右孩子节点*/
23. int right(int i)
24. {
25. return (2 * i + 2);
26. }
27. /*对以某一节点为根的子树做堆调整(保证最大堆性质)*/
28. void HeapAdjust(int A[], int i, int heap_size)
29. {
30. int l = left(i);
31. int r = right(i);
32. int largest;
33. int temp;
34. if(l < heap_size && A[l] > A[i])
35. {
36. largest = l;
37. }
38. else
39. {
40. largest = i;
41. }
42. if(r < heap_size && A[r] > A[largest])
43. {
44. largest = r;
45. }
46. if(largest != i)
47. {
48. temp = A[i];
49. A[i] = A[largest];
50. A[largest] = temp;
51. HeapAdjust(A, largest, heap_size);
52. }
53. }
54. /*建立最大堆*/
55. void BuildHeap(int A[]，int heap_size)
56. {
57. for(int i = (heap_size-2)/2; i >= 0; i--)
58. {
59. HeapAdjust(A, i, heap_size);
60. }
61. }
62. /*输出结果*/
63. void print(int A[]， int heap_size)
64. {
65. for(int i = 0; i < heap_size;i++)
66. {
67. printf("%d ", A[i]);
68. }
69. printf("\n");
70. }
71. /*堆排序*/
72. void HeapSort(int A[], int heap_size)
73. {
74. BuildHeap(A, heap_size);
75. int temp;
76. for(int i = heap_size - 1; i >= 0; i--)
77. {
78. temp = A[0];
79. A[0] = A[i];
80. A[i] = temp;
81. HeapAdjust(A, 0, i);
82. }
83. print(A, heap_size);
84. }
85. /*测试，对给定数组做堆排序*/
86. int main(int argc, char* argv[])
87. {
88. const int heap_size = 13;
89. int A[] = {19, 1, 10, 14, 16, 4, 7, 9, 3, 2, 8, 5, 11};
90. HeapSort(A, heap_size);
91. system("pause");
92. return 0;
93. }

1. #include "stdafx.h"
2. #include <vector>
3. #include <iostream>
4. #include <algorithm>
5. #include <functional> // for greater<>
6. using namespace std;
7. int _tmain(int argc, _TCHAR* argv[])
8. {
9. vector<float> bigs(10000,0);
10. vector<float>::iterator it;
11. // Init vector data
12. for (it = bigs.begin(); it != bigs.end(); it++)
13. {
14. *it = (float)rand()/7; // random values;
15. }
16. cout << bigs.size() << endl;
17. make_heap(bigs.begin(),bigs.end(), greater<float>()); // The first one is the smallest one!
18. float ff;
19. for (int i = 0; i < 1000000000; i++)
20. {
21. ff = (float) rand() / 7;
22. if (ff > bigs.front()) // replace the first one ?
23. {
24. // set the smallest one to the end!
25. pop_heap(bigs.begin(), bigs.end(), greater<float>());
26. // remove the last/smallest one
27. bigs.pop_back();
28. // add to the last one
29. bigs.push_back(ff);
30. // mask heap again, the first one is still the smallest one
31. push_heap(bigs.begin(),bigs.end(),greater<float>());
32. }
33. }
34. // sort by ascent
35. sort_heap(bigs.begin(), bigs.end(), greater<float>());
36. return 0;
37. }

1. //将有二个有序数列a[first...mid]和a[mid...last]合并。
2. void MergeArray(int a[], int first, int mid, int last, int temp[])
3. {
4. int i = first, j = mid + 1;
5. int m = mid,   n = last;
6. int k = 0;
7. while (i <= m && j <= n)
8. {
9. if (a[i] <= a[j])
10. temp[k++] = a[i++];
11. else
12. temp[k++] = a[j++];
13. }
14. while (i <= m)
15. temp[k++] = a[i++];
16. while (j <= n)
17. temp[k++] = a[j++];
18. for (i = 0; i < k; i++)
19. a[first + i] = temp[i];
20. }
21. //递归地完成归并排序
22. void MergeSort(int a[], int first, int last, int temp[])
23. {
24. if (first < last)
25. {
26. int mid = (first + last) / 2;
27. mergesort(a, first, mid, temp);    //左边有序
28. mergesort(a, mid + 1, last, temp); //右边有序
29. mergearray(a, first, mid, last, temp); //再将二个有序数列合并
30. }
31. }

1. #include<iostream>
2. #include<stdlib.h>
3. using namespace std;
4. void printArray(int arry[],int len)
5. {
6. for(int i=0;i<len;i++)
7. cout<<arry[i]<<" ";
8. cout<<endl;
9. }
10. int MergeArray(int arry[],int start,int mid,int end,int temp[])//数组的归并操作
11. {
12. //int leftLen=mid-start+1;//arry[start...mid]左半段长度
13. //int rightLlen=end-mid;//arry[mid+1...end]右半段长度
14. int i=mid;
15. int j=end;
16. int k=0;//临时数组末尾坐标
17. int count=0;
18. //设定两个指针ij分别指向两段有序数组的头元素，将小的那一个放入到临时数组中去。
19. while(i>=start&&j>mid)
20. {
21. if(arry[i]>arry[j])
22. {
23. temp[k++]=arry[i--];//从临时数组的最后一个位置开始排序
24. count+=j-mid;//因为arry[mid+1...j...end]是有序的，如果arry[i]>arry[j]，那么也大于arry[j]之前的元素，从a[mid+1...j]一共有j-(mid+1)+1=j-mid
25. }
26. else
27. {
28. temp[k++]=arry[j--];
29. }
30. }
31. cout<<"调用MergeArray时的count："<<count<<endl;
32. while(i>=start)//表示前半段数组中还有元素未放入临时数组
33. {
34. temp[k++]=arry[i--];
35. }
36. while(j>mid)
37. {
38. temp[k++]=arry[j--];
39. }
40. //将临时数组中的元素写回到原数组当中去。
41. for(i=0;i<k;i++)
42. arry[end-i]=temp[i];
43. printArray(arry,8);//输出进过一次归并以后的数组，用于理解整体过程
44. return count;
45. }
46. int InversePairsCore(int arry[],int start,int end,int temp[])
47. {
48. int inversions = 0;
49. if(start<end)
50. {
51. int mid=(start+end)/2;
52. inversions+=InversePairsCore(arry,start,mid,temp);//找左半段的逆序对数目
53. inversions+=InversePairsCore(arry,mid+1,end,temp);//找右半段的逆序对数目
54. inversions+=MergeArray(arry,start,mid,end,temp);//在找完左右半段逆序对以后两段数组有序，然后找两段之间的逆序对。最小的逆序段只有一个元素。
55. }
56. return inversions;
57. }
58. int InversePairs(int arry[],int len)
59. {
60. int *temp=new int[len];
61. int count=InversePairsCore(arry,0,len-1,temp);
62. delete[] temp;
63. return count;
64. }
65. void main()
66. {
67. //int arry[]={7,5,6,4};
68. int arry[]={1,3,7,8,2,4,6,5};
69. int len=sizeof(arry)/sizeof(int);
70. //printArray(arry,len);
71. int count=InversePairs(arry,len);
72. //printArray(arry,len);
73. //cout<<count<<endl;
74. system("pause");
75. }

1. #include<iostream>
2. #include<cmath>
3. #include<cstdlib>
4. #include<Windows.h>
5. using namespace std;
6. void insert_sort(int arr[],int n)
7. {
8. for(int i=1;i<n;++i)
9. {
10. int val=arr[i];
11. int j=i-1;
12. while(arr[j]>val&&j>=0)
13. {
14. arr[j+1]=arr[j];
15. --j;
16. }
17. arr[j+1]=val;
18. }
19. }
20. void aux_merge(int arr[],int n,int m,int aux[])
21. {
22. for(int i=0;i<m;++i)
23. swap(aux[i],arr[n+i]);
24. int p=n-1,q=m-1;
25. int dst=n+m-1;
26. for(int i=0;i<n+m;++i)
27. {
28. if(p>=0)
29. {
30. if(q>=0)
31. {
32. if(arr[p]>aux[q])
33. {
34. swap(arr[p],arr[dst]);
35. p--;
36. }
37. else
38. {
39. swap(aux[q],arr[dst]);
40. q--;
41. }
42. }
43. else
44. break;
45. }
46. else
47. {
48. swap(aux[q],arr[dst]);
49. q--;
50. }
51. dst--;
52. }
53. }
54. void local_merge(int arr[],int n)
55. {
56. int m=sqrt((float)n);
57. int k=n/m;
58. for(int i=0;i<m;++i)
59. swap(arr[k*m-m+i],arr[n/2/m*m+i]);
60. for(int i=0;i<k-2;++i)
61. {
62. int index=i;
63. for(int j=i+1;j<k-1;++j)
64. if(arr[j*m]<arr[index*m])
65. index=j;
66. if(index!=i)
67. for(int j=0;j<m;++j)
68. swap(arr[i*m+j],arr[index*m+j]);
69. }
70. for(int i=0;i<k-2;++i)
71. aux_merge(arr+i*m,m,m,arr+(k-1)*m);
72. int s=n%m+m;
73. insert_sort(arr+(n-2*s),2*s);
74. aux_merge(arr,n-2*s,s,arr+(k-1)*m);
75. insert_sort(arr+(k-1)*m,s);
76. }
77. void local_merge_sort(int arr[],int n)
78. {
79. if(n<=1)
80. return;
81. if(n<=10)
82. {
83. insert_sort(arr,n);
84. return;
85. }
86. local_merge_sort(arr,n/2);
87. local_merge_sort(arr+n/2,n-n/2);
88. local_merge(arr,n);
89. }
90. void merge_sort(int arr[],int temp[],int n)
91. {
92. if(n<=1)
93. return;
94. if(n<=10)
95. {
96. insert_sort(arr,n);
97. return;
98. }
99. merge_sort(arr,temp,n/2);
100. merge_sort(arr+n/2,temp,n-n/2);
101. for(int i=0;i<n/2;++i)
102. temp[i]=arr[i];
103. for(int i=n/2;i<n;++i)
104. temp[n+n/2-i-1]=arr[i];
105. int left=0,right=n-1;
106. for(int i=0;i<n;++i)
107. if(temp[left]<temp[right])
108. arr[i]=temp[left++];
109. else
110. arr[i]=temp[right--];
111. }
112. const int n=2000000;
113. int arr1[n],arr2[n];
114. int temp[n];
115. int main()
116. {
117. for(int i=0;i<n;++i)
118. arr1[i]=arr2[i]=rand();
119. int begin=GetTickCount();
120. merge_sort(arr1,temp,n);
121. cout<<GetTickCount()-begin<<endl;
122. begin=GetTickCount();
123. local_merge_sort(arr2,n);
124. cout<<GetTickCount()-begin<<endl;
125. for(int i=0;i<n;++i)
126. if(arr1[i]!=arr2[i])
127. cout<<"ERROR"<<endl;
128. system("pause");
129. }

1. #include <time.h>
2. #include <iostream>
3. #include <iomanip>
4. using namespace  std;
5. /*initial arr*/
6. void InitialArr(double *arr,int n)
7. {
8. srand((unsigned)time(NULL));
9. for (int i = 0; i<n;i++)
10. {
11. arr[i] = rand()/double(RAND_MAX+1);   //(0.1)
12. }
13. }
14. /* print arr*/
15. void PrintArr(double *arr,int n)
16. {
17. for (int i = 0;i < n; i++)
18. {
19. cout<<setw(15)<<arr[i];
20. if ((i+1)%5 == 0 || i ==  n-1)
21. {
22. cout<<endl;
23. }
24. }
25. }
26. void BucketSort(double * arr,int n)
27. {
28. double **bucket = new double*[10];
29. for (int i = 0;i<10;i++)
30. {
31. bucket[i] = new double[n];
32. }
33. int count[10] = {0};
34. for (int i = 0 ; i < n ; i++)
35. {
36. double temp = arr[i];
37. int flag = (int)(arr[i]*10); //flag标识小树的第一位
38. bucket[flag][count[flag]] = temp; //用二维数组的每个向量来存放小树第一位相同的数据
39. int j = count[flag]++;
40. /* 利用插入排序对每一行进行排序 */
41. for(;j > 0 && temp < bucket[flag][j - 1]; --j)
42. {
43. bucket[flag][j] = bucket[flag][j-1];
44. }
45. bucket[flag][j] =temp;
46. }
47. /* 所有数据重新链接 */
48. int k=0;
49. for (int i = 0 ; i < 10 ; i++)
50. {
51. for (int j = 0 ; j< count[i];j++)
52. {
53. arr[k] = bucket[i][j];
54. k++;
55. }
56. }
57. for (int i = 0 ; i<10 ;i++)
58. {
59. delete bucket[i];
60. bucket[i] =NULL;
61. }
62. delete []bucket;
63. bucket = NULL;
64. }
65. void main()
66. {
67. double *arr=new double[10];
68. InitialArr(arr, 10);
69. BucketSort(arr, 10);
70. PrintArr(arr,10);
71. delete [] arr;
72. }

1. //距离平均值为offset = (arrayMax - arrayMin) / (n - 1), 则距离最大的数必然大于这个值
2. //每个桶只要记住桶中的最大值和最小值，依次比较上一个桶的最大值与下一个桶的最小值的差值，找最大的即可.
3. #include <iostream>
4. #define MAXSIZE 100    //实数的个数
5. #define MAXNUM 32767
6. using namespace std;
7. struct Barrel
8. {
9. double min;   //桶中最小的数
10. double max;   //桶中最大的数
11. bool flag;   //标记桶中有数
12. };
13. int BarrelOperation(double* array, int n)
14. {
15. Barrel barrel[MAXSIZE];  //实际使用的桶
16. int nBarrel = 0;  //实际使用桶的个数
17. Barrel tmp[MAXSIZE];   //临时桶，用于暂存数据
18. double arrayMax = -MAXNUM, arrayMin = MAXNUM;
19. for(int i = 0; i < n; i++) {
20. if(array[i] > arrayMax)
21. arrayMax = array[i];
22. if(array[i] < arrayMin)
23. arrayMin = array[i];
24. }
25. double offset = (arrayMax - arrayMin) / (n - 1);  //所有数的平均间隔
26. //对桶进行初始化
27. for(i = 0; i < n; i++) {
28. tmp[i].flag = false;
29. tmp[i].max = arrayMin;
30. tmp[i].min = arrayMax;
31. }
32. //对数据进行分桶
33. for(i = 0; i < n; i++) {
34. int pos = (int)((array[i] - arrayMin) / offset);
35. if(!tmp[pos].flag) {
36. tmp[pos].max = tmp[pos].min = array[i];
37. tmp[pos].flag = true;
38. } else {
39. if(array[i] > tmp[pos].max)
40. tmp[pos].max = array[i];
41. if(array[i] < tmp[pos].min)
42. tmp[pos].min = array[i];
43. }
44. }
45. for(i = 0; i <= n; i++) {
46. if(tmp[i].flag)
47. barrel[nBarrel++] = tmp[i];
48. }
49. int maxOffset = 0.0;
50. for(i = 0; i < nBarrel - 1; i++) {
51. if((barrel[i+1].min - barrel[i].max) > maxOffset)
52. maxOffset = barrel[i+1].min - barrel[i].max;
53. }
54. return maxOffset;
55. }
56. int main()
57. {
58. double array[MAXSIZE] = {1, 8, 6, 11, 7, 13, 16, 5};  //所需处理的数据
59. int n = 8; //数的个数
60. //double array[MAXSIZE] = {8, 6, 11};
61. //int n = 3;
62. int maxOffset = BarrelOperation(array, n);
63. cout << maxOffset << endl;
64. return 0;
65. }

1. #include <stdlib.h>
2. #include <string.h>
3. #include <stdio.h>
4. /**************************************************************
5. 功能：计数排序。
6. 参数： data ： 要排序的数组
7. size ：数组元素的个数
8. k   ：数组中元素数组最大值 +1 （这个需要+1）
9. 返回值： 成功0；失败-1.
10. *************************************************************/
11. int ctsort(int *data, int size, int k)
12. {
13. int * counts = NULL,/*计数数组*/
14. * temp = NULL;/*保存排序后的数组*/
15. int i = 0;
16. /*申请数组空间*/
17. if ((counts = (int *) malloc( k * sizeof(int))) == NULL)
18. return -1;
19. if ((temp = (int *) malloc( k * sizeof(int))) == NULL)
20. return -1;
21. /*初始化计数数组*/
22. for (i = 0; i < k; i ++)
23. counts[i] = 0;
24. /*数组中出现的元素，及出现次数记录*/
25. for(i = 0; i < size; i++)
26. counts[data[i]] += 1;
27. /*调整元素计数中，加上前一个数*/
28. for (i = 1; i < k; i++)
29. counts[i] += counts[i - 1];
30. /*使用计数数组中的记录数值，来进行排序，排序后保存的temp*/
31. for (i = size -1; i >= 0; i --){
32. temp[counts[data[i]] - 1] = data[i];
33. counts[data[i]] -= 1;
34. }
35. memcpy(data,temp,size * sizeof(int));
36. free(counts);
37. free(temp);
38. return 0;
39. }
40. int main()
41. {
42. int a[8] = {2,0,2,1,4,6,7,4};
43. int max = a[0],
44. i = 0;
45. /*获得数组中中的数值*/
46. for ( i = 1; i < 8; i++){
47. if (a[i] > max)
48. max = a[i];
49. }
50. ctsort(a,8,max+1);
51. for (i = 0;i < 8;i ++)
52. printf("%d\n",a[i]);
53. }

十二、基数排序

1）算法简介

基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。基数排序的发明可以追溯到1887年赫尔曼·何乐礼在打孔卡片制表机（Tabulation Machine）上的贡献。

2）算法描述和分析

整个算法过程描述如下：

1、将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。

2、从最低位开始，依次进行一次排序。

3、这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。

基数排序的时间复杂度是 O(k•n)，其中n是排序元素个数，k是数字位数。

注意这不是说这个时间复杂度一定优于O(n·log(n))，因为k的大小一般会受到n的影响。 以排序n个不同整数来举例，假定这些整数以B为底，这样每位数都有B个不同的数字，k就一定不小于logB(n)。由于有B个不同的数字，所以就需要B个不同的桶，在每一轮比较的时候都需要平均n·log2(B) 次比较来把整数放到合适的桶中去，所以就有：

k 大于或等于 logB(n)

每一轮(平均)需要 n·log2(B) 次比较

所以，基数排序的平均时间T就是：

T ≥ logB(n)·n·log2(B) = log2(n)·logB(2)·n·log2(B) = log2(n)·n·logB(2)·log2(B) = n·log2(n)

所以和比较排序相似，基数排序需要的比较次数：T ≥ n·log2(n)。 故其时间复杂度为 Ω(n·log2(n)) = Ω(n·log n) 。

3）算法图解、flash演示、视频演示

图解：

Flash：

可参见http://ds.fzu.edu.cn/fine/resources/FlashContent.asp?id=91中的flash过程

视频：

http://www.tudou.com/programs/view/vfoUHC-tgi0

4）算法代码

5）考察点、重点和频度分析

计数排序在处理密集整数排序的问题的时候非常有限，尤其是有时候题目对空间并不做太大限制，那使用计数排序能够达到O(n)的时间复杂度，远快于所有基于比较的其他排序方法。

总结

总结一下各种排序算法如下：