八种基本排序

 1 //1冒泡排序
 2 void BuddleSort(int a[], int n)//由小到大，每比较一次小的向前
 3 {
 4     int i, j, t;
 5     for (i = 0; i < n - 1; i++)//控制循环次数为n-1
 6     {
 7         for (j = n - 1; j>i; j--)//循环从最后一个元素开始，因为下面考虑到下标j-1，所以这里j>i而不是j>=i
 8         {
 9             if (a[j - 1] > a[j])//后面一个小于前面一个则交换，结果是较小的数向前移
10             {
11                 t = a[j - 1];
12                 a[j - 1] = a[j];
13                 a[j] = t;
14             }
15         }
16         printf("第%2d遍:", i + 1);
17         for (j = 0; j < n; j++)
18             printf("%d ", a[j]);
19         printf("\n");
20     }
21 }

 1 //改进后的冒泡排序，使排序完成后跳出循环（有可能循环不需要循环n-1次）
 2 void BuddleSort1(int a[], int n)
 3 {
 4     int i, j, t, flag = 0;//flag标志
 5     for (i = 0; i < n - 1; i++)
 6     {
 7         for (j = n - 1; j>i; j--)
 8         {
 9             if (a[j - 1] > a[j])
10             {
11                 t = a[j - 1];
12                 a[j - 1] = a[j];
13                 a[j] = t;
14                 flag = 1;//记录是否发生交换，没有发生则说明排序已完成
15             }
16         }
17         printf("第%2d遍:", i + 1);
18         for (j = 0; j < n; j++)
19             printf("%d ", a[j]);
20         printf("\n");
21         if (flag == 0)//没有发生交换直接跳出循环
22             break;
23         else
24             flag = 0;
25     }
26 }

 1 //2快速排序
 2 int Division(int a[], int left, int right)//分割
 3 {
 4     int base = a[left];//基准元素
 5     while (left < right)
 6     {
 7         while (left<right&&a[right]>base)
 8             --right;//从右向左找第一个比基数小的元素
 9         a[left] = a[right];
10         while (left<right&&a[left]<base)
11             ++left; //从左向右找第一个比基数大的元素
12         a[right] = a[left];
13     }
14     a[left] = base;
15     return left;
16 }
17 void QuickSort(int a[], int left, int right)
18 {
19     int i, j;
20     if (left < right)
21     {
22         i = Division(a, left, right);
23         QuickSort(a, left, i - 1);
24         QuickSort(a, i + 1, right);
25     }
26 }

 1 //3简单选择排序
 2 void  SelectSort(int a[], int n)//思路：选择最小的放在1，剩下的中选择最小的放在2，...放在3， ...放在4......
 3 {
 4     int i, j, t, k;
 5     for (i = 0; i < n - 1; i++)//控制循环次数n-1
 6     {
 7         k = i;//存放最小值
 8         for (j = i + 1; j < n; j++)//与后面每一个比较
 9         {
10             if (a[k]>a[j])k = j;//不断把较小的值赋给a[k]直到最小
11         }
12         //找到最小值的位置k
13         //交换
14         t = a[i];
15         a[i] = a[k];
16         a[k] = t;
17         printf("第%2d遍:", i + 1);
18         for (j = 0; j < n; j++)
19             printf("%d ", a[j]);
20         printf("\n");
21     }
22 }

 1 //4堆排序
 2 void HeapAdjust(int a[], int s, int n)
 3 {
 4     int j, t;
 5     while (2 * s + 1 < n)//第s个节点有右子树
 6     {
 7         j = 2 * s + 1;
 8         if ((j + 1) < n)
 9         {
10             if (a[j] < a[j + 1])//左子树小于右子树，则需要比较右子树
11                 j++;//序号增加1，知晓右子树
12         }
13         if (a[s] < a[j])//比较s和j为序号的数据
14         {
15             t = a[s];//交换数据
16             a[s] = a[j];
17             a[j] = t;
18             s = j;//堆被破坏，需要重新调整
19         }
20         else//比较左右孩子均大则堆未破坏，不再需要调整
21             break;
22     }
23 }
24 void HeapSort(int a[], int n)
25 {
26     int t, i;
27     int j;
28     for (i = n / 2 - 1; i >= 0; i--)//将a[0，n-1]建成大根堆
29         HeapAdjust(a, i, n);
30     for (i = n - 1; i > 0; i--)
31     {
32         t = a[0];//与第i个记录交换
33         a[0] = a[i];
34         a[i] = t;
35         HeapAdjust(a, 0, i);//将a[0]至a[i]重新调整为堆
36     }
37 }

 1 //5插入排序
 2 void InsertSort(int a[], int n)//前面n个元素已排序，取一个元素插入序列中，有序，再插...
 3 {
 4     int i, j, t;
 5     for (i = 1; i < n; i++)//控制循环次数（i=0时，可以看成为有一个有序序列）
 6     {
 7         t = a[i];//取出一个未排序的数据，同时给出一个空位（以供前面的有序序列向后移）
 8         for (j = i - 1; j >= 0 && t < a[j]; --j)//因为前面序列是有序的，所以由后向前比较，小于则元素后移，大于则停止循环（此时已找到位置j+1）
 9             a[j + 1] = a[j];
10         a[j + 1] = t;
11         printf("第%2d遍:", i + 1);
12         for (j = 0; j < n; j++)
13             printf("%d ", a[j]);
14         printf("\n");
15     }
16 }

 1 //6希尔排序
 2 void ShellSort(int a[], int n)
 3 {
 4     int d, i, j, x;
 5     d = n / 2;//n为数组长度，增量
 6     while (d >= 1)
 7     {
 8         for (i = d; i<n; i++)
 9         {
10 
11             x = a[i];
12             j = i - d;
13             while (j >= 0 && a[j] > x)
14             {
15                 a[j + d] = a[j];
16                 j = j - d;
17             }
18             a[j + d] = x;
19         }
20         d /= 2;
21     }
22 
23 }

 1 //合并排序
 2 void NergeStep(int a[], int r[], int s, int m, int n)//相邻有序段的合并
 3 {
 4     int i, j, k;
 5     k = s;
 6     i = s;
 7     j = m + 1;
 8     while (i <= m&&j <= n)//当两个有序表都结束时，循环比较
 9     {
10         if (a[i] <= a[j])//当较小的元素复制到R中
11             r[k++] = a[i++];
12         else
13             r[k++] = a[j++];
14     }
15     while (i <= m)//将未合并的部分复制到R中
16         r[k++] = a[i++];
17     while (j <= n)//将未合并的部分复制到R中
18         r[k++] = a[j++];
19 }
20 void NergePass(int a[], int r[], int n, int len)//
21 {
22     int s, e;
23     s = 0;
24     while (s + len < n)//至少有两个有序段
25     {
26         e = s + 2 * len - 1;
27         if (e >= n)//最后一段可能少于len个结点
28             e = n - 1;
29         NergeStep(a, r, s, s + len - 1, e);//相邻有序段和合并
30         s = e + 1;//下一对有序段中的左段的开始下标
31     }
32     if (s<n)//还剩一个有序段，将其从A中复制到R中
33     for (; s < n; s++)
34         r[s] = a[s];
35 }
36 void NergeSort(int a[], int n)
37 {
38     int *p;
39     int len = 1;//有序序列的长度
40     int f = 0;//变量f做标志
41     if (!(p = (int *)malloc(sizeof(int)*n)))//分配内存空间，保存临时数据
42 
43     {
44         printf("\n");
45         exit(0);
46     }
47     while (len < n)
48     {
49         if (f)//交替地在A和P之间来回合并
50             NergePass(p, a, n, len);//调用函数，对p合并到a
51         else
52             NergePass(a, p, n, len);//调用函数，对a合并到p
53         len *= 2;//增加有序序列长度
54         f = 1 - f;//使f值在0与1之间切换
55     }
56     if (f)//若进行了排序
57     for (f = 0; f < n; f++)//将数组p中的元素复制到数组a
58         a[f] = p[f];
59     free(p);//释放分配内存
60 }