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

                                                                    快速排序

     1.算法思想

      快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。它采用了一种分治的策略,通常称其为分治法(Divide-and-ConquerMethod)。

     (1)分治法的基本思想

      分治法的基本思想是:将原问题分解为若干个规模更小但结构与原问题相似的子问题。递归地解这些子问题,然后将这些子问题的解组合为原问题的解。

      (2)快速排序的基本思想

       设当前待排序的无序区为R[low..high],利用分治法可将快速排序的基本思想描述为:
       ①分解: 
      在R[low..high]中任选一个记录作为基准(Pivot),以此基准将当前无序区划分为左、右两个较小的子区间R[low..pivotpos-1)和R  [pivotpos+1..high],并使左边子区间中所有记录的关键字均小于等于基准记录(不妨记为pivot)的关键字pivot.key,右边的子区间中所有记录的关键字均大于等于pivot.key,而基准记录pivot则位于正确的位置(pivotpos)上,它无须参加后续的排序。
      注意:
         划分的关键是要求出基准记录所在的位置pivotpos。划分的结果可以简单地表示为(注意pivot=R[pivotpos]):
         R[low..pivotpos-1].keys≤R[pivotpos].key≤R[pivotpos+1..high].keys
                      其中low≤pivotpos≤high。
      ②求解:
         通过递归调用快速排序对左、右子区间R[low..pivotpos-1]和R[pivotpos+1..high]快速排序。
      ③组合:
         因为当"求解"步骤中的两个递归调用结束时,其左、右两个子区间已有序。

    2.快速排序算法QuickSort

    void QuickSort(SeqList R,int low,int high)
    { 
        int pivotpos;                          //划分后的基准记录的位置
        if(low<high)
        { 
            pivotpos=Partition(R,low,high);     //对R[low..high]做划分
            QuickSort(R,low,pivotpos-1);        //对左区间递归排序
            QuickSort(R,pivotpos+1,high);       //对右区间递归排序
        }
    } 
     

     3.划分算法Partition
     (1)简单的划分方法
          ① 具体做法
      第一步:(初始化)设置两个指针i和j,它们的初值分别为区间的下界和上界,即i=low,i=high;选取无序区的第一个记录R[i](即R[low])作为基准记录,并将它保存在变量pivot中;
      第二步:令j自high起向左扫描,直到找到第1个关键字小于pivot.key的记录R[j],将R[j])移至i所指的位置上,这相当于R[j]和基准R[i](即pivot)进行了交换,使关键字小于基准关键字pivot.key的记录移到了基准的左边,交换后R[j]中相当于是pivot;然后,令i指针自i+1位置开始向右扫描,直至找到第1个关键字大于pivot.key的记录R[i],将R[i]移到i所指的位置上,这相当于交换了R[i]和基准R[j],使关键字大于基准关键字的记录移到了基准的右边,交换后R[i]中又相当于存放了pivot;接着令指针j自位置j-1开始向左扫描,如此交替改变扫描方向,从两端各自往中间靠拢,直至i=j时,i便是基准pivot最终的位置,将pivot放在此位置上就完成了一次划分。

          ②划分算法:

    int Partition(SeqList R,int i,int j)
    {
        ReceType pivot=R[i];                       //用区间的第1个记录作为基准 
        while(i<j)
        {   
            while(i<j&&R[j].key>=pivot.key)       //从右向左扫描,查找第1个关键字小于pivot.key的记录R[j]
                j--; 
            if(i<j)                               //表示找到的R[j]的关键字<pivot.key
            {
                swap(R[i],R[j]); 
                i++;
            }
            while(i<j&&R[i].key<=pivot.key) 
                i++;      
            if(i<j)                              //表示找到了R[i],使R[i].key>pivot.key
            {
                swap(R[j],R[i]); 
                j--;
            }        
        }
        return i;
    } 
    测试程序
    /*快速排序  2011.10.1*/
     
    #include <iostream>
    #include<algorithm>
    using namespace std;
    
    int partion(int a[],int low,int high)   //返回枢轴位置 
    {
        int i=low;
        int j=high;
        int pivot=a[low];
        while(i<j)
        {
            while(i<j&&a[j]>=pivot)
            {
                j--;
            }
            if(i<j)
            {
                swap(a[i],a[j]);
                i++;
            }
            while(i<j&&a[i]<=pivot)
            {
                i++;
            }
            if(i<j)
            {
                swap(a[i],a[j]);
                j--;
            }
        }
        return i;
    }
    
    void quickSort(int a[],int low,int high)  //快速排序 
    {
        if(low<high)
        {
            int pivotpos=partion(a,low,high);
            quickSort(a,low,pivotpos-1);
            quickSort(a,pivotpos+1,high);
        }
    } 
    int main(int argc, char *argv[])
    {
        int n;
        while(scanf("%d",&n)!=EOF)
        {
            int i;
            int *a=new int[n];
            for(i=0;i<n;i++)
            {
                scanf("%d",&a[i]);
            }
            quickSort(a,0,n-1);
            for(i=0;i<n;i++)
            {
                printf("%d ",a[i]);
            }
            printf("\n");
        }
        return 0;
    }
  • 相关阅读:
    2019.6.20刷题统计
    36 线程 队列 守护线程 互斥锁 死锁 可重入锁 信号量
    35 守护进程 互斥锁 IPC 共享内存 的方式 生产者消费者模型
    34 进程 pid ppid 并发与并行,阻塞与非阻塞 join函数 process对象 孤儿进程与僵尸进程
    33 udp 域名 进程
    32 粘包 文件传输
    31 socket客户端. 服务器 异常 语法
    30 网络编程
    29 元类 异常
    26 封装 反射 常用内置函数
  • 原文地址:https://www.cnblogs.com/dolphin0520/p/2102529.html
Copyright © 2011-2022 走看看