【分治】简单说说快排

说到快拍,大家都会首先想到sort函数这个神奇的东西

但是,我们总得知道快拍主要用的分治思想

所以就说一说快拍吧

首先是分类

快拍主要有三种方式:

一、以第一个数为基准排序

二、以中间的数为基准快排

三、随机生成一个位置,用这个位置上的数快排

代码如下:

#include<cstdio>
#include<algorithm>
#include<iostream>
#include<cstdlib>
#include<ctime>
using namespace std;

int n,a[2000002];

/*int rrand(int l,int r)                      //三中用于生成随机位置
{
    srand((unsigned)time(NULL));
    return (int)(rand()%(r-l+1)+l);
}*/

void qsort(int l,int r)                       //以中间的数为基准快排
{
    int i,j,mid,p;
    i=l;j=r;
    mid=a[(l+r)/2];
    do
    {
        while(a[i]<mid) i++;
        while(a[j]>mid) j--;
        if(i<=j)
        {
            p=a[i];
            a[i]=a[j];
            a[j]=p;
            i++;
            j--;
        }
    }while(i<=j);
    if(l<j) qsort(l,j);
    if(i<r) qsort(i,r);
}

/*void qsort(int l,int r)                                 //随机&首位快排
{
    int i=l,j=r+1,temp=rrand(l,r),k=0;       //首位的话是temp=a[i]
    if(r-l<2) return;
    while(i<j)
    {
        while(i<j)
        {
            j--;
            if(a[j]<temp)
            {
                swap(i,j);
                break;
            }
        }
        while(i<j)
        {
            i++;
            if(a[i]>temp)
            {
                swap(i,j);
                break;
            }
        }
    }
    a[i]=temp;
    qsort(l,i);
    qsort(i+1,r);
}
*/
int main()
{
    freopen("sorttest.in","r",stdin);
    freopen("sorttest.out","w",stdout);

    scanf("%d",&n);
    for(int i=n;i>=1;i--) scanf("%d",&a[i]);
    /*sort(a+1,a+n+1);                                   //喜闻乐见的sort
    for(int i=1;i<=n;++i)printf("%d ",a[i]);
    */
    qsort(1,n);
    for(int i=1;i<=n;++i)printf("%d ",a[i]);
    fclose(stdout);
    return 0;
}
时间: 2024-08-24 18:18:33

【分治】简单说说快排的相关文章

常用算法之 冒泡、选择、插入、快排

常用简单算法 一.冒泡排序 冒泡排序的基本思想是,对相邻的元素进行两两比较,假设这连个数字是, a.b 同时排序规则是升序,如果a>b 则他们位置进行交换,这样,每一趟会将最小或最大的元素“浮”到顶端,最终达到完全有序. 大概明白是什么意思了就详细的看下下面这张动图,进一步理解 冒泡排序关键点: 趟    趟就是我们完成整个排序所需要的次数,一次能认一个数据的位置 无序区   无序区就是没经过排序的数据 def bubble_sort(li): # 确认排序完成所需要循环的次数 -1 是因为最后

快排、归并排序(分治)、堆排序

一.快速排序 1)算法简介 快速排序是由C. A. R. Hoare所发展的一种排序算法.其基本思想是基本思想是,通过一趟排序将待排记录分隔成独立的两部分,其中一部分记录的关键字均比另一部分的关键字小,则可分别对这两部分记录继续进行排序,以达到整个序列有序. 2)算法描述 快速排序使用分治法来把一个串(list)分为两个子串行(sub-lists). 步骤为: 1.从数列中挑出一个元素,称为 "基准"(pivot), 2.重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准

最简单的两种快排----掌握思想和过程

俗话说:天下武功,无坚不破.对于算法当然也是要使用时间最快.占用空间最小的算法来实现了.下面就是最简单的两种快排(其实可以算是一种). 注意:我代码里面打的备注仅供参考,建议不要背模板(因为没有固定的模板),可以写一个数列按着代码跑两圈或者把代码改一下输出每次排序后的结果. 总之,师傅领进门,修行在个人.奋斗把!骚年! ※冒泡排序.选择排序: 1 #include "cstdio" 2 #include "iostream" 3 using namespace st

排序算法的简单实现(冒泡和快排)

排序算法 冒泡排序 原理:把相邻的元素两两比较,根据大小来交换元素的位置. 原始的冒泡排序是稳定排序.由于该排序的每一轮要遍历所以元素,轮转的次数和元素数量相当,所以时间复杂度是 O(N^2). java代码表达如下: import java.util.Arrays; public class BubbleSort{ private static void sort(int array[]){ int tmp = 0; for (int i = 0; i < array.length; i++)

快排和归并分治总结

快排和归并排序都运用了分治的思想,所以在我看来这两种排序方法都有自己的相似性. 快排 在快排中,首先运用的是分割的方式,选取pivot,将比pivot小的元素放在pivot前面.将比pivot大的元素放在pivot后面. quickSort(arr[],low,high) { if(low<high) { pi = partition(arr,low,high); quickSort(arr,low,pi-1); quickSort(arr,pi+1,high); } } 接下来是实现这个方法的

Python实现排序(冒泡、快排、归并)

Thomas H.Cormen 的<算法导论>上介绍的几个经典排序算法的Python实现. 1.冒泡排序: 简单的两重循环遍历,使最小(最大)的值不断地往上升(下沉)而实现的排序,算法时间为O(n2). 代码如下: 1 def up_sort(a): 2 # 冒泡排序 3 4 a_length = len(a) 5 while True: 6 i = 0 7 j = 1 8 9 while True: 10 if a[i] > a[j]: 11 a[i], a[j] = a[j], a[

算法导论学习之快排+各种排序算法时间复杂度总结

快排是一种最常用的排序算法,因为其平均的时间复杂度是nlgn,并且其中的常数因子比较小. 一.快速排序 快排和合并排序一样都是基于分治的排序算法;快排的分治如下: 分解:对区间A[p,r]进行分解,返回q,使得A[p–q-1]都不大于A[q] A[q+1,r]都大于A[q]; 求解:对上面得到的区间继续递归进行快排 合并:因为快排是原地排序,所以不需要特别的合并 从上可以看出最重要的就是分解函数,其按关键值将数组划分成3部分,其具体实现的过程见代码注释. 我们一般取数组的最后一个元素作为划分比较

霍尔快排的C语言实现

专题的前一篇讲了快速排序的始祖——霍尔快排,那么这里就简单地实现一下霍尔快排. 补充说明下,快排的一个核心步骤是选取枢纽元,通常的做法是将第一个元素用作枢纽元,<算法导论>里的快排例子和Hoare快排都是这种枢纽元选择.先撇开效率不说,我们先看看Hoare快排的实现:香格里拉娱乐城 01 #include "stdio.h" 02 #include "math.h" 03 #include "stdlib.h" 04   05 int

排序(一)归并、快排、优先队列等

排序(一) 初级排序算法 选择排序 思想:首先,找到数组中最小的那个元素.其次,将它和数组的第一个元素交换位置.再次,在剩下的元素中找到最小的元素,将它与数组的第二个元素交换位置.如此往复,直到将整个数组排序. [图例] 图中,x轴方向为数组的索引,y轴方向为待排序元素的值. 选择排序有两个很鲜明的特点: 运行时间和输入无关.为了找出最小的元素而扫描一遍数组并不能为下一遍扫描提供什么信息.这种性质在某些情况下是缺点.(无论数组的初始状态是什么,此算法效率都一样低效) 数据移动是最少的.每次交换都