《算法导论》 — Chapter 7 快速排序

快速排序(QuickSort)也是一种排序算法,对包含n个数组的输入数组,最坏情况运行时间为O(n^2)。虽然这个最坏情况运行时间比较差,但是快速排序通常是用于排序的最佳实用选择,这是因为其平均性能相当好,期望的运行时间为O(nlgn),且O(nlgn)中隐含的常数因子很小,另外它还能够进行就地排序在虚拟环境中也能很好的工作。

原理

快速排序也和合并排序一样,基于分治法,分为分解、解决、合并三个步骤;

分解:数组array[low…high]被分为两个(可能空)子数组array[low…temp-1]和array[temp+1…high],使得array[low…temp-1]中的每一个元素都小于等于array[temp],而array[temp+1…high]中的每一个元素都大于array[temp],下标temp也是在这个过程中被计算出来;

解决:通过递归的调用快速排序,对子数组array[low…temp-1],array[temp+1…high]进行排序;

合并:因为两个子数组是就地排序的,将他们的合并不需要操作,整个数组array[low…high]是已经排好序的。

本章介绍了快速排序算法的原理、程序实现(包括随机化版本)及其性能分析。

快排算法实现

#include <iostream>
#include <ctime>
#include <cstdlib>
#define N 10

using namespace std;

//快速排序的递归算法
void quickSort(int * array, int low, int high);
//求分割点
int partition(int * array, int low, int high);
//交换两个变量的值
void exchange(int &a, int &b);

int main()
{
    //声明一个待排序数组
    int array[N];
    //设置随机化种子,避免每次产生相同的随机数
    srand(time(0));
    for (int i = 0; i<N; i++)
    {
        array[i] = rand() % 101;//数组赋值使用随机函数产生1-100之间的随机数
    }
    cout << "排序前:" << endl;
    for (int j = 0; j<N; j++)
    {
        cout << array[j] << "  ";
    }
    cout << endl << "排序后:" << endl;
    //调用快速排序函数对该数组进行排序
    quickSort(array, 0, N - 1);
    for (int k = 0; k<N; k++)
    {
        cout << array[k] << "  ";
    }
    cout << endl;
    return 0;
}//main

void quickSort(int * array, int low, int high)
{
    if (low < high)
    {
        int temp = partition(array, low, high);
        quickSort(array, low, temp - 1);
        quickSort(array, temp + 1, high);
    }
}

int partition(int * array, int low, int high)
{
    int i = low - 1;
    //默认将划分段的最后一个元素为主元
    int x = array[high];

    for (int j = low; j<high; j++)
    {
        if (array[j] <= x)//在array[i]左边都是小于x即array[high]的数,右边均是大于它的数
        {
            i += 1;
            exchange(array[i], array[j]);
        }
    }
    exchange(array[i + 1], array[high]);
    return i + 1;//所以循环完毕后,i+1就是该数组的分割点
}
void exchange(int &a, int &b)
{
    int temp = a;
    a = b;
    b = temp;
}

快速排序的随机化版本

在上面介绍的快速排序算法实现中,Partition(A , p , r)总是默认A[r]为主元,作为比较标准。如果可以采用随机取样的随机化技术的话,将会使得分析更加简单。下面是随机化版本的快速排序算法实现:

#include <iostream>
#include <ctime>
#include <cstdlib>
#define N 10

using namespace std;

//快速排序的递归算法
void quickSort(int * array, int low, int high);
//求分割点
int partition(int * array, int low, int high);

//以low ~ high 之间的一个随机元素作为主元 , 求分割点
int randomPartition(int *array, int low, int high);

//交换两个变量的值
void exchange(int &a, int &b);

int main()
{
    //声明一个待排序数组
    int array[N];
    //设置随机化种子,避免每次产生相同的随机数
    srand(time(0));
    for (int i = 0; i<N; i++)
    {
        array[i] = rand() % 101;//数组赋值使用随机函数产生1-100之间的随机数
    }
    cout << "排序前:" << endl;
    for (int j = 0; j<N; j++)
    {
        cout << array[j] << "  ";
    }
    cout << endl << "排序后:" << endl;
    //调用快速排序函数对该数组进行排序
    quickSort(array, 0, N - 1);
    for (int k = 0; k<N; k++)
    {
        cout << array[k] << "  ";
    }
    cout << endl;

    system("pause");

    return 0;
}//main

void quickSort(int * array, int low, int high)
{
    if (low < high)
    {
        int temp = randomPartition(array, low, high);
        quickSort(array, low, temp - 1);
        quickSort(array, temp + 1, high);
    }
}

int partition(int * array, int low, int high)
{
    int i = low - 1;
    //默认将划分段的最后一个元素为主元
    int x = array[high];

    for (int j = low; j<high; j++)
    {
        if (array[j] <= x)//在array[i]左边都是小于x即array[high]的数,右边均是大于它的数
        {
            i += 1;
            exchange(array[i], array[j]);
        }
    }
    exchange(array[i + 1], array[high]);
    return i + 1;//所以循环完毕后,i+1就是该数组的分割点
}

int randomPartition(int *array, int low, int high)
{
    //找到low ~ high 之间的一个随机位置
    int i = rand() % (high - low + 1) + low;

    //交换该随机主元至尾部,
    exchange(array[i], array[high]);

    return partition(array, low, high);
}

void exchange(int &a, int &b)
{
    int temp = a;
    a = b;
    b = temp;
}

随机版本的快排与普通快排区别并不是很大,改动的仅仅是求分割点步骤中的主元选取,也就是增加了randomPartition函数,选定好主元元素下标i后,将该元素交换至段尾,依然调用partition函数求分割点。

快速排序性能分析

快速排序的运行时间与划分是否对称有关,而后者又与选择了哪一个元素进行划分有关。如果划分是对称的,那么本算法在渐近意义上与合并排序一样快,如果划分是不对称的那么本算法在渐进意义上与插入排序一样慢。下面分别讨论快速排序的最坏情况划分、最佳情况划分、平衡的划分。

最坏情况划分:快速排序的最坏情况划分行为发生在划分过程中产生的两个区域分别包含n-1个元素和0个元素的时候。假设算法每次递归调用都出现了这种不对称划分,划分的时间代价为O(n),因为对一个大小为0的数组进行递归调用后,返回了T(n)=O(1),故算法的运行时间可递归的表示为:

T(n) = T(n-1) + T(0) + O(n) = T(n-1) + O(n)

从直观上来看,如果将每一层递归的代价加起来,就可以得到一个算术级数(等式(array,2)其和值的量极为O(n^2))利用代换法可以比较直接的证明递归式 T(n) = T(n-1) + O(n)的解为 T(n) = O(n^2)。

因此如果在算法的每一层递归上,划分都是最大程度不对称的,那么算法的运行时间为O(n^2),亦即快速排序算法的最坏情况运行时间不如插入排序的好。此外当输入数组完全排好序时,快速排序的运行时间是O(n^2),而插入排序的运行时间为O(n)。

最佳情况划分:在Partition可能做的最平衡划分中,得到的两个子问题的大小都不可能大于[n/2],因为若其中一个子问题的大小为[n/2],则另外一个子问题的大小必然为[n/2]-1。在这种情况下,快速排序的运行速度要快得多,这时表达其运行时间的递归式为:

T(n) <= 2T(n/2) + O(n)

解该递归式可得T(n) = O(nlgn)。由于在每一层递归划分的两边都是对称的,因此从渐进意义上来看,算法运行的就更快了。

平衡的划分: 快速排序的平均情况运行时间与其最佳情况运行时间很接近,而不是非常接近与其最坏情况运行时间(证明原因详细参考《算法导论》原书第二版P88),因为任何一种按常数比例进行划分都会产生深度为O(lgn)的递归树,其中每一层的代价都是O(n),因而每当按照常数比例进行划分时,总的运行时间都是O(nlgn)。

练习

思考题

版权声明:本文为博主原创文章,未经博主允许不得转载。

时间: 2024-10-07 20:35:03

《算法导论》 — Chapter 7 快速排序的相关文章

算法导论——lec 07 快速排序

一. 快速排序的描述 1. 快速排序是一种原地排序的算法,最坏情况下的时间复杂度为Θ(n^2),期望的运行时间为Θ(n logn),且其中隐含的常数因子较小. 2. 快速排序分三个步骤: 分解:数组A[p...r]被划分成两个数组A[p...q-1]和A[q+1...r],使得A[p...q-1]中的元素都小于等于A[q],A[q+1...r]中的元素都大于等于A[q].下标q在这个划分过程中计算. 解决:递归调用快速排序,对子数组A[p...q-1]和A[q+1...r]进行排序. 合并:两个

算法导论4:快速排序 2016.1.4

今天上最后一节史纲课,老师说不管什么学科,最重要的就是思想.我觉得很有道理. 好吧,不扯了.原谅我看书选择了速读策略,中间有很多感觉目前还很难看懂,以后有时间再细细学习.把略过去的在这里记一下. 一.矩阵乘法算法.复杂度从n^3优化到了n^2.81 (数字比较神奇).因为还没学线性代数,所以以后学了再看. 二.递归复杂度的计算和估计.这部分看起来有些复杂,好像需要比较高的数学水平,有空研究一下. 三.堆排序.这个以前已经写过了.http://www.cnblogs.com/itlqs/p/475

算法导论7.3快速排序的随机化版本

以下摘自网络 随机化快排:快速排序的最坏情况基于每次划分对主元的选择.基本的快速排序选取第一个元素作为主元.这样在数组已经有序的情况下,每次划分将得到最坏的结果.一种比较常见的优化方法是随机化算法,即随机选取一个元素作为主元.这种情况下虽然最坏情况仍然是O(n^2),但最坏情况不再依赖于输入数据,而是由于随机函数取值不佳.实际上,随机化快速排序得到理论最坏情况的可能性仅为1/(2^n).所以随机化快速排序可以对于绝大多数输入数据达到O(nlogn)的期望时间复杂度.一位前辈做出了一个精辟的总结:

【算法导论学习-015】数组中选择第i小元素(Selection in expected linear time)

1.算法思想 问题描述:从数组array中找出第i小的元素(要求array中没有重复元素的情况),这是个经典的"线性时间选择(Selection in expected linear time)"问题. 思路:算法导论215页9.2 Selection in expect linear time 2.java实现 思路:算法导论216页伪代码 /*期望为线性时间的选择算法,输入要求,array中没有重复的元素*/ public static int randomizedSelect(i

算法导论第七章快速排序

一.快速排序概述 关于快速排序,我之前写过两篇文章,一篇是写VC库中的快排函数,另一篇是写了快排的三种实现方法.现在再一次看算法导论,发现对快速排序又有了些新的认识,总结如下: (1).快速排序最坏情况下的时间复杂度为O(n^2),虽然最坏情况下性能较差,但快排在实际应用中是最佳选择.原因在于:其平均性能较好,为O(nlgn),且O(nlgn)记号中的常数因子较小,而且是稳定排序. (2).快速排序的思想和合并排序一样,即分治.快排排序的分治思想体现在: a.首先从待排序的数中选择一个作为基数,

《算法导论》 — Chapter 7 高速排序

序 高速排序(QuickSort)也是一种排序算法,对包括n个数组的输入数组.最坏情况执行时间为O(n^2). 尽管这个最坏情况执行时间比較差.可是高速排序一般是用于排序的最佳有用选择.这是由于其平均性能相当好.期望的执行时间为O(nlgn).且O(nlgn)中隐含的常数因子非常小.另外它还能够进行就地排序在虚拟环境中也能非常好的工作. GitHub chapter 7 程序代码下载 原理 高速排序也和合并排序一样,基于分治法,分为分解.解决.合并三个步骤. 分解:数组array[low-hig

快速排序的算法导论划分形式和hoare划分

1. hoare划分 1 int hoare_partition(int a[], int begin, int end) 2 { 3 int pivot = a[begin]; 4 int ini = begin; 5 int ter = end; 6 while (ini < ter) 7 { 8 while (a[ini] <= pivot && ini <end) 9 ++ini; 10 while (a[ter] >= pivot && t

快速排序之算法导论实现

#include <iostream> using namespace std; int partition(int *a,int p,int r) { int x=a[r]; int i=p-1;//note i important which is used for //storage the number smaller than flag x=a[r] for (int j=p;j<r;j++) { if (a[j]<x)// if a[j] smaller than x=

快速排序实现代码 算法导论7.1 7.2 7.4

快速排序通常是实际排序中应用最好的选择,因为平均性能很好,且是原址排序,不稳定. 书上的大部分内容在分析其运行时间,感觉看一下就好了(还是蛮喜欢数学的,可是...) #include <iostream> #include <algorithm> #include <random> using namespace std; //实际应用比较多,原址排序 typedef int index; index Partition(int *a, index p, index r