排序算法精要-优快云博客

以前有句话说程序==算法+数据结构，其实不然，如果说编程像是在盖楼房，那么学好数据结构和算法，就是在打下一个完美的地基。

所以今天闲着无聊，给大家总结总结，几个非常非常基础的算法，这在许多公司的笔试，面试中都要可能出现。今天我所要想讨论的是排序算法，说到排序算法，大家在熟悉不过的是冒泡排序算法，在我后来接触的一些列排序算法中，后来想想每个算法都有其巧妙之处，也不单单是为了追求的时间上的效率。下面我就来列出主要的几种排序算法。

1.冒泡排序算法，平均时间复杂度o(n2),作为一种性能还算不错的排序算法

2.选择排序算法

3.插入排序算法

4.归并排序算法

5.桶排序算法

6.基数排序算法

7.希尔排序算法

8.堆排序算法，其中涉及到了一些数据结果中的一些的知识

9.快速排序算法，快速排序算法，在此类中的排序性能中算是最好吧，但是如果一组数字基本都是有序的情况的时候，快速排序就又会被退化为冒泡排序，基本排序算法差差不多都列在上面了，具体掌握上述中排序算法的精髓，对于面试还是很有帮助的

----------------------------------------------------------

问题：设有一数组，其大小为10个元素（int str[10]）数组内的数据是无序。现在要求我们通过编程将这个无序的数组变成一个从小到大排序的数组（从下标为0开始）

思路：按照题目的要求，毫无疑问，正确的结果应该就像这样： 1 2 3 4 5 6 7 8 9 10 要做到这样，最简单和最直接想到的方法就是进行对比交换。

首先，把10个数里最小的个数放到下标为0的位置上（str[0]）
通过将下标为0的数（str[0]）与剩下其余9个数进行对比交换（将较少者放置在下标为0的位置上），就可以得到这10个数最小的那个
10个数最小的那位确定后，接下来就要找剩下9个数最小的那个。
因为已经确定出一个最小的数，所以就不要动str[0]，直接从str[1]开始，与剩下的8个数对比交换，找出9个数中最小的那位放到下标为1（str[1]）的位置上
继续按照这个思路就可以将这十个数变成有序的（从小到大）的数组

代码：

[cpp]view plaincopyprint? 
    
 #include <stdio.h>  
   
 void swap(int *a, int *b); //交换两个数  
   
 int main()  
 {  
     int     str[10];  
     int     i, j;  
     //初始化数组为10 9 8 7 6 5 4 3 2 1  
     for (i = 0; i < 10; i++)  
     {  
         str[i] = 10 - i;  
     }  
     //排序，从a[0]开始排，从小到大  
     for (i = 0; i < 10; i++)  
     {  
         for (j = i + 1; j < 10; j++)  
         {  
             if (str[i] > str[j])  
             {  
                 swap(&str[i], &str[j]);  
             }  
         }  
     }  
         //将十个数输出  
     for (i = 0; i < 10; i++)  
         printf("%d\n", str[i]);  
     return    0;  
 }  
 void swap(int *a, int *b)  
 {  
     int     c;  
      c = *a;  
     *a = *b;  
     *b =  c;  
 }  

这个方法是比较容易想到的实现方法。但 存在不足：就是本来位于前面的较小数被交换到后面

演示：

开始： 9 4 5 6 8 3 2 7 10 1 （下标从左到右分别是0~9）按照上面的程序进行对比交换

第一次： 4 9 5 6 8 3 2 7 10 1

第二次： 4 9 5 6 8 3 2 7 10 1

。。。：（没有交换）

第五次： 3 9 5 6 8 4 2 7 10 1

第六次： 2 9 5 6 8 3 4 7 10 1

。。。：（没有交换）

第十次： 1 9 5 6 8 3 4 7 10 2

可以看出，原来较小的数是在前面的，经过一轮的交换后放到后面了

那么怎样解决这个不足呢？可以使用冒泡排序

什么是冒泡排序呢？

你可以这样理解：（从小到大排序）存在10个不同大小的气泡，由底至上地把较少的气泡逐步地向上升，这样经过遍历一次后，最小的气泡就会被上升到顶（下标为0），然后再从底至上地这样升，循环直至十个气泡大小有序。

在冒泡排序中， 最重要的思想是两两比较，将两者较少的升上去

冒泡排序最坏情况的时间复杂度是O(n²)

代码：

[cpp]view plaincopyprint? 
     
 #include <stdio.h>  
 void swap(int *a, int *b);  
 int main()  
 {  
     int    array[10] = {15, 225, 34, 42, 52, 6, 7856, 865, 954, 10};  
     int    i, j;  
     for (i = 0; i < 10; i++)  
     {  
         //每一次由底至上地上升  
         for (j = 9; j > i; j--)  
         {  
             if (array[j] < array[j-1])  
             {  
                     swap(&array[j], &array[j-1]);  
             }  
         }  
     }  
     for (i = 0; i < 10; i++)  
     {  
         printf("%d\n", array[i]);  
     }  
     return    0;  
 }  
 void swap(int *a, int *b)  
 {  
     int    temp;  
     temp = *a;  
       *a = *b;  
       *b = temp;  
 }  
-----====================================================
选择排序算法
 
 假定存在数组 array[0..n-1], 选择排序的核心思想是：
 第 i 趟排序是从后面的 n - i + 1（i = 1，2，3，4，. . .，n - 1）个元素中选择一个值最小的元素与该 n - i + 1 个元素的最前门的那个元素交换位置，即与整个序列的第 i 个元素交换位置。如此下去，直到 i = n - 1，排序结束。
 也可描述为：
 每一趟排序从序列中未排好序的那些元素中选择一个值最小的元素，然后将其与这些未排好序的元素的第一个元素交换位置。
 
 
 特点：
 1. 算法完成需要 n - 1 趟排序，按照算法的描述，n - 1 趟排序之后数组中的前 n - 1 个元素已经处于相应的位置，第 n 个元素也处于相应的位置上。
 2. 第 i 趟排序，实际上就是需要将数组中第 i 个元素放置到数组的合适位置，这里需要一个临时变量 j 来遍历序列中未排好序的那些元素，另一临时变量 d 来记录未排好序的那些元素中值最小的元素的下标值，
 3. 一趟遍历开始时，令 d = i，假定未排序序列的第一个元素就是最小的元素，遍历完成后，变量 d 所对应的值就是值最小的元素，判断 d 是否是未排序序列的第一个元素，如果是，则不需要交换元素，如果不是，则需要交换array[d] 和 array[i]。
 4. 此方法是不稳定排序算法，可对数组{a1 = 49，a2 = 38, a3 = 65, a4 = 49, a5 = 12, a6 = 42} 排序就可以看出，排序完成后 a1 和 a4的相对位置改变了。
 5. 此方法移动元素的次数比较少，但是不管序列中元素初始排列状态如何，第 i 趟排序都需要进行 n - i 次元素之间的比较，因此总的比较次数为
 1 + 2 + 3 + 4 +5 + . . . + n - 1 = n(n-1)/2, 时间复杂度是 O(n^2).
 
 
 看代码：
 
[cpp]view plaincopyprint? 
        
 #include <stdlib.h>  
 #include <stdio.h>  
   
 void selectSort(int array[], int n)  
 {  
     int i, j, d;  
     int temp;  
     for(i = 0; i < n - 1; ++i)  
     {  
         d = i;   //开始一趟选择排序，假定第i个元素是后面n - i + 1个未排序的元素中最小的元素  
         for(j = i + 1; j < n; ++j)  
             if(array[j] < array[d])  //如果发现比当前最小元素还小的元素，则更新记录最小元素的下标d  
                 d = j;  
   
         if(d != i)   //如果最小元素的下标不是后面n - i + 1的未排序序列的第一个元素，则需要交换第i个元素和后面找到的最小元素的位置  
         {  
             temp = array[d];  
             array[d] = array[i];  
             array[i] = temp;  
         }  
     }  
 }  
   
 int main()  
 {  
     int array[] = {3, 1, 15, 11, 89, 5};  
     int size = sizeof(array)/sizeof(int);  
     selectSort(array, size);  
   
     for(int i = 0; i < size; ++i)  
     {  
         printf("%d ", array[i]);  
     }  
     printf("\n");  
 }  
 =======================================================
 插入排序算法
 
 经典排序算法 – 插入排序Insertion sort  
 插入排序就是每一步都将一个待排数据按其大小插入到已经排序的数据中的适当位置，直到全部插入完毕。 
 插入排序方法分直接插入排序和折半插入排序两种，这里只介绍直接插入排序，折半插入排序留到“查找”内容中进行。 
   图1演示了对4个元素进行直接插入排序的过程，共需要(a),(b),(c)三次插入。
 
 以下代码仅供参考,欢迎指正

          
         
        /// <summary>
        /// 插入排序
        /// </summary>
        /// <param name="unsorted"></param>
        static void insertion_sort(int[] unsorted)
        {
            for (int i = 1; i < unsorted.Length; i++)
            {
                if (unsorted[i - 1] > unsorted[i])
                {
                    int temp = unsorted[i];
                    int j = i;
                    while (j > 0 && unsorted[j - 1] > temp)
                    {
                        unsorted[j] = unsorted[j - 1];
                        j--;
                    }
                    unsorted[j] = temp;
                }
            }
        }

        static void Main(string[] args)
        {
            int[] x = { 6, 2, 4, 1, 5, 9 };
            insertion_sort(x);
            foreach (var item in x)
            {
                if (item > 0)
                    Console.WriteLine(item + ",");
            }
            Console.ReadLine();
        }
          
         


         =================================
        

         归并排序算法
 
        
 经典排序算法 - 归并排序Merge sort
 原理,把原始数组分成若干子数组,对每一个子数组进行排序,
 继续把子数组与子数组合并,合并后仍然有序,直到全部合并完,形成有序的数组
 举例
 无序数组[6 2 4 1 5 9]
 先看一下每个步骤下的状态,完了再看合并细节
 第一步 [6 2 4 1 5 9]原始状态
 第二步 [2 6] [1 4] [5 9]两两合并排序,排序细节后边介绍
 第三步 [1 2 4 6] [5 9]继续两组两组合并
 第四步 [1 2 4 5 6 9]合并完毕,排序完毕
 输出结果[1 2 4 5 6 9]
 合并细节
 详细介绍第二步到第三步的过程,其余类似
 第二步:[2 6] [1 4] [5 9]
 两两合并,其实仅合并[2 6] [1 4],所以[5 9]不管它,
 原始状态
 第一个数组[2 6]
 第二个数组[1 4]
 --------------------
 第三个数组[...]
  
 第1步,顺序从第一,第二个数组里取出一个数字:2和1
 比较大小后将小的放入第三个数组,此时变成下边这样
 第一个数组[2 6]
 第二个数组[4]
 --------------------
 第三个数组[1]
  
 第2步,继续刚才的步骤,顺序从第一,第二个数组里取数据,2和4,
 同样的比较大小后将小的放入第三个数组,此时状态如下
 第一个数组[6]
 第二个数组[4]
 --------------------
 第三个数组[1 2]
  
 第3步,再重复前边的步骤变成,将较小的4放入第三个数组后变成如下状态
 第一个数组[6]
 第二个数组[...]
 --------------------
 第三个数组[1 2 4]
  
 第4步,最后将6放入,排序完毕
 第一个数组[...]
 第二个数组[...]
 --------------------
 第三个数组[1 2 4 6]
  
 [ 1 2 4 6 ]与[ 5 9 ]的合并过程与上边一样,不再分解
 代码仅供参考

           
          
        static void merge(int[] unsorted, int first, int mid, int last, int[] sorted)
        {
            int i = first, j = mid;
            int k = 0;
            while (i < mid && j < last)
                if (unsorted[i] < unsorted[j])
                    sorted[k++] = unsorted[i++];
                else
                    sorted[k++] = unsorted[j++];

            while (i < mid)
                sorted[k++] = unsorted[i++];
            while (j < last)
                sorted[k++] = unsorted[j++];

            for (int v = 0; v < k; v++)
                unsorted[first + v] = sorted[v];
        }

        static void merge_sort(int[] unsorted, int first, int last, int[] sorted)
        {
            if (first + 1 < last)
            {
                int mid = (first + last) / 2;
                Console.WriteLine("{0}-{1}-{2}", first, mid, last);
                merge_sort(unsorted, first, mid, sorted);
                merge_sort(unsorted, mid, last, sorted);
                merge(unsorted, first, mid, last, sorted);
            }
        }

        static void Main(string[] args)
        {
            int[] x = { 6, 2, 4, 1, 5, 9 };
            int[] sorted = new int[x.Length];
            merge_sort(x, 0, x.Length, sorted);
            for (int i = 0; i < sorted.Length; i++)
            {
                if (x[i] > 0)
                    Console.WriteLine(x[i]);
            }
            Console.ReadLine();
        }
           
          