再看数据结构之——快速排序

　　出来混，迟早要还的~~~

　　在自学考试数据结构导论中，有一个快速排序的问题，以前的博客也提到过，但是由于太过匆忙，发生了一点错误的理解，一句话来说：自考的债软考来还。

（一）快速排序：

　　基本思想：快速排序时交换排序的一种，实质是对冒泡排序的一种改进。它的基本思想：在记录中取一个记录的键值为标准，通常取第一个记录键值为基准，通过一趟排序将待排序的记录分为小于或等于这个键值和大于这个键值的两个独立部分，这是一部分的记录键值均比另一部分记录的键值小，然后，对这两个记录继续分别进行快速排序，直至最后整个序列实现排序。

　　事例说明：对序列45  38  66 90  88  10 25 44运用快速排序法进行排序

过程描述：

取45作为基准，首先和最后一个进行对比，得到的结果：44 38  66 90  88  10 25 45  

　　然后再拿38和45对比，得到结果：44 38  66 90  88  10 25 45  

　　继续拿66和45对比，得到结果：44 38 45  90  88  10 25  66 

　　再拿25和45做对比，得到结果：44 38 25  90  88  10  45 66 

　　再拿90和45做对比，得到结果：44 38 25  45  88  10  90  66

　　再拿10和45做对比，得到结果：44 38 25  10  88  45  90  66

　　剩下88和45做对比，得到结果：44 38 25  10  45  88  90  66

　　这样经过第一次快速排序法后得到【44 38 25  10 】45【88  90  66】左边都是小于45的，右边都是大于45的，然后再对45两边的子集合分别进行快速排序

　　【44 38 25  10 】和【88  90  66】快速排序过程分别如下：

　　第一次：10 38 25  44 　　　　　　　　66　90　88  

　　第二次：10 38 25  44　　　　　　　【66　88　90】

　　第三次：10 38 25  44

　　整个集合经过第二次快速排序后得到的结果：

　　10 38 25  44 45 66 88 90

　　剩下10 38 25继续进行快速排序

　　以10为基准，对比25　得到结果：10 38 25

　　以10为基准，对比38　得到结果：10 38 25

　　所以，整个集合经过第三次大的快速排序之后10 38 25 44 45 66 88 90

　　再对38 25进行快速排序，得到最后的排序结果：

　　10 25 38 44 45 66 88 90

二、代码实现:

namespace ConsoleApplication1
{

    public class QuickSort
    {
        /// <summary> 
        /// 快速排序
        /// </summary> 
        /// <param name="numbers">待排序数组</param> 
        /// <param name="left">数组第一个元素索引Index</param> 
        /// <param name="right">数组最后一个元素索引Index</param> 
        private static void Sort(int[] numbers, int left, int right)
        {
            //左边索引小于右边，则还未排序完成 
            if (left < right)
            {
                //取中间的元素作为比较基准，小于他的往左边移，大于他的往右边移 
                int middle = numbers[(left + right) / 2];
                int i = left - 1;
                int j = right + 1;
                while (true)
                {
                    while (numbers[++i] < middle) ;
                    while (numbers[--j] > middle) ;

                    if (i >= j)
                        break;
                    Swap(numbers, i, j);
                }
                Sort(numbers, left, i - 1);
                Sort(numbers, j + 1, right);
            }
        }
        /// <summary> 
        /// 交换元素值 
        /// </summary> 
        /// <param name="numbers">数组</param> 
        /// <param name="i">当前左边索引</param> 
        /// <param name="j">当前右边索引</param> 
        private static void Swap(int[] numbers, int i, int j)
        {
            int number = numbers[i];
            numbers[i] = numbers[j];
            numbers[j] = number;
        }

        public static void Main()
        {
            //定义数组           
            int[] arr = new int[10];
            //生成随机数
            Random rdm = new Random();
            Console.WriteLine("排序前：");
            for (int i = 0; i < 10; i++)
            {
                arr[i] = rdm.Next(0, 100);
                Console.Write(arr[i] + " , ");
            }
            Console.WriteLine("");
            Console.WriteLine("排序后：");
            //调用快速排序法对进行生成的随机数组进行排序
            Sort(arr, 0, arr.Length - 1);
            StringBuilder temp = new StringBuilder();
            for (int i = 0; i < arr.Length; i++)
            {
                temp.Append(arr[i].ToString() + ",");
            }
            Console.WriteLine(temp.ToString().Substring(0, temp.Length - 1));
            Console.ReadLine();
        }
    }
}

　三、小感：

　　“不会的问题，挂着，我认为这样的学习效率是最高的”——老爷子如是说。

　　“有压力，不会的问题迟早会解决的”——我也说