产生随机数,测试快排

  1 #include<iostream>
  2 #include<cstdlib>
  3 #include<ctime>
  4 #include<fstream>
  5 #include<algorithm>
  6 using namespace std;
  7 int main()
  8 {
  9     srand(unsigned(time(0)));
 10     freopen("random1.txt","w",stdout);
 11     for(int i = 0 ; i < 1000 ; i++)
 12     {
 13         int a = rand() % 100;
 14         cout<< a <<" ";
 15     }
 16     fclose(stdout);
 17
 18 }
 19 #include<iostream>
 20 #include<cstdlib>
 21 #include<ctime>
 22 #include<fstream>
 23 #include<algorithm>
 24 using namespace std;
 25 int fuzhukuaipai(int a[],int i,int j)
 26 {
 27      int key = a[i];
 28      while(i<j){
 29
 30      while(a[j]>=key&&i<j)--j;
 31      a[i] = a[j];
 32   while(a[i]<=key&&i<j)++i;
 33     a[j] = a[i];
 34     }
 35     a[i] = key;
 36     return i;
 37 }
 38 void kuaipai(int a[],int i,int j)
 39 {
 40         if(i<j)
 41         {
 42             int p = fuzhukuaipai(a,i,j);
 43             kuaipai(a,i,p-1);
 44             kuaipai(a,p+1,j);
 45         }
 46 }
 47 int Partition(int a[],int p , int r)
 48 {
 49     int x = a[r];
 50     int i = p-1;
 51     for(int j = p ; j < r ;j++ )
 52     {
 53         if(a[j]<=x)
 54         {
 55             i ++;
 56             swap(a[i],a[j]);
 57         }
 58     }
 59     swap (a[i+1],a[r]);
 60     return i+1;
 61 }
 62 void QuickSort(int a[],int p,int r)
 63 {
 64     if(p<r)
 65     {
 66         int q=Partition(a,p,r);
 67         QuickSort(a,p,q-1);
 68         QuickSort(a,q+1,r);
 69     }
 70 }
 71 void maopao(int a[],int n)
 72 {
 73     for(int i = 0 ; i < n ; i ++)
 74     {
 75         for(int j = i ; j < n ; j++)
 76         {
 77             if(a[i]>a[j])swap(a[i],a[j]);
 78         }
 79     }
 80 }
 81 int main()
 82 {
 83     int a[100000] ;
 84     ifstream fin;
 85     fin.open("random_number.txt");
 86     for(int i = 0 ; i < 100000 ; i++)
 87     {
 88         fin>>a[i];
 89     }
 90     fin.close();
 91     time_t Start;
 92     time_t End;
 93     Start = clock();
 94    // QuickSort(a,0,100000);
 95     kuaipai(a,0,100000);
 96     End = clock();
 97     cout<<"kuaipai-spend:"<<End-Start<<endl;
 98 //    ofstream fout;
 99 //    fout.open("aftersort.txt");
100 //    for(int i = 0 ; i < 100000 ; i ++)
101 //    {
102 //            fout<<a[i]<<"\t";
103 //    }
104 fin.open("random_number.txt");
105     for(int i = 0 ; i < 100000 ; i++)
106     {
107         fin>>a[i];
108     }
109     fin.close();
110     Start = clock();
111     QuickSort(a,0,100000);
112     End = clock();
113     cout<<"QuickSort-spend:"<<End-Start<<endl;
114
115
116     fin.open("random_number.txt");
117     for(int i = 0 ; i < 100000 ; i++)
118     {
119         fin>>a[i];
120     }
121     fin.close();
122     Start = clock();
123     sort(a,a+100000);
124     End = clock();
125     cout<<"Sort-spend:"<<End-Start<<endl;
126
127 }
时间: 2024-11-06 02:00:51

产生随机数,测试快排的相关文章

JavaScript快排与原生sort的测试

今天工作室断网!果断回宿舍,不然各种资料都没有.(他说将来会找到!)不好意思,又哼起来了.进入主题,大家都知道,快排是各种排序算法中,最高效的也是应用最广的,还有更重要的一点,面试特别爱考的! 其实大家或多或少都听说过快排,也就是先从取出一个基准值,然后再把其它的数与之相对比,小的放左边的集合里,大的放右边的集合里,再通过递归不断重复该步骤,实现最高效率的quickSort. Talk is cheap, show you my code! 排序结果我就不写出来啦,大家都会数大小,哈哈哈. 刚说

topK问题最小堆和快排哪个快

最近一直纠结这个问题.看了很多帖子,决定自己写个例子,实测结果如下: 总数1万个取最大100,快排略快,最小堆偶尔快. 总数10万个取最大100,最小堆略快,快排偶尔快. 总数100万个取最大100,最小堆完胜,快排没戏,而且最小堆大概快了2倍. 总数1000万个取最大100,最小堆完虐,快排没戏,而且最小堆快了大概2倍. 结论:最小堆比快排优秀. 原因: 1.速度确实快. 2.最小堆不需要打乱原数据顺序,而快排会打乱.(并不是快的原因,而是最小堆的优点) 3.如果内存有限,无法加载所有数据,则

快排的递归和非递归

常用的快排都是用递归写的,因为比较简单,但是可以用栈来实现非递归的快排. 第一种是递归的快排 #include<stdio.h> #include <stdlib.h> #include <time.h> int quick(int a[],int i ,int j) {     int tmp=0,key,b=0;     int im,jm;     im=i;     jm=j;     key=a[i];     if(i>j)         retur

快排,随机快排,双路快排,三路快排的理解

再讲快排之前,首先对于任何一个数组,无论之前是多么杂乱,排完之后是不是一定存在一个数作为分界点(也就是所谓的支点),在支点左边全是小于等于这个支点的,然后在这个支点右边的全是大于等于这个支点的,快排过程就是寻找这个支点过程 先看普通的快排(普通单路快排) 代码如下 let findIndex = (arr, l, len) => { let par = arr[l], j = l for (let i = l + 1; i <= len; i++) { if (arr[i] < par)

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[

题目1434:今年暑假不AC (项目安排类:结束时间快排,判断开始时间)

题目描述: “今年暑假不AC?”“是的.”“那你干什么呢?”“看世界杯呀,笨蛋!”“@#$%^&*%...”确实如此,世界杯来了,球迷的节日也来了,估计很多ACMer也会抛开电脑,奔向电视作为球迷,一定想看尽量多的完整的比赛,当然,作为新时代的好青年,你一定还会看一些其它的节目,比如新闻联播(永远不要忘记关心国家大事).非常6+7.超级女生,以及王小丫的<开心辞典>等等,假设你已经知道了所有你喜欢看的电视节目的转播时间表,你会合理安排吗?(目标是能看尽量多的完整节目) 输入:     

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

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

排序算法复习:直接插入排序、堆排序、快排、冒泡排序

冒泡排序,感觉是最简单的排序: 基本思路:每次把数组中最小的一个元素像气泡一样浮动.固定到最顶端: 从前向后遍历数组,每次拿到一个元素,就执行一遍冒泡: 从数组末尾开始,到当前元素截止,从后向前遍历,每次比较数组中相邻的两个元素,如果后者比较小,就把两者互换. 这样经过第一次冒泡,可以把最小的元素『浮』到数组的首位.第二次冒泡会把第二小的元素『浮』到数组的第二位.直到所有的元素都被『浮动』到正确的位置. 代码极其简单: var BubbleSort = function (array) { va

算法总结——三大排序(快排,计数排序,归并)

快排: 适用条件:方便...只要数字不是很多 复杂度:O(nlogn)  每一层n复杂度,共logn层 原理:利用一个随机数与最后面一个数交换,那么这个随机数就到了最后一位,然后循环,如果前面的数大于最后一个数,那么把这个数放到前面去,经过一次排序之后,前面的数都是大于最后一个的,然后对1到k和k+1到n进行排序,一层一层地下去 模板: #include<cstdio> #include<algorithm> #include<time.h> using namespa