1、冒泡排序
最简单的一种排序算法。先从数组中找到最大值(或最小值)并放到数组最左端(或最右端)，然后在剩下的数字中找到次大值(或次小值)，以此类推，直到数组有序排列。算法的时间复杂度为O(n^2)。
- // 冒泡排序
2
void BubbleSort(int arr[], int length)
3. {
4. for (int i = 0; i < length; i++)
5. {
6. for (int j = 0; j < length - i - 1; j++)
7. {
8. if (arr[j] > arr[j + 1])
9. {
10. int temp;
11. temp = arr[j + 1];
12. arr[j + 1] = arr[j];
13. arr[j] = temp;
14. }
15. }
16. }
17. }
2、选择排序
严蔚敏版《数据结构》中对选择排序的基本思想描述为：每一趟在n-i+1(i=1,2,…,n-1)个记录中选取关键字最小的记录作为有序序列中第i个记录。具体来说，假设长度为n的数组arr，要按照从小到大排序，那么先从n个数字中找到最小值min1，如果最小值min1的位置不在数组的最左端(也就是min1不等于arr[0])，则将最小值min1和arr[0]交换，接着在剩下的n-1个数字中找到最小值min2，如果最小值min2不等于arr[1]，则交换这两个数字，依次类推，直到数组arr有序排列。算法的时间复杂度为O(n^2)。
- // 选择排序
2. void SelectionSort(int arr[], int length)
3. {
4. for (int i = 0; i < length; i++)
5. {
6. int index = i;
7. for (int j = i+1; j < length; j++)
8. {
9. if (arr[j] < arr[index])
10. {
11. index = j;
12. }
13. }
14. if (index == i)
15. continue;
16. else
17. {
18. int temp;
19. temp = arr[index];
20. arr[index] = arr[i];
21. arr[i] = temp;
22. }
23. }
24. }
3、插入排序
插入排序的基本思想就是将无序序列插入到有序序列中。例如要将数组arr=[4,2,8,0,5,1]排序，可以将4看做是一个有序序列(图中用蓝色标出)，将[2,8,0,5,1]看做一个无序序列。无序序列中2比4小，于是将2插入到4的左边，此时有序序列变成了[2,4]，无序序列变成了[8,0,5,1]。无序序列中8比4大，于是将8插入到4的右边，有序序列变成了[2,4,8],无序序列变成了[0,5,1]。以此类推，最终数组按照从小到大排序。该算法的时间复杂度为O(n^2)。
- // 插入排序
2. void InsertSort(int arr[], int length)
3. {
4. for (int i = 1; i < length; i++)
5. {
6. int j;
7. if (arr[i] < arr[i - 1])
8. {
9. int temp = arr[i];
10. for (j = i - 1; j >= 0 && temp < arr[j]; j--)
11. {
12. arr[j + 1] = arr[j];
13. }
14. arr[j + 1] = temp;
15. }
16. }
17. }
4、希尔排序
希尔排序(Shell’s Sort)在插入排序算法的基础上进行了改进，算法的时间复杂度与前面几种算法相比有较大的改进。其算法的基本思想是：先将待排记录序列分割成为若干子序列分别进行插入排序，待整个序列中的记录"基本有序"时，再对全体记录进行一次直接插入排序。
- // 插入排序
2. void ShellSort(int arr[], int length)
3. {
4. int increasement = length;
5. int i, j, k;
6. do
7. {
8. // 确定分组的增量
9. increasement = increasement / 3 + 1;
10. for (i = 0; i < increasement; i++)
11. {
12. for (j = i + increasement; j < length; j += increasement)
13. {
14. if (arr[j] < arr[j - increasement])
15. {
16. int temp = arr[j];
17. for (k = j - increasement; k >= 0 && temp < arr[k]; k -= increasement)
18. {
19. arr[k + increasement] = arr[k];
20. }
21. arr[k + increasement] = temp;
22. }
23. }
24. }
25. } while (increasement > 1);
26. }
5、快速排序
快速排序的基本思想是：通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，已达到整个序列有序。一趟快速排序的具体过程可描述为：从待排序列中任意选取一个记录(通常选取第一个记录)作为基准值，然后将记录中关键字比它小的记录都安置在它的位置之前，将记录中关键字比它大的记录都安置在它的位置之后。这样，以该基准值为分界线，将待排序列分成的两个子序列。
一趟快速排序的具体做法为：设置两个指针low和high分别指向待排序列的开始和结尾，记录下基准值baseval(待排序列的第一个记录)，然后先从high所指的位置向前搜索直到找到一个小于baseval的记录并互相交换，接着从low所指向的位置向后搜索直到找到一个大于baseval的记录并互相交换，重复这两个步骤直到low=high为止。
- // 快速排序
2. void QuickSort(int arr[], int start, int end)
3. {
4. if (start >= end)
5. return;
6. int i = start;
7. int j = end;
8. // 基准数
9. int baseval = arr[start];
10. while (i < j)
11. {
12. // 从右向左找比基准数小的数
13. while (i < j && arr[j] >= baseval)
14. {
15. j--;
16. }
17. if (i < j)
18. {
19. arr[i] = arr[j];
20. i++;
21. }
22. // 从左向右找比基准数大的数
23. while (i < j && arr[i] < baseval)
24. {
25. i++;
26. }
27. if (i < j)
28. {
29. arr[j] = arr[i];
30. j--;
31. }
32. }
33. // 把基准数放到i的位置
34. arr[i] = baseval;
35. // 递归
36. QuickSort(arr, start, i - 1);
37. QuickSort(arr, i + 1, end);
38. }
6、归并排序
“归并”的含义是将两个或两个以上的有序序列组合成一个新的有序表。假设初始序列含有n个记录，则可以看成是n个有序的子序列，每个子序列的长度为1，然后两两归并，得到 （ 表示不小于x的最小整数）个长度为2(或者是1)的有序子序列，再两两归并。如此重复，直到得到一个长度为n的有序序列为止。这种排序方法称为2-路归并排序。
- // 归并排序
2. void MergeSort(int arr[], int start, int end, int * temp)
3. {
4. if (start >= end)
5. return;
6. int mid = (start + end) / 2;
7. MergeSort(arr, start, mid, temp);
8. MergeSort(arr, mid + 1, end, temp);
9.
10. // 合并两个有序序列
11. int length = 0; // 表示辅助空间有多少个元素
12. int i_start = start;
13. int i_end = mid;
14. int j_start = mid + 1;
15. int j_end = end;
16. while (i_start <= i_end && j_start <= j_end)
17. {
18. if (arr[i_start] < arr[j_start])
19. {
20. temp[length] = arr[i_start];
21. length++;
22. i_start++;
23. }
24. else
25. {
26. temp[length] = arr[j_start];
27. length++;
28. j_start++;
29. }
30. }
31. while (i_start <= i_end)
32. {
33. temp[length] = arr[i_start];
34. i_start++;
35. length++;
36. }
37. while (j_start <= j_end)
38. {
39. temp[length] = arr[j_start];
40. length++;
41. j_start++;
42. }
43. // 把辅助空间的数据放到原空间
44. for (int i = 0; i < length; i++)
45. {
46. arr[start + i] = temp[i];
47. }
48. }
7、堆排序
堆的定义如下: n个元素的序列{k1, k2, … , kn}当且仅当满足一下条件时，称之为堆。
可以将堆看做是一个完全二叉树。并且，每个结点的值都大于等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于等于其左右孩子结点的值，称为小顶堆。
堆排序(Heap Sort)是利用堆进行排序的方法。其基本思想为：将待排序列构造成一个大顶堆(或小顶堆)，整个序列的最大值(或最小值)就是堆顶的根结点，将根节点的值和堆数组的末尾元素交换，此时末尾元素就是最大值(或最小值)，然后将剩余的n-1个序列重新构造成一个堆，这样就会得到n个元素中的次大值(或次小值)，如此反复执行，最终得到一个有序序列。
. /*
2. @param arr 待调整的数组
3. @param i 待调整的结点的下标
4. @param length 数组的长度
5. */
6. void HeapAdjust(int arr[], int i, int length)
7. {
8. // 调整i位置的结点
9. // 先保存当前结点的下标
10. int max = i;
11. // 当前结点左右孩子结点的下标
12. int lchild = i * 2 + 1;
13. int rchild = i * 2 + 2;
14. if (lchild < length && arr[lchild] > arr[max])
15. {
16. max = lchild;
17. }
18. if (rchild < length && arr[rchild] > arr[max])
19. {
20. max = rchild;
21. }
22. // 若i处的值比其左右孩子结点的值小，就将其和最大值进行交换
23. if (max != i)
24. {
25. int temp;
26. temp = arr[i];
27. arr[i] = arr[max];
28. arr[max] = temp;
29. // 递归
30. HeapAdjust(arr, max, length);
31. }
32. }
33.
34. // 堆排序
35. void HeapSort(int arr[], int length)
36. {
37. // 初始化堆
38. // length / 2 - 1是二叉树中最后一个非叶子结点的序号
39. for (int i = length / 2 - 1; i >= 0; i--)
40. {
41. HeapAdjust(arr, i, length);
42. }
43. // 交换堆顶元素和最后一个元素
44. for (int i = length - 1; i >= 0; i--)
45. {
46. int temp;
47. temp = arr[i];
48. arr[i] = arr[0];
49. arr[0] = temp;
50. HeapAdjust(arr, 0, i);
51. }
52. }
11万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
