快速排序

原创 2015年11月18日 20:43:55

概要

  1. 理解快速排序的思想
  2. 理解分治以及排序过程的设计巧妙之处
  3. 深入理解时间复杂度分析,最好与最坏情况下的时间复杂度分析,生成树分析法,代入法,主方法。

伪代码

//返回的是分割点,即主元
//循环维护的部分为四个部分
// p...i...j.....r
// p..i 维护 <= r 的元素
// i+1 ... j 维护 > r 的元素
// j+1 ... r-1 的元素暂时没有处理,一次过程只需要O(n)
// r主元作为评价标准

partition(A, p, r)
{
        x = A[r]; //主元,作为依据
        i = p - 1;
        for j = p to r-1 
        {
                if (A[j] <= x) //升序
                {
                        i++;
                        exchange A[i] with A[j]
                }
        }
        exchange A[i + 1] with A[r]

        return i + 1;      
}

//第一次调用的时候要用, qsort_normal(A, 1, A.length);
qsort_normal(A, p, r)
{
        if (p < r) 
        {
                q = partition(A, p, r);
                qsort_normal(A, p, q - 1);
                qsort_normal(A, q + 1, r);
        }
}

最好情况下,期望时间复杂度是 O(n * log n)
最坏情况下,期望时间复杂度是 O(n * n)

一般情况下,划分会导致一部分差一部分好,只要好坏的比例是常数比例,其期望时间复杂度就是 O(n * log n),可以用生成树来证明:
假设比例是 alpha : 1 - alpha , (alpha <= 1/2)
那么 alpha < 1 - alpha
因此生成树里最先到达叶子的部分(即最短)满足:
c * exp(alpha, k) = 1
最后到达叶子的部分(即最长)满足:
c * exp(1-alpha, k) = 1
求解,都是log n,加上n次,因此复杂度仍然是 O(n * log n)

实现代码

qsort.h文件

#ifndef QSORT_NORMAL_H
#define QSORT_NORMAL_H

#include <stdio.h>
#include <stdlib.h>

typedef int DATATYPE;


int partition(DATATYPE *array, DATATYPE p, DATATYPE r)
{
    DATATYPE pivot = array[r];
    DATATYPE i = p - 1;
    for (DATATYPE j = p; j <= r - 1; j++) {
        if (array[j] <= pivot) {
            i++;
            DATATYPE temp = array[i];
            array[i] = array[j];
            array[j] = temp;
        }
    }
    DATATYPE temp_ = array[i + 1];
    array[i + 1] = array[r];
    array[r] = temp_;

    return i + 1;
}

void qsort_normal(DATATYPE *array, DATATYPE i, DATATYPE j)
{   
    // first call (A, 1, length);
    if (i < j) {
        DATATYPE q = partition(array, i, j);
        qsort_normal(array, i, q - 1);
        qsort_normal(array, q + 1, j);
    }
}

#endif

qsort.c 文件

#include "./qsort_normal.h"


int main()
{
    DATATYPE array[11] = {3, 4, 5, 1, 7, 23, 8, 10, 4, 2};

    qsort_normal(array, 0, 10);

    for (int i = 1; i <= 10; i++) {
        printf("%d ", array[i]);
    }

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

相关文章推荐

C#快速排序练习

  • 2017-06-20 11:40
  • 30KB
  • 下载

算法导论二:快速排序

快速排序采用的是分治策略,其方法是将一个数组a[p,r]划分为两个子数组a[p,q-1],a[q+1,r],使其左子数组元素中的元素均小于等于a[q],右子数组元素均大于a[q],并递归划分两个子数组...

快速排序代码

简单的快速排序

  • 2015-01-23 09:57
  • 479B
  • 下载

快速排序

上一节的冒泡排序可以说是我们学习第一个真正的排序算法,并且解决了桶排序浪费空间的问题,但在算法的执行效率上却牺牲了很多,它的时间复杂度达到了O(N2)。假如我们的计算机每秒钟可以运行10亿次,那么对1...

快速排序原创数据(20组)

  • 2015-10-30 21:48
  • 7.57MB
  • 下载

第一篇博客——快速排序

快速排序

快速排序算法

内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)