排序降低---------------------

点击这里进入杭电上的测试题                      点击这里进入厦大的测试题

杭电的题我用  希尔排序 +Hibbard增量序列 过不去.代码如下(因为是测试的 所以有点乱)

 1 #include<stdio.h>                  //这个直接就跪了   超时/
 2 #include<algorithm>
 3 using namespace std;
 4 int a[1000011],i,j,m,n,t,d,p,q,tmp;
 5 int main()
 6 {
 7     while(scanf("%d%d",&t,&q)!=EOF)
 8     {
 9         for(i=0;i<t;i++)
10             scanf("%d",&a[i]);
11         for(d=(t/2)-1;d>0;d=d/2)  //  从n/2开始 一直向下传送 d直到d=1
12         {
13             for(p=d;p<t;p++)   //从这里开始  就是  纯粹的 插入排序了.
14             {
15                 tmp=a[p];
16                 for(i=p;i>=d&&a[i-d]<tmp;i=i-d)
17                 {
18                     a[i]=a[i-d];
19                 }
20                 a[i]=tmp;
21             }
22         }
23         for(i=0;i<t-1;i++)
24             printf("%d ",a[i]);
25         printf("%d\n",a[t-1]);
26     }
27 }

但是快速排序水过去了.

 1 //差点跪,时间是 904  差一点点跪.  这个好像不是 完整的快排     有待补充
 2 #include<stdio.h>
 3 #include<algorithm>
 4 using namespace std;
 5 int a[1000011],i,j,m,n,t,d,p,q,tmp;
 6 int main()
 7 {
 8     while(scanf("%d%d",&t,&q)!=EOF)
 9     {
10         for(i=0;i<t;i++)
11             scanf("%d",&a[i]);
12         sort(a,a+t);
13         for(i=t-1;i>t-q;i--)
14             printf("%d ",a[i]);
15         printf("%d\n",a[t-q]);
16     }
17 }

这是用stl的快速排序  别人的代码 //我还没看到  以后会重新过来写.

 1 #include <stdio.h>
 2 #include <algorithm>
 3
 4 using namespace std;
 5
 6 static int a[1000000];
 7
 8 int main()
 9 {
10     int i,n,m;
11     while(EOF != scanf("%d %d",&n,&m))
12     {
13         for(i=0;i<n;i++)
14             scanf("%d",&a[i]);
15         make_heap(a,a+n);
16         printf("%d",a[0]);
17         for(i=1;i<m;i++)
18         {
19             pop_heap(a,a+n-i+1);
20             printf(" %d",a[0]);
21         }
22         printf("\n");
23     }
24     return 0;
25 }

至于厦大的   希尔 和 快排

 1 #include<stdio.h>
 2 #include<algorithm>
 3 using namespace std;
 4 int a[1000011],i,j,m,n,t,d,p,tmp;
 5 int main()
 6 {
 7     while(scanf("%d",&t)!=EOF)
 8     {
 9         for(i=0;i<t;i++)
10             scanf("%d",&a[i]);
11         for(d=(t/2)-1;d>0;d=d/2)  //  从n/2开始 一直向下传送 d直到d=1
12    {
13        for(p=d;p<t;p++)   //从这里开始  就是  纯粹的 插入排序了.
14        {
15            tmp=a[p];
16            for(i=p;i>=d&&a[i-d]>tmp;i=i-d)
17            {
18                 a[i]=a[i-d];
19            }
20            a[i]=tmp;
21        }
22    }
23         for(i=0;i<t-1;i++)
24             printf("%d ",a[i]);
25         printf("%d\n",a[t-1]);
26     }
27 }
28 /**************************************************************
29     Problem: 1004
30     User: xpower
31     Language: C++
32     Result: Accepted
33     Time:700 ms
34     Memory:4940 kb
35 ****************************************************************/
#include<stdio.h>
#include<algorithm>
using namespace std;
int a[1000011],i,j,m,n,t;
int main()
{
    while(scanf("%d",&t)!=EOF)
    {
        for(i=0;i<t;i++)
            scanf("%d",&a[i]);
        sort(a,a+t);
        for(i=0;i<t-1;i++)
            printf("%d ",a[i]);
        printf("%d\n",a[t-1]);
    }
}
/**************************************************************
    Problem: 1004
    User: xpower
    Language: C++
    Result: Accepted
    Time:508 ms
    Memory:4944 kb
****************************************************************/
时间: 2024-10-30 23:25:03

排序降低---------------------的相关文章

莫队模板

https://vjudge.net/problem/SPOJ-DQUERY 此题连接: 题目大意:给出一个n个数的序列: 接下来有k个询问,每一次询问某一区间里的不同数的个数: 莫队思想:分块 排序 暴力:先将所有询问存储起来,然后玄学排序降低复杂度: 1 #include<cstdio> 2 #include<algorithm> 3 #include<math.h> 4 #include<string.h> 5 #include<queue>

数据结构——各排序算法的比较

1.从时间复杂度比较  从平均时间复杂度来考虑,直接插入排序.冒泡排序.直接选择排序是三种简单的排序方法,时间复杂度都为O(n2),而快速排序.堆排序.二路归并排序的时间复杂度都为O(nlog2n),希尔排序的复杂度介于这两者之间.若从最好的时间复杂度考虑,则直接插入排序和冒泡排序的时间复杂度最好,为O(n),其它的最好情形同平均情形相同.若从最坏的时间复杂度考虑,则快速排序的为O(n2),直接插入排序.冒泡排序.希尔排序同平均情形相同,但系数大约增加一倍,所以运行速度将降低一半,最坏情形对直接

hdu1285(拓扑排序)

这道题要求没有输赢关系的两个元素必须按照升序输出,有输赢关系的,赢得在输的前面,所以用队列或者栈来降低时间复杂度的优化过的拓扑排序会出错. 比如这组输入 5 3 1 2 2 3 4 5 至少我写的两种拓扑排序都wa了.但是不用队列或者栈来优化的话, 1.每次都从头至尾扫描一遍,找到一个没标记过的节点, 2.将它标记 3.然后删除从它出来的每条边. 重复这三个操作,加标记的次序,就是题目要的答案. 下面的代码中用到了队列,但只是用来保存答案而已.并没有用它优化的意思. #include <iost

算法学习之排序算法(三)(选择排序法)

1.引言 选择排序工作原理是每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,直到全部待排序的数据元素排完. 选择排序是不稳定的排序方法.选择排序是和冒泡排序差不多的一种排序.和冒泡排序交换相连数据不一样的是,选择排序只有在确定了最小的数据之后,才会发生交换.怎么交换呢?我们可以以下面一组数据作为测试: 2, 1, 5, 4, 9 第一次排序:1, 2, 5, 4, 9 第二次排序: 1, 2, 5, 4, 9 第三次排序: 1, 2, 4, 5, 9 第四次排序:

【学习排序】 Learning to Rank 中Listwise关于ListNet算法讲解及实现

前一篇文章"Learning to Rank中Pointwise关于PRank算法源码实现"讲述了基于点的学习排序PRank算法的实现.该篇文章主要讲述Listwise Approach和基于神经网络的ListNet算法及Java实现.包括: 1.基于列的学习排序(Listwise)介绍 2.ListNet算法介绍 3.ListNet算法Java实现 LTR中单文档方法是将训练集里每一个文档当做一个训练实例,文档对方法是将同一个查询的搜索结果里任意两个文档对作为一个训练实例,文档列方法

数据结构学习笔记-排序/队/栈/链/堆/查找树/红黑树

排序: 插入排序:每次从剩余数据中选取一个最小的,插入已经排序完成的序列中 合并排序:将数据分成左右两组分别排序,然后合并,对每组数据的排序递归处理. 冒泡排序:重复交换两个相邻元素,从a[1]开始向a[0]方向冒泡,然后a[2]...当a[i]无法继续往前挤的时候说明前面的更小了,而且越往前越小(挤得越往前) 堆排序:构造最大堆,每次取走根结点(自然是最大的),再调用MAX-HEAPIFY算法(见后文的堆)恢复最大堆的性质,重复取走根结点 快速排序(对A[r]-A[n]进行排序): 1.从序列

排序——直接选择排序(简单选择排序)

直接选择排序也称简单选择排序,是一种相对简单的排序算法,它的基本思想是:从一列数中找出最小的,和第一个交换:剩下的重新找出最小的,和这列数的第二个交换,......一直进行n-1次比较之后,该数列已经为有序数列了. 例如:已知一组无序数列:6 3 5 1 4 2 9 第一次:[6 3 5 1 4 2 9] 最小数为:1 第二次:1 [3 5 6 4 2 9] 最小数为:2 第三次:1 2 [5 6 4 3 9] 最小数为:3 第四次:1 2 3 [6 4 5 9] 最小数为:4 第五次:1 2

内部排序(3)——插入排序之折半插入排序

因为插入排序的基本思想是在一个有序序列中插入一个新的记录,则能够利用"折半查找"查询插入位置,由此得到的插入排序算法为"折半插入排序".算法例如以下: void BInsertSort () { // 对顺序表L作折半插入排序 for ( i=2; i<length; ++i ) { <span style="white-space:pre"> </span>r[0] = r[i]; // 将r[i]暂存到r[0]

八大排序算法

转载:http://blog.csdn.net/hguisu/article/details/7776068 目录(?)[+] 概述 排序有内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存. 我们这里说说八大排序就是内部排序. 当n较大,则应采用时间复杂度为O(nlog2n)的排序方法:快速排序.堆排序或归并排序序. 快速排序:是目前基于比较的内部排序中被认为是最好的方法,当待排序的关键字是随机分布时,快速