各种排序算法

快速排序

快速排序作为复杂排序中最好用的排序算法，作为程序员是必须要掌握的。

先说说排序算法的思路，我们对照着下图慢慢说。

比如我们有一个数组：

角标 0 1 2 3 4 5 6
数组 6 4 7 3 9 2 8

我们随便选择一个值为基准数X，我们这里选择0位置的数字6，X=6。然后我们创建两个游标 i和j 。因为我们是要对整个数组进行排序，那么我们就给游标一个初始值： i = 0 ，j = 6 。

初始化的工作完成了，接下来是排序的核心内容了。

第一步，把比基准数大的数放在右边，把比基准数小的数放左边。

我们从右边开始向左移动游标j，选择一个比基准数小的数放到基准数的位置。当j为5的时候，发现2小于等于6。

角标 0 1 2 3 4 5 6
数组 2 4 7 3 9 ? 8

接下来我们从左边开始向右移动游标i,选择一个比基准数大的数放到之前空去来的位置。当i移动到2的时候，发现7大于等于6。

角标 0 1 2 3 4 5 6
数组 2 4 ? 3 9 7 8

然后我们又由右向左移动j，找一个大于6的值。是不是有种荡秋千的感觉。我们发现了当j为3的时候，9大于等于6。

角标 0 1 2 3 4 5 6
数组 2 4 3 ? 9 7 8

之后我们向右移动i，当为3的时候，i就和j相等了!我们把基准数赋值给这个‘?’，第一步就完成了！

角标 0 1 2 3 4 5 6
数组 2 4 3 6 9 7 8

我们可以发现比基准数小的数在基准数的左边，比基准值大的数在基准数的右边，而基准数的位置就是最终排序结果的位置。

第二步，我们把基准数左边和右边都提取出来，得到两个小的集合。

角标 0 1 2 
数组 2 4 3

和

角标 0 1 2 
数组 9 7 8

我们把这两个数组分别使用第一步的方法，接着分下去。分到的集合继续分下去，直到不能分下去为止。因为这种分割的方法，我称它为二分法。

我找到了一幅图，可能会比较形象，容易大家理解。

想来大家对快速排序的思路比较清晰了。我们使用代码来实现这个思路：

 /// <summary>
    /// 快速排序
    /// </summary>
    /// <param name="arrayAway">需要排序的集合</param>
    /// <param name="left">开始位置的角标</param>
    /// <param name="right">结束位置的角标</param>
    public void QuickSort( int[] arrayAway, int left, int right)
    {
        if (left < right) //左边必须小于右边
        {
            int X = arrayAway[left];
            int i = left;
            int j = right;

            while (i < j)
            {
                //从右至左移动,找到一个比基准数小的数，把这个数放到基准数的位置。
                while (i < j)
                {
                    if (arrayAway[j] <= X)
                    {
                        arrayAway[i] = arrayAway[j];
                        break;
                    }
                    else
                    {
                        j--;  
                    }
                }

                //从左至右移动,找到一个比基准数大的数，把这个数放到之前空出的位置（角标为j的位置）上。
                while (i < j)
                {
                    if (arrayAway[i] >= X)
                    {
                        arrayAway[j] = arrayAway[i];
                        break;
                    }
                    else
                    {
                        i++;
                    }
                }
            }
            //第一步的最后，将基准值放到i=j的位置。
            arrayAway[i] = X;

            //第二步，我们递归这个方法
            QuickSort( arrayAway, left, i - 1);
            QuickSort( arrayAway, i + 1, right);
        }
    }

怎么样？是不是很简单！大家去试试吧！

直接插入排序

还是先讲讲思路，我们从数组第二个数据开始遍历，将这个数和他前面的数进行比较，如果前面的数大于这个数，就将前面数的位置向后移动一位，不大于就将这个数放到前面位置的后面一位（原地不动），遍历完了没有插入就放到角标为0的位置。

思路说的有点绕，我们以一个实例来详细说明。

角标 0 1 2 3 4 5 6
数组 6 4 7 3 9 2 8

我们从角标为1的位置，这个位置的数是4，拿他和前面比较，6大于4，把6移动到角标1的位置，然后继续遍历，遍历完没有插入，把这个数放到角标为0的位置。

角标 0 1 2 3 4 5 6
数组 4 6 7 3 9 2 8

我们继续选择2号位置的7，将7和前面的数比较，6小于7，那么7的位置不变。

我们选择角标为3的数3，拿它和前面的数比较，3小于4、6、7，7、6、4依次向后移动一位，3没有插入，我们把他放到角标为0的位置。

角标 0 1 2 3 4 5 6
数组 3 4 6 7 9 2 8

说到这，其实思路已经很清楚了，也没有再继续啰嗦的必要了。我们使用代码来实现这个思路。

 void InsertSort(int[] arrayAway)
    {
        for (int i = 1; i < arrayAway.Length; i++ )
        {
            int X = arrayAway[i];
            bool flag = false;
            //将X和前面相比较，如果值大于X，向后移动一位，如果小于，就讲X放到前面值得后一位（也就是当前X的位置）
            for (int j = i - 1; j >= 0;j-- )
            {
                if (arrayAway[j] > X)
                {
                    arrayAway[j + 1] = arrayAway[j];
                }
                else 
                {
                    arrayAway[j + 1] = X;
                    flag = true;
                    break;
                }
            }

            if (!flag) arrayAway[0] = X;
        }
    }

冒泡排序

先说说思路。从右往左相邻的两个数两两比较，把小的数放前，一次循环，把最小的数放到最前面。然后将除了最前面一个数从右至左两两比较，确定第二小的数，这样依次从前往后确定数的位置，实现排序。我们来看图说话：

从角标为5的位置开始，1、3比较，1小，1放前面，然后1、6比较，1小，放前面，依次这样，将1放到最前面。就实现了最小值放最前面。

我们用代码来实现这个思路：

void BubblingSort(int[] arrayAway)
    {
        for (int i = 0; i < arrayAway.Length;i++)
        {
            int X = 0; //交换位置的容器
            for (int j = arrayAway.Length - 1; j > 0;j--)
            {
                //如果前面的大于后面的，就交换位置
                if(arrayAway[j-1]>arrayAway[j]){

                    X = arrayAway[j];
                    arrayAway[j] = arrayAway[j - 1];
                    arrayAway[j - 1] = X;
                }
            }
        }
    }

来看一张图便于理解冒泡排序：

简单选择排序

简单选择排序和冒泡排序有点相似，都是通过循环来找到最大数/最小数，然后找到第二大/小的数，不同的是冒泡排序是在不断的交换来事件排序，而选择排序是直接在里面找到我们想要的数。

以0号位置的数42为基准数，假设他为最小值，遍历它后面的数，如果有比他小的数就记录下来，和0号位置的42交换，那么就找到了第一小的数。接着从1号位置开始，假设为最小值，遍历后面的数找到第二小的数，以此类推实现排序。

我们用代码来实现这种排序：

  void SelectSort(int[] arrayAway)
    {
        for (int i = 0; i < arrayAway.Length - 1;i++ )
        {
            int min = arrayAway[i];
            int minIndex = i;
            for (int j = i + 1; j < arrayAway.Length;j++)
            {
                if(arrayAway[j]<min){
                    min = arrayAway[j] ;
                    minIndex = j;
                }
            }

            if(minIndex != i){
                int temp = arrayAway[i];
                arrayAway[i] = arrayAway[minIndex];
                arrayAway[minIndex] = temp;
            }
        }
    }

简单选择排序示意图：