【排序算法】排序算法之快速排序

　　最近在学习排序算法，就排序算法中的四大经典排序：冒泡排序、快速排序、选择排序、插入排序。会出一系列的讲解排序算法的博 客。

一、快速排序的思想

　　上一篇写了冒泡排序,这一篇就讲讲我对快速排序的理解吧。快速排序，如何个快速法，简而言之就是取第一个数为基准数，将比这个基准数小的都放在左边，大的都放在右边，基准数在中间，第一轮之后，再对左边块中进行刚刚的排序换位，直到左边的都排序都正确了，再对右边的块进行排序换位。如此看来，其实就是一分为二、二分为4，不断分隔，不断调整的过程。

　　下面以一个具体数组，来分析快速排序的过程。

0	1	2	3	4	5	6	7
25	73	66	10	37	84	5	17

 　 首先咱们取第一个数25为基准数,由于把基准数提出来了，那么intarray[0]就空出来了。flag=25。left=0,right=7.

　　首先右→左(7→0)，看又那个数比flag小，right--过程中，当right=7时，发现intarray[7]<flag，则用intarray[7]来填充intarray[0]的空缺，intarray[0]=intarray[7].

　　left=0,right=7

0	1	2	3	4	5	6	7
17	73	66	10	37	84	5	空位

　　如此intarray[7]的位置空下来了。左→右（0→7），left++,寻找比flag大的数据，当left=1时，找到了比flag大的数据，intarray[1]可以填充intarray[7]的空位了。

　　left=1,right=7

0	1	2	3	4	5	6	7
17	空位	66	10	37	84	5	73

     继续右→左（7→1）找比25小的数，right--,right=6时，intarray[6]可以填充intarray[1]的空位了。

     left=1,right=6

0	1	2	3	4	5	6	7
17	5	66	10	37	84	空位

　  继续左→右（1→6），left++,寻找比25大的数，left=2时，找到。intarray[2]可以填充intarray[6]的空位了。

　　left=2,right=6

0	1	2	3	4	5	6	7
17	5	空位	10	37	84	66	73

　 从右至左（6-2），right--,intarray[3]可以填充intarray[2]的空位了。

     left=2,right=3

0	1	2	3	4	5	6	7
17	5	10	空位	37	84	66	73

 　从左至右（2-3），left++，在下标为3的地方相遇了，则intarray[3]的空位就是flag了。

0	1	2	3	4	5	6	7
17	5	10	25	37	84	66	73

    至此，以25为基准的第一轮排序结束，现在比25大的都在左边大的都在右边，黄色下标的为一个新的数组，蓝色下表的为另一个数组。

    再次重复第一轮的排序，直到数组数组不可分割，只有一个数为止，至此，排序完成。

二、快速排序代码

　　快速排序的思想咱们都领会了，那么代码实现就简单了。

　　

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace kuaisu
{
   class Program
    {
        static void Main(string[] args)
        {
            int[] intarrays = { 25, 73, 66, 10, 37, 84, 5, 17 };
            quick_sort(intarrays, 0, 7);
            foreach (int item in intarrays)
            {
                Console.Write(item + "   ");
            }
            Console.ReadKey();
        }
        static void quick_sort(int[] intarray, int left, int right)
        {
            if (left < right)
            {
                int i = left, j = right, flag = intarray[left];
                while (i < j)
                {
                    while (i < j && intarray[j] >=flag)//从右向左开始，寻找比flag小的数字
                    {
                        j--;//比flag大，则跳过，先前进
                    }
                    if (i < j)//找到，则用该值填补空缺
                    {
                        intarray[i++] = intarray[j];//intarray[i++]等价于intarray[i]=intarray[j];i++
                    }
                    while (i < j && intarray[i] <=flag)//从左向右，寻找比flag大的数字
                    {
                        i++;//比flag小，跳过，向后推进
                    }
                    if (i < j)//找到
                    {
                        intarray[j--] = intarray[i];
                    }
                }
                intarray[i] = flag;//一轮结束，重新确定基准数
                quick_sort(intarray, left, i - 1); //左边，递归调用
                quick_sort(intarray, i + 1, right);//右边,递归调用
            }
        }
    }
}

打印结果如图：