排序5-快速排序

最新推荐文章于 2020-06-16 15:53:43 发布
最新推荐文章于 2020-06-16 15:53:43 发布
阅读量739 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 快速排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zwhlxl/article/details/46695131
版权

基本思想

快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）。
这里写图片描述

算法步骤

算法步骤简述如下：

  • 选择一个基准值（pivot）（选择方法很多，可以固体选某个值，比如第一个或最后一个或中间值，或者是三数取中法等）；
  • 将比基准值（pivot）小的数值划分到基准值左边，构成左子串列，将比基准值（pivot）大的数值划分到基准值右边，构成右子串列；
  • 分别对左子串列和右子串列递归地作上述两个步骤；
  • 直到左子串列或右子串列只剩一个值或者为空。

基准值的选取

上面的第一步基准值的选择对快速排序的效率有很大关系。基准值（pivot）的选择办法有下面几种：

  • 固定位置：第一个，最后一个或中间值；
  • 随机选取：用随机函数随机选取一个；
  • 三数取中：去第一个，中间值和最后一个数的平均值。

固定位置和随机选取的方法容易造成一种极端，如果选取的那个数刚好是最小值或最大值，比如数组是有序的，就会导致一个很差的分割，是左子串或右子串列为0，而且随机选取过程还会有额外的时间开销。所以都是不可取的。三数取中的办法就避免了上面的情况。

时间空间复杂度

快速排序的时间性能跟递归的深度有关，而空间复杂度跟递归造成的栈空间使用有关。最好的情况是，选取的基准值刚好是中位数，刚好将数据等分成2个子串，递归树也就是平衡的。递归调用需要 log2n 次，空间复杂度为 O(logn) ，时间复杂度为 O(nlogn) ；最坏的情况就是待排序的数据是有序的，正序或者逆序。递归需要 n−1 次，空间复杂度则需要 O(n) 时间复杂度为 O(n2)

代码实现

#define MAX_LENGTH_INSERT_SORT 7   // 数组长度阈值

int  Partition(int arr[], int Left, int Right)
{
    /* 三数取中*/
    int mid = Left + (Right - Left) / 2;
    if(arr[Left] > arr[Right])
        swap(arr[Left],arr[Right]);

    if(arr[mid] > arr[Right])
        swap(arr[mid], arr[Right]);

    if(arr[mid] > arr[Left])
        swap(arr[mid], arr[Left]);

    int pivot_key = arr[Left];

    while(Left < Right)
    {
        while(Left < Right && arr[Right] >= pivot_key )
            Right --;

        arr[Left] = arr[Right];

        while(Left < Right && arr[Left] <= pivot_key)
            Left ++;
        arr[Right] = arr[Left];

    }

    arr[Left] = pivot_key;
    return Left;
}

void QSort(int arr[], int Left, int Right)
{
    int pivot_index;

   /*当Right - Left 大于 MAX_LENGTH_INSERT_SORT 采用 快排，否则使用直接插入*/
    if(Right - Left > MAX_LENGTH_INSERT_SORT)
    {
        pivot_index = Partition(arr, Left, Right);
        QSort(arr, Left, pivot_index - 1);
        QSort(arr, pivot_index + 1, Right);
    }

    else
        Insert_sort(arr, Right - Left + 1); // 直接插入法是简单排序当中性能最好的
}

void Quick_sort(int arr[], int len)
{
    QSort(arr, 0, len - 1);
}

测试程序

#include <iostream>
#include <cstring>
#include <ctime>
#include <cmath>
using namespace std;


#define ArraySize 100000


void swap(int *x, int *y)
{
    int temp;
    temp = *x;
    *x   = *y;
    *y   = temp;
}

void Bubble_sort(int arr[], int len)
{
    for(int i = 0; i < len; i ++)
    {
        for(int j = i + 1; j < len; j ++)
            if(arr[i] > arr[j])
                swap(arr[i], arr[j]);
    }
}

void Bubble_sort1(int arr[], int len)
{
    for(int i = 0; i < len; i ++)
    {
        for(int j = len - 1; j >= i; j --)
        {
            if(arr[i] > arr[j])
                swap(arr[i], arr[j]);
        }
    }
}

void Bubble_sort2(int arr[], int len)
{
    bool flag = true;

    while(flag)
    {
        flag = false;
        for(int i = 0; i < len; i ++)
            for(int j = len - 1; j >= i; j --)
                if(arr[i] > arr[j])
                    swap(arr[i], arr[j]);
    }
}

void Slect_sort(int arr[], int len)
{
    for(int i = 0; i < len; i ++)
    {
        int min_index = i ;
        for(int j = i + 1; j < len; j ++)
        {
            if(arr[min_index] > arr[j])
                min_index = j;
        }

        if(i != min_index)
            swap(arr[i],arr[min_index]);
    }
}

void Insert_sort(int arr[], int len)
{

    for(int i= 1; i < len; i ++)
    {   
        int key = arr[i];
        int j = i;
        while(j && arr[j - 1] > key)
        {
            arr[j] = arr[j - 1];
            j --;
        }

        arr[j] = key;
    }
}

void Shell_sort(int arr[], int len)
{
    int increment = len / 2;

    while(increment)
    {
        for(int i = increment; i < len; i ++)
        {
            int key = arr[i];
            /*int j ;
            for(j = i; j >= increment; j -= increment)
            {
                if(arr[j-increment] > key )
                    arr[j] = arr[j-increment];
                else 
                    break;

            }*/

            int j = i;
            while(j >= increment && arr[j-increment] > key)
            {
                arr[j] = arr[j-increment];
                j -= increment;
            }

            arr[j] = key;
        }

        increment /= 2;
    }
}

void Shell_sort1(int arr[], int len)
{
    int increment = 0;
    for(increment = len/2; increment > 0; increment /=2)
    {
        for(int i = increment; i < len; i++)
        {
            int key = arr[i];
            int j = 0;
            for(j = i; j >= increment; j -=increment)
            {
                if(arr[j-increment] > key)
                    arr[j] = arr[j-increment];
                else 
                    break;
            }

            arr[j] = key;
        }
    }
}

void Shell_sort2(int arr[], int len)
{
    int index = log( 2*len + 1) / log(3.0);

    //cout << index << endl;

    int increment = ( pow(3.0, index) - 1 ) / 2;

    //cout << increment << endl;

    while(increment)
    {
        for(int i = increment; i < len; i ++)
        {
            int key = arr[i];
            /*int j ;
            for(j = i; j >= increment; j -= increment)
            {
                if(arr[j-increment] > key )
                    arr[j] = arr[j-increment];
                else 
                    break;

            }*/

            int j = i;
            while(j >= increment && arr[j-increment] > key)
            {
                arr[j] = arr[j-increment];
                j -= increment;
            }

            arr[j] = key;
        }
        index -= 1;
        increment = ( pow(3.0, index) - 1 ) / 2;
    }
}

void Heap_adjust(int arr[], int index, int len)
{


    while(true)
    {
        int iMax = index;
        int iLeft = 2 * index + 1;
        int iRight = 2 * index + 2;

        if(iLeft < len && arr[index] < arr[iLeft])
            iMax = iLeft;
        if(iRight < len && arr[index] < arr[iRight])
            iMax = iRight;
        if(iMax != index)
        {
            swap(arr[index], arr[iMax]);
            index = iMax;
        }
        else 
            break;
    }



}

void Heap_adjust2(int arr[], int index, int len)
{
    int iMax = index;
    int iLeft = 2 * index + 1;
    int iRight = 2 * index + 2;

    if(iLeft < len && arr[index] < arr[iLeft])
        iMax = iLeft;

    if(iRight < len && arr[index] < arr[iRight])
        iMax = iRight;

    if(iMax != index)
    {
        swap(arr[index], arr[iMax]);
        Heap_adjust2(arr, iMax, len);
    }
}

void Build_maxheap(int arr[], int len)
{
    for(int i = len / 2; i >= 0; i --)
    {
        Heap_adjust(arr, i , len);
    }
}

void Heap_Sort(int arr[], int len)
{
    Build_maxheap(arr, len);

    for(int i = len - 1; i > 0; i --)
    {
        swap(arr[0], arr[i]);
        Heap_adjust(arr, 0, i);
    }
}

void Print_array(int arr[], int len)
{
    for(int i = 0; i < len; i++)
    {
        cout << arr[i] << " ";
    }
    cout << endl;

}

void merge_array(int arr[], int tmp[], int Left, int mid, int Right)
{
    assert(arr && Left >= 0 && Left <= mid && mid <= Right);
    int i = Left;
    int j = mid + 1;
    int index = 0;

    while(i <= mid && j <= Right)
    {
        if(arr[i] <= arr[j])
            tmp[index++] = arr[i++];
        else
            tmp[index++] = arr[j++];
    }

    while(i <= mid)
        tmp[index++] = arr[i++];

    while(j <= Right)
        tmp[index++] = arr[j++];

    memcpy(arr + Left, tmp, (Right - Left + 1) * sizeof(int)); 
}
void merge_sort(int arr[], int tmp[], int Left, int Right)
{
    assert(arr && Left >= 0);
    int mid;

    if(Left < Right)
    {
        mid = (Left + Right) / 2;
        merge_sort(arr, tmp, Left, mid);
        merge_sort(arr, tmp, mid + 1, Right);
        merge_array(arr, tmp, Left, mid, Right);
    }

}

void Merge_Sort(int arr[], int len)
{
    assert(arr && len);
    int *tmp_arr;
    //tmp_arr = (int *)malloc(len * sizeof(int));
    tmp_arr = new int[len];

    merge_sort(arr, tmp_arr, 0, len - 1);

    delete[] tmp_arr;

}


#define MAX_LENGTH_INSERT_SORT 7   // 数组长度阈值

int  Partition(int arr[], int Left, int Right)
{
    /* 三数取中*/
    int mid = Left + (Right - Left) / 2;
    if(arr[Left] > arr[Right])
        swap(arr[Left],arr[Right]);

    if(arr[mid] > arr[Right])
        swap(arr[mid], arr[Right]);

    if(arr[mid] > arr[Left])
        swap(arr[mid], arr[Left]);

    int pivot_key = arr[Left];

    while(Left < Right)
    {
        while(Left < Right && arr[Right] >= pivot_key )
            Right --;

        arr[Left] = arr[Right];

        while(Left < Right && arr[Left] <= pivot_key)
            Left ++;
        arr[Right] = arr[Left];

    }

    arr[Left] = pivot_key;
    return Left;
}

void QSort(int arr[], int Left, int Right)
{
    int pivot_index;

   /*当Right - Left 大于 MAX_LENGTH_INSERT_SORT 采用 快排，否则使用直接插入*/
    if(Right - Left > MAX_LENGTH_INSERT_SORT)
    {
        pivot_index = Partition(arr, Left, Right);
        QSort(arr, Left, pivot_index - 1);
        QSort(arr, pivot_index + 1, Right);
    }

    else
        Insert_sort(arr, Right - Left + 1); // 直接插入法是简单排序当中性能最好的
}

void Quick_sort(int arr[], int len)
{
    QSort(arr, 0, len - 1);
}

int main(int argc, char const *argv[])
{
    /* code */
    int Array[ArraySize];
    int Array1[ArraySize];
    int Array2[ArraySize];
    int Array3[ArraySize];

    time_t begin , end;

    srand(time(NULL));



    for(int i = 0; i < ArraySize; i ++)
    {
        Array[i] = rand()%ArraySize;
        //cout << Array[i] << " ";
    }

    memcpy(Array1, Array, ArraySize * sizeof(Array1[0]));
    memcpy(Array2, Array, ArraySize * sizeof(Array2[0]));
    memcpy(Array3, Array, ArraySize * sizeof(Array2[0]));
//  Print_array(Array, ArraySize);

/*  begin = clock();
    Bubble_sort2(Array, ArraySize);
    end = clock();
    cout << "Bubble_sort runtime:   " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;

    begin = clock();
    Slect_sort(Array1, ArraySize);
    end = clock();
    cout << "Slect_sort runtime:   " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;

    begin = clock();
    Insert_sort(Array2, ArraySize);
    end = clock();
    cout << "Insert_sort runtime:   " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;*/ 

    begin = clock();
    Shell_sort2(Array, ArraySize);
    end = clock();
    cout << "Shell_sort2 runtime:   " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;

    begin = clock();
    Heap_Sort(Array1, ArraySize);
    end = clock();
    cout << "Heap_Sort runtime:   " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;

    begin = clock();
    Merge_Sort(Array2, ArraySize);
    end = clock();
    cout << "Merge_Sort runtime:   " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;

    //Print_array(Array2, ArraySize);

    begin = clock();
    Quick_sort(Array3, ArraySize);
    end = clock();
    cout << "Quick_sort runtime:   " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;


    //Print_array(Array3, ArraySize);
    return 0;
}

运行结果如下：

Shell_sort2 runtime:   0.028s
Heap_Sort runtime:   0.005s
Merge_Sort runtime:   0.013s
Quick_sort runtime:   0.011s

参考文献

知无涯之std::sort源码剖析
http://feihu.me/blog/2014/sgi-std-sort/

zengwh513
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
排序5：快速排序
小菜鸟也想飞的博客
05-01 351
排序5：快速排序
必须会的排序算法---（1）直接插入排序
09-15 326
中秋快乐/~~手动微笑 package test; import java.util.Arrays; /** * 直接插入排序 ，时间复杂度为 O（n^2） * 数组a[n]，长度是n+1； * 思想： * 前1个元素已经排列好，拿第二个元素去比较，然后插入合适的位置 * 。。。 * 前n个元素已经按大小排列好，拿第n+1个元素去和前边的比较，然后插入合适的位置 * * @
直接插入排序练习
Jian_Ze的博客
07-19 238
一、要求 　　产生五个随机数，并由小到大输出，要求采用边写入边排序方法 二、源码 1 #include <stdio.h> 2 #include <stdlib.h> 3 int main(int argc, const char * argv[]) { 4 //定义一个随机数数组 5 int ranArr[...
11.排序算法_3_插入排序
weixin_34259559的博客
06-20 67
为什么80%的码农都做不了架构师？>>> ...
快速排序的5种优化方法
qq_19525389的博客
08-05 2万+
三种快速排序以及快速排序的优化 1、快速排序的基本思想：    快速排序使用分治的思想，通过一趟排序将待排序列分割成两部分，其中一部分记录的关键字均比另一部分记录的关键字小。之后分别对这两部分记录继续进行排序，递归地以达到整个序列有序的目的。 2、快速排序的三个步骤： (1)选择基准：在待排序列中，按照某种方式挑出一个元素，作为 "基准"（pivot） (2)分割操作：以该基准在序列中...
十大经典排序算法-快速排序算法详解
热门推荐
qq_35344198的博客
06-16 8万+
一、什么是快速排序 1.概念 快速排序（Quick Sort）是从冒泡排序算法演变而来的，实际上是在冒泡排序基础上的递归分治法。快速排序在每一轮挑选一个基准元素，并让其他比它大的元素移动到数列一边，比它小的元素移动到数列的另一边，从而把数列拆解成了两个部分 2.算法原理 这是一个无序数列：4、5、8、1、7、2、6、3，我们要将它按从小到大排序。按照快速排序的思想，我们先选择一个基准元素，进行排序 我们选取4为我们的基准元素，并设置基准元素的位置为index，设置两个指针left和right，分别指向最左
算法 - 快速排序（C#）
了解➔熟悉➔掌握➔精通
01-29 7万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net /* * 快速排序（QuickSort）是对冒泡排序的一种改进。它的基本思想是： * 通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据要小， * 然后再按此方法对这两部分数据分别进行快速排序，整个排序...
详解Java常用排序算法-快速排序
08-26
快速排序算法详解 快速排序（Quick Sort）是一种分治思想的排序算法，它的基本思想是通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，然后再分别对这两部分记录继续...
快速排序 - QuickSort - JAVA实现
最新发布
06-14
快速排序 import java.util.Arrays; public class QuickSort { public static void quickSort(int[] arr) { if (arr == null || arr.length ) { return; } quickSort(arr, 0, arr.length - 1); } ...
快速排序.txt-算法
03-01
快速排序
C语言-快速排序
07-23
用C语言实现快速排序 void input(); void output(); void quick_sort(int low,int high); int part(int low,int high);
FPGA并行快速排序算法-位宽可设
11-24
只需两个时钟即可输出12个数据的排序结果，内容简单易懂
Java基础-数组常见排序方式
weixin_34026276的博客
04-18 221
　　　　　　　　　　　　　　　　　　Java基础-数组常见排序方式 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰 版权声明：原创作品，谢绝转载！否则将追究法律责任。 　　数据的排序一般都是生序排序，即元素从小到大排列。常见的有两种排序方式：选择排序和冒泡排序。选择排序的特点是每个元素都进行比较，二冒泡排序是数组中相邻元素进行比较。接下来我们...
分治算法例子集锦
zengwh
03-07 2万+
分治算法例子集锦
动态规划（DP）之入门学习-数字三角形
zengwh
05-29 2万+
数字三角形案例题目描述 Description下图给出了一个数字三角形，请编写一个程序，计算从顶至底的某处的一条路径，使该路径所经过的数字的总和最大。 （1）每一步可沿左斜线向下或右斜线向下 （2）1 < 三角形行数 < 100 （3）三角形数字为0，1，…99 输入描述 Input Description有很多个测试案例，对于每一个测试案例， 通过键盘逐行输入，第1行是输入整数（如
二叉树最大深度和最小深度
zengwh
08-12 1万+
二叉树的最大深度给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的距离。如果二叉树为空，则深度为0 如果不为空，分别求左子树的深度和右子树的深度，去最大的再加1，因为根节点深度是1，要加进去。int maxDepth(TreeNode *root) { // write your code (here) if(root == NULL)
散列表-开放地址法和链地址法的实现
zengwh
06-30 9890
基本定义散列技术是在记录的存储位置和它的关键字之间建立一个确定的对应关系 f，使得每个关键字key对应一个存储位置f(key)。这种对应关系f称为散列或哈希函数。采用上述思想将数据存储在一块连续的存储空间中，这块连续的存储空间称为散列或哈希表。关键字对应的存储位置称为散列地址。散列技术最适合的求解问题是查找与给定值相等的记录。 如果碰到两个不同的关键字key1≠key2key_1 \neq key
数组和链表的归并排序算法实现（C语言）
zengwh
03-05 9392
数组和链表的归并排序算法实现（C语言）
后缀表达式的栈实现(C语言）
zengwh
01-21 6944
中缀表达式转为后缀表达式的栈实现以及计算(C语言）
排序子系请选择1--冒泡排序 2--简单选择 3--堆排序 4--直接插入 5--希尔排序 6--快速排序 0--输入数据c语言
06-03
介绍一下排序子系，排序是计算机科学中...6. 快速排序：通过选取一个基准元素，将序列分成两部分，一部分比基准元素小，另一部分比基准元素大，递归地对两个子序列进行快速排序。 如果您需要输入数据c语言，请输入0。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值