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

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

一、快速排序的思想

  上一篇写了冒泡排序,这一篇就讲讲我对快速排序的理解吧。快速排序,如何个快速法,简而言之就是取第一个数为基准数,将比这个基准数小的都放在左边,大的都放在右边,基准数在中间,第一轮之后,再对左边块中进行刚刚的排序换位,直到左边的都排序都正确了,再对右边的块进行排序换位。如此看来,其实就是一分为二、二分为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);//右边,递归调用
            }
        }
    }
}

 

 

 

打印结果如图:

 

 

posted @ 2014-02-25 14:11  后知然后觉  阅读(1409)  评论(6编辑  收藏  举报