阿伟_
阿伟_

数据结构与算法--查找与排序


Top
  1. 线性查找
  2. 二分查找
  3. 冒泡排序
  4. 插入排序
  5. 选择排序
  6. 快速排序
  7. 归并排序

1 线性查找

1.1 问题

线性查找，又称为顺序查找，是指在所有给定的值中从一端开始逐个检查每个元素是否为要查找的对象，直到找到为止的过程。

1.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：逐个查找要查找的对象

代码如下：


      
      
      
      
    
       
       
       
       
  1. #include <stdio.h>
    2. 
       
       
       
       
  2. 
       
       
       
       
  3. typedef char DataType;
    4. 
       
       
       
       
  4. int mySearch(DataType *ts, int n, const DataType d) {
    5. 
       
       
       
       
  5.     for (int i = 0; i < n; i++)
    6. 
       
       
       
       
  6.         if (ts[i] == d)
    7. 
       
       
       
       
  7.             return i;
    8. 
       
       
       
       
  8.     return -1;
    9. 
       
       
       
       
  9. }
    10.

上述代码中，以下代码：


      
      
      
      
    
       
       
       
       
  1. int mySearch(DataType *ts, int n, const DataType d) {
    2.

是线性查找的函数头，它有三个形参，第一个形参是要查找的数组，第二个形参是数组中元素的个数，第三个形参是要查找的对象。

1.3 完整代码

本案例的完整代码如下所示：


      
      
      
      
    
       
       
       
       
  1. #include <stdio.h>
    2. 
       
       
       
       
  2. 
       
       
       
       
  3. typedef char DataType;
    4. 
       
       
       
       
  4. int mySearch(DataType *ts, int n, const DataType d) {
    5. 
       
       
       
       
  5.     for (int i = 0; i < n; i++)
    6. 
       
       
       
       
  6.         if (ts[i] == d)
    7. 
       
       
       
       
  7.             return i;
    8. 
       
       
       
       
  8.     return -1;
    9. 
       
       
       
       
  9. }
    10. 
       
       
       
       
  10. 
       
       
       
       
  11. int main()
    12. 
       
       
       
       
  12. {
    13. 
       
       
       
       
  13.     char cs[6] = {'*','A','B','C','D','E'};
    14. 
       
       
       
       
  14.     printf("%d\n", mySearch(cs, 6, '*'));
    15. 
       
       
       
       
  15.     printf("%d\n", mySearch(cs, 6, 'A'));
    16. 
       
       
       
       
  16.     printf("%d\n", mySearch(cs, 6, 'D'));
    17. 
       
       
       
       
  17.     printf("%d\n", mySearch(cs, 6, 'C'));
    18. 
       
       
       
       
  18. }
    19.

2 二分查找

2.1 问题

二分查找算法，又称折半搜索、二分搜索，是一种在有序数组中查找某一特定元素的搜索算法。

二分查找算法的查找过程是这样的。首先，要求待查找的数组是排好序的数组，我们假设数组是升序的，即从小到大排序。然后，将要查找的元素与数组的中间元素相对比，如果相等，则表示要查找的元素被找到了，并停止查找；如果要查找的元素小于数组的中间元素，则从数组中间元素开始到数组最后的元素都大于要查找的元素，也就不需要在其中查找了，只需要在数组中间元素到数组第一个元素之间查找；如果要查找的元素大于数组的中间元素，则从数组中间元素到数组第一个元素都小于要查找的元素，也就不需要在其中查找了，只需要在数组中间元素到数组最后的元素之间查找。

由此可见，二分查找算法在查找的过程中只需对比一次，就可以使待查找的对象个数减少一半。查找速度非常快，所以二分查找算法得到了广泛的应用。

2.2 方案

为了理解二分查找算法，我们先假设有一个长度为11的数组，数组内容如图-1所示：

图-1

图-1中的数组是排好序的数组，从小到大排序。数组左边的数字7为数组的第一个元素，数组右边的数字94为数组的最后一个元素。要查找的元素假设为22。查找过程如下：

首先，确定查找范围，因为是第一次在数组中查找，所以整个数组都是待查找的范围，这样将带查找范围的下界low定为数组的第一个元素7，上界high定为数组的最后一个元素94，那么在上下界中间的元素就是数组元素56，我们用mid表示。

然后，将要查找的元素22与中间的元素，即数组元素56，相对比。因为22小于56，所以从中间元素mid到数组的上界high之间的所有元素都大于22，由图-1可以看出，mid到high之间分别是56、66、79、84、88、94，它们都大于22。由此可知这些元素都可以排除在下次查找的范围内了。即一次对比，就可以使待查找的对象个数减少一半。

最后，确定新的待查找范围，如图-2所示：

图-2

新的查找范围的下界low定为数组的第一个元素7，上界high定为数组的元素40，因为在上一次查找的过程中，数组元素56、66、79、84、88、94均已被排除在查找范围之外了。由上下界可以得到中间元素的数组元素为18，用mid表示。

然后，将要查找的元素22与中间的元素，即数组元素18，相对比。因为22大于18，所以从中间元素mid到数组的下界low之间的所有元素都小于22，由图-2可以看出，low到mid之间分别是7、12、18，它们都小于22。由此可知这些元素也都可以排除在下次查找的范围内了。

这样，再确定新的查找范围，如图-3所示：

图-3

新的查找范围的下界low定为数组元素22，上界high定为数组的元素40，因为在上一次查找的过程中，数组元素7、12、18均已被排除在查找范围之外了。由于上下界之间只有2个元素，所以中间元素的数组元素为22，用mid表示。

然后，将要查找的元素22与中间的元素，即数组元素22，相对比。因为相等，所以在数组中找到了要查找的元素。程序结束。

2.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：定义上下界

1)定义一个变量L，用于代表下界。

2)定义一个变量R，用于代表上界。

代码如下：


      
      
      
      
    
       
       
       
       
  1. int mySearch(DataType *ts, int n, const DataType d) {
    2. 
       
       
       
       
  2.     int L = 0;
    3. 
       
       
       
       
  3.     int R = n - 1;
    4. 
       
       
       
       
  4. }
    5.

步骤二：确定中间点

1)定义一个变量M，用于代表中间点。

2)将中间点元素与要查找的元素对比，如果相等，则表示找到了要查找的元素，程序退出。

代码如下：


      
      
      
      
    
       
       
       
       
  1. int mySearch(DataType *ts, int n, const DataType d) {
    2. 
       
       
       
       
  2.     int L = 0;
    3. 
       
       
       
       
  3.     int R = n - 1;
    4. 
       
       
       
       
  4. 
       
       
       
       
  5.         int M = (L + R)/2;
    6. 
       
       
       
       
  6.         if (ts[M] == d) return M;
    7. 
       
       
       
       
  7. }
    8.

步骤三：重新确定查找范围

如果中间点元素小于要查找的元素，则将下界L更改为M+1，否则将上界R更改为M-1。

代码如下：


      
      
      
      
    
       
       
       
       
  1. int mySearch(DataType *ts, int n, const DataType d) {
    2. 
       
       
       
       
  2.     int L = 0;
    3. 
       
       
       
       
  3.     int R = n - 1;
    4. 
       
       
       
       
  4. 
       
       
       
       
  5.         int M = (L + R)/2;
    6. 
       
       
       
       
  6.         if (ts[M] == d) return M;
    7. 
       
       
       
       
  7.         if (ts[M] < d)
    8. 
       
       
       
       
  8.             L = M+1;
    9. 
       
       
       
       
  9.         else
    10. 
       
       
       
       
  10.             R = M - 1;
    11. 
       
       
       
       
  11. 
       
       
       
       
  12.     return -1;
    13. 
       
       
       
       
  13. }
    14.

步骤四：按新范围重新查找

如果，一次未找到，则需要设置循环反复查找，直到找到或待查找范围内的元素个数为0。

代码如下：


      
      
      
      
    
       
       
       
       
  1. int mySearch(DataType *ts, int n, const DataType d) {
    2. 
       
       
       
       
  2.     int L = 0;
    3. 
       
       
       
       
  3.     int R = n - 1;
    4. 
       
       
       
       
  4.     while (L <= R) {
    5. 
       
       
       
       
  5.         int M = (L + R)/2;
    6. 
       
       
       
       
  6.         if (ts[M] == d) return M;
    7. 
       
       
       
       
  7.         if (ts[M] < d)
    8. 
       
       
       
       
  8.             L = M+1;
    9. 
       
       
       
       
  9.         else
    10. 
       
       
       
       
  10.             R = M - 1;
    11. 
       
       
       
       
  11.     }
    12. 
       
       
       
       
  12.     return -1;
    13. 
       
       
       
       
  13. }
    14.

上述代码中，以下代码：


      
      
      
      
    
       
       
       
       
  1.     while (L <= R) {
    2.

中的L<=R这个循环条件为真时，表示待查找范围内的数组元素个数至少为1。当这个循环条件为假时，则表示待查找范围内的数组元素个数已经为0，即没有可查找的对象了。

2.4 完整代码

本案例的完整代码如下所示：


      
      
      
      
    
       
       
       
       
  1. typedef char DataType;
    2. 
       
       
       
       
  2. int mySearch(DataType *ts, int n, const DataType d) {
    3. 
       
       
       
       
  3.     int L = 0;
    4. 
       
       
       
       
  4.     int R = n - 1;
    5. 
       
       
       
       
  5.     while (L <= R) {
    6. 
       
       
       
       
  6.         int M = (L + R)/2;
    7. 
       
       
       
       
  7.         if (ts[M] == d) return M;
    8. 
       
       
       
       
  8.         if (ts[M] < d)
    9. 
       
       
       
       
  9.             L = M+1;
    10. 
       
       
       
       
  10.         else
    11. 
       
       
       
       
  11.             R = M - 1;
    12. 
       
       
       
       
  12.     }
    13. 
       
       
       
       
  13.     return -1;
    14. 
       
       
       
       
  14. }
    15. 
       
       
       
       
  15. 
       
       
       
       
  16. int main()
    17. 
       
       
       
       
  17. {
    18. 
       
       
       
       
  18.     char cs[6] = {'*','A','B','C','D','E'};
    19. 
       
       
       
       
  19.     printf("%d\n", mySearch(cs, 6, '*'));
    20. 
       
       
       
       
  20.     printf("%d\n", mySearch(cs, 6, 'A'));
    21. 
       
       
       
       
  21.     printf("%d\n", mySearch(cs, 6, 'D'));
    22. 
       
       
       
       
  22.     printf("%d\n", mySearch(cs, 6, 'C'));
    23. 
       
       
       
       
  23. }
    24.

3 冒泡排序

3.1 问题

冒泡排序是一种著名的排序方法。

冒泡排序的过程是这样的，首先，将待排序的数组中的第一个元素与第二个元素相对比，如果这两个元素的大小顺序不是我们要求的顺序，则将它们交换过来。然后，将待排序的数组中的第二个元素与第三个元素相对比，如果这两个元素的大小顺序也不是我们要求的顺序，则也将它们交换过来。下一步，是对比第三个元素与第四个元素，直至倒数第二个元素与最后一个元素相对比。这样一趟对比下来，小的数据元素会一点一点的往前放，而大的数据元素会一点一点的往后放。反复多趟的这样对比，直到所有数据都排好序为止。

3.2 方案

为了理解冒泡排序算法，我们先假设有一个长度为10的数组，数组内容如图-4所示：

图-4

图-4中的数组元素为无序状态，现需要将数组内的元素排序成从小到大的升序状态。可以先进行第一趟比较。首先比较第1个和第2个数，也就是数组第一个元素3和数组第二个元素2，将小数放前，大数放后。交换后如图-5所示：

图-5

然后，将图-5中的第2个和第3个数，也就是数组第二个元素3和数组第三个元素4，进行对比，由于3小于4，所以不进行交换。接着将图-5中的第3个和第4个数对比后发现也不需要交换。这样依次进行对比，直到图-5中的第7个和第8个数，也就是数组第七个元素9和数组第八个元素1，对比时，需要将它们交换过来，如图-6所示：

图-6

继续第一趟比较，图-6中的第8个和第9个数，也就是数组第八个元素9和数组第九个元素6，对比时，需要将它们交换过来，如图-7所示：

图-7

第一趟最后比较，图-7中的第9个和第10个数，也就是数组第九个元素9和数组第十个元素0，对比时，需要将它们交换过来，如图-8所示：

图-8

至此，第一趟比较结束，我们会发现数组中的最大值通过不断的位置交换，移到了数组最后一个元素的位置。但其它元素仍然是无序状态。所以需要进行第二趟比较，只是此次比较的范围应刨除数组的最后一个元素。当第二趟比较结束时，倒数第二大的数组元素值会被放置到数组的倒数第二个位置，如图-9所示：

图-9

第二趟比较结束后，依次进行后面的比较，直到数组内的元素按照升序排好为止。整个排序过程如图-10所示：

图-10

由图－10可以看出，实现冒泡排序算法时，需要使用嵌套的两个循环来实现：外层循环用于控制排序的趟次，里层循环用于控制每趟排序中的两两交换。

3.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：第一趟比较

设置循环，将待排序数组中的数组元素两两进行比较，如果有不符合要求的顺序的，进行交换。

代码如下所示：


      
      
      
      
    
       
       
       
       
  1. void bubble(DataType* a, int n) {
    2. 
       
       
       
       
  2.         for (int j = 0; j < n -  i - 1; j++) {
    3. 
       
       
       
       
  3.             if (a[j] > a[j + 1]) {
    4. 
       
       
       
       
  4.                 DataType t = a[j];
    5. 
       
       
       
       
  5.                 a[j] = a[j + 1];
    6. 
       
       
       
       
  6.                 a[j + 1] = t;
    7. 
       
       
       
       
  7.                 flag = false;
    8. 
       
       
       
       
  8.             }
    9. 
       
       
       
       
  9.         }
    10. 
       
       
       
       
  10. }
    11.

步骤二：多趟比较，直至排好序

设置外层循环，进行多趟比较。

代码如下所示：


      
      
      
      
    
       
       
       
       
  1. void bubble(DataType* a, int n) {
    2. 
       
       
       
       
  2.     for (int i = 0; i < n - 1; i++) {
    3. 
       
       
       
       
  3.         for (int j = 0; j < n -  i - 1; j++) {
    4. 
       
       
       
       
  4.             if (a[j] > a[j + 1]) {
    5. 
       
       
       
       
  5.                 DataType t = a[j];
    6. 
       
       
       
       
  6.                 a[j] = a[j + 1];
    7. 
       
       
       
       
  7.                 a[j + 1] = t;
    8. 
       
       
       
       
  8.                 flag = false;
    9. 
       
       
       
       
  9.             }
    10. 
       
       
       
       
  10.         }
    11. 
       
       
       
       
  11.     }
    12. 
       
       
       
       
  12. }
    13.

步骤三：设置标志，提高效率

代码如下所示：


      
      
      
      
    
       
       
       
       
  1. void bubble(DataType* a, int n) {
    2. 
       
       
       
       
  2.     for (int i = 0; i < n - 1; i++) {
    3. 
       
       
       
       
  3.         bool flag = true;
    4. 
       
       
       
       
  4.         for (int j = 0; j < n -  i - 1; j++) {
    5. 
       
       
       
       
  5.             if (a[j] > a[j + 1]) {
    6. 
       
       
       
       
  6.                 DataType t = a[j];
    7. 
       
       
       
       
  7.                 a[j] = a[j + 1];
    8. 
       
       
       
       
  8.                 a[j + 1] = t;
    9. 
       
       
       
       
  9.                 flag = false;
    10. 
       
       
       
       
  10.             }
    11. 
       
       
       
       
  11.         }
    12. 
       
       
       
       
  12.         if (flag) break;
    13. 
       
       
       
       
  13.     }
    14. 
       
       
       
       
  14. }
    15.

上述代码中，以下代码：


      
      
      
      
    
       
       
       
       
  1.         bool flag = true;
    2.

定义一个布尔型变量，初始化为真，为真代表数组已经排好序了。

上述代码中，以下代码：


      
      
      
      
    
       
       
       
       
  1.         for (int j = 0; j < n -  i - 1; j++) {
    2. 
       
       
       
       
  2.             if (a[j] > a[j + 1]) {
    3. 
       
       
       
       
  3.                 DataType t = a[j];
    4. 
       
       
       
       
  4.                 a[j] = a[j + 1];
    5. 
       
       
       
       
  5.                 a[j + 1] = t;
    6. 
       
       
       
       
  6.                 flag = false;
    7. 
       
       
       
       
  7.             }
    8. 
       
       
       
       
  8.         }
    9.

是进行某趟比较，在该趟比较过程中，如果数组中所有元素两两比较均为假，则就不需要进行交换，而此时flag=false；语句也就不会执行。因此循环退出时，flag为真，即数组已经排好序了。

上述代码中，以下代码：


      
      
      
      
    
       
       
       
       
  1.         if (flag) break;
    2.

表示如果flag为真，即数组已经排好序，则停止排序。

3.4 完整代码

本案例的完整代码如下所示：


      
      
      
      
    
       
       
       
       
  1. typedef int DataType;
    2. 
       
       
       
       
  2. void bubble(DataType* a, int n) {
    3. 
       
       
       
       
  3.     for (int i = 0; i < n - 1; i++) {
    4. 
       
       
       
       
  4.         bool flag = true;
    5. 
       
       
       
       
  5.         for (int j = 0; j < n -  i - 1; j++) {
    6. 
       
       
       
       
  6.             if (a[j] > a[j + 1]) {
    7. 
       
       
       
       
  7.                 DataType t = a[j];
    8. 
       
       
       
       
  8.                 a[j] = a[j + 1];
    9. 
       
       
       
       
  9.                 a[j + 1] = t;
    10. 
       
       
       
       
  10.                 flag = false;
    11. 
       
       
       
       
  11.             }
    12. 
       
       
       
       
  12.         }
    13. 
       
       
       
       
  13.         if (flag) break;
    14. 
       
       
       
       
  14.     }
    15. 
       
       
       
       
  15. }
    16. 
       
       
       
       
  16. 
       
       
       
       
  17. void print(DataType* a, int n) {
    18. 
       
       
       
       
  18.     for (int i = 0; i < n; i++)
    19. 
       
       
       
       
  19.         printf("%d ", a[i]);
    20. 
       
       
       
       
  20.     printf("\n");
    21. 
       
       
       
       
  21. }
    22. 
       
       
       
       
  22. 
       
       
       
       
  23. int main() {
    24. 
       
       
       
       
  24.     int a[10] = {3, 2, 4, 5, 7, 8, 9, 1, 6, 0};
    25. 
       
       
       
       
  25.     bubble(a, 10);
    26. 
       
       
       
       
  26.     print(a, 10);
    27. 
       
       
       
       
  27.     
    28. 
       
       
       
       
  28.     return 0;
    29. 
       
       
       
       
  29. }
    30.

4 插入排序

插入排序算法是一种简单直观的排序算法。

插入排序的过程是这样的，首先，将待排序的数组分成两部分，一部分是已经排好序的部分，另一部分是未排好序的部分。在开始排序前，已排好序的部分只有一个数组元素，即数组的第一个元素；未排好序的部分是数组中除第一个元素外的其它所有元素。然后，将未排好序部分中的第一个数组元素，插入到已排序部分当中适当的位置，以保证已排序部分仍然是保持排序状态。此时，已排序部分就变成两个数组元素，而未排序部分的数组元素同时少了一个。依次类推，逐个从未排好序的部分拿出一个元素，插入到已排序部分当中适当的位置，直至数组按顺序排好为止。

4.1 方案

为了理解插入排序算法，我们先假设有一个长度为10的数组，数组内容如图-17所示：

图-11

图-17中的数组元素为无序状态，现需要将数组内的元素排序成从小到大的升序状态。首先将数组中的所有元素分成两个部分，一部分已排好序的部分，另一部分是未排好序的部分，在开始时，已排好序的部分只有一个数组元素，剩余的数组元素为未排好序的部分，如图-18所示：

图-12

将未排好序部分的一个元素取出，插入到已排好序部分的适当位置，如图-18中，将数组元素2从未排好序部分取出，与已排好序的部分的数组元素3对比，因为2小于3，所以将2插入到3的前面，如图-19所示：

图-13

此时，已排好序的部分变成了2个元素，而未排好序的部分少了一个元素，然后，再将未排好序部分的一个元素取出，插入到已排好序部分的适当位置，如图-19中，将数组元素4从未排好序部分取出，与已排好序的部分的数组元素3对比，因为4大于3，所以直接将4划入已排好序的部分，如图-20所示：

图-14

此时，已排好序的部分变成了3个元素，而未排好序的部分又少了一个元素，依次类推，逐个将未排好序的部分的元素插入到已排序的部分，直至整个数组都排好序为止。整个排序过程如图-21所示：

图-15

4.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：将未排序部分的第一个元素插入到已排序部分

首先，定义临时变量，用于保存未排序部分的第一个元素

然后，设置循环，将未排序部分的第一个元素插入到已排序部分。

代码如下所示：


      
      
      
      
    
       
       
       
       
  1. void insert(DataType *a, int n) {
    2. 
       
       
       
       
  2.         int i = 1;
    3. 
       
       
       
       
  3.         //把选择的元素放在临时变量中
    4. 
       
       
       
       
  4.         DataType t = a[i];
    5. 
       
       
       
       
  5.         int j = 0;
    6. 
       
       
       
       
  6.         for (j = i; j > 0 && a[j - 1] > t; j--) {
    7. 
       
       
       
       
  7.             a[j] = a[j - 1];
    8. 
       
       
       
       
  8.         }
    9. 
       
       
       
       
  9.         a[j] = t;
    10. 
       
       
       
       
  10. }
    11.

上述代码中，以下代码：


      
      
      
      
    
       
       
       
       
  1.         for (j = i; j > 0 && a[j - 1] > t; j--) {
    2. 
       
       
       
       
  2.             a[j] = a[j - 1];
    3. 
       
       
       
       
  3.         }
    4. 
       
       
       
       
  4.         a[j] = t;
    5.

是将未排序部分的第一个元素t插入到已排序部分的适当位置a[j]。

步骤二：将所有未排序部分的元素插入到已排序部分

设置循环，逐个将未排序部分元素取出来，插入到已排序部分。

代码如下所示：


      
      
      
      
    
       
       
       
       
  1. void insert(DataType *a, int n) {
    2. 
       
       
       
       
  2.     for (int i = 1; i < n; i++) {
    3. 
       
       
       
       
  3.         //把选择的元素放在临时变量中
    4. 
       
       
       
       
  4.         DataType t = a[i];
    5. 
       
       
       
       
  5.         int j = 0;
    6. 
       
       
       
       
  6.         for (j = i; j > 0 && a[j - 1] > t; j--) {
    7. 
       
       
       
       
  7.             a[j] = a[j - 1];
    8. 
       
       
       
       
  8.         }
    9. 
       
       
       
       
  9.         a[j] = t;
    10. 
       
       
       
       
  10.     }
    11. 
       
       
       
       
  11. }
    12.

4.3 完整代码

本案例的完整代码如下所示：


      
      
      
      
    
       
       
       
       
  1. typedef int DataType;
    2. 
       
       
       
       
  2. void insert(DataType *a, int n) {
    3. 
       
       
       
       
  3.     for (int i = 1; i < n; i++) {
    4. 
       
       
       
       
  4.         //把选择的元素放在临时变量中
    5. 
       
       
       
       
  5.         DataType t = a[i];
    6. 
       
       
       
       
  6.         int j = 0;
    7. 
       
       
       
       
  7.         for (j = i; j > 0 && a[j - 1] > t; j--) {
    8. 
       
       
       
       
  8.             a[j] = a[j - 1];
    9. 
       
       
       
       
  9.         }
    10. 
       
       
       
       
  10.         a[j] = t;
    11. 
       
       
       
       
  11.     }
    12. 
       
       
       
       
  12. }
    13. 
       
       
       
       
  13. 
       
       
       
       
  14. void print(DataType* a, int n) {
    15. 
       
       
       
       
  15.     for (int i = 0; i < n; i++)
    16. 
       
       
       
       
  16.         printf("%d ", a[i]);
    17. 
       
       
       
       
  17.     printf("\n");
    18. 
       
       
       
       
  18. }
    19. 
       
       
       
       
  19. 
       
       
       
       
  20. int main() {
    21. 
       
       
       
       
  21.     int a[10] = {3, 2, 4, 5, 7, 8, 9, 1, 6, 0};
    22. 
       
       
       
       
  22. 
       
       
       
       
  23.     insert(a, 10);
    24. 
       
       
       
       
  24.     print(a, 10);
    25. 
       
       
       
       
  25.     
    26. 
       
       
       
       
  26.     return 0;
    27. 
       
       
       
       
  27. }
    28.

5 选择排序

5.1 问题

选择排序是一种简单直观的排序方法。

选择排序的过程是这样的，首先，在待排序的数组中找到一个最小的数组元素，将该最小数组元素与数组的第一个元素进行交换，这样交换之后，数组的第一个元素就变成了数组元素中的最小值。然后，再在待排序数组的剩余元素中找到一个最小的数组元素，将该最小数组元素与数组的第二个元素进行交换，这样交换之后，数组的第二个元素就变成了数组元素中的第二小的值。依次类推，直至数组按顺序排好为止。

5.2 方案

为了理解选择排序算法，我们先假设有一个长度为10的数组，数组内容如图-11所示：

图-16

图-11中的数组元素为无序状态，现需要将数组内的元素排序成从小到大的升序状态。首先在数组的所有元素中找到一个最小的元素，如图-12所示：

图-17

将该元素与数组的第一个元素进行交换，如图-13所示：

图-18

这样交换之后，数组的第一个元素就变成了数组元素中的最小值。然后，再在除第一个元素外的其它数组元素中，寻找最小的数组元素，如图-14所示：

图-19

将这个第二小的数组元素与数组的第二个位置的元素进行交换，如图-15所示：

图-20

这样交换之后，数组的第二个元素就变成了数组元素中的第二小的值。依次类推，再在剩余的数组元素中找最小值，与数组第三个位置的元素进行交换，直至数组排好序为止。整个排序过程如图-16所示：

图-21

由图－16可以看出，实现选择排序算法时，需要使用嵌套的两个循环来实现：外层循环用于控制排序的趟次，里层循环用于寻找指定范围内的最小值。

5.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：寻找数组中指定范围内的最小元素

首先，定义一个变量，用于存放最小元素在数组中的下标。

然后，设置循环，遍历数组找出最小元素。

代码如下所示：


      
      
      
      
    
       
       
       
       
  1. void selects(DataType *a, int n) {
    2. 
       
       
       
       
  2.         int i = 0;
    3. 
       
       
       
       
  3.         int k = i; //这里认为k就是最小元素的下标
    4. 
       
       
       
       
  4.         for (int j = i + 1; j < n; j++) {
    5. 
       
       
       
       
  5.             if (a[j] < a[k]) {
    6. 
       
       
       
       
  6.                 k = j;
    7. 
       
       
       
       
  7.             }
    8. 
       
       
       
       
  8.         }
    9. 
       
       
       
       
  9. }
    10.

步骤二：将最小元素与数组第一个位置的元素交换

代码如下所示：


      
      
      
      
    
       
       
       
       
  1. void selects(DataType *a, int n) {
    2. 
       
       
       
       
  2.         int i = 0;
    3. 
       
       
       
       
  3.         int k = i; //这里认为k就是最小
    4. 
       
       
       
       
  4.         for (int j = i + 1; j < n; j++) {
    5. 
       
       
       
       
  5.             if (a[j] < a[k]) {
    6. 
       
       
       
       
  6.                 k = j;
    7. 
       
       
       
       
  7.             }
    8. 
       
       
       
       
  8.         }
    9. 
       
       
       
       
  9.         if (k != i) {
    10. 
       
       
       
       
  10.             swap(a[k], a[i]);
    11. 
       
       
       
       
  11.         }
    12. 
       
       
       
       
  12. }
    13.

上述代码中，以下代码：


      
      
      
      
    
       
       
       
       
  1.         if (k != i) {
    2.

是判断最小元素的下标是否就是数组第一个位置元素的下标，如果是则不需要再进行交换。

步骤三：将数组剩余元素排序

设置外层循环，依次寻找最小元素并进行交换。

代码如下所示：


      
      
      
      
    
       
       
       
       
  1. void selects(DataType *a, int n) {
    2. 
       
       
       
       
  2.     for (int i = 0; i < n - 1; i++) {
    3. 
       
       
       
       
  3.         int k = i; //这里认为k就是最小
    4. 
       
       
       
       
  4.         for (int j = i + 1; j < n; j++) {
    5. 
       
       
       
       
  5.             if (a[j] < a[k]) {
    6. 
       
       
       
       
  6.                 k = j;
    7. 
       
       
       
       
  7.             }
    8. 
       
       
       
       
  8.         }
    9. 
       
       
       
       
  9.         if (k != i) {
    10. 
       
       
       
       
  10.             swap(a[k], a[i]);
    11. 
       
       
       
       
  11.         }
    12. 
       
       
       
       
  12.     }
    13. 
       
       
       
       
  13. }
    14.

5.4 完整代码

本案例的完整代码如下所示：


      
      
      
      
    
       
       
       
       
  1. typedef int DataType;
    2. 
       
       
       
       
  2. 
       
       
       
       
  3. void selects(DataType *a, int n) {
    4. 
       
       
       
       
  4.     for (int i = 0; i < n - 1; i++) {
    5. 
       
       
       
       
  5.         int k = i; //这里认为k就是最小
    6. 
       
       
       
       
  6.         for (int j = i + 1; j < n; j++) {
    7. 
       
       
       
       
  7.             if (a[j] < a[k]) {
    8. 
       
       
       
       
  8.                 k = j;
    9. 
       
       
       
       
  9.             }
    10. 
       
       
       
       
  10.         }
    11. 
       
       
       
       
  11.         if (k != i) {
    12. 
       
       
       
       
  12.             swap(a[k], a[i]);
    13. 
       
       
       
       
  13.         }
    14. 
       
       
       
       
  14.     }
    15. 
       
       
       
       
  15. }
    16. 
       
       
       
       
  16. 
       
       
       
       
  17. void print(DataType* a, int n) {
    18. 
       
       
       
       
  18.     for (int i = 0; i < n; i++)
    19. 
       
       
       
       
  19.         printf("%d ", a[i]);
    20. 
       
       
       
       
  20.     printf("\n");
    21. 
       
       
       
       
  21. }
    22. 
       
       
       
       
  22. 
       
       
       
       
  23. int main() {
    24. 
       
       
       
       
  24.     int a[10] = {3, 2, 4, 5, 7, 8, 9, 1, 6, 0};
    25. 
       
       
       
       
  25.     
    26. 
       
       
       
       
  26.     selects(a, 10);
    27. 
       
       
       
       
  27.     print(a, 10);
    28. 
       
       
       
       
  28. 
       
       
       
       
  29.     return 0;
    30. 
       
       
       
       
  30. }
    31.

6 快速排序

6.1 问题

快速排序算法是一种基于交换的排序，系统地交换反序的记录的偶对，直到不再有这样一来的偶对为止。它是对冒泡排序的一种改进。

快速排序的过程是这样的。首先，将待排序的数组从前向后和从后向前各取出一个元素进行对比交换，从而将待排序的数组分成两个部分，前一部分的所有元素都小于后一部分的所有元素，但前后两部分内部仍然是无序的状态。然后再将前一部分的所有元素从前向后和从后向前各取出一个元素进行对比交换，从而将前一部分的所有元素再分成两个部分，这两部分的前一部分的所有元素都小于后一部分的所有元素，依次类推，直到被分割的部分只有一个元素为止。下一步，再将后一部分的所有元素从前向后和从后向前各取出一个元素进行对比交换并分成两个部分。这样分到最后，数组将排好序。

6.2 方案

为了理解快速排序算法，我们先假设有一个长度为10的数组，数组内容如图-22所示：

图-22

图-22中的数组元素为无序状态，现需要将数组内的元素排序成从小到大的升序状态。首先将数组中的第一个元素3与最后一个元素0进行比较，因为3大于0，所以将它们两个进行交换，如图-23所示：

图-23

然后，将数组的第二个元素2与数组的最后一个元素3进行比较，因为2小于3，所以再那数组的第三个元素4与数组的最后一个元素3进行比较，因为4大于3，所以将它们两个进行交换，如图-24所示：

图-24

下一步，将数组的第三个元素3与数组的倒数第二个元素6进行比较，因为3小于6，所以再那数组的第三个元素3与数组的倒数第三个元素1进行比较，因为3大于1，所以将它们两个进行交换，如图-25所示：

图-25

下一步，将数组的第四个元素5与数组的倒数第三个元素3进行比较，因为5大于3，所以将它们两个进行交换，如图-26所示：

图-26

下一步，将数组的第四个元素3与数组的倒数第四个元素9进行比较，因为3小于9，所以再那数组的第四个元素3与数组的倒数第五个元素8进行比较，还因为3小于8，所以再那数组的第四个元素3与数组的倒数第六个元素7进行比较，再因为3小于7，不进行交换，至此将数组分成了两个部分，如图-27所示：

图-27

前一部分的所有元素均小于后一部分的所有元素。最后，先将前一部分按上述方法再分，再将后一部分再分，直到每一部分只有一个元素，无需排序为止。因为前一部分总是比后一部分小，所以当排序停止时，数组就已经排好序了。

6.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：终止分组条件

当只有一个元素时，停止排序。

代码如下：


      
      
      
      
    
       
       
       
       
  1. void qsorts(DataType *a, int n) {
    2. 
       
       
       
       
  2.     if(n <= 1) return;
    3. 
       
       
       
       
  3. }
    4.

上述代码中，形参变量n得到的是数组元素个数 ，当n小于等于1时，使函数返回。

步骤二：将数组分成两部分

首先，定义一个变量L，用于存储数组的上界

然后，再定义一个变量R，用于存储数组的下界。

最后，设置循环将数组分成两部分

代码如下：


      
      
      
      
    
       
       
       
       
  1. void qsorts(DataType *a, int n) {
    2. 
       
       
       
       
  2.     if(n <= 1) return;
    3. 
       
       
       
       
  3.     int L = 0;
    4. 
       
       
       
       
  4.     int R = n - 1;
    5. 
       
       
       
       
  5.     while (L < R) {
    6. 
       
       
       
       
  6.         //一次分组
    7. 
       
       
       
       
  7.         while (L < R && a[L] <= a[R]) R--;
    8. 
       
       
       
       
  8.         DataType t = a[L];
    9. 
       
       
       
       
  9.         a[L] = a[R];
    10. 
       
       
       
       
  10.         a[R] = t;
    11. 
       
       
       
       
  11.         while (L < R && a[L] <= a[R]) L++;
    12. 
       
       
       
       
  12.         t = a[L];
    13. 
       
       
       
       
  13.         a[L] = a[R];
    14. 
       
       
       
       
  14.         a[R] = t;
    15. 
       
       
       
       
  15.     }
    16. 
       
       
       
       
  16. }
    17.

上述代码中，以下代码：


      
      
      
      
    
       
       
       
       
  1.         while (L < R && a[L] <= a[R]) R--;
    2. 
       
       
       
       
  2.         DataType t = a[L];
    3. 
       
       
       
       
  3.         a[L] = a[R];
    4. 
       
       
       
       
  4.         a[R] = t;
    5.

是从后向前寻找不符合顺序的元素，找到后，将其进行交换。

上述代码中，以下代码：


      
      
      
      
    
       
       
       
       
  1.         while (L < R && a[L] <= a[R]) L++;
    2. 
       
       
       
       
  2.         t = a[L];
    3. 
       
       
       
       
  3.         a[L] = a[R];
    4. 
       
       
       
       
  4.         a[R] = t;
    5.

是从前向后寻找不符合顺序的元素，找到后，将其进行交换。

步骤三：递归分组

将分好的前后两部分用递归的方法再分。

代码如下：


      
      
      
      
    
       
       
       
       
  1. void qsorts(DataType *a, int n) {
    2. 
       
       
       
       
  2.     if(n <= 1) return;
    3. 
       
       
       
       
  3.     int L = 0;
    4. 
       
       
       
       
  4.     int R = n - 1;
    5. 
       
       
       
       
  5.     while (L < R) {
    6. 
       
       
       
       
  6.         //一次分组
    7. 
       
       
       
       
  7.         while (L < R && a[L] <= a[R]) R--;
    8. 
       
       
       
       
  8.         DataType t = a[L];
    9. 
       
       
       
       
  9.         a[L] = a[R];
    10. 
       
       
       
       
  10.         a[R] = t;
    11. 
       
       
       
       
  11.         while (L < R && a[L] <= a[R]) L++;
    12. 
       
       
       
       
  12.         t = a[L];
    13. 
       
       
       
       
  13.         a[L] = a[R];
    14. 
       
       
       
       
  14.         a[R] = t;
    15. 
       
       
       
       
  15.     }
    16. 
       
       
       
       
  16.     //继续左边分组
    17. 
       
       
       
       
  17.     qsorts(a, L);
    18. 
       
       
       
       
  18.     //继续右边分组
    19. 
       
       
       
       
  19.     qsorts(a + L + 1, n - L - 1);
    20. 
       
       
       
       
  20. }
    21.

6.4 完整代码

本案例的完整代码如下所示：


      
      
      
      
    
       
       
       
       
  1. typedef int DataType;
    2. 
       
       
       
       
  2. void qsorts(DataType *a, int n) {
    3. 
       
       
       
       
  3.     if(n <= 1) return;
    4. 
       
       
       
       
  4.     int L = 0;
    5. 
       
       
       
       
  5.     int R = n - 1;
    6. 
       
       
       
       
  6.     while (L < R) {
    7. 
       
       
       
       
  7.         //一次分组
    8. 
       
       
       
       
  8.         while (L < R && a[L] <= a[R]) R--;
    9. 
       
       
       
       
  9.         DataType t = a[L];
    10. 
       
       
       
       
  10.         a[L] = a[R];
    11. 
       
       
       
       
  11.         a[R] = t;
    12. 
       
       
       
       
  12.         while (L < R && a[L] <= a[R]) L++;
    13. 
       
       
       
       
  13.         t = a[L];
    14. 
       
       
       
       
  14.         a[L] = a[R];
    15. 
       
       
       
       
  15.         a[R] = t;
    16. 
       
       
       
       
  16.     }
    17. 
       
       
       
       
  17.     //继续左边分组
    18. 
       
       
       
       
  18.     qsorts(a, L);
    19. 
       
       
       
       
  19.     //继续右边分组
    20. 
       
       
       
       
  20.     qsorts(a + L + 1, n - L - 1);
    21. 
       
       
       
       
  21. }
    22. 
       
       
       
       
  22. 
       
       
       
       
  23. void print(DataType* a, int n) {
    24. 
       
       
       
       
  24.     for (int i = 0; i < n; i++)
    25. 
       
       
       
       
  25.         printf("%d ", a[i]);
    26. 
       
       
       
       
  26.     printf("\n");
    27. 
       
       
       
       
  27. }
    28. 
       
       
       
       
  28. 
       
       
       
       
  29. int main() {
    30. 
       
       
       
       
  30.     int a[10] = {3, 2, 4, 5, 7, 8, 9, 1, 6, 0};
    31. 
       
       
       
       
  31.     
    32. 
       
       
       
       
  32.     qsorts(a, 10);
    33. 
       
       
       
       
  33.     print(a, 10);
    34. 
       
       
       
       
  34.     
    35. 
       
       
       
       
  35.     return 0;
    36. 
       
       
       
       
  36. }
    37.

7 归并排序

7.1 问题

归并排序是将两个已经排好序的序列合并成一个序列的操作。

归并排序的过程是这样的。首先，将待排序的数组中的元素从中间分为前后两部分。然后再将前一部分继续分成两部份，后一部分也继续分成两部分，依次类推，直到单个元素为止。最后两两按序合并，直到整个数组合并成一个有序数组为止。

7.2 方案

为了理解归并排序算法，我们先假设有一个长度为8的数组，数组内容如图-28所示：

图-28

现需要将数组内的元素先分成前后两部分，如图-29所示：

图-29

然后，将前后两部分继续分解，直至单个元素为止，如图-30所示：

图-30

下一步，重新两两合并，在合并的过程中注意先进行了排序，如图-31所示：

图-31

下一步，继续合并，直至整个数组排好序为止，如图-32所示：

图-32

7.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：将数组分成前后两部分

使用递归方法，将数组先分成前后两部分，然后再将前一部分分解，最后将后一部分分解。

代码如下：


      
      
      
      
    
       
       
       
       
  1. //内部使用递归
    2. 
       
       
       
       
  2. void MergeSort(int sourceArr[],int startIndex,int endIndex)
    3. 
       
       
       
       
  3. {
    4. 
       
       
       
       
  4.     int midIndex;
    5. 
       
       
       
       
  5.     if(startIndex<endIndex)
    6. 
       
       
       
       
  6.     {
    7. 
       
       
       
       
  7.         midIndex=(startIndex+endIndex)/2;
    8. 
       
       
       
       
  8.         MergeSort(sourceArr,startIndex,midIndex);
    9. 
       
       
       
       
  9.         MergeSort(sourceArr,midIndex+1,endIndex);
    10. 
       
       
       
       
  10.     }
    11. 
       
       
       
       
  11. }
    12.

上述代码中，以下代码：


      
      
      
      
    
       
       
       
       
  1.         midIndex=(startIndex+endIndex)/2;
    2.

是确定将数组分成前后两部分的中间点。

步骤二：将前后两部分重新按序合并

代码如下：


      
      
      
      
    
       
       
       
       
  1. #include<stdlib.h>
    2. 
       
       
       
       
  2. #include<stdio.h>
    3. 
       
       
       
       
  3. 
       
       
       
       
  4. #define SIZE 8
    5. 
       
       
       
       
  5. 
       
       
       
       
  6. void Merge(int sourceArr[],int startIndex,int midIndex,int endIndex)
    7. 
       
       
       
       
  7. {
    8. 
       
       
       
       
  8.     int start = startIndex;
    9. 
       
       
       
       
  9.     int i,j,k;
    10. 
       
       
       
       
  10.     int tempArr[SIZE];
    11. 
       
       
       
       
  11.     for(i=midIndex+1,j=startIndex;startIndex<=midIndex&&i<=endIndex;j++)
    12. 
       
       
       
       
  12.         if(sourceArr[startIndex]<=sourceArr[i])
    13. 
       
       
       
       
  13.             tempArr[j]=sourceArr[startIndex++];
    14. 
       
       
       
       
  14.         else
    15. 
       
       
       
       
  15.             tempArr[j]=sourceArr[i++];
    16. 
       
       
       
       
  16.     if(startIndex<=midIndex)
    17. 
       
       
       
       
  17.         for(k=0;k<=midIndex-startIndex;k++)
    18. 
       
       
       
       
  18.             tempArr[j+k]=sourceArr[startIndex+k];
    19. 
       
       
       
       
  19.     if(i<=endIndex)
    20. 
       
       
       
       
  20.         for(k=0;k<=endIndex-i;k++)
    21. 
       
       
       
       
  21.             tempArr[j+k]=sourceArr[i+k];
    22. 
       
       
       
       
  22.     for(i=start;i<=endIndex;i++)
    23. 
       
       
       
       
  23.         sourceArr[i]=tempArr[i];
    24. 
       
       
       
       
  24. }
    25. 
       
       
       
       
  25. 
       
       
       
       
  26. //内部使用递归
    27. 
       
       
       
       
  27. void MergeSort(int sourceArr[],int startIndex,int endIndex)
    28. 
       
       
       
       
  28. {
    29. 
       
       
       
       
  29.     int midIndex;
    30. 
       
       
       
       
  30.     if(startIndex<endIndex)
    31. 
       
       
       
       
  31.     {
    32. 
       
       
       
       
  32.         midIndex=(startIndex+endIndex)/2;
    33. 
       
       
       
       
  33.         MergeSort(sourceArr,startIndex,midIndex);
    34. 
       
       
       
       
  34.         MergeSort(sourceArr,midIndex+1,endIndex);
    35. 
       
       
       
       
  35.         Merge(sourceArr,startIndex,midIndex,endIndex);
    36. 
       
       
       
       
  36.     }
    37. 
       
       
       
       
  37. }
    38.

上述代码中，以下代码：


      
      
      
      
    
       
       
       
       
  1.     int tempArr[SIZE];
    2.

是定义一个临时数组，用于合并过程中排序时使用。

上述代码中，以下代码：


      
      
      
      
    
       
       
       
       
  1.     for(i=midIndex+1,j=startIndex;startIndex<=midIndex&&i<=endIndex;j++)
    2. 
       
       
       
       
  2.         if(sourceArr[startIndex]<=sourceArr[i])
    3. 
       
       
       
       
  3.             tempArr[j]=sourceArr[startIndex++];
    4. 
       
       
       
       
  4.         else
    5. 
       
       
       
       
  5.             tempArr[j]=sourceArr[i++];
    6.

是先挑选前后两部分中小的数组元素放入临时数组。

上述代码中，以下代码：


      
      
      
      
    
       
       
       
       
  1.     if(startIndex<=midIndex)
    2. 
       
       
       
       
  2.         for(k=0;k<=midIndex-startIndex;k++)
    3. 
       
       
       
       
  3.             tempArr[j+k]=sourceArr[startIndex+k];
    4.

是将前一部分中剩余的元素放入临时数组。

上述代码中，以下代码：


      
      
      
      
    
       
       
       
       
  1.     if(i<=endIndex)
    2. 
       
       
       
       
  2.         for(k=0;k<=endIndex-i;k++)
    3. 
       
       
       
       
  3.             tempArr[j+k]=sourceArr[i+k];
    4.

是将后一部分中剩余的元素放入临时数组。

上述代码中，以下代码：


      
      
      
      
    
       
       
       
       
  1.     for(i=start;i<=endIndex;i++)
    2. 
       
       
       
       
  2.         sourceArr[i]=tempArr[i];
    3.

是将临时数组内的内容放回到待排序数组中。

7.4 完整代码

本案例的完整代码如下所示：


      
      
      
      
    
       
       
       
       
  1. #include<stdlib.h>
    2. 
       
       
       
       
  2. #include<stdio.h>
    3. 
       
       
       
       
  3. 
       
       
       
       
  4. #define SIZE 8
    5. 
       
       
       
       
  5. 
       
       
       
       
  6. void Merge(int sourceArr[],int startIndex,int midIndex,int endIndex)
    7. 
       
       
       
       
  7. {
    8. 
       
       
       
       
  8.     int start = startIndex;
    9. 
       
       
       
       
  9.     int i,j,k;
    10. 
       
       
       
       
  10.     int tempArr[SIZE];
    11. 
       
       
       
       
  11.     for(i=midIndex+1,j=startIndex;startIndex<=midIndex&&i<=endIndex;j++)
    12. 
       
       
       
       
  12.         if(sourceArr[startIndex]<=sourceArr[i])
    13. 
       
       
       
       
  13.             tempArr[j]=sourceArr[startIndex++];
    14. 
       
       
       
       
  14.         else
    15. 
       
       
       
       
  15.             tempArr[j]=sourceArr[i++];
    16. 
       
       
       
       
  16.     if(startIndex<=midIndex)
    17. 
       
       
       
       
  17.         for(k=0;k<=midIndex-startIndex;k++)
    18. 
       
       
       
       
  18.             tempArr[j+k]=sourceArr[startIndex+k];
    19. 
       
       
       
       
  19.     if(i<=endIndex)
    20. 
       
       
       
       
  20.         for(k=0;k<=endIndex-i;k++)
    21. 
       
       
       
       
  21.             tempArr[j+k]=sourceArr[i+k];
    22. 
       
       
       
       
  22.     for(i=start;i<=endIndex;i++)
    23. 
       
       
       
       
  23.         sourceArr[i]=tempArr[i];
    24. 
       
       
       
       
  24. }
    25. 
       
       
       
       
  25. 
       
       
       
       
  26. //内部使用递归
    27. 
       
       
       
       
  27. void MergeSort(int sourceArr[],int startIndex,int endIndex)
    28. 
       
       
       
       
  28. {
    29. 
       
       
       
       
  29.     int midIndex;
    30. 
       
       
       
       
  30.     if(startIndex<endIndex)
    31. 
       
       
       
       
  31.     {
    32. 
       
       
       
       
  32.         midIndex=(startIndex+endIndex)/2;
    33. 
       
       
       
       
  33.         MergeSort(sourceArr,startIndex,midIndex);
    34. 
       
       
       
       
  34.         MergeSort(sourceArr,midIndex+1,endIndex);
    35. 
       
       
       
       
  35.         Merge(sourceArr,startIndex,midIndex,endIndex);
    36. 
       
       
       
       
  36.     }
    37. 
       
       
       
       
  37. }
    38. 
       
       
       
       
  38. 
       
       
       
       
  39. //调用
    40. 
       
       
       
       
  40. int main(int argc,char * argv[])
    41. 
       
       
       
       
  41. {
    42. 
       
       
       
       
  42.     int a[SIZE] = {8,4,6,3,1,7,5,2};
    43. 
       
       
       
       
  43.     MergeSort(a,0,SIZE-1);
    44. 
       
       
       
       
  44.     for(int i=0;i<SIZE;i++)
    45. 
       
       
       
       
  45.         printf("%d ",a[i]);
    46. 
       
       
       
       
  46.     printf("\n");
    47. 
       
       
       
       
  47.     return 0;
    48. 
       
       
       
       
  48. }
    49.
Top
  1. 线性查找
  2. 二分查找
  3. 冒泡排序
  4. 插入排序
  5. 选择排序
  6. 快速排序
  7. 归并排序

1 线性查找

1.1 问题

线性查找，又称为顺序查找，是指在所有给定的值中从一端开始逐个检查每个元素是否为要查找的对象，直到找到为止的过程。

1.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：逐个查找要查找的对象

代码如下：


       
       
       
       
    
        
        
        
        
  1. #include <stdio.h>
    2. 
        
        
        
        
  2. 
        
        
        
        
  3. typedef char DataType;
    4. 
        
        
        
        
  4. int mySearch(DataType *ts, int n, const DataType d) {
    5. 
        
        
        
        
  5.     for (int i = 0; i < n; i++)
    6. 
        
        
        
        
  6.         if (ts[i] == d)
    7. 
        
        
        
        
  7.             return i;
    8. 
        
        
        
        
  8.     return -1;
    9. 
        
        
        
        
  9. }
    10.

上述代码中，以下代码：


       
       
       
       
    
        
        
        
        
  1. int mySearch(DataType *ts, int n, const DataType d) {
    2.

是线性查找的函数头，它有三个形参，第一个形参是要查找的数组，第二个形参是数组中元素的个数，第三个形参是要查找的对象。

1.3 完整代码

本案例的完整代码如下所示：


       
       
       
       
    
        
        
        
        
  1. #include <stdio.h>
    2. 
        
        
        
        
  2. 
        
        
        
        
  3. typedef char DataType;
    4. 
        
        
        
        
  4. int mySearch(DataType *ts, int n, const DataType d) {
    5. 
        
        
        
        
  5.     for (int i = 0; i < n; i++)
    6. 
        
        
        
        
  6.         if (ts[i] == d)
    7. 
        
        
        
        
  7.             return i;
    8. 
        
        
        
        
  8.     return -1;
    9. 
        
        
        
        
  9. }
    10. 
        
        
        
        
  10. 
        
        
        
        
  11. int main()
    12. 
        
        
        
        
  12. {
    13. 
        
        
        
        
  13.     char cs[6] = {'*','A','B','C','D','E'};
    14. 
        
        
        
        
  14.     printf("%d\n", mySearch(cs, 6, '*'));
    15. 
        
        
        
        
  15.     printf("%d\n", mySearch(cs, 6, 'A'));
    16. 
        
        
        
        
  16.     printf("%d\n", mySearch(cs, 6, 'D'));
    17. 
        
        
        
        
  17.     printf("%d\n", mySearch(cs, 6, 'C'));
    18. 
        
        
        
        
  18. }
    19.

2 二分查找

2.1 问题

二分查找算法，又称折半搜索、二分搜索，是一种在有序数组中查找某一特定元素的搜索算法。

二分查找算法的查找过程是这样的。首先，要求待查找的数组是排好序的数组，我们假设数组是升序的，即从小到大排序。然后，将要查找的元素与数组的中间元素相对比，如果相等，则表示要查找的元素被找到了，并停止查找；如果要查找的元素小于数组的中间元素，则从数组中间元素开始到数组最后的元素都大于要查找的元素，也就不需要在其中查找了，只需要在数组中间元素到数组第一个元素之间查找；如果要查找的元素大于数组的中间元素，则从数组中间元素到数组第一个元素都小于要查找的元素，也就不需要在其中查找了，只需要在数组中间元素到数组最后的元素之间查找。

由此可见，二分查找算法在查找的过程中只需对比一次，就可以使待查找的对象个数减少一半。查找速度非常快，所以二分查找算法得到了广泛的应用。

2.2 方案

为了理解二分查找算法，我们先假设有一个长度为11的数组，数组内容如图-1所示：

图-1

图-1中的数组是排好序的数组，从小到大排序。数组左边的数字7为数组的第一个元素，数组右边的数字94为数组的最后一个元素。要查找的元素假设为22。查找过程如下：

首先，确定查找范围，因为是第一次在数组中查找，所以整个数组都是待查找的范围，这样将带查找范围的下界low定为数组的第一个元素7，上界high定为数组的最后一个元素94，那么在上下界中间的元素就是数组元素56，我们用mid表示。

然后，将要查找的元素22与中间的元素，即数组元素56，相对比。因为22小于56，所以从中间元素mid到数组的上界high之间的所有元素都大于22，由图-1可以看出，mid到high之间分别是56、66、79、84、88、94，它们都大于22。由此可知这些元素都可以排除在下次查找的范围内了。即一次对比，就可以使待查找的对象个数减少一半。

最后，确定新的待查找范围，如图-2所示：

图-2

新的查找范围的下界low定为数组的第一个元素7，上界high定为数组的元素40，因为在上一次查找的过程中，数组元素56、66、79、84、88、94均已被排除在查找范围之外了。由上下界可以得到中间元素的数组元素为18，用mid表示。

然后，将要查找的元素22与中间的元素，即数组元素18，相对比。因为22大于18，所以从中间元素mid到数组的下界low之间的所有元素都小于22，由图-2可以看出，low到mid之间分别是7、12、18，它们都小于22。由此可知这些元素也都可以排除在下次查找的范围内了。

这样，再确定新的查找范围，如图-3所示：

图-3

新的查找范围的下界low定为数组元素22，上界high定为数组的元素40，因为在上一次查找的过程中，数组元素7、12、18均已被排除在查找范围之外了。由于上下界之间只有2个元素，所以中间元素的数组元素为22，用mid表示。

然后，将要查找的元素22与中间的元素，即数组元素22，相对比。因为相等，所以在数组中找到了要查找的元素。程序结束。

2.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：定义上下界

1)定义一个变量L，用于代表下界。

2)定义一个变量R，用于代表上界。

代码如下：


       
       
       
       
    
        
        
        
        
  1. int mySearch(DataType *ts, int n, const DataType d) {
    2. 
        
        
        
        
  2.     int L = 0;
    3. 
        
        
        
        
  3.     int R = n - 1;
    4. 
        
        
        
        
  4. }
    5.

步骤二：确定中间点

1)定义一个变量M，用于代表中间点。

2)将中间点元素与要查找的元素对比，如果相等，则表示找到了要查找的元素，程序退出。

代码如下：


       
       
       
       
    
        
        
        
        
  1. int mySearch(DataType *ts, int n, const DataType d) {
    2. 
        
        
        
        
  2.     int L = 0;
    3. 
        
        
        
        
  3.     int R = n - 1;
    4. 
        
        
        
        
  4. 
        
        
        
        
  5.         int M = (L + R)/2;
    6. 
        
        
        
        
  6.         if (ts[M] == d) return M;
    7. 
        
        
        
        
  7. }
    8.

步骤三：重新确定查找范围

如果中间点元素小于要查找的元素，则将下界L更改为M+1，否则将上界R更改为M-1。

代码如下：


       
       
       
       
    
        
        
        
        
  1. int mySearch(DataType *ts, int n, const DataType d) {
    2. 
        
        
        
        
  2.     int L = 0;
    3. 
        
        
        
        
  3.     int R = n - 1;
    4. 
        
        
        
        
  4. 
        
        
        
        
  5.         int M = (L + R)/2;
    6. 
        
        
        
        
  6.         if (ts[M] == d) return M;
    7. 
        
        
        
        
  7.         if (ts[M] < d)
    8. 
        
        
        
        
  8.             L = M+1;
    9. 
        
        
        
        
  9.         else
    10. 
        
        
        
        
  10.             R = M - 1;
    11. 
        
        
        
        
  11. 
        
        
        
        
  12.     return -1;
    13. 
        
        
        
        
  13. }
    14.

步骤四：按新范围重新查找

如果，一次未找到，则需要设置循环反复查找，直到找到或待查找范围内的元素个数为0。

代码如下：


       
       
       
       
    
        
        
        
        
  1. int mySearch(DataType *ts, int n, const DataType d) {
    2. 
        
        
        
        
  2.     int L = 0;
    3. 
        
        
        
        
  3.     int R = n - 1;
    4. 
        
        
        
        
  4.     while (L <= R) {
    5. 
        
        
        
        
  5.         int M = (L + R)/2;
    6. 
        
        
        
        
  6.         if (ts[M] == d) return M;
    7. 
        
        
        
        
  7.         if (ts[M] < d)
    8. 
        
        
        
        
  8.             L = M+1;
    9. 
        
        
        
        
  9.         else
    10. 
        
        
        
        
  10.             R = M - 1;
    11. 
        
        
        
        
  11.     }
    12. 
        
        
        
        
  12.     return -1;
    13. 
        
        
        
        
  13. }
    14.

上述代码中，以下代码：


       
       
       
       
    
        
        
        
        
  1.     while (L <= R) {
    2.

中的L<=R这个循环条件为真时，表示待查找范围内的数组元素个数至少为1。当这个循环条件为假时，则表示待查找范围内的数组元素个数已经为0，即没有可查找的对象了。

2.4 完整代码

本案例的完整代码如下所示：


       
       
       
       
    
        
        
        
        
  1. typedef char DataType;
    2. 
        
        
        
        
  2. int mySearch(DataType *ts, int n, const DataType d) {
    3. 
        
        
        
        
  3.     int L = 0;
    4. 
        
        
        
        
  4.     int R = n - 1;
    5. 
        
        
        
        
  5.     while (L <= R) {
    6. 
        
        
        
        
  6.         int M = (L + R)/2;
    7. 
        
        
        
        
  7.         if (ts[M] == d) return M;
    8. 
        
        
        
        
  8.         if (ts[M] < d)
    9. 
        
        
        
        
  9.             L = M+1;
    10. 
        
        
        
        
  10.         else
    11. 
        
        
        
        
  11.             R = M - 1;
    12. 
        
        
        
        
  12.     }
    13. 
        
        
        
        
  13.     return -1;
    14. 
        
        
        
        
  14. }
    15. 
        
        
        
        
  15. 
        
        
        
        
  16. int main()
    17. 
        
        
        
        
  17. {
    18. 
        
        
        
        
  18.     char cs[6] = {'*','A','B','C','D','E'};
    19. 
        
        
        
        
  19.     printf("%d\n", mySearch(cs, 6, '*'));
    20. 
        
        
        
        
  20.     printf("%d\n", mySearch(cs, 6, 'A'));
    21. 
        
        
        
        
  21.     printf("%d\n", mySearch(cs, 6, 'D'));
    22. 
        
        
        
        
  22.     printf("%d\n", mySearch(cs, 6, 'C'));
    23. 
        
        
        
        
  23. }
    24.

3 冒泡排序

3.1 问题

冒泡排序是一种著名的排序方法。

冒泡排序的过程是这样的，首先，将待排序的数组中的第一个元素与第二个元素相对比，如果这两个元素的大小顺序不是我们要求的顺序，则将它们交换过来。然后，将待排序的数组中的第二个元素与第三个元素相对比，如果这两个元素的大小顺序也不是我们要求的顺序，则也将它们交换过来。下一步，是对比第三个元素与第四个元素，直至倒数第二个元素与最后一个元素相对比。这样一趟对比下来，小的数据元素会一点一点的往前放，而大的数据元素会一点一点的往后放。反复多趟的这样对比，直到所有数据都排好序为止。

3.2 方案

为了理解冒泡排序算法，我们先假设有一个长度为10的数组，数组内容如图-4所示：

图-4

图-4中的数组元素为无序状态，现需要将数组内的元素排序成从小到大的升序状态。可以先进行第一趟比较。首先比较第1个和第2个数，也就是数组第一个元素3和数组第二个元素2，将小数放前，大数放后。交换后如图-5所示：

图-5

然后，将图-5中的第2个和第3个数，也就是数组第二个元素3和数组第三个元素4，进行对比，由于3小于4，所以不进行交换。接着将图-5中的第3个和第4个数对比后发现也不需要交换。这样依次进行对比，直到图-5中的第7个和第8个数，也就是数组第七个元素9和数组第八个元素1，对比时，需要将它们交换过来，如图-6所示：

图-6

继续第一趟比较，图-6中的第8个和第9个数，也就是数组第八个元素9和数组第九个元素6，对比时，需要将它们交换过来，如图-7所示：

图-7

第一趟最后比较，图-7中的第9个和第10个数，也就是数组第九个元素9和数组第十个元素0，对比时，需要将它们交换过来，如图-8所示：

图-8

至此，第一趟比较结束，我们会发现数组中的最大值通过不断的位置交换，移到了数组最后一个元素的位置。但其它元素仍然是无序状态。所以需要进行第二趟比较，只是此次比较的范围应刨除数组的最后一个元素。当第二趟比较结束时，倒数第二大的数组元素值会被放置到数组的倒数第二个位置，如图-9所示：

图-9

第二趟比较结束后，依次进行后面的比较，直到数组内的元素按照升序排好为止。整个排序过程如图-10所示：

图-10

由图－10可以看出，实现冒泡排序算法时，需要使用嵌套的两个循环来实现：外层循环用于控制排序的趟次，里层循环用于控制每趟排序中的两两交换。

3.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：第一趟比较

设置循环，将待排序数组中的数组元素两两进行比较，如果有不符合要求的顺序的，进行交换。

代码如下所示：


       
       
       
       
    
        
        
        
        
  1. void bubble(DataType* a, int n) {
    2. 
        
        
        
        
  2.         for (int j = 0; j < n -  i - 1; j++) {
    3. 
        
        
        
        
  3.             if (a[j] > a[j + 1]) {
    4. 
        
        
        
        
  4.                 DataType t = a[j];
    5. 
        
        
        
        
  5.                 a[j] = a[j + 1];
    6. 
        
        
        
        
  6.                 a[j + 1] = t;
    7. 
        
        
        
        
  7.                 flag = false;
    8. 
        
        
        
        
  8.             }
    9. 
        
        
        
        
  9.         }
    10. 
        
        
        
        
  10. }
    11.

步骤二：多趟比较，直至排好序

设置外层循环，进行多趟比较。

代码如下所示：


       
       
       
       
    
        
        
        
        
  1. void bubble(DataType* a, int n) {
    2. 
        
        
        
        
  2.     for (int i = 0; i < n - 1; i++) {
    3. 
        
        
        
        
  3.         for (int j = 0; j < n -  i - 1; j++) {
    4. 
        
        
        
        
  4.             if (a[j] > a[j + 1]) {
    5. 
        
        
        
        
  5.                 DataType t = a[j];
    6. 
        
        
        
        
  6.                 a[j] = a[j + 1];
    7. 
        
        
        
        
  7.                 a[j + 1] = t;
    8. 
        
        
        
        
  8.                 flag = false;
    9. 
        
        
        
        
  9.             }
    10. 
        
        
        
        
  10.         }
    11. 
        
        
        
        
  11.     }
    12. 
        
        
        
        
  12. }
    13.

步骤三：设置标志，提高效率

代码如下所示：


       
       
       
       
    
        
        
        
        
  1. void bubble(DataType* a, int n) {
    2. 
        
        
        
        
  2.     for (int i = 0; i < n - 1; i++) {
    3. 
        
        
        
        
  3.         bool flag = true;
    4. 
        
        
        
        
  4.         for (int j = 0; j < n -  i - 1; j++) {
    5. 
        
        
        
        
  5.             if (a[j] > a[j + 1]) {
    6. 
        
        
        
        
  6.                 DataType t = a[j];
    7. 
        
        
        
        
  7.                 a[j] = a[j + 1];
    8. 
        
        
        
        
  8.                 a[j + 1] = t;
    9. 
        
        
        
        
  9.                 flag = false;
    10. 
        
        
        
        
  10.             }
    11. 
        
        
        
        
  11.         }
    12. 
        
        
        
        
  12.         if (flag) break;
    13. 
        
        
        
        
  13.     }
    14. 
        
        
        
        
  14. }
    15.

上述代码中，以下代码：


       
       
       
       
    
        
        
        
        
  1.         bool flag = true;
    2.

定义一个布尔型变量，初始化为真，为真代表数组已经排好序了。

上述代码中，以下代码：


       
       
       
       
    
        
        
        
        
  1.         for (int j = 0; j < n -  i - 1; j++) {
    2. 
        
        
        
        
  2.             if (a[j] > a[j + 1]) {
    3. 
        
        
        
        
  3.                 DataType t = a[j];
    4. 
        
        
        
        
  4.                 a[j] = a[j + 1];
    5. 
        
        
        
        
  5.                 a[j + 1] = t;
    6. 
        
        
        
        
  6.                 flag = false;
    7. 
        
        
        
        
  7.             }
    8. 
        
        
        
        
  8.         }
    9.

是进行某趟比较，在该趟比较过程中，如果数组中所有元素两两比较均为假，则就不需要进行交换，而此时flag=false；语句也就不会执行。因此循环退出时，flag为真，即数组已经排好序了。

上述代码中，以下代码：


       
       
       
       
    
        
        
        
        
  1.         if (flag) break;
    2.

表示如果flag为真，即数组已经排好序，则停止排序。

3.4 完整代码

本案例的完整代码如下所示：


       
       
       
       
    
        
        
        
        
  1. typedef int DataType;
    2. 
        
        
        
        
  2. void bubble(DataType* a, int n) {
    3. 
        
        
        
        
  3.     for (int i = 0; i < n - 1; i++) {
    4. 
        
        
        
        
  4.         bool flag = true;
    5. 
        
        
        
        
  5.         for (int j = 0; j < n -  i - 1; j++) {
    6. 
        
        
        
        
  6.             if (a[j] > a[j + 1]) {
    7. 
        
        
        
        
  7.                 DataType t = a[j];
    8. 
        
        
        
        
  8.                 a[j] = a[j + 1];
    9. 
        
        
        
        
  9.                 a[j + 1] = t;
    10. 
        
        
        
        
  10.                 flag = false;
    11. 
        
        
        
        
  11.             }
    12. 
        
        
        
        
  12.         }
    13. 
        
        
        
        
  13.         if (flag) break;
    14. 
        
        
        
        
  14.     }
    15. 
        
        
        
        
  15. }
    16. 
        
        
        
        
  16. 
        
        
        
        
  17. void print(DataType* a, int n) {
    18. 
        
        
        
        
  18.     for (int i = 0; i < n; i++)
    19. 
        
        
        
        
  19.         printf("%d ", a[i]);
    20. 
        
        
        
        
  20.     printf("\n");
    21. 
        
        
        
        
  21. }
    22. 
        
        
        
        
  22. 
        
        
        
        
  23. int main() {
    24. 
        
        
        
        
  24.     int a[10] = {3, 2, 4, 5, 7, 8, 9, 1, 6, 0};
    25. 
        
        
        
        
  25.     bubble(a, 10);
    26. 
        
        
        
        
  26.     print(a, 10);
    27. 
        
        
        
        
  27.     
    28. 
        
        
        
        
  28.     return 0;
    29. 
        
        
        
        
  29. }
    30.

4 插入排序

插入排序算法是一种简单直观的排序算法。

插入排序的过程是这样的，首先，将待排序的数组分成两部分，一部分是已经排好序的部分，另一部分是未排好序的部分。在开始排序前，已排好序的部分只有一个数组元素，即数组的第一个元素；未排好序的部分是数组中除第一个元素外的其它所有元素。然后，将未排好序部分中的第一个数组元素，插入到已排序部分当中适当的位置，以保证已排序部分仍然是保持排序状态。此时，已排序部分就变成两个数组元素，而未排序部分的数组元素同时少了一个。依次类推，逐个从未排好序的部分拿出一个元素，插入到已排序部分当中适当的位置，直至数组按顺序排好为止。

4.1 方案

为了理解插入排序算法，我们先假设有一个长度为10的数组，数组内容如图-17所示：

图-11

图-17中的数组元素为无序状态，现需要将数组内的元素排序成从小到大的升序状态。首先将数组中的所有元素分成两个部分，一部分已排好序的部分，另一部分是未排好序的部分，在开始时，已排好序的部分只有一个数组元素，剩余的数组元素为未排好序的部分，如图-18所示：

图-12

将未排好序部分的一个元素取出，插入到已排好序部分的适当位置，如图-18中，将数组元素2从未排好序部分取出，与已排好序的部分的数组元素3对比，因为2小于3，所以将2插入到3的前面，如图-19所示：

图-13

此时，已排好序的部分变成了2个元素，而未排好序的部分少了一个元素，然后，再将未排好序部分的一个元素取出，插入到已排好序部分的适当位置，如图-19中，将数组元素4从未排好序部分取出，与已排好序的部分的数组元素3对比，因为4大于3，所以直接将4划入已排好序的部分，如图-20所示：

图-14

此时，已排好序的部分变成了3个元素，而未排好序的部分又少了一个元素，依次类推，逐个将未排好序的部分的元素插入到已排序的部分，直至整个数组都排好序为止。整个排序过程如图-21所示：

图-15

4.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：将未排序部分的第一个元素插入到已排序部分

首先，定义临时变量，用于保存未排序部分的第一个元素

然后，设置循环，将未排序部分的第一个元素插入到已排序部分。

代码如下所示：


       
       
       
       
    
        
        
        
        
  1. void insert(DataType *a, int n) {
    2. 
        
        
        
        
  2.         int i = 1;
    3. 
        
        
        
        
  3.         //把选择的元素放在临时变量中
    4. 
        
        
        
        
  4.         DataType t = a[i];
    5. 
        
        
        
        
  5.         int j = 0;
    6. 
        
        
        
        
  6.         for (j = i; j > 0 && a[j - 1] > t; j--) {
    7. 
        
        
        
        
  7.             a[j] = a[j - 1];
    8. 
        
        
        
        
  8.         }
    9. 
        
        
        
        
  9.         a[j] = t;
    10. 
        
        
        
        
  10. }
    11.

上述代码中，以下代码：


       
       
       
       
    
        
        
        
        
  1.         for (j = i; j > 0 && a[j - 1] > t; j--) {
    2. 
        
        
        
        
  2.             a[j] = a[j - 1];
    3. 
        
        
        
        
  3.         }
    4. 
        
        
        
        
  4.         a[j] = t;
    5.

是将未排序部分的第一个元素t插入到已排序部分的适当位置a[j]。

步骤二：将所有未排序部分的元素插入到已排序部分

设置循环，逐个将未排序部分元素取出来，插入到已排序部分。

代码如下所示：


       
       
       
       
    
        
        
        
        
  1. void insert(DataType *a, int n) {
    2. 
        
        
        
        
  2.     for (int i = 1; i < n; i++) {
    3. 
        
        
        
        
  3.         //把选择的元素放在临时变量中
    4. 
        
        
        
        
  4.         DataType t = a[i];
    5. 
        
        
        
        
  5.         int j = 0;
    6. 
        
        
        
        
  6.         for (j = i; j > 0 && a[j - 1] > t; j--) {
    7. 
        
        
        
        
  7.             a[j] = a[j - 1];
    8. 
        
        
        
        
  8.         }
    9. 
        
        
        
        
  9.         a[j] = t;
    10. 
        
        
        
        
  10.     }
    11. 
        
        
        
        
  11. }
    12.

4.3 完整代码

本案例的完整代码如下所示：


       
       
       
       
    
        
        
        
        
  1. typedef int DataType;
    2. 
        
        
        
        
  2. void insert(DataType *a, int n) {
    3. 
        
        
        
        
  3.     for (int i = 1; i < n; i++) {
    4. 
        
        
        
        
  4.         //把选择的元素放在临时变量中
    5. 
        
        
        
        
  5.         DataType t = a[i];
    6. 
        
        
        
        
  6.         int j = 0;
    7. 
        
        
        
        
  7.         for (j = i; j > 0 && a[j - 1] > t; j--) {
    8. 
        
        
        
        
  8.             a[j] = a[j - 1];
    9. 
        
        
        
        
  9.         }
    10. 
        
        
        
        
  10.         a[j] = t;
    11. 
        
        
        
        
  11.     }
    12. 
        
        
        
        
  12. }
    13. 
        
        
        
        
  13. 
        
        
        
        
  14. void print(DataType* a, int n) {
    15. 
        
        
        
        
  15.     for (int i = 0; i < n; i++)
    16. 
        
        
        
        
  16.         printf("%d ", a[i]);
    17. 
        
        
        
        
  17.     printf("\n");
    18. 
        
        
        
        
  18. }
    19. 
        
        
        
        
  19. 
        
        
        
        
  20. int main() {
    21. 
        
        
        
        
  21.     int a[10] = {3, 2, 4, 5, 7, 8, 9, 1, 6, 0};
    22. 
        
        
        
        
  22. 
        
        
        
        
  23.     insert(a, 10);
    24. 
        
        
        
        
  24.     print(a, 10);
    25. 
        
        
        
        
  25.     
    26. 
        
        
        
        
  26.     return 0;
    27. 
        
        
        
        
  27. }
    28.

5 选择排序

5.1 问题

选择排序是一种简单直观的排序方法。

选择排序的过程是这样的，首先，在待排序的数组中找到一个最小的数组元素，将该最小数组元素与数组的第一个元素进行交换，这样交换之后，数组的第一个元素就变成了数组元素中的最小值。然后，再在待排序数组的剩余元素中找到一个最小的数组元素，将该最小数组元素与数组的第二个元素进行交换，这样交换之后，数组的第二个元素就变成了数组元素中的第二小的值。依次类推，直至数组按顺序排好为止。

5.2 方案

为了理解选择排序算法，我们先假设有一个长度为10的数组，数组内容如图-11所示：

图-16

图-11中的数组元素为无序状态，现需要将数组内的元素排序成从小到大的升序状态。首先在数组的所有元素中找到一个最小的元素，如图-12所示：

图-17

将该元素与数组的第一个元素进行交换，如图-13所示：

图-18

这样交换之后，数组的第一个元素就变成了数组元素中的最小值。然后，再在除第一个元素外的其它数组元素中，寻找最小的数组元素，如图-14所示：

图-19

将这个第二小的数组元素与数组的第二个位置的元素进行交换，如图-15所示：

图-20

这样交换之后，数组的第二个元素就变成了数组元素中的第二小的值。依次类推，再在剩余的数组元素中找最小值，与数组第三个位置的元素进行交换，直至数组排好序为止。整个排序过程如图-16所示：

图-21

由图－16可以看出，实现选择排序算法时，需要使用嵌套的两个循环来实现：外层循环用于控制排序的趟次，里层循环用于寻找指定范围内的最小值。

5.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：寻找数组中指定范围内的最小元素

首先，定义一个变量，用于存放最小元素在数组中的下标。

然后，设置循环，遍历数组找出最小元素。

代码如下所示：


       
       
       
       
    
        
        
        
        
  1. void selects(DataType *a, int n) {
    2. 
        
        
        
        
  2.         int i = 0;
    3. 
        
        
        
        
  3.         int k = i; //这里认为k就是最小元素的下标
    4. 
        
        
        
        
  4.         for (int j = i + 1; j < n; j++) {
    5. 
        
        
        
        
  5.             if (a[j] < a[k]) {
    6. 
        
        
        
        
  6.                 k = j;
    7. 
        
        
        
        
  7.             }
    8. 
        
        
        
        
  8.         }
    9. 
        
        
        
        
  9. }
    10.

步骤二：将最小元素与数组第一个位置的元素交换

代码如下所示：


       
       
       
       
    
        
        
        
        
  1. void selects(DataType *a, int n) {
    2. 
        
        
        
        
  2.         int i = 0;
    3. 
        
        
        
        
  3.         int k = i; //这里认为k就是最小
    4. 
        
        
        
        
  4.         for (int j = i + 1; j < n; j++) {
    5. 
        
        
        
        
  5.             if (a[j] < a[k]) {
    6. 
        
        
        
        
  6.                 k = j;
    7. 
        
        
        
        
  7.             }
    8. 
        
        
        
        
  8.         }
    9. 
        
        
        
        
  9.         if (k != i) {
    10. 
        
        
        
        
  10.             swap(a[k], a[i]);
    11. 
        
        
        
        
  11.         }
    12. 
        
        
        
        
  12. }
    13.

上述代码中，以下代码：


       
       
       
       
    
        
        
        
        
  1.         if (k != i) {
    2.

是判断最小元素的下标是否就是数组第一个位置元素的下标，如果是则不需要再进行交换。

步骤三：将数组剩余元素排序

设置外层循环，依次寻找最小元素并进行交换。

代码如下所示：


       
       
       
       
    
        
        
        
        
  1. void selects(DataType *a, int n) {
    2. 
        
        
        
        
  2.     for (int i = 0; i < n - 1; i++) {
    3. 
        
        
        
        
  3.         int k = i; //这里认为k就是最小
    4. 
        
        
        
        
  4.         for (int j = i + 1; j < n; j++) {
    5. 
        
        
        
        
  5.             if (a[j] < a[k]) {
    6. 
        
        
        
        
  6.                 k = j;
    7. 
        
        
        
        
  7.             }
    8. 
        
        
        
        
  8.         }
    9. 
        
        
        
        
  9.         if (k != i) {
    10. 
        
        
        
        
  10.             swap(a[k], a[i]);
    11. 
        
        
        
        
  11.         }
    12. 
        
        
        
        
  12.     }
    13. 
        
        
        
        
  13. }
    14.

5.4 完整代码

本案例的完整代码如下所示：


       
       
       
       
    
        
        
        
        
  1. typedef int DataType;
    2. 
        
        
        
        
  2. 
        
        
        
        
  3. void selects(DataType *a, int n) {
    4. 
        
        
        
        
  4.     for (int i = 0; i < n - 1; i++) {
    5. 
        
        
        
        
  5.         int k = i; //这里认为k就是最小
    6. 
        
        
        
        
  6.         for (int j = i + 1; j < n; j++) {
    7. 
        
        
        
        
  7.             if (a[j] < a[k]) {
    8. 
        
        
        
        
  8.                 k = j;
    9. 
        
        
        
        
  9.             }
    10. 
        
        
        
        
  10.         }
    11. 
        
        
        
        
  11.         if (k != i) {
    12. 
        
        
        
        
  12.             swap(a[k], a[i]);
    13. 
        
        
        
        
  13.         }
    14. 
        
        
        
        
  14.     }
    15. 
        
        
        
        
  15. }
    16. 
        
        
        
        
  16. 
        
        
        
        
  17. void print(DataType* a, int n) {
    18. 
        
        
        
        
  18.     for (int i = 0; i < n; i++)
    19. 
        
        
        
        
  19.         printf("%d ", a[i]);
    20. 
        
        
        
        
  20.     printf("\n");
    21. 
        
        
        
        
  21. }
    22. 
        
        
        
        
  22. 
        
        
        
        
  23. int main() {
    24. 
        
        
        
        
  24.     int a[10] = {3, 2, 4, 5, 7, 8, 9, 1, 6, 0};
    25. 
        
        
        
        
  25.     
    26. 
        
        
        
        
  26.     selects(a, 10);
    27. 
        
        
        
        
  27.     print(a, 10);
    28. 
        
        
        
        
  28. 
        
        
        
        
  29.     return 0;
    30. 
        
        
        
        
  30. }
    31.

6 快速排序

6.1 问题

快速排序算法是一种基于交换的排序，系统地交换反序的记录的偶对，直到不再有这样一来的偶对为止。它是对冒泡排序的一种改进。

快速排序的过程是这样的。首先，将待排序的数组从前向后和从后向前各取出一个元素进行对比交换，从而将待排序的数组分成两个部分，前一部分的所有元素都小于后一部分的所有元素，但前后两部分内部仍然是无序的状态。然后再将前一部分的所有元素从前向后和从后向前各取出一个元素进行对比交换，从而将前一部分的所有元素再分成两个部分，这两部分的前一部分的所有元素都小于后一部分的所有元素，依次类推，直到被分割的部分只有一个元素为止。下一步，再将后一部分的所有元素从前向后和从后向前各取出一个元素进行对比交换并分成两个部分。这样分到最后，数组将排好序。

6.2 方案

为了理解快速排序算法，我们先假设有一个长度为10的数组，数组内容如图-22所示：

图-22

图-22中的数组元素为无序状态，现需要将数组内的元素排序成从小到大的升序状态。首先将数组中的第一个元素3与最后一个元素0进行比较，因为3大于0，所以将它们两个进行交换，如图-23所示：

图-23

然后，将数组的第二个元素2与数组的最后一个元素3进行比较，因为2小于3，所以再那数组的第三个元素4与数组的最后一个元素3进行比较，因为4大于3，所以将它们两个进行交换，如图-24所示：

图-24

下一步，将数组的第三个元素3与数组的倒数第二个元素6进行比较，因为3小于6，所以再那数组的第三个元素3与数组的倒数第三个元素1进行比较，因为3大于1，所以将它们两个进行交换，如图-25所示：

图-25

下一步，将数组的第四个元素5与数组的倒数第三个元素3进行比较，因为5大于3，所以将它们两个进行交换，如图-26所示：

图-26

下一步，将数组的第四个元素3与数组的倒数第四个元素9进行比较，因为3小于9，所以再那数组的第四个元素3与数组的倒数第五个元素8进行比较，还因为3小于8，所以再那数组的第四个元素3与数组的倒数第六个元素7进行比较，再因为3小于7，不进行交换，至此将数组分成了两个部分，如图-27所示：

图-27

前一部分的所有元素均小于后一部分的所有元素。最后，先将前一部分按上述方法再分，再将后一部分再分，直到每一部分只有一个元素，无需排序为止。因为前一部分总是比后一部分小，所以当排序停止时，数组就已经排好序了。

6.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：终止分组条件

当只有一个元素时，停止排序。

代码如下：


       
       
       
       
    
        
        
        
        
  1. void qsorts(DataType *a, int n) {
    2. 
        
        
        
        
  2.     if(n <= 1) return;
    3. 
        
        
        
        
  3. }
    4.

上述代码中，形参变量n得到的是数组元素个数 ，当n小于等于1时，使函数返回。

步骤二：将数组分成两部分

首先，定义一个变量L，用于存储数组的上界

然后，再定义一个变量R，用于存储数组的下界。

最后，设置循环将数组分成两部分

代码如下：


       
       
       
       
    
        
        
        
        
  1. void qsorts(DataType *a, int n) {
    2. 
        
        
        
        
  2.     if(n <= 1) return;
    3. 
        
        
        
        
  3.     int L = 0;
    4. 
        
        
        
        
  4.     int R = n - 1;
    5. 
        
        
        
        
  5.     while (L < R) {
    6. 
        
        
        
        
  6.         //一次分组
    7. 
        
        
        
        
  7.         while (L < R && a[L] <= a[R]) R--;
    8. 
        
        
        
        
  8.         DataType t = a[L];
    9. 
        
        
        
        
  9.         a[L] = a[R];
    10. 
        
        
        
        
  10.         a[R] = t;
    11. 
        
        
        
        
  11.         while (L < R && a[L] <= a[R]) L++;
    12. 
        
        
        
        
  12.         t = a[L];
    13. 
        
        
        
        
  13.         a[L] = a[R];
    14. 
        
        
        
        
  14.         a[R] = t;
    15. 
        
        
        
        
  15.     }
    16. 
        
        
        
        
  16. }
    17.

上述代码中，以下代码：


       
       
       
       
    
        
        
        
        
  1.         while (L < R && a[L] <= a[R]) R--;
    2. 
        
        
        
        
  2.         DataType t = a[L];
    3. 
        
        
        
        
  3.         a[L] = a[R];
    4. 
        
        
        
        
  4.         a[R] = t;
    5.

是从后向前寻找不符合顺序的元素，找到后，将其进行交换。

上述代码中，以下代码：


       
       
       
       
    
        
        
        
        
  1.         while (L < R && a[L] <= a[R]) L++;
    2. 
        
        
        
        
  2.         t = a[L];
    3. 
        
        
        
        
  3.         a[L] = a[R];
    4. 
        
        
        
        
  4.         a[R] = t;
    5.

是从前向后寻找不符合顺序的元素，找到后，将其进行交换。

步骤三：递归分组

将分好的前后两部分用递归的方法再分。

代码如下：


       
       
       
       
    
        
        
        
        
  1. void qsorts(DataType *a, int n) {
    2. 
        
        
        
        
  2.     if(n <= 1) return;
    3. 
        
        
        
        
  3.     int L = 0;
    4. 
        
        
        
        
  4.     int R = n - 1;
    5. 
        
        
        
        
  5.     while (L < R) {
    6. 
        
        
        
        
  6.         //一次分组
    7. 
        
        
        
        
  7.         while (L < R && a[L] <= a[R]) R--;
    8. 
        
        
        
        
  8.         DataType t = a[L];
    9. 
        
        
        
        
  9.         a[L] = a[R];
    10. 
        
        
        
        
  10.         a[R] = t;
    11. 
        
        
        
        
  11.         while (L < R && a[L] <= a[R]) L++;
    12. 
        
        
        
        
  12.         t = a[L];
    13. 
        
        
        
        
  13.         a[L] = a[R];
    14. 
        
        
        
        
  14.         a[R] = t;
    15. 
        
        
        
        
  15.     }
    16. 
        
        
        
        
  16.     //继续左边分组
    17. 
        
        
        
        
  17.     qsorts(a, L);
    18. 
        
        
        
        
  18.     //继续右边分组
    19. 
        
        
        
        
  19.     qsorts(a + L + 1, n - L - 1);
    20. 
        
        
        
        
  20. }
    21.

6.4 完整代码

本案例的完整代码如下所示：


       
       
       
       
    
        
        
        
        
  1. typedef int DataType;
    2. 
        
        
        
        
  2. void qsorts(DataType *a, int n) {
    3. 
        
        
        
        
  3.     if(n <= 1) return;
    4. 
        
        
        
        
  4.     int L = 0;
    5. 
        
        
        
        
  5.     int R = n - 1;
    6. 
        
        
        
        
  6.     while (L < R) {
    7. 
        
        
        
        
  7.         //一次分组
    8. 
        
        
        
        
  8.         while (L < R && a[L] <= a[R]) R--;
    9. 
        
        
        
        
  9.         DataType t = a[L];
    10. 
        
        
        
        
  10.         a[L] = a[R];
    11. 
        
        
        
        
  11.         a[R] = t;
    12. 
        
        
        
        
  12.         while (L < R && a[L] <= a[R]) L++;
    13. 
        
        
        
        
  13.         t = a[L];
    14. 
        
        
        
        
  14.         a[L] = a[R];
    15. 
        
        
        
        
  15.         a[R] = t;
    16. 
        
        
        
        
  16.     }
    17. 
        
        
        
        
  17.     //继续左边分组
    18. 
        
        
        
        
  18.     qsorts(a, L);
    19. 
        
        
        
        
  19.     //继续右边分组
    20. 
        
        
        
        
  20.     qsorts(a + L + 1, n - L - 1);
    21. 
        
        
        
        
  21. }
    22. 
        
        
        
        
  22. 
        
        
        
        
  23. void print(DataType* a, int n) {
    24. 
        
        
        
        
  24.     for (int i = 0; i < n; i++)
    25. 
        
        
        
        
  25.         printf("%d ", a[i]);
    26. 
        
        
        
        
  26.     printf("\n");
    27. 
        
        
        
        
  27. }
    28. 
        
        
        
        
  28. 
        
        
        
        
  29. int main() {
    30. 
        
        
        
        
  30.     int a[10] = {3, 2, 4, 5, 7, 8, 9, 1, 6, 0};
    31. 
        
        
        
        
  31.     
    32. 
        
        
        
        
  32.     qsorts(a, 10);
    33. 
        
        
        
        
  33.     print(a, 10);
    34. 
        
        
        
        
  34.     
    35. 
        
        
        
        
  35.     return 0;
    36. 
        
        
        
        
  36. }
    37.

7 归并排序

7.1 问题

归并排序是将两个已经排好序的序列合并成一个序列的操作。

归并排序的过程是这样的。首先，将待排序的数组中的元素从中间分为前后两部分。然后再将前一部分继续分成两部份，后一部分也继续分成两部分，依次类推，直到单个元素为止。最后两两按序合并，直到整个数组合并成一个有序数组为止。

7.2 方案

为了理解归并排序算法，我们先假设有一个长度为8的数组，数组内容如图-28所示：

图-28

现需要将数组内的元素先分成前后两部分，如图-29所示：

图-29

然后，将前后两部分继续分解，直至单个元素为止，如图-30所示：

图-30

下一步，重新两两合并，在合并的过程中注意先进行了排序，如图-31所示：

图-31

下一步，继续合并，直至整个数组排好序为止，如图-32所示：

图-32

7.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：将数组分成前后两部分

使用递归方法，将数组先分成前后两部分，然后再将前一部分分解，最后将后一部分分解。

代码如下：


       
       
       
       
    
        
        
        
        
  1. //内部使用递归
    2. 
        
        
        
        
  2. void MergeSort(int sourceArr[],int startIndex,int endIndex)
    3. 
        
        
        
        
  3. {
    4. 
        
        
        
        
  4.     int midIndex;
    5. 
        
        
        
        
  5.     if(startIndex<endIndex)
    6. 
        
        
        
        
  6.     {
    7. 
        
        
        
        
  7.         midIndex=(startIndex+endIndex)/2;
    8. 
        
        
        
        
  8.         MergeSort(sourceArr,startIndex,midIndex);
    9. 
        
        
        
        
  9.         MergeSort(sourceArr,midIndex+1,endIndex);
    10. 
        
        
        
        
  10.     }
    11. 
        
        
        
        
  11. }
    12.

上述代码中，以下代码：


       
       
       
       
    
        
        
        
        
  1.         midIndex=(startIndex+endIndex)/2;
    2.

是确定将数组分成前后两部分的中间点。

步骤二：将前后两部分重新按序合并

代码如下：


       
       
       
       
    
        
        
        
        
  1. #include<stdlib.h>
    2. 
        
        
        
        
  2. #include<stdio.h>
    3. 
        
        
        
        
  3. 
        
        
        
        
  4. #define SIZE 8
    5. 
        
        
        
        
  5. 
        
        
        
        
  6. void Merge(int sourceArr[],int startIndex,int midIndex,int endIndex)
    7. 
        
        
        
        
  7. {
    8. 
        
        
        
        
  8.     int start = startIndex;
    9. 
        
        
        
        
  9.     int i,j,k;
    10. 
        
        
        
        
  10.     int tempArr[SIZE];
    11. 
        
        
        
        
  11.     for(i=midIndex+1,j=startIndex;startIndex<=midIndex&&i<=endIndex;j++)
    12. 
        
        
        
        
  12.         if(sourceArr[startIndex]<=sourceArr[i])
    13. 
        
        
        
        
  13.             tempArr[j]=sourceArr[startIndex++];
    14. 
        
        
        
        
  14.         else
    15. 
        
        
        
        
  15.             tempArr[j]=sourceArr[i++];
    16. 
        
        
        
        
  16.     if(startIndex<=midIndex)
    17. 
        
        
        
        
  17.         for(k=0;k<=midIndex-startIndex;k++)
    18. 
        
        
        
        
  18.             tempArr[j+k]=sourceArr[startIndex+k];
    19. 
        
        
        
        
  19.     if(i<=endIndex)
    20. 
        
        
        
        
  20.         for(k=0;k<=endIndex-i;k++)
    21. 
        
        
        
        
  21.             tempArr[j+k]=sourceArr[i+k];
    22. 
        
        
        
        
  22.     for(i=start;i<=endIndex;i++)
    23. 
        
        
        
        
  23.         sourceArr[i]=tempArr[i];
    24. 
        
        
        
        
  24. }
    25. 
        
        
        
        
  25. 
        
        
        
        
  26. //内部使用递归
    27. 
        
        
        
        
  27. void MergeSort(int sourceArr[],int startIndex,int endIndex)
    28. 
        
        
        
        
  28. {
    29. 
        
        
        
        
  29.     int midIndex;
    30. 
        
        
        
        
  30.     if(startIndex<endIndex)
    31. 
        
        
        
        
  31.     {
    32. 
        
        
        
        
  32.         midIndex=(startIndex+endIndex)/2;
    33. 
        
        
        
        
  33.         MergeSort(sourceArr,startIndex,midIndex);
    34. 
        
        
        
        
  34.         MergeSort(sourceArr,midIndex+1,endIndex);
    35. 
        
        
        
        
  35.         Merge(sourceArr,startIndex,midIndex,endIndex);
    36. 
        
        
        
        
  36.     }
    37. 
        
        
        
        
  37. }
    38.

上述代码中，以下代码：


       
       
       
       
    
        
        
        
        
  1.     int tempArr[SIZE];
    2.

是定义一个临时数组，用于合并过程中排序时使用。

上述代码中，以下代码：


       
       
       
       
    
        
        
        
        
  1.     for(i=midIndex+1,j=startIndex;startIndex<=midIndex&&i<=endIndex;j++)
    2. 
        
        
        
        
  2.         if(sourceArr[startIndex]<=sourceArr[i])
    3. 
        
        
        
        
  3.             tempArr[j]=sourceArr[startIndex++];
    4. 
        
        
        
        
  4.         else
    5. 
        
        
        
        
  5.             tempArr[j]=sourceArr[i++];
    6.

是先挑选前后两部分中小的数组元素放入临时数组。

上述代码中，以下代码：


       
       
       
       
    
        
        
        
        
  1.     if(startIndex<=midIndex)
    2. 
        
        
        
        
  2.         for(k=0;k<=midIndex-startIndex;k++)
    3. 
        
        
        
        
  3.             tempArr[j+k]=sourceArr[startIndex+k];
    4.

是将前一部分中剩余的元素放入临时数组。

上述代码中，以下代码：


       
       
       
       
    
        
        
        
        
  1.     if(i<=endIndex)
    2. 
        
        
        
        
  2.         for(k=0;k<=endIndex-i;k++)
    3. 
        
        
        
        
  3.             tempArr[j+k]=sourceArr[i+k];
    4.

是将后一部分中剩余的元素放入临时数组。

上述代码中，以下代码：


       
       
       
       
    
        
        
        
        
  1.     for(i=start;i<=endIndex;i++)
    2. 
        
        
        
        
  2.         sourceArr[i]=tempArr[i];
    3.

是将临时数组内的内容放回到待排序数组中。

7.4 完整代码

本案例的完整代码如下所示：


       
       
       
       
    
        
        
        
        
  1. #include<stdlib.h>
    2. 
        
        
        
        
  2. #include<stdio.h>
    3. 
        
        
        
        
  3. 
        
        
        
        
  4. #define SIZE 8
    5. 
        
        
        
        
  5. 
        
        
        
        
  6. void Merge(int sourceArr[],int startIndex,int midIndex,int endIndex)
    7. 
        
        
        
        
  7. {
    8. 
        
        
        
        
  8.     int start = startIndex;
    9. 
        
        
        
        
  9.     int i,j,k;
    10. 
        
        
        
        
  10.     int tempArr[SIZE];
    11. 
        
        
        
        
  11.     for(i=midIndex+1,j=startIndex;startIndex<=midIndex&&i<=endIndex;j++)
    12. 
        
        
        
        
  12.         if(sourceArr[startIndex]<=sourceArr[i])
    13. 
        
        
        
        
  13.             tempArr[j]=sourceArr[startIndex++];
    14. 
        
        
        
        
  14.         else
    15. 
        
        
        
        
  15.             tempArr[j]=sourceArr[i++];
    16. 
        
        
        
        
  16.     if(startIndex<=midIndex)
    17. 
        
        
        
        
  17.         for(k=0;k<=midIndex-startIndex;k++)
    18. 
        
        
        
        
  18.             tempArr[j+k]=sourceArr[startIndex+k];
    19. 
        
        
        
        
  19.     if(i<=endIndex)
    20. 
        
        
        
        
  20.         for(k=0;k<=endIndex-i;k++)
    21. 
        
        
        
        
  21.             tempArr[j+k]=sourceArr[i+k];
    22. 
        
        
        
        
  22.     for(i=start;i<=endIndex;i++)
    23. 
        
        
        
        
  23.         sourceArr[i]=tempArr[i];
    24. 
        
        
        
        
  24. }
    25. 
        
        
        
        
  25. 
        
        
        
        
  26. //内部使用递归
    27. 
        
        
        
        
  27. void MergeSort(int sourceArr[],int startIndex,int endIndex)
    28. 
        
        
        
        
  28. {
    29. 
        
        
        
        
  29.     int midIndex;
    30. 
        
        
        
        
  30.     if(startIndex<endIndex)
    31. 
        
        
        
        
  31.     {
    32. 
        
        
        
        
  32.         midIndex=(startIndex+endIndex)/2;
    33. 
        
        
        
        
  33.         MergeSort(sourceArr,startIndex,midIndex);
    34. 
        
        
        
        
  34.         MergeSort(sourceArr,midIndex+1,endIndex);
    35. 
        
        
        
        
  35.         Merge(sourceArr,startIndex,midIndex,endIndex);
    36. 
        
        
        
        
  36.     }
    37. 
        
        
        
        
  37. }
    38. 
        
        
        
        
  38. 
        
        
        
        
  39. //调用
    40. 
        
        
        
        
  40. int main(int argc,char * argv[])
    41. 
        
        
        
        
  41. {
    42. 
        
        
        
        
  42.     int a[SIZE] = {8,4,6,3,1,7,5,2};
    43. 
        
        
        
        
  43.     MergeSort(a,0,SIZE-1);
    44. 
        
        
        
        
  44.     for(int i=0;i<SIZE;i++)
    45. 
        
        
        
        
  45.         printf("%d ",a[i]);
    46. 
        
        
        
        
  46.     printf("\n");
    47. 
        
        
        
        
  47.     return 0;
    48. 
        
        
        
        
  48. }
    49.

你可能感兴趣的:(查找&&排序,查找,排序)

  • QQ群采集助手，精准引流必备神器 2401_87347160 其他经验分享
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
  • 《投行人生》读书笔记 小蘑菇的树洞
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
  • 回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录leetcode算法职场和发展
    重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
  • 每日一题——第八十四题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：编写函数1、输入10个职工的姓名和职工号2、按照职工由大到小顺序排列，姓名顺序也随之调整3、要求输入一个职工号，用折半查找法找出该职工的姓名#define_CRT_SECURE_NO_WARNINGS#include#include#defineMAX_EMPLOYEES10typedefstruct{intid;charname[50];}Empolyee;voidinputEmploye
  • docker igotyback eureka云原生
    Docker容器的文件系统是隔离的，但是可以通过挂载卷（Volumes）或绑定挂载（BindMounts）将宿主机的文件系统目录映射到容器内部。要查看Docker容器的映射路径，可以使用以下方法：查看容器配置：使用dockerinspect命令可以查看容器的详细配置信息，包括挂载的卷。例如：bashdockerinspect在输出的JSON格式中，查找"Mounts"部分，这里会列出所有的挂载信息
  • 数据结构之哈希表 X同学的开始 数据结构数据结构散列表
    哈希表(散列表)出现的原因在顺序表中查找时，需要从表头开始，依次遍历比较a[i]与key的值是否相等，直到相等才返回索引i；在有序表中查找时，我们经常使用的是二分查找，通过比较key与a[i]的大小来折半查找，直到相等时才返回索引i。最终通过索引找到我们要找的元素。但是，这两种方法的效率都依赖于查找中比较的次数。我们有一种想法，能不能不经过比较，而是直接通过关键字key一次得到所要的结果呢？这时，
  • C语言代码练习（第十九天） 小小框架 C语言C语言重点练习c语言
    今日练习：52、有一个已经排好序的数组，要求输入一个数后，按原来排序的规律将它插入数组中53、输出"魔方阵"。所谓魔方阵是指它的每一行，每一列和对角线之和均相等。54、找出一个二维数组中的鞍点，即该位置上的元素在该行上最大、在该列上最小。也可能没有鞍点。有一个已经排好序的数组，要求输入一个数后，按原来排序的规律将它插入数组中运行代码intmain(){intarr[11]={1,3,9,12,15
  • 《 C++ 修炼全景指南：九 》打破编程瓶颈！掌握二叉搜索树的高效实现与技巧 Lenyiin C++修炼全景指南技术指南c++算法stl
    摘要本文详细探讨了二叉搜索树（BinarySearchTree,BST）的核心概念和技术细节，包括插入、查找、删除、遍历等基本操作，并结合实际代码演示了如何实现这些功能。文章深入分析了二叉搜索树的性能优势及其时间复杂度，同时介绍了前驱、后继的查找方法等高级功能。通过自定义实现的二叉搜索树类，读者能够掌握其实际应用，此外，文章还建议进一步扩展为平衡树（如AVL树、红黑树）以优化极端情况下的性能退化。
  • Table列表复现框实现【勾选-搜索-再勾选】 ～四时春～ java开发语言elementuivue
    Table列表复现框实现【勾选-搜索-再勾选】概要整体架构流程代码实现技术细节注意参考文献概要最近在开发时遇到一个问题，在进行表单渲染时，正常选中没有问题，单如果需要搜索选中时，一个是已选中的不会回填，二是在搜索的结果中进行选中，没有实现，经过排查，查找资料后实现。例如：整体架构流程具体的实现效果如下：代码实现{{scope.row.userName}}已选区{{userItem.userName
  • 《 C++ 修炼全景指南：十 》自平衡的艺术：深入了解 AVL 树的核心原理与实现 Lenyiin C++修炼全景指南技术指南c++数据结构stl
    摘要本文深入探讨了AVL树（自平衡二叉搜索树）的概念、特点以及实现细节。我们首先介绍了AVL树的基本原理，并详细分析了其四种旋转操作，包括左旋、右旋、左右双旋和右左双旋，阐述了它们在保持树平衡中的重要作用。接着，本文从头到尾详细描述了AVL树的插入、删除和查找操作，配合完整的代码实现和详尽的注释，使读者能够全面理解这些操作的执行过程。此外，我们还提供了AVL树的遍历方法，包括中序、前序和后序遍历，
  • JavaScript `Map` 和 `WeakMap`详细解释 跳房子的前端 JavaScript原生方法javascript前端开发语言
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
  • rose中原焦点团队网络初级27期、中级27期分享第201天20211019 rosewshx
    今天出差回来上班，很多事情又都拥挤到了一起，列表排序逐一落实吧。排出来心里就不慌乱了，稳得住事情去逐一解决。调整烦躁慌乱的心态，平稳住按部就班就好，让觉察时时在。
  • [实践应用] 深度学习之模型性能评估指标 YuanDaima2048 深度学习工具使用深度学习人工智能损失函数性能评估pytorchpython机器学习
    文章总览：YuanDaiMa2048博客文章总览深度学习之模型性能评估指标分类任务回归任务排序任务聚类任务生成任务其他介绍在机器学习和深度学习领域，评估模型性能是一项至关重要的任务。不同的学习任务需要不同的性能指标来衡量模型的有效性。以下是对一些常见任务及其相应的性能评估指标的详细解释和总结。分类任务分类任务是指模型需要将输入数据分配到预定义的类别或标签中。以下是分类任务中常用的性能指标：准确率(
  • Leetcode 3286. Find a Safe Walk Through a Grid Espresso Macchiato leetcode笔记leetcode3286leetcodemeidumleetcode双周赛139bfs最优路径
    Leetcode3286.FindaSafeWalkThroughaGrid1.解题思路2.代码实现题目链接：3286.FindaSafeWalkThroughaGrid1.解题思路这一题的话思路上就是一个宽度优先遍历，我们按照health进行排序进行宽度优先遍历，看看在health被消耗完之前是否可能走到终点即可。2.代码实现给出python代码实现如下：classSolution:deffin
  • 《算法》四学习——1.1节 进阶的Farmer 算法算法笔记
    前言买了一本算法4，每天看一点，对每个小结来个学习总结，输出驱动输入。本篇笔记针对第一章基础1.1基础编程模型1.1节总结了相关的语法、语言特性和书中将会用到的库。笔记自己在编码中容易遗漏的点&&优先级比||高在开发中习惯了加括号，所以没注意到这点，教材上也有但是忘记了二分查找中计算mid=left+(right-left)/2这样计算可以有效避免(left+right)/2溢出答疑java无穷大
  • Acwing 区间合并 Curry_Math 算法学习算法c++开发语言
    区间合并主要思想：给定很多区间。若两个区间有交集，将二者合并成一个区间。具体做法:先按照区间的左端点进行排序然后遍历每个区间，根据不同的情况进行合并，有一下几种情况：第一种情况，区间不变；第二种情况，end更新为区间i的右端点；以上两种情况，可以归结为end更新为max（end，r）;r为区间右端点第三种情况，将当前维护的区间加入结果，并将维护的区间更新为区间i；下面给出区间合并的板子：//区间合
  • 排序 路小白同学
    1.冒泡排序冒泡算法是一种基础的排序算法，这种算法会重复的比较数组中相邻的两个元素。如果一个元素比另一个元素大（小），那么就交换这两个元素的位置。重复这一比较直至最后一个元素。这一比较会重复n-1趟，每一趟比较n-j次，j是已经排序好的元素个数。每一趟比较都能找出未排序元素中最大或者最小的那个数字。这就如同水泡从水底逐个飘到水面一样。冒泡排序是一种时间复杂度较高，效率较低的排序方法。其空间复杂度是
  • C#动态加载DLL程序集及使用反射创建实例-简记 不全 C#相关Asp.netWebFormAsp.netMVCc#Assembly反射程序集
    Assembly动态加载程序集：分两种情况：1、需要加载的程序集已经在程序中被引用了，则直接从当前程序域中查找即可：Assemblyassembly=AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(x=>x.GetName().Name.Contains("theAssemblyName"));2、需要加载的程序集未被加载，则使用程序集
  • Python精选200Tips：121-125 AnFany Python200+Tipspython开发语言
    Spendyourtimeonself-improvement121Requests-简化的HTTP请求处理发送GET请求发送POST请求发送PUT请求发送DELETE请求会话管理处理超时文件上传122BeautifulSoup-网页解析和抓取解析HTML和XML文档查找单个标签查找多个标签使用CSS选择器查找标签提取文本修改文档内容删除标签处理XML文档123Scrapy-强大的网络爬虫框架示例
  • 228.第一个错误的版本 vbuer
    你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。假设你有n个版本[1,2,...,n]，你想找出导致之后所有版本出错的第一个错误的版本。你可以通过调用boolisBadVersion(version)接口来判断版本号version是否在单元测试中出错。实现一个函数来查找第一个错
  • HTTP 响应状态码详解 云博客-资源宝 笔记httpHTTP响应状态码详解
    HTTP状态码详解：HTTP状态码,是用以表示WEB服务器HTTP响应状态的3位数字代码小技巧：Ctrl+F快速查找Http状态码状态码含义100客户端应当继续发送请求。这个临时响应是用来通知客户端它的部分请求已经被服务器接收，且仍未被拒绝。客户端应当继续发送请求的剩余部分，或者如果请求已经完成，忽略这个响应。服务器必须在请求完成后向客户端发送一个最终响应。101服务器已经理解了客户端的请求，并将
  • 18068 选择排序 蠢蠢的打码 高级应用程序设计算法数据结构
    ###思路1.**初始化**：定义变量`i`,`j`,`k`和临时变量`tmp`。2.**外层循环**：遍历数组的每个元素，`i`从0到`n-2`。3.**内层循环**：从`i+1`到`n-1`，找到最小元素的索引`k`。4.**交换**：将最小元素与当前元素交换。###伪代码1.初始化`i`,`j`,`k`和`tmp`。2.外层循环从`i=0`到`n-2`：-设置`k=i`。-内层循环从`j=i
  • ⭐算法入门⭐《归并排序》简单01 —— LeetCode 21. 合并两个有序链表 英雄哪里出来 《LeetCode算法全集》算法数据结构链表c++归并排序
    饭不食，水不饮，题必须刷C语言免费动漫教程，和我一起打卡！《光天化日学C语言》LeetCode太难？先看简单题！《C语言入门100例》数据结构难？不存在的！《数据结构入门》LeetCode太简单？算法学起来！《夜深人静写算法》文章目录一、题目1、题目描述2、基础框架3、原题链接二、解题报告1、思路分析2、时间复杂度3、代码详解三、本题小知识一、题目1、题目描述  将两个不降序链表合并为一个新的不降
  • shp文件解析转换为geojson/wkt格式字符串 自律_平庸 前端数据库大数据
    此函数用于处理上传的ZIP文件并将其转换为GeoJSON格式的字符串。具体步骤如下：验证上传文件是否为ZIP格式。创建临时目录以解压ZIP文件。解压缩ZIP文件至临时目录。查找解压后的.shp文件。如果缺少.shx或.dbf辅助文件，则创建空文件。读取Shapefile数据。将特征集合转换为GeoJSON格式。清理临时文件和资源。函数返回转换后的GeoJSON字符串。publicStringshp
  • 【华为OD机试真题 python】输出指定字母在字符串的中的索引【2022 Q4 | 100分】 无痕de泪 华为OD机试真题python输出指定字母在字符串的中的索引字符串华为odpython
    前言《华为OD笔试真题python》专栏含华为OD机试真题、华为面试题、牛客网华为专栏真题。如果您正在准备华为的面试，或者华为od的机会，有任何想了解的可以私信我进行交流。我会尽可能的给一些建议，和帮您解答！PS：文中答案仅供参考，不能照抄哦■题目描述【输出指定字母在字符串的中的索引】给定一个字符串，把字符串按照大写在前小写在后排序，输出排好后的第K个字母在原来字符串的索引。相同字母输出第一个出现
  • B3798 梦熊培养计划 summ1ts 算法数据结构
    排序：sort()函数方法1：sort(起始地址，末尾地址+1)；方法2：sort(起始地址，末尾地址+1，cmp)；//cmp是自定义的排序规则sort是默认升序排序的，如果需要自定义排序，可以写一个比较函数，用第二种方法排序。例如：对一个数组a进行升序排列，（a中的元素存储从a[1]~a[n]），则可以写成：sort(a+1,a+1+n);如果元素存储是:a[0]~a[n-1]，则写成：sor
  • 汇总相同清单工程量的进一步思考-对清单去重精简寻找签证的可能性 极算手
    工程情景当我们遇到单项工程里包含多个单位工程，比如别墅群、住宅群等同一户型同一项目施工做法都一样同一清单特征严格意义讲描述做法应当唯一实际工作中我们可能遇到即使在同一单位工程中同一项目清单特征描述可能也不一样那我们如何在众多清单特征中寻找同一做法的不同清单描述呢？操作方法可能千千万万我个人尝试下来还是利用VBA最为便捷去重操作几千条清单中重复的清单高能高达上千条直接查找对比必然耗费大量时间精力首一
  • C语言：冒泡排序的注意事项及具体实现 z_鑫 c语言算法数据结构开发语言
    一、注意事项1、函数声明为：voidbubble_sort(void*base,size_tnum,size_twidth,int(*cmp)(constvoid*e1,constvoid*e2));2、base指向所要排序的数组3、num为数组的元素个数4、width为一个元素占多少个字节的空间5、cmp为函数指针，指向用来进行比较的函数6、每趟排序都会把当前未排序部分的最大值移到正确的位置二、
  • linux find命令 落雨无风 linux
    find.-name"*.v"|xargsgrep"altera_mf"#在当前目录查找所有.v文件，并找出altera_mf的行持续更新中------
  • 洛谷水题 记录 木木ainiks 算法c++数据结构
    P1093[NOIP2007普及组]奖学金sort排序即可注意cmp的写法#include#includeusingnamespacestd;structnode{intid;intchinese;intmath;intenglish;intcount;}a[305];intcmp(node&a,node&b){if(a.count!=b.count){returna.count>b.count;
  • iOS http封装 374016526 ios服务器交互http网络请求
    程序开发避免不了与服务器的交互，这里打包了一个自己写的http交互库。希望可以帮到大家。   内置一个basehttp，当我们创建自己的service可以继承实现。   KuroAppBaseHttp *baseHttp = [[KuroAppBaseHttp alloc] init]; [baseHttp setDelegate:self]; [baseHttp
  • lolcat ：一个在 Linux 终端中输出彩虹特效的命令行工具 brotherlamp linuxlinux教程linux视频linux自学linux资料
      那些相信 Linux 命令行是单调无聊且没有任何乐趣的人们，你们错了，这里有一些有关 Linux 的文章，它们展示着 Linux 是如何的有趣和“淘气” 。 在本文中，我将讨论一个名为“lolcat”的小工具 – 它可以在终端中生成彩虹般的颜色。 何为 lolcat ? Lolcat 是一个针对 Linux，BSD 和 OSX 平台的工具，它类似于 cat 命令，并为 cat
  • MongoDB索引管理（1）——[九] eksliang mongodbMongoDB管理索引
    转载请出自出处：http://eksliang.iteye.com/blog/2178427 一、概述       数据库的索引与书籍的索引类似，有了索引就不需要翻转整本书。数据库的索引跟这个原理一样，首先在索引中找，在索引中找到条目以后，就可以直接跳转到目标文档的位置，从而使查询速度提高几个数据量级。       不使用索引的查询称
  • Informatica参数及变量 18289753290 Informatica参数变量
    下面是本人通俗的理解，如有不对之处，希望指正 info参数的设置：在info中用到的参数都在server的专门的配置文件中（最好以parma）结尾 下面的GLOBAl就是全局的，$开头的是系统级变量，$$开头的变量是自定义变量。如果是在session中或者mapping中用到的变量就是局部变量，那就把global换成对应的session或者mapping名字。 [GLOBAL] $Par
  • python 解析unicode字符串为utf8编码字符串 酷的飞上天空 unicode
    php返回的json字符串如果包含中文，则会被转换成\uxx格式的unicode编码字符串返回。 在浏览器中能正常识别这种编码，但是后台程序却不能识别，直接输出显示的是\uxx的字符，并未进行转码。   转换方式如下   >>> import json >>> q = '{"text":"\u4
  • Hibernate的总结 永夜-极光 Hibernate
    1.hibernate的作用,简化对数据库的编码,使开发人员不必再与复杂的sql语句打交道   做项目大部分都需要用JAVA来链接数据库，比如你要做一个会员注册的 页面，那么 获取到用户填写的 基本信后，你要把这些基本信息存入数据库对应的表中，不用hibernate还有mybatis之类的框架，都不用的话就得用JDBC，也就是JAVA自己的，用这个东西你要写很多的代码，比如保存注册信
  • SyntaxError: Non-UTF-8 code starting with '\xc4' 随便小屋 python
    刚开始看一下Python语言，传说听强大的，但我感觉还是没Java强吧！ 写Hello World的时候就遇到一个问题，在Eclipse中写的，代码如下 ''' Created on 2014年10月27日 @author: Logic ''' print("Hello World!");  运行结果 SyntaxError: Non-UTF-8
  • 学会敬酒礼仪 不做酒席菜鸟 aijuans 菜鸟
    俗话说，酒是越喝越厚，但在酒桌上也有很多学问讲究，以下总结了一些酒桌上的你不得不注意的小细节。 细节一：领导相互喝完才轮到自己敬酒。敬酒一定要站起来，双手举杯。 细节二：可以多人敬一人，决不可一人敬多人，除非你是领导。 细节三：自己敬别人，如果不碰杯，自己喝多少可视乎情况而定，比如对方酒量，对方喝酒态度，切不可比对方喝得少，要知道是自己敬人。 细节四：自己敬别人，如果碰杯，一
  • 《创新者的基因》读书笔记 aoyouzi 读书笔记《创新者的基因》
    创新者的基因   创新者的“基因”，即最具创意的企业家具备的五种“发现技能”：联想，观察，实验，发问，建立人脉。   第一部分破坏性创新，从你开始 第一章破坏性创新者的基因 如何获得启示： 发现以下的因素起到了催化剂的作用：(1) -个挑战现状的问题；(2)对某项技术、某个公司或顾客的观察；(3) -次尝试新鲜事物的经验或实验；(4)与某人进行了一次交谈，为他点醒
  • 表单验证技术 百合不是茶 JavaScriptDOM对象String对象事件
    js最主要的功能就是验证表单,下面是我对表单验证的一些理解,贴出来与大家交流交流  ,数显我们要知道表单验证需要的技术点, String对象,事件,函数   一:String对象;通常是对字符串的操作;   1,String的属性;   字符串.length;表示该字符串的长度; var str= "java"
  • web.xml配置详解之context-param bijian1013 javaservletweb.xmlcontext-param
    一.格式定义： <context-param> <param-name>contextConfigLocation</param-name> <param-value>contextConfigLocationValue></param-value> </context-param> 作用：该元
  • Web系统常见编码漏洞（开发工程师知晓） Bill_chen sqlPHPWebfckeditor脚本
    1.头号大敌：SQL Injection 原因：程序中对用户输入检查不严格，用户可以提交一段数据库查询代码，根据程序返回的结果， 获得某些他想得知的数据，这就是所谓的SQL Injection，即SQL注入。 本质: 对于输入检查不充分，导致SQL语句将用户提交的非法数据当作语句的一部分来执行。 示例： String query = "SELECT id FROM users
  • 【MongoDB学习笔记六】MongoDB修改器 bit1129 mongodb
    本文首先介绍下MongoDB的基本的增删改查操作，然后，详细介绍MongoDB提供的修改器，以完成各种各样的文档更新操作  MongoDB的主要操作 show dbs 显示当前用户能看到哪些数据库 use foobar 将数据库切换到foobar show collections 显示当前数据库有哪些集合 db.people.update，update不带参数，可
  • 提高职业素养，做好人生规划 白糖_ 人生
      培训讲师是成都著名的企业培训讲师，他在讲课中提出的一些观点很新颖，在此我收录了一些分享一下。注：讲师的观点不代表本人的观点，这些东西大家自己揣摩。   1、什么是职业规划：职业规划并不完全代表你到什么阶段要当什么官要拿多少钱，这些都只是梦想。职业规划是清楚的认识自己现在缺什么，这个阶段该学习什么，下个阶段缺什么，又应该怎么去规划学习，这样才算是规划。  
  • 国外的网站你都到哪边看？ bozch 技术网站国外
    学习软件开发技术，如果没有什么英文基础，最好还是看国内的一些技术网站，例如：开源OSchina，csdn，iteye,51cto等等。 个人感觉如果英语基础能力不错的话，可以浏览国外的网站来进行软件技术基础的学习，例如java开发中常用的到的网站有apache.org 里面有apache的很多Projects,springframework.org是spring相关的项目网站,还有几个感觉不错的
  • 编程之美-光影切割问题 bylijinnan 编程之美
    package a; public class DisorderCount { /**《编程之美》“光影切割问题” * 主要是两个问题： * 1.数学公式（设定没有三条以上的直线交于同一点）： * 两条直线最多一个交点，将平面分成了4个区域； * 三条直线最多三个交点，将平面分成了7个区域； * 可以推出：N条直线 M个交点，区域数为N+M+1。
  • 关于Web跨站执行脚本概念 chenbowen00 Web安全跨站执行脚本
    跨站脚本攻击(XSS)是web应用程序中最危险和最常见的安全漏洞之一。安全研究人员发现这个漏洞在最受欢迎的网站,包括谷歌、Facebook、亚马逊、PayPal,和许多其他网站。如果你看看bug赏金计划,大多数报告的问题属于 XSS。为了防止跨站脚本攻击,浏览器也有自己的过滤器,但安全研究人员总是想方设法绕过这些过滤器。这个漏洞是通常用于执行cookie窃取、恶意软件传播,会话劫持,恶意重定向。在
  • [开源项目与投资]投资开源项目之前需要统计该项目已有的用户数 comsci 开源项目
            现在国内和国外,特别是美国那边,突然出现很多开源项目,但是这些项目的用户有多少,有多少忠诚的粉丝,对于投资者来讲,完全是一个未知数,那么要投资开源项目,我们投资者必须准确无误的知道该项目的全部情况,包括项目发起人的情况,项目的维持时间..项目的技术水平,项目的参与者的势力,项目投入产出的效益.....
  • oracle alert log file（告警日志文件） daizj oracle告警日志文件alert log file
    The alert log is a chronological log of messages and errors, and includes the following items: All internal errors (ORA-00600), block corruption errors (ORA-01578), and deadlock errors (ORA-00060)
  • 关于 CAS SSO 文章声明 denger SSO
    由于几年前写了几篇 CAS 系列的文章，之后陆续有人参照文章去实现，可都遇到了各种问题，同时经常或多或少的收到不少人的求助。现在这时特此说明几点： 1.  那些文章发表于好几年前了，CAS 已经更新几个很多版本了，由于近年已经没有做该领域方面的事情，所有文章也没有持续更新。 2. 文章只是提供思路，尽管 CAS 版本已经发生变化，但原理和流程仍然一致。最重要的是明白原理，然后
  • 初二上学期难记单词 dcj3sjt126com englishword
    lesson 课 traffic 交通 matter 要紧；事物 happy 快乐的，幸福的 second 第二的 idea 主意；想法；意见 mean 意味着 important 重要的，重大的 never 从来，决不 afraid 害怕 的 fifth 第五的 hometown 故乡，家乡 discuss 讨论；议论 east 东方的 agree 同意；赞成 bo
  • uicollectionview 纯代码布局, 添加头部视图 dcj3sjt126com Collection
    #import <UIKit/UIKit.h> @interface myHeadView : UICollectionReusableView { UILabel *TitleLable; } -(void)setTextTitle; @end #import "myHeadView.h" @implementation m
  • N 位随机数字串的 JAVA 生成实现 FX夜归人 javaMath随机数Random
    /** * 功能描述 随机数工具类<br /> * @author FengXueYeGuiRen * 创建时间 2014-7-25<br /> */ public class RandomUtil { // 随机数生成器 private static java.util.Random random = new java.util.R
  • Ehcache（09）——缓存Web页面 234390216 ehcache页面缓存
    页面缓存 目录 1       SimplePageCachingFilter 1.1      calculateKey 1.2      可配置的初始化参数 1.2.1     cach
  • spring中少用的注解@primary解析 jackyrong primary
    这次看下spring中少见的注解@primary注解，例子 @Component public class MetalSinger implements Singer{ @Override public String sing(String lyrics) { return "I am singing with DIO voice
  • Java几款性能分析工具的对比 lbwahoo java
    Java几款性能分析工具的对比 摘自：http://my.oschina.net/liux/blog/51800   在给客户的应用程序维护的过程中，我注意到在高负载下的一些性能问题。理论上，增加对应用程序的负载会使性能等比率的下降。然而，我认为性能下降的比率远远高于负载的增加。我也发现，性能可以通过改变应用程序的逻辑来提升，甚至达到极限。为了更详细的了解这一点，我们需要做一些性能
  • JVM参数配置大全 nickys jvm应用服务器
    JVM参数配置大全 /usr/local/jdk/bin/java -Dresin.home=/usr/local/resin -server -Xms1800M -Xmx1800M -Xmn300M -Xss512K -XX:PermSize=300M -XX:MaxPermSize=300M -XX:SurvivorRatio=8 -XX:MaxTenuringThreshold=5 -
  • 搭建 CentOS 6 服务器(14) - squid、Varnish rensanning varnish
    （一）squid 安装 # yum install httpd-tools -y # htpasswd -c -b /etc/squid/passwords squiduser 123456 # yum install squid -y 设置 # cp /etc/squid/squid.conf /etc/squid/squid.conf.bak # vi /etc/
  • Spring缓存注解@Cache使用 tom_seed spring
    参考资料 http://www.ibm.com/developerworks/cn/opensource/os-cn-spring-cache/ http://swiftlet.net/archives/774   缓存注解有以下三个： @Cacheable      @CacheEvict     @CachePut
  • dom4j解析XML时出现"java.lang.noclassdeffounderror: org/jaxen/jaxenexception"错误 xp9802
    java.lang.NoClassDefFoundError: org/jaxen/JaxenExc 关键字: java.lang.noclassdeffounderror: org/jaxen/jaxenexception 使用dom4j解析XML时，要快速获取某个节点的数据，使用XPath是个不错的方法，dom4j的快速手册里也建议使用这种方式 执行时却抛出以下异常： Exceptio
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他