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

　　最近在學習排序算法，就排序算法中的四大經典排序：冒泡排序、快速排序、選擇排序、插入排序。會出一系列的講解排序算法的博 客。

一、快速排序的思想

　　上一篇寫了冒泡排序,這一篇就講講我對快速排序的理解吧。快速排序，如何個快速法，簡而言之就是取第一個數為基准數，將比這個基准數小的都放在左邊，大的都放在右邊，基准數在中間，第一輪之后，再對左邊塊中進行剛剛的排序換位，直到左邊的都排序都正確了，再對右邊的塊進行排序換位。如此看來，其實就是一分為二、二分為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);//右邊,遞歸調用
            }
        }
    }
}

 

 

 

打印結果如圖：