各种排序算法（连载中。。。）

亲们 期末考试啊 暂停更新 2.8左右恢复

 

 

新博客开张，就拿排序算法开张吧。。。我尽量从最简单的排序算法开始，不定期连载更新中~

ps:在我学会JAVA和C++之前，程序都用C来写吧，水平有限，大家凑和着看吧 重点是算法！~

（图片来源于网络）

 目录：

1.插入排序——直接插入排序。

2.插入排序——希尔排序。

3.选择排序——简单选择排序。

4.选择排序——堆排序。

5.交换排序——冒泡排序。

6.交换排序——快速排序（大力推荐使用）。

7.归并排序。

8.基数排序。

 

1.插入排序——直接插入排序。

　　具体算法描述如下：（个人认为很好理解）

1. 从第一个元素开始，该元素可以认为已经被排序
2. 取出下一个元素，在已经排序的元素序列中从前往后扫描
3. 如果该元素（已排序）大于新元素，将该元素移到下一位置
4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
5. 将新元素插入到该位置后
6. 重复步骤2~5

　　ps：可以采用二分查找法来减少比较操作的数目，称为二分查找插入排序法。

　　C语言代码如下：

 1 #include<stdio.h>

 2 #define MAXN 10000

 3 int main()

 4 {

 5     printf("请输入一组数，每个数之间以“，”隔开，Enter键结束输入\n");

 6     int arr[MAXN];                                //定义一个足够大的数组

 7     int i=0,j,k,count = 0;

 8     while(count<MAXN)                           //读入数组，存入数组a中；

 9     {

10         scanf("%d",&arr[i++]);

11         count++;

12         if(getchar() == '\n')   break;

13     }

14     int target;

15     for (i=1; i<count; i++)                     //开始排序

16     {

17         j=i;

18         target = arr[i];                          //从第二个数开始，依次作为参考点

19         while (j>0 && target<arr[j-1])

20         {

21             arr[j] = arr[j-1];

22             j--;

23         }

24         arr[j] = target;

25     }

26     for(i=0;i<count;i++)

27         printf("%d ",arr[i]);

28     return 0;

29 }

<--点击左侧+展开

 ps：修改：输入时以一个空格隔开

2.插入排序——希尔排序（相对于直接插入排序，效率进一步提高）。

　　希尔排序(Shell Sort)是插入排序的一种。是针对直接插入排序算法的改进。该方法又称缩小增量排序，因DL．Shell于1959年提出而得名。

　　希尔排序（渐减增量排序法）思想：1959年Donald L. Shell提出Shell排序法 ，源自对直接插入算法的改进.

　　具体算法描述如下：

　　先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量为1）时，再对全体元素进行一次直接插入排序。因为直接插入排序在元素基本有序的情况下（接近最好情况），效率是很高的，因此希尔排序在时间效率上比前两种方法有较大提高。

 　　C语言代码如下：

 1 #include<stdio.h>

 2 #define MAXN 10000

 3 

 4 void shellsort(int a[], int n)

 5 {

 6     int i, j, gap;

 7     for (gap = n / 2; gap > 0; gap /= 2)

 8     {

 9         for (i = 0; i < gap; i++)        //直接插入排序

10         {

11             for (j = i + gap; j < n; j += gap)

12                 if (a[j] < a[j - gap])

13                 {

14                     int temp = a[j];

15                     int k = j - gap;

16                     while (k >= 0 && a[k] > temp)

17                     {

18                         a[k + gap] = a[k];

19                         k -= gap;

20                     }

21                     a[k + gap] = temp;

22                 }

23         }

24     }

25 }

26 

27 int main()

28 {

29     printf("请输入一组数，每个数之间以1个空格隔开，Enter键结束输入\n");

30     int arr[MAXN];                                //定义一个足够大的数组

31     int i=0,j,k,count = 0;

32     while(count<MAXN)                           //读入数组，存入数组a中；

33     {

34         scanf("%d",&arr[i++]);

35         count++;

36         if(getchar() == '\n')   break;

37     }

38     shellsort(arr,count);

39     for(i=0;i<count;i++)

40         printf("%d ",arr[i]);

41     return 0;

42 }

<--点击左侧+展开

3.选择排序——简单选择排序。

　　又到了一种简单易理解的算法 0.0 

　　原理如下（摘自百度百科）：

　　设所排序序列的记录个数为n。i取1,2,…,n-1,从所有n-i+1个记录（Ri,Ri+1,…,Rn）中找出排序码最小的记录，与第i个记录交换。执行n-1趟 后就完成了记录序列的排序。

　　C语言代码如下：

 1 #include<stdio.h>

 2 #define MAXN 10000

 3 int main()

 4 {

 5     printf("请输入一组数，每个数之间以“，”隔开，Enter键结束输入\n");

 6     int arr[MAXN];                                //定义一个足够大的数组

 7     int i=0,j,k,count = 0;

 8     while(count<MAXN)                           //读入数组，存入数组a中；

 9     {

10         scanf("%d",&arr[i++]);

11         count++;

12         if(getchar() == '\n')   break;

13     }

14 

15     for(i=0;i<count;i++)

16     {

17         k=i;

18         for(j=i+1;j<count;j++)　

19         {

20             if(a[k]>a[j])

21                 k=j;

22         }

23         if (k!=i)

24         {

25             t=a[i];             //互换

26             a[i]=a[k];

27             a[k]=t;

28         }

29 

30     }

31     for(i=0;i<count;i++)

32         printf("%d ",arr[i]);

33     return 0;

34 }

<--点击左侧+展开

　　JAVA语言代码如下：

 1 class SelectionSort

 2 {

 3     public static void main(String[] args)

 4     {

 5         int[] arr = new int[]{1,9,5,7,65,1,5,6,1,5,3,2,7};

 6         selectionSort(arr);

 7         printArr(arr);

 8     }

 9 

10     public static void selectionSort(int arr[])

11     {

12         int tempMax = 0;

13         for(int i = 0;i<arr.length;i++)

14         {

15             for(int j = i+1;j<arr.length;j++)

16             {

17                 if(arr[i]>arr[j])

18                 {

19                     tempMax = arr[i];

20                     arr[i] = arr[j];

21                     arr[j] = tempMax;                

22                 }

23             }

24         }

25     }

26 

27     public static void printArr(int arr[])

28     {

29         for(int i = 0;i<arr.length;i++)

30             System.out.print(arr[i]+" ");

31     }

32 }

<--点击左侧+展开

 

4.选择排序——堆排序。

　　待补充...

5.交换排序——冒泡排序。

　　这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端，故名。

　　由于冒泡排序简洁的特点，它通常被用来对于计算机程序设计入门的学生介绍算法的概念。

　　冒泡排序算法的运作如下：（来自百度百科）

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

　　C语言代码如下：

 1 #include<stdio.h>

 2 #define MAXN 10000

 3 

 4 void bubble_sort(int a[],int n)

 5 {

 6     int i,j,temp;

 7     for(j=0;j<n-1;j++)

 8     {

 9         for(i=0;i<n-1-j;i++)

10         {

11             if(a[i]>a[i+1])         //数组元素大小按升序排列

12             {

13                 temp=a[i];          //交换

14                 a[i]=a[i+1];

15                 a[i+1]=temp;

16             }

17         }

18     }

19 }

20 int main()

21 {

22     printf("请输入一组数，每个数之间以1个空格隔开，Enter键结束输入\n");

23     int arr[MAXN];                                       //定义一个足够大的数组

24     int i=0,j,k,count = 0;

25     while(count<MAXN)                                    //读入数组，存入数组a中；

26     {

27         scanf("%d",&arr[i++]);

28         count++;

29         if(getchar() == '\n')   break;

30     }

31     bubble_sort(arr,count);

32     for(i=0;i<count;i++)

33         printf("%d ",arr[i]);

34     return 0;

35 }

<--点击左侧+展开

6.交换排序——快速排序（大力推荐使用）。

　　终于写到了我最喜欢的快速排序算法。

　　原理介绍如下：（摘自百度百科）

　　快速排序（Quicksort）是对冒泡排序的一种改进。由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。　　

　　一趟快速排序的算法是：

　　1）设置两个变量i、j，排序开始的时候：i=0，j=N-1；

　　2）以第一个数组元素作为关键数据，赋值给 key，即 key=A[0]；

　　3）从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于 key的值A[j]，将A[j]和A[i]互换；

　　4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于 key的A[i]，将A[i]和A[j]互换；

　　5）重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于 key,4中A[i]不大于 key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。

　　ps：更加详细的过程解释请参考百度百科 快速排序 词条。

　　C语言代码如下：

 1 #include<stdio.h>

 2 #define MAXN 10000

 3 

 4 void QuickSort(int a[],int numsize)

 5 {

 6     int i=0,j=numsize-1;

 7     int key=a[0];

 8     if(numsize>1)                      //确保数组长度至少为2，否则无需排序

 9     {

10         while(i<j)                      //循环结束条件

11         {

12             for(;j>i;j--)

13                 if(a[j]<key)

14                 {

15                     a[i++]=a[j];

16                     break;

17                 }

18             for(;i<j;i++)

19                 if(a[i]>key)

20                 {

21                     a[j--]=a[i];

22                     break;

23                 }

24         }

25         a[i]=key;

26         QuickSort(a,i);                        //递归

27         QuickSort(a+i+1,numsize-i-1);          //递归

28     }

29 }

30 

31 int main()

32 {

33     printf("请输入一组数，每个数之间以1个空格隔开，Enter键结束输入\n");

34     int arr[MAXN];                                //定义一个足够大的数组

35     int i=0,j,k,count = 0;

36     while(count<MAXN)                           //读入数组，存入数组a中；

37     {

38         scanf("%d",&arr[i++]);

39         count++;

40         if(getchar() == '\n')   break;

41     }

42     QuickSort(arr,count);

43     for(i=0;i<count;i++)

44         printf("%d ",arr[i]);

45     return 0;

46 }

<--点击左侧+展开

7.归并排序。

　　待补充...

8.基数排序。

　　待补充...