zoukankan      html  css  js  c++  java
  • 快速排序

    基本思想

    快速排序也是基于分治算法得。步骤如下:

    (1)选择一个基准元素,通常选择第一个元素或者最后一个元素;

    (2)通过一趟排序讲待排序的记录分割成独立的两部分,其中一部分记录的元素值均比基准元素值小。另一部分记录的元素值比基准值大;

    (3)此时基准元素在其排好序后的正确位置;

    (4)然后分别对这两部分记录用同样的方法继续进行排序,直到整个序列有序。

    上图中,演示的是第一轮快速排序的过程,首先将第一个元素选为基准点,从右端第一个元素开始扫描,找到第一个比57小的元素(19)时停止,两者交换位置,然后从左端开始扫描,找到第一个比57的元素(68)时停止,两者交换位置,周而复始,直到57找不到可交换的元素为止,至此一轮快速排序结束。

    这时,比57小的元素都在左边,比57大的元素都在右边,分别对两边的数组段继续进行快速排序,依次类推,最终使整个数组有序。

    java实现

    1. //快速排序  
    2.       public void quikSort(){  
    3.              recursiveQuikSort(0,array.length-1);  
    4.       }  
    5.        
    6.       /** 
    7.        * 递归的快速排序 
    8.        *@param low  数组的最小下标 
    9.        *@param high  数组的最大下标 
    10.        */  
    11.       private void recursiveQuikSort(int low,int high){  
    12.              if(low>=high){  
    13.                     return;  
    14.              }else{  
    15.                     int pivot = array[low];  //以第一个元素为基准  
    16.                     int partition =partition(low,high,pivot);  //对数组进行划分,比pivot小的元素在低位段,比pivot大的元素在高位段  
    17.                      
    18.                     display();   
    19.                      
    20.                     recursiveQuikSort(low,partition-1);  //对划分后的低位段进行快速排序  
    21.                     recursiveQuikSort(partition+1,high);  //对划分后的高位段进行快速排序  
    22.              }  
    23.       }  
    24.        
    25.       /** 
    26.        * 以pivot为基准对下标low到high的数组进行划分 
    27.        *@param low 数组段的最小下标 
    28.        *@param high 数组段的最大下标 
    29.        *@param pivot 划分的基准元素 
    30.        *@return 划分完成后基准元素所在位置的下标 
    31.        */  
    32.       private int partition(int low,int high,int pivot){  
    33.               
    34.              while(low<high){  
    35.                      
    36.                     while(low<high &&array[high]>=pivot){  //从右端开始扫描,定位到第一个比pivot小的元素  
    37.                            high--;  
    38.                     }  
    39.                     swap(low,high);  
    40.                      
    41.                     while(low<high &&array[low]<=pivot){  //从左端开始扫描,定位到第一个比pivot大的元素  
    42.                            low++;  
    43.                     }  
    44.                     swap(low,high);  
    45.                      
    46.              }  
    47.              return low;  
    48.               
    49.       }  
    50.       /** 
    51.        * 交换数组中两个元素的数据 
    52.        *@param low 欲交换元素的低位下标 
    53.        *@param high 欲交换元素的高位下标 
    54.        */  
    55.       private void swap(int low,int high){  
    56.              int temp = array[high];  
    57.              array[high] = array[low];  
    58.              array[low] = temp;  
    59.       }  
    //快速排序
          public void quikSort(){
                 recursiveQuikSort(0,array.length-1);
          }
         
          /**
           * 递归的快速排序
           *@param low  数组的最小下标
           *@param high  数组的最大下标
           */
          private void recursiveQuikSort(int low,int high){
                 if(low>=high){
                        return;
                 }else{
                        int pivot = array[low];  //以第一个元素为基准
                        int partition =partition(low,high,pivot);  //对数组进行划分,比pivot小的元素在低位段,比pivot大的元素在高位段
                       
                        display(); 
                       
                        recursiveQuikSort(low,partition-1);  //对划分后的低位段进行快速排序
                        recursiveQuikSort(partition+1,high);  //对划分后的高位段进行快速排序
                 }
          }
         
          /**
           * 以pivot为基准对下标low到high的数组进行划分
           *@param low 数组段的最小下标
           *@param high 数组段的最大下标
           *@param pivot 划分的基准元素
           *@return 划分完成后基准元素所在位置的下标
           */
          private int partition(int low,int high,int pivot){
                
                 while(low<high){
                       
                        while(low<high &&array[high]>=pivot){  //从右端开始扫描,定位到第一个比pivot小的元素
                               high--;
                        }
                        swap(low,high);
                       
                        while(low<high &&array[low]<=pivot){  //从左端开始扫描,定位到第一个比pivot大的元素
                               low++;
                        }
                        swap(low,high);
                       
                 }
                 return low;
                
          }
          /**
           * 交换数组中两个元素的数据
           *@param low 欲交换元素的低位下标
           *@param high 欲交换元素的高位下标
           */
          private void swap(int low,int high){
                 int temp = array[high];
                 array[high] = array[low];
                 array[low] = temp;
          }

    算法分析

    在归并排序中,我们详细推算了时间复杂度,快速排序与归并排序一样采取了分治算法,它的时间复杂度也是O(N*log2N)。

    对于分治算法一般都是如此,用递归的方法把数据项分为两组,然后调用自身来分别处理每一组数据。算法实际上是以2为底,运行时间与N*log2N成正比

    对于快速排序来说,最理想的状态是随机分布的数据,即我们任意选定的枢纽处于中间位置,有一半元素小于它,有一半元素大于它。当数据时由小到大排列或者由大到小排列时,快速排序的效率最低,时间复杂度扩大为O(N2)

    选定第一个元素为枢纽实现起来确实很简单,但是当它为最大值或最小值时,快速排序的效率会严重降低。假如选中的元素为数组的中值,自然是最好的选择,但是却要遍历整个数组来确定中值,这个过程可能比排序花费的时间还长,得不偿失。折衷的方法是找到数组中的第一个、最后一个以及处于中间位置的元素,选出三者的中值作为枢纽,既避免了枢纽是最值的情况,也不会像在全部元素中寻找中值那样费时间。这种方法被称为“三项取中法”(median-of-three)。

  • 相关阅读:
    最短路总结
    关于最小生成树(并查集)prime和kruskal
    关于优先队列浅析(priority_queue)
    惨痛第十届蓝桥杯总结(附录蓝桥省赛知识点总结)-C++ B组
    初识STL vector
    sort();对结构体数组的排序
    Git 分支管理
    Git 远程仓库
    Matlab R2016a 破解教程
    Ubuntu卡在logo界面
  • 原文地址:https://www.cnblogs.com/mark-meng/p/6045876.html
Copyright © 2011-2022 走看看