快速排序

哎。。。今天很想搞搞算法方面的只是了。然后开始了第一个基础算法的学习------快速排序。

参考地址：10个基础算法大全

具体快速排序的参考地址：快速排序

下面直接进入主题吧：

 思路：快速排序是基于分治模式处理的，对一个典型子数组A[p..r] 排序的分治过程分为三个步骤：

    1.分解：

         A[p...r]被划分为两个（可能空）子数组A[p...q-1]和A[q+1...r],使得A[p...q-1]<=A[q]<=A[q+1..r]

    2.解决：通过递归调用快速排序，对子数组A[p...q-1]和A[q+1...r]排序。

    3.合并：

 示例：对一下数组，进行快速排序，下面给了patition过程。

         2      8         7        1          3         5        6      4(主元)

      

   示例代码:(java)

           

<span style="font-size:18px;">public class quickSort{
     

      public static  void main(String[] args){</span>

<span style="font-size:18px;">	    //初始化一个带排序的数组</span>

<span style="font-size:18px;">	     int[] arr = {1,4,6,2,5,8,7,6,9,12}; </span>

<span style="font-size:18px;">            // 默认是第一个下标和最后一个下标</span>

<span style="font-size:18px;">	     quick_sort(arr,0,9);</span>

<span style="font-size:18px;"> </span>

<span style="font-size:18px;">	     int i;</span>

<span style="font-size:18px;">    	     for(i=0;i<10;++i){</span>

<span style="font-size:18px;">		System.out.print(arr[i]+"  ");</span>

<span style="font-size:18px;">	     }</span>

<span style="font-size:18px;">      }</span>

<span style="font-size:18px;">      private static void quick_sort(int[] arr,int low,int high){</span>

<span style="font-size:18px;">	     if(low<high){</span>

<span style="font-size:18px;">		  //进行分组</span>

<span style="font-size:18px;">		  int mid=partition(arr,low,high);</span>

<span style="font-size:18px;">		  quick_sort(arr,low,mid-1);</span>

<span style="font-size:18px;">		  quick_sort(arr,mid+1,high);</span>

<span style="font-size:18px;">	     }</span>

<span style="font-size:18px;">      }</span>

<span style="font-size:18px;"> </span>

<span style="font-size:18px;">      //第一步是要整个数组分成两个区，返回一个分界线。</span>

<span style="font-size:18px;">      private static int partition(int[] arr,int low,int high){</span>

<span style="font-size:18px;"> </span>

<span style="font-size:18px;">	     //获取到最后一个元素作为主元素</span>

<span style="font-size:18px;">	     int pivot=arr[high];</span>

<span style="font-size:18px;">	     //获取到下标为当个数组的最小下标并且减1</span>

<span style="font-size:18px;">	     int i=low-1;</span>

<span style="font-size:18px;">	     int j,tmp;</span>

<span style="font-size:18px;">             //遍历整个数组进行比较</span>

<span style="font-size:18px;">   	     for(j=low;j<high;++j){</span>

<span style="font-size:18px;">		    if(arr[j]<pivot){</span>

<span style="font-size:18px;">			 tmp=arr[++i];</span>

<span style="font-size:18px;">			 arr[i] = arr[j];</span>

<span style="font-size:18px;">			 arr[j] = tmp;</span>

<span style="font-size:18px;">		    }</span>

<span style="font-size:18px;">	     }</span>

<span style="font-size:18px;">	     //下面的这个是记录你替换到哪里了，用来确定主元的真正位置。</span>

<span style="font-size:18px;">	     tmp = arr[i+1];</span>

<span style="font-size:18px;">  	     arr[i+1] = arr[high];</span>

<span style="font-size:18px;">  	     arr[high] = tmp;</span>

<span style="font-size:18px;">	     return i+1;</span>

<span style="font-size:18px;">      }</span>

<span style="font-size:18px;"> </span>

<span style="font-size:18px;"> </span>

<span style="font-size:18px;">}</span>

时间的复杂度：

     最坏情况：发生在划分过程产生的俩个区域分别包含n-1个元素和一个0元素的时候，即假设算法每一次递归调用过程中都出现了，这种划分不对称。

                       那么划分的代价为（n），因为对一个大小为0的数组递归调用后，返回T（0）=O（1）。

                      估算法的运行时间可以递归的表示为：T（n）=T（n-1）+T（0）+O（n)=T(n-1)+O(n).
                      可以证明为T（n）=O（n^2）。因此，如果在算法的每一层递归上，划分都是最大程度不对称的，

                      那么算法的运行时间就是O（n^2）。

    最快情况：即PARTITION可能做的最平衡的划分中，得到的每个子问题都不能大于n/2.

                      因为其中一个子问题的大小为|_n/2_|。

                     另一个子问题的大小为|-n/2-|-1.在这种情况下，快速排序的速度要快得多：
                     T(n)<=2T（n/2）+O（n）.可以证得，T（n）=O（nlgn）。