• 希尔排序

    Accepted 1040 0MS 1224K 564 B G++
    #include "cstdio"
    using namespace std;
    int arr[];
    int main() {
    int t, n;
    scanf("%d", &t);
    while (t--) {
    scanf("%d", &n);
    for (int i = ; i < n; i++) {
    scanf("%d", &arr[i]);
    }
    // 一开始将增量设置为n的一半,将n个数分成n/2份进行插排,每份大概只有两个数,每次增量减半
    for (int i = n >> ; i > ; i >>= ) {
    for (int j = i; j < n; j++) {
    int u = arr[j];
    int id = j - i;
    while (id >= && arr[id] > u) {
    arr[id + i] = arr[id];
    id -= i;
    }
    arr[id + i] = u;
    }
    }
    printf("%d", arr[]);
    for (int i = ; i < n; i++) {
    printf(" %d", arr[i]);
    }
    puts("");
    }
    return ;
    }

    希尔排序是优化版的插入排序。

  • 快速排序
    Accepted 1040 0MS 1372K 1736 B G++
    #include "bits/stdc++.h"
    using namespace std;
    typedef long long LL;
    const int INF = 0x3f3f3f3f;
    int arr[];
    void quickSort(int l, int r) {
    /*
    注意一种错误写法:if (l == r)
    在排序9 8这样的数据时会造成无限循环
    */
    if (l >= r) {
    return;
    }
    int mid = l + r >> , id;
    // 找arr[l]、arr[r]、arr[mid]三个点中的中位数
    if (arr[l] <= arr[mid] && arr[l] <= arr[r]) {
    id = arr[mid] <= arr[r] ? mid : r;
    } else {
    if (arr[mid] <= arr[r]) {
    id = arr[l] <= arr[r] ? l : r;
    } else {
    id = arr[l] <= arr[mid] ? l : mid;
    }
    }
    // 将找到的中位数放在待排序数组的最左端
    swap(arr[l], arr[id]);
    int le = l + , gt = r;
    // 在下面的循环过程中,arr[l + 1]到arr[le]小于等于arr[l],arr[gt]到arr[r]大于arr[l];
    while (le < gt) {
    if (arr[le] <= arr[l]) {
    le++;
    } else if (arr[gt] <= arr[l]){
    swap(arr[le], arr[gt]);
    le++;
    gt--;
    } else {
    while (arr[gt] > arr[l] && le < gt) {
    gt--;
    }
    }
    }
    if (arr[le] > arr[l]) {
    le--;
    }
    swap(arr[le], arr[l]);
    /*
    注意一个错误写法:quickSort(l, le);
    在排序如4 0 2 4这样的数据时会造成无限循环
    */
    quickSort(l, le - );
    quickSort(le + , r);
    }
    int main() {
    int t, n;
    scanf("%d", &t);
    while (t--) {
    scanf("%d", &n);
    for (int i = ; i <= n; i++) {
    scanf("%d", &arr[i]);
    }
    quickSort(, n);
    for (int i = ; i < n; i++) {
    printf("%d ", arr[i]);
    }
    printf("%d\n", arr[n]);
    }
    return ;
    }

    这是最常用的一种排序方式,Java里面的Array.sort用的就是这种方式进行排序的,还有就是之前一直说这种排序方式的复杂度为nlogn,但是要注意nlgn是最好情况。一般达不到的,在排序个数小于等于8时用n^2复杂度的插入排序反而更快,所以quickSort函数里还可以进行一个判断if (r - l + 1 <= 8){插排}来进行优化。

  • 插入排序
    Accepted 1040 0MS 1380K 705 B G++
    #include "bits/stdc++.h"
    using namespace std;
    typedef long long LL;
    const int INF = 0x3f3f3f3f;
    int arr[];
    int main() {
    int t, n;
    scanf("%d", &t);
    while (t--) {
    scanf("%d", &n);
    for (int i = ; i < n; i++) {
    scanf("%d", &arr[i]);
    }
    for (int i = ; i < n; i++) {
    int temp = arr[i], j = i - ;
    while (j >= && arr[j] > temp) {
    arr[j + ] = arr[j];
    j--;
    }
    arr[j + ] = temp;
    }
    printf("%d", arr[]);
    for (int i = ; i < n; i++) {
    printf(" %d", arr[i]);
    }
    puts("");
    }
    return ;
    }

    就是让arr[0]到arr[i - 1]保持有序之后把arr[i]插入到前面的有序数列中去从而使arr[0]到arr[i]有序,逆序转正序的情况下复杂度最高,算法复杂度为O(N^2);

  • 归并排序
    Accepted 1040 0MS 1376K 1270B G++
    #include "bits/stdc++.h"
    using namespace std;
    typedef long long LL;
    const int INF = 0x3f3f3f3f;
    int arr[], help[];
    void mergeSort(int l, int r) {
    if (l >= r) {
    return;
    }
    int mid = l + r >> ;
    // 递归排序l到mid和mid + 1到r
    mergeSort(l, mid);
    mergeSort(mid + , r);
    // 将l到r拷贝到help数组对应位置,此时可将help[l]到help[mid]看成一个数组,help[mid + 1]到help[r]看成另一个数组
    memmove(help + l, arr + l, sizeof(int) * (r - l + ));
    int L = l, R = mid + , id = l;
    // 每次取出help[L]和help[R]中值小的填入arr[id]直到一边被取完为止
    while (L <= mid && R <= r) {
    if (help[L] <= help[R]) {
    arr[id++] = help[L++];
    } else {
    arr[id++] = help[R++];
    }
    }
    // 如果被取完的是help[l],那么help[R]后面的数已经存在于arr中对应位置不用移动,否则将help[L]后面的数移到arr数组后面;
    while (L <= mid) {
    arr[id++] = help[L++];
    }
    }
    int main() {
    int t, n;
    scanf("%d", &t);
    while (t--) {
    scanf("%d", &n);
    for (int i = ; i <= n; i++) {
    scanf("%d", &arr[i]);
    }
    mergeSort(, n);
    for (int i = ; i < n; i++) {
    printf("%d ", arr[i]);
    }
    printf("%d\n", arr[n]);
    }
    return ;
    }

    和快速排序一样是O(nlogn)的排序方法,这个方法需要借助辅助空间。

  • 堆排序
    Accepted 1040 0MS 1372K 1117 B G++
    #include "bits/stdc++.h"
    using namespace std;
    typedef long long LL;
    typedef pair<int, int> PII;
    const int INF = 0x3f3f3f3f;
    int arr[], m;
    void maxHeapFix(int id) {
    // mx存左右儿子中比较大的,一开始假设左儿子比右儿子大
    int mx = id << ;
    // 如果左儿子越界,右儿子肯定越界,id为叶子节点,直接返回
    if (mx > m) {
    return;
    }
    // 否则如果右儿子没越界并且右儿子大于左儿子,则mx = 右儿子
    if (mx < m && arr[mx | ] > arr[mx]) {
    mx |= ;
    }
    if (arr[mx] > arr[id]) {
    swap(arr[mx], arr[id]);
    maxHeapFix(mx);
    }
    }
    int main() {
    int t, n;
    scanf("%d", &t);
    while (t--) {
    scanf("%d", &n);
    for (int i = ; i <= n; i++) {
    scanf("%d", &arr[i]);
    }
    m = n;
    for (int i = n >> ; i; i--) {
    maxHeapFix(i);
    }
    while (m != ) {
    swap(arr[], arr[m--]);
    maxHeapFix();
    }
    for (int i = ; i < n; i++) {
    printf("%d ", arr[i]);
    }
    printf("%d\n", arr[n]);
    }
    return ;
    }

    就是不断维护大顶堆,大顶堆的堆顶是堆中最大,和最后一个元素交换后将堆的大小减1后继续维护大顶堆,复杂度O(nlgn)

  • 基数排序
    Accepted 1040 0MS 1416K 1160 B G++
    #include "bits/stdc++.h"
    using namespace std;
    typedef long long LL;
    const int INF = 0x3f3f3f3f;
    // 选取基数,不一定非要选10
    const int BASE = ;
    vector<int> arr;
    // 因为涉及负数排序,bucket开基数的两倍,前一半用来存负数
    vector<int> bucket[BASE << ];
    int main() {
    int t, n , m;
    scanf("%d", &t);
    while (t--) {
    arr.clear();
    scanf("%d", &n);
    for (int i = ; i < n; i++) {
    scanf("%d", &m);
    arr.push_back(m);
    }
    // 因为int中绝对值最大为 1LL << 31, 所以上限设为1LL << 31
    for (LL bit = ; bit <= 1LL << ; bit *= BASE) {
    for (int i : arr) {
    // 这里可以想象成进制转换,将i转换成BASE进制后求某一位
    bucket[i / bit % BASE + BASE].push_back(i);
    }
    arr.clear();
    for (int i = ; i < BASE << ; i++) {
    arr.insert(arr.end(), bucket[i].begin(), bucket[i].end());
    bucket[i].clear();
    }
    }
    printf("%d", arr[]);
    for (int i = ; i < n; i++) {
    printf(" %d", arr[i]);
    }
    puts("");
    }
    return ;
    }

    基数排序原理有点像字典序,从右边往左一遍遍扫描,高位补0。其时间复杂度为O (nlog(r)m),其中r为所采取的基数,而m为堆数。

  • 桶排序
    Accepted 1040 0MS 1412K 1142 B G++
    #include "bits/stdc++.h"
    using namespace std;
    typedef long long LL;
    const int INF = 0x3f3f3f3f;
    int t, n, m;
    vector<int> bucket[];
    int getHash(LL m) {
    // 减INT_MIN的作用是保证m为非负数,减完后的最大值为(1LL << 32) - 1,为保证哈希值在[0,n)的范围内除1LL << 32
    return (m - INT_MIN) * n / (1LL << );
    }
    void insert(int id, int m) {
    int j = bucket[id].size();
    bucket[id].push_back(m);
    while (j > && bucket[id][j - ] > m) {
    bucket[id][j] = bucket[id][j - ];
    j--;
    }
    bucket[id][j] = m;
    }
    int main() {
    scanf("%d", &t);
    while (t--) {
    scanf("%d", &n);
    for (int i = ; i < n; i++) {
    scanf("%d", &m);
    insert(getHash(m), m);
    }
    bool flag = true;
    for (int i = ; i < n; i++) {
    for (auto j : bucket[i]) {
    if (flag) {
    printf("%d", j);
    flag = false;
    } else {
    printf(" %d", j);
    }
    }
    bucket[i].clear();
    }
    puts("");
    }
    return ;
    }

    桶排序的适用范围是数据平均分布的情况,这种情况下复杂度很低可达到O(N),所以考虑在一个桶内的数不会太多,用插入排序。但是分布极不均匀的情况下(所有数据在一个桶中)将退化成插入排序;

HDU-1040-As Easy As A+B(各种排序)的更多相关文章

  1. HDU 1040.As Easy As A+B【排序】【如题(水!水!水!)】【8月24】

    As Easy As A+B Problem Description These days, I am thinking about a question, how can I get a probl ...

  2. HDU 1040 As Easy As A+B (排序。。。水题)

    题意:给定n个数,让你从小到大排序. 析:不说什么了. 代码如下: #include <cstdio> #include <iostream> #include <cst ...

  3. hdu 1040 As Easy As A+B(排序)

    题意:裸排序 思路:排序 #include<iostream> #include<stdio.h> #include<algorithm> using namesp ...

  4. hdu 1040 As Easy As A+B

    As Easy As A+B Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) T ...

  5. HDU 1040 As Easy As A+B(排序)

    As Easy As A+B Problem Description These days, I am thinking about a question, how can I get a probl ...

  6. HDU 1040 As Easy As A+B [补]

    今天去老校区找她,不想带电脑了,所以没时间A题了 /*******************************************************************/ As Ea ...

  7. 杭电 1040 As Easy As A+B 【排序】

    题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=1040 解题思路:数据不大,可以直接用冒泡排序 #include<stdio.h> int ...

  8. HDU 5572 An Easy Physics Problem (计算几何+对称点模板)

    HDU 5572 An Easy Physics Problem (计算几何) 题目链接http://acm.hdu.edu.cn/showproblem.php?pid=5572 Descripti ...

  9. hdu 5058 So easy

    题目连接 http://acm.hdu.edu.cn/showproblem.php?pid=5058 So easy Description Small W gets two files. Ther ...

  10. hdu 5475 An easy problem(暴力 || 线段树区间单点更新)

    http://acm.hdu.edu.cn/showproblem.php?pid=5475 An easy problem Time Limit: 8000/5000 MS (Java/Others ...

随机推荐

  1. order by rand()优化

    优化前: SELECT id, loan_id, NAME, company FROM tablename WHERE time BETWEEN 1522512000 AND 1525103999 A ...

  2. swift bannerview 广告轮播图

    class BannerView: UIView,UIScrollViewDelegate{ //图⽚⽔平放置到scrollView上 private var scrollView:UIScrollV ...

  3. C盘满了解决办法之查看文件夹占用的统计界面

    TreeSize Free软件,可以实时查看文件夹使用情况: 百度搜索: 下载安装完以后的显示界面如下:

  4. 洛谷P1525 关押罪犯(并查集、二分图判定)

    本人蒟蒻,只能靠题解AC,看到大佬们的解题思路,%%%%%% https://www.luogu.org/problemnew/show/P1525 题目描述 S城现有两座监狱,一共关押着N名罪犯,编 ...

  5. 初识数据库MySQL

    一.认识数据库  1:什么是数据(Data) 描述事物的符号记录被称为数据,这个符号可以是数字,文字,图片,声音,语言等 2:什么是数据库(DataBase,简称DB) 数据库是存放数据的仓库,库一般 ...

  6. Snapchat欲联手亚马逊推扫一扫功能,社交应用营收来源将有大变化?

    当下的社交应用,已经不能完全仅用"社交"的标签进行定义.因为目前的社交应用不仅承载着大众的喜怒哀乐和沟通指责,更在逐渐打造起一个连接多方的生态系统.甚至只从自身的营收.利润出发,社 ...

  7. 爬虫笔记(十一)——认识cookie

    什么是cookie? 在爬虫的使用中,如果涉及登录等操作时,经常会使用到cookie.简单的来说,我们访问每一个互联网页面,都是通过HTTP协议进行的,而HTTP协议是一个无状态协议,所谓的无状态协议 ...

  8. [HNOI2006]最短母串问题(AC自动机+状态压缩+bfs)

    快要THUSC了,来水几道模板题吧. 这题其实是AC自动机模板.看到长度最短,首先就想到AC自动机.那么就直接暴力法来吧,把每个串建立在AC自动机上,建立fail指针,然后由于n<=12,可以把 ...

  9. IOS之Core Foundation框架和Cocoa Foundation框架的区别(转)

    Core Foundation框架 (CoreFoundation.framework) 是一组C语言接口,它们为iOS应用程序提供基本数据管理和服务功能.下面列举该框架支持进行管理的数据以及可提供的 ...

  10. C# 接口练习

    #define debug using System; using System.Collections; namespace ConsoleApp1 { interface IAnimal { in ...