算法速成（1）七大排序算法

算法就好比程序开发中的利剑，所到之处，刀起头落。

 

针对现实中的排序问题，算法有七把利剑可以助你马道成功。

 

首先排序分为四种： 

      交换排序： 包括冒泡排序，快速排序。

      选择排序： 包括直接选择排序，堆排序。

      插入排序： 包括直接插入排序，希尔排序。

      合并排序： 合并排序。

 

那么今天我们讲的就是交换排序，我们都知道，C#类库提供的排序是快排，为了让今天玩的有意思点，

我们设计算法来跟类库提供的快排较量较量。争取KO对手。

 

冒泡排序：

首先我们自己来设计一下“冒泡排序”，这种排序很现实的例子就是：

我抓一把沙仍进水里，那么沙子会立马沉入水底， 沙子上的灰尘会因为惯性暂时沉入水底，但是又会立马像气泡一样浮出水面，最后也就真相大白咯。

 

关于冒泡的思想，我不会说那么官方的理论，也不会贴那些文字上来，我的思想就是看图说话。

那么我们就上图.

           

要达到冒泡的效果，我们就要把一组数字竖起来看，大家想想，如何冒泡？如何来体会重的沉底，轻的上浮？

 

第一步:  我们拿40跟20比，发现40是老大，不用交换。

第二步:  然后向前推一步，就是拿20跟30比，发现30是老大，就要交换了。

第三步：拿交换后的20跟10比，发现自己是老大，不用交换。

第四步：拿10跟50交换，发现50是老大，进行交换。

 

最后，我们经过一次遍历，把数组中最小的数字送上去了，看看，我们向目标又迈进了一步。

 

现在大家思想都知道了，下面我们就强烈要求跟快排较量一下，不是你死就是我活。

using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Diagnostics;using System.Threading;namespace BubbleSort{    public class Program    {        static void Main(string[] args)        {            //五次比较            for (int i = 1; i <= 5; i++)            {                List<int> list = new List<int>();                //插入2k个随机数到数组中                for (int j = 0; j < 2000; j++)                {                    Thread.Sleep(1);                    list.Add(new Random((int)DateTime.Now.Ticks).Next(0, 100000));                }                Console.WriteLine("\n第" + i + "次比较：");                Stopwatch watch = new Stopwatch();                watch.Start();                var result = list.OrderBy(single => single).ToList();                watch.Stop();                Console.WriteLine("\n快速排序耗费时间：" + watch.ElapsedMilliseconds);                Console.WriteLine("输出前是十个数:" + string.Join(",", result.Take(10).ToList()));                watch.Start();                result = BubbleSort(list);                watch.Stop();                Console.WriteLine("\n冒泡排序耗费时间：" + watch.ElapsedMilliseconds);                Console.WriteLine("输出前是十个数:" + string.Join(",", result.Take(10).ToList()));            }        }        //冒泡排序算法        static List<int> BubbleSort(List<int> list)        {            int temp;            //第一层循环： 表明要比较的次数，比如list.count个数，肯定要比较count-1次            for (int i = 0; i < list.Count - 1; i++)            {                //list.count-1：取数据最后一个数下标，//j>i: 从后往前的的下标一定大于从前往后的下标，否则就超越了。                for (int j = list.Count - 1; j > i; j--)                {                    //如果前面一个数大于后面一个数则交换                    if (list[j - 1] > list[j])                    {                        temp = list[j - 1];                        list[j - 1] = list[j];                        list[j] = temp;                    }                }            }            return list;        }    }}

 

呜呜，看着这两种排序体检报告，心都凉了，冒泡被快排KO了，真惨，难怪人家说冒泡效率低，原来真tmd低。

 

快速排序：

既然能把冒泡KO掉，马上就激起我们的兴趣，tnd快排咋这么快，一定要好好研究一下。

首先上图：    

 

从图中我们可以看到：

left指针，right指针，base参照数。

其实思想是蛮简单的，就是通过第一遍的遍历（让left和right指针重合）来找到数组的切割点。

第一步：首先我们从数组的left位置取出该数（20）作为基准（base）参照物。

第二步：从数组的right位置向前找，一直找到比（base）小的数，

            如果找到，将此数赋给left位置（也就是将10赋给20），

            此时数组为：10，40，50，10，60，

            left和right指针分别为前后的10。

第三步：从数组的left位置向后找，一直找到比（base）大的数，

             如果找到，将此数赋给right的位置（也就是40赋给10），

             此时数组为：10，40，50，40，60，

             left和right指针分别为前后的40。

第四步：重复“第二,第三“步骤，直到left和right指针重合，

             最后将（base）插入到40的位置，

             此时数组值为： 10，20，50，40，60，至此完成一次排序。

第五步：此时20已经潜入到数组的内部，20的左侧一组数都比20小，20的右侧作为一组数都比20大，

            以20为切入点对左右两边数按照"第一，第二，第三，第四"步骤进行，最终快排大功告成。

 

同样，我们把自己设计的快排跟类库提供的快拍比较一下。看谁牛X。

using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading;using System.Diagnostics;namespace QuickSort{    public class Program    {        static void Main(string[] args)        {            //5次比较            for (int i = 1; i <= 5; i++)            {                List<int> list = new List<int>();                //插入200个随机数到数组中                for (int j = 0; j < 200; j++)                {                    Thread.Sleep(1);                    list.Add(new Random((int)DateTime.Now.Ticks).Next(0, 10000));                }                Console.WriteLine("\n第" + i + "次比较：");                Stopwatch watch = new Stopwatch();                watch.Start();                var result = list.OrderBy(single => single).ToList();                watch.Stop();                Console.WriteLine("\n系统定义的快速排序耗费时间：" + watch.ElapsedMilliseconds);                Console.WriteLine("输出前是十个数:" + string.Join(",", result.Take(10).ToList()));                watch.Start();                new QuickSortClass().QuickSort(list, 0, list.Count - 1);                watch.Stop();                Console.WriteLine("\n俺自己写的快速排序耗费时间：" + watch.ElapsedMilliseconds);                Console.WriteLine("输出前是十个数:" + string.Join(",", list.Take(10).ToList()));            }        }    }    public class QuickSortClass    {        ///<summary>/// 分割函数///</summary>///<param name="list">待排序的数组</param>///<param name="left">数组的左下标</param>///<param name="right"></param>///<returns></returns>        public int Division(List<int> list, int left, int right)        {            //首先挑选一个基准元素            int baseNum = list[left];            while (left < right)            {                //从数组的右端开始向前找，一直找到比base小的数字为止(包括base同等数)                while (left < right && list[right] >= baseNum)                    right = right - 1;                //最终找到了比baseNum小的元素，要做的事情就是此元素放到base的位置                list[left] = list[right];                //从数组的左端开始向后找，一直找到比base大的数字为止（包括base同等数）                while (left < right && list[left] <= baseNum)                    left = left + 1;                //最终找到了比baseNum大的元素，要做的事情就是将此元素放到最后的位置                list[right] = list[left];            }            //最后就是把baseNum放到该left的位置            list[left] = baseNum;            //最终，我们发现left位置的左侧数值部分比left小，left位置右侧数值比left大//至此，我们完成了第一篇排序            return left;        }        public void QuickSort(List<int> list, int left, int right)        {            //左下标一定小于右下标，否则就超越了            if (left < right)            {                //对数组进行分割，取出下次分割的基准标号                int i = Division(list, left, right);                //对“基准标号“左侧的一组数值进行递归的切割，以至于将这些数值完整的排序                QuickSort(list, left, i - 1);                //对“基准标号“右侧的一组数值进行递归的切割，以至于将这些数值完整的排序                QuickSort(list, i + 1, right);            }        }    }}

 

 

不错，快排就是快，难怪内库非要用他来作为排序的标准。

 

嗯，最后要分享下：

冒泡的时间复杂度为： 0(n) - 0(n^2)

快排的时间复杂度为: 

    平均复杂度： N(logN)

    最坏复杂度：  0(n^2)

选择排序，包括“直接选择排序”和“堆排序”。

 

话说上次“冒泡排序”被快排虐了，而且“快排”赢得了内库的重用，众兄弟自然眼红，非要找快排一比高下。

这不今天就来了两兄弟找快排算账。

 

1.直接选择排序： 

先上图：

 

说实话，直接选择排序最类似于人的本能思想，比如把大小不一的玩具让三岁小毛孩对大小排个序，

那小孩首先会在这么多玩具中找到最小的放在第一位，然后找到次小的放在第二位，以此类推。。。。。。

，小孩子多聪明啊，这么小就知道了直接选择排序。羡慕中........

 

对的，小孩子给我们上了一课，

第一步： 我们拿80作为参照物（base），在80后面找到一个最小数20,然后将80跟20交换。

第二步:  第一位数已经是最小数字了，然后我们推进一步在30后面找一位最小数，发现自己最小，不用交换。

第三步：........

最后我们排序完毕。大功告成。

 

既然是来挑战的，那就5局3胜制。

using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading;using System.Diagnostics;namespace SelectionSort{    public class Program    {        static void Main(string[] args)        {            //5次比较            for (int i = 1; i <= 5; i++)            {                List<int> list = new List<int>();                //插入2w个随机数到数组中                for (int j = 0; j < 20000; j++)                {                    Thread.Sleep(1);                    list.Add(new Random((int)DateTime.Now.Ticks).Next(1000, 1000000));                }                Console.WriteLine("\n第" + i + "次比较：");                Stopwatch watch = new Stopwatch();                watch.Start();                var result = list.OrderBy(single => single).ToList();                watch.Stop();                Console.WriteLine("\n快速排序耗费时间：" + watch.ElapsedMilliseconds);                Console.WriteLine("输出前十个数:" + string.Join(",", result.Take(10).ToList()));                watch.Start();                result = SelectionSort(list);                watch.Stop();                Console.WriteLine("\n直接选择排序耗费时间：" + watch.ElapsedMilliseconds);                Console.WriteLine("输出前十个数:" + string.Join(",", list.Take(10).ToList()));            }        }        //选择排序        static List<int> SelectionSort(List<int> list)        {            //要遍历的次数            for (int i = 0; i < list.Count - 1; i++)            {                //假设tempIndex的下标的值最小                int tempIndex = i;                for (int j = i + 1; j < list.Count; j++)                {                    //如果tempIndex下标的值大于j下标的值,则记录较小值下标j                    if (list[tempIndex] > list[j])                        tempIndex = j;                }                //最后将假想最小值跟真的最小值进行交换                var tempData = list[tempIndex];                list[tempIndex] = list[i];                list[i] = tempData;            }            return list;        }    }}

比赛结果公布：

 

堆排序：

要知道堆排序，首先要了解一下二叉树的模型。

下图就是一颗二叉树，具体的情况我后续会分享的。

那么堆排序中有两种情况（看上图理解）：

    大根堆：  就是说父节点要比左右孩子都要大。

    小根堆：  就是说父节点要比左右孩子都要小。

 

那么要实现堆排序,必须要做两件事情：

   第一：构建大根堆。

           首先上图：

           

首先这是一个无序的堆，那么我们怎样才能构建大根堆呢？

     第一步： 首先我们发现，这个堆中有2个父节点(2,,3);

     第二步： 比较2这个父节点的两个孩子（4，5），发现5大。

     第三步： 然后将较大的右孩子（5）跟父节点（2）进行交换，至此3的左孩子堆构建完毕，

                 如图：

                         

     第四步： 比较第二个父节点（3）下面的左右孩子（5，1），发现左孩子5大。

     第五步： 然后父节点（3）与左孩子（5）进行交换，注意，交换后，堆可能会遭到破坏，

                 必须按照以上的步骤一，步骤二，步骤三进行重新构造堆。

           

最后构造的堆如下:

                 

 

   第二：输出大根堆。

             至此，我们把大根堆构造出来了，那怎么输出呢？我们做大根堆的目的就是要找出最大值，

         那么我们将堆顶（5）与堆尾（2）进行交换，然后将（5）剔除根堆，由于堆顶现在是（2），

         所以破坏了根堆，必须重新构造，构造完之后又会出现最大值，再次交换和剔除，最后也就是俺们

         要的效果了，

 

 

发现自己兄弟被别人狂殴，，堆排序再也坐不住了，决定要和快排干一场。

同样，快排也不甘示弱，谁怕谁？

 

using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading;using System.Diagnostics;namespace HeapSort{    public class Program    {        static void Main(string[] args)        {            //5次比较            for (int j = 1; j <= 5; j++)            {                List<int> list = new List<int>();                //插入2w个数字                for (int i = 0; i < 20000; i++)                {                    Thread.Sleep(1);                    list.Add(new Random((int)DateTime.Now.Ticks).Next(1000, 100000));                }                Console.WriteLine("\n第" + j + "次比较：");                Stopwatch watch = new Stopwatch();                watch.Start();                var result = list.OrderBy(single => single).ToList();                watch.Stop();                Console.WriteLine("\n快速排序耗费时间:" + watch.ElapsedMilliseconds);                Console.WriteLine("输出前十个数" + string.Join(",", result.Take(10).ToList()));                watch = new Stopwatch();                watch.Start();                HeapSort(list);                watch.Stop();                Console.WriteLine("\n堆排序耗费时间:" + watch.ElapsedMilliseconds);                Console.WriteLine("输出前十个数" + string.Join(",", list.Take(10).ToList()));            }        }        ///<summary>/// 构建堆///</summary>///<param name="list">待排序的集合</param>///<param name="parent">父节点</param>///<param name="length">输出根堆时剔除最大值使用</param>        static void HeapAdjust(List<int> list, int parent, int length)        {            //temp保存当前父节点            int temp = list[parent];            //得到左孩子(这可是二叉树的定义，大家看图也可知道)            int child = 2 * parent + 1;            while (child < length)            {                //如果parent有右孩子，则要判断左孩子是否小于右孩子                if (child + 1 < length && list[child] < list[child + 1])                    child++;                //父亲节点大于子节点，就不用做交换                if (temp >= list[child])                    break;                //将较大子节点的值赋给父亲节点                list[parent] = list[child];                //然后将子节点做为父亲节点，已防止是否破坏根堆时重新构造                parent = child;                //找到该父亲节点较小的左孩子节点                child = 2 * parent + 1;            }            //最后将temp值赋给较大的子节点，以形成两值交换            list[parent] = temp;        }        ///<summary>/// 堆排序///</summary>///<param name="list"></param>        public static void HeapSort(List<int> list)        {            //list.Count/2-1:就是堆中父节点的个数            for (int i = list.Count / 2 - 1; i >= 0; i--)            {                HeapAdjust(list, i, list.Count);            }            //最后输出堆元素            for (int i = list.Count - 1; i > 0; i--)            {                //堆顶与当前堆的第i个元素进行值对调                int temp = list[0];                list[0] = list[i];                list[i] = temp;                //因为两值交换，可能破坏根堆，所以必须重新构造                HeapAdjust(list, 0, i);            }        }    }}

结果公布：

 

堆排序此时心里很尴尬，双双被KO，心里想，一定要捞回面子，一定要赢，

 

于是堆排序提出了求“前K大问题”。（就是在海量数据中找出前几大的数据），

快排一口答应，小意思，没问题。

双方商定，在2w随机数中找出前10大的数：

 
using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading;using System.Diagnostics;namespace QuickSort{    public class Program    {        static void Main(string[] args)        {            //5此比较            for (int j = 1; j <= 5; j++)            {                List<int> list = new List<int>();                for (int i = 0; i < 20000; i++)                {                    Thread.Sleep(1);                    list.Add(new Random((int)DateTime.Now.Ticks).Next(1000, 100000));                }                Console.WriteLine("\n第" + j + "次比较：");                Stopwatch watch = new Stopwatch();                watch.Start();                var result = list.OrderByDescending(single => single).Take(10).ToList();                watch.Stop();                Console.WriteLine("\n快速排序求前K大耗费时间:" + watch.ElapsedMilliseconds);                Console.WriteLine("输出前十个数:" + string.Join(",", result.Take(10).ToList()));                watch = new Stopwatch();                watch.Start();                result = HeapSort(list, 10);                watch.Stop();                Console.WriteLine("\n堆排序求前K大耗费时间：" + watch.ElapsedMilliseconds);                Console.WriteLine("输出前十个数:" + string.Join(",", list.Take(10).ToList()));            }        }        ///<summary>/// 构建堆///</summary>///<param name="list">待排序的集合</param>///<param name="parent">父节点</param>///<param name="length">输出根堆时剔除最大值使用</param>        static void HeapAdjust(List<int> list, int parent, int length)        {            //temp保存当前父节点            int temp = list[parent];            //得到左孩子(这可是二叉树的定义哇)            int child = 2 * parent + 1;            while (child < length)            {                //如果parent有右孩子，则要判断左孩子是否小于右孩子                if (child + 1 < length && list[child] < list[child + 1])                    child++;                //父节点大于子节点，不用做交换                if (temp >= list[child])                    break;                //将较大子节点的值赋给父亲节点                list[parent] = list[child];                //然后将子节点做为父亲节点，已防止是否破坏根堆时重新构造                parent = child;                //找到该父节点左孩子节点                child = 2 * parent + 1;            }            //最后将temp值赋给较大的子节点，以形成两值交换            list[parent] = temp;        }        ///<summary>/// 堆排序///</summary>///<param name="list">待排序的集合</param>///<param name="top">前K大</param>///<returns></returns>        public static List<int> HeapSort(List<int> list, int top)        {            List<int> topNode = new List<int>();            //list.Count/2-1:就是堆中非叶子节点的个数            for (int i = list.Count / 2 - 1; i >= 0; i--)            {                HeapAdjust(list, i, list.Count);            }            //最后输出堆元素（求前K大）            for (int i = list.Count - 1; i >= list.Count - top; i--)            {                //堆顶与当前堆的第i个元素进行值对调                int temp = list[0];                list[0] = list[i];                list[i] = temp;                //最大值加入集合                topNode.Add(temp);                //因为顺序被打乱，必须重新构造堆                HeapAdjust(list, 0, i);            }            return topNode;        }    }}

求前K大的输出结果：

 

 

最后堆排序赶紧拉着直接选择排序一路小跑了，因为求前K大问题已经不是他原本来的目的。

 

ps： 直接选择排序的时间复杂度为：O(n^2)

       堆排序的时间复杂度：O(NlogN)

直接插入排序：

       这种排序其实蛮好理解的，很现实的例子就是俺们斗地主，当我们抓到一手乱牌时，我们就要按照大小梳理扑克，30秒后，

   扑克梳理完毕，4条3，5条s，哇塞......  回忆一下，俺们当时是怎么梳理的。

       最左一张牌是3，第二张牌是5，第三张牌又是3，赶紧插到第一张牌后面去，第四张牌又是3，大喜，赶紧插到第二张后面去，

   第五张牌又是3，狂喜，哈哈，一门炮就这样产生了。

 

     怎么样，生活中处处都是算法，早已经融入我们的生活和血液。

     

     下面就上图说明：

             

      看这张图不知道大家可否理解了，在插入排序中，数组会被划分为两种，“有序数组块”和“无序数组块”，

     

      对的，第一遍的时候从”无序数组块“中提取一个数20作为有序数组块。

              第二遍的时候从”无序数组块“中提取一个数60有序的放到”有序数组块中“，也就是20，60。

              第三遍的时候同理，不同的是发现10比有序数组的值都小，因此20，60位置后移，腾出一个位置让10插入。

                      然后按照这种规律就可以全部插入完毕。

  

using System;using System.Collections.Generic;using System.Linq;using System.Text;namespace InsertSort{    public class Program    {        static void Main(string[] args)        {            List<int> list = new List<int>() { 3, 1, 2, 9, 7, 8, 6 };            Console.WriteLine("排序前：" + string.Join(",", list));            InsertSort(list);            Console.WriteLine("排序后：" + string.Join(",", list));        }        static void InsertSort(List<int> list)        {            //无须序列            for (int i = 1; i < list.Count; i++)            {                var temp = list[i];                int j;                //有序序列                for (j = i - 1; j >= 0 && temp < list[j]; j--)                {                    list[j + 1] = list[j];                }                list[j + 1] = temp;            }        }    }}

看的出来，希尔排序优化了不少，w级别的排序中，相差70几倍哇。

 

归并排序：

       个人感觉，我们能容易看的懂的排序基本上都是O (n^2)，比较难看懂的基本上都是N(LogN)，所以归并排序也是比较难理解的，尤其是在代码

 编写上，本人就是搞了一下午才搞出来，嘻嘻。

归并排序中中两件事情要做：

            第一： “分”,  就是将数组尽可能的分，一直分到原子级别。

            第二： “并”，将原子级别的数两两合并排序，最后产生结果。

using System;using System.Collections.Generic;using System.Linq;using System.Text;namespace MergeSort{    class Program    {        static void Main(string[] args)        {            int[] array = { 3, 2, 1, 8, 9, 0 };            MergeSort(array, new int[array.Length], 0, array.Length - 1);            Console.WriteLine(string.Join(",", array));        }        ///<summary>/// 数组的划分///</summary>///<param name="array">待排序数组</param>///<param name="temparray">临时存放数组</param>///<param name="left">序列段的开始位置，</param>///<param name="right">序列段的结束位置</param>        static void MergeSort(int[] array, int[] temparray, int left, int right)        {            if (left < right)            {                //取分割位置                int middle = (left + right) / 2;                //递归划分数组左序列                MergeSort(array, temparray, left, middle);                //递归划分数组右序列                MergeSort(array, temparray, middle + 1, right);                //数组合并操作                Merge(array, temparray, left, middle + 1, right);            }        }        ///<summary>/// 数组的两两合并操作///</summary>///<param name="array">待排序数组</param>///<param name="temparray">临时数组</param>///<param name="left">第一个区间段开始位置</param>///<param name="middle">第二个区间的开始位置</param>///<param name="right">第二个区间段结束位置</param>        static void Merge(int[] array, int[] temparray, int left, int middle, int right)        {            //左指针尾            int leftEnd = middle - 1;            //右指针头            int rightStart = middle;            //临时数组的下标            int tempIndex = left;            //数组合并后的length长度            int tempLength = right - left + 1;            //先循环两个区间段都没有结束的情况            while ((left <= leftEnd) && (rightStart <= right))            {                //如果发现有序列大，则将此数放入临时数组                if (array[left] < array[rightStart])                    temparray[tempIndex++] = array[left++];                else                    temparray[tempIndex++] = array[rightStart++];            }            //判断左序列是否结束            while (left <= leftEnd)                temparray[tempIndex++] = array[left++];            //判断右序列是否结束            while (rightStart <= right)                temparray[tempIndex++] = array[rightStart++];            //交换数据            for (int i = 0; i < tempLength; i++)            {                array[right] = temparray[right];                right--;            }        }    }}

ps: 插入排序的时间复杂度为：O(N^2)

     希尔排序的时间复杂度为：平均为：O(N^3/2)

                                       最坏： O(N^2)

     归并排序时间复杂度为： O(NlogN)

                空间复杂度为:  O(N) 

 

本文借鉴：http://www.cnblogs.com/huangxincheng/archive/2011/11/20/2255695.html

感谢博主的详细讲解，受用中！