快速排序/随机快速排序

快速排序是一个递归算法,重点是Partition()函数的实现过程。随机快速排序中调用Randomized_Partition(),此函数的实现只需要在Partition()的基础上前面多一个随机化和交换的过程。

int Partition(int*A,int p,int r);

int Randomized_Partition(int*A,int p,int r); 

void Quicksort(int *A,int p,int r);

void Randomized_Quicksort(int*A,int p,int r);

void Swap(int &a,int &b);

Quicksort.h

  1 #include<iostream>
  2 #include<time.h>
  3 #include<stdio.h>
  4 #include <stdlib.h>
  5 #include<fstream>
  6 using namespace std;
  7
  8 #include"Quicksort.h"
  9
 10 #define N 10000
 11
 12 int Num[N];
 13 int choice;
 14 double start,finish;
 15
 16 int main(void)
 17 {
 18
 19     // Write N random numbers to data.txt
 20     ofstream in;
 21     in.open("data.txt",ios::trunc); //ios::trunc表示在打开文件前将文件清空,由于是写入,文件不存在则创建
 22     int x;
 23     srand((unsigned) time(NULL));
 24     cout<<"Numbers needed to be sort are:"<<endl;
 25     for(int n=0;n<N;n++)
 26     {
 27         x = rand() %100;
 28         //cout<<x<<" ";
 29         in<<x<<" ";
 30         Num[n] = x;
 31
 32     }
 33     cout<<endl;
 34     in.close(); //勿忘关闭文件
 35                 /*
 36                 // Read data from data.txt
 37                 ifstream fin("data.txt");
 38                 vector<int> vec;
 39
 40                   //fin Input value into idata,like cin>>a , cin get value from keyboard,fin get value from file
 41                   //This reading method won‘t get twice of the last data
 42                   int idata;
 43                   fin >> idata;
 44                   while (fin)
 45                   {
 46                   vec.push_back(idata);
 47                   fin >> idata;
 48                   }
 49
 50                     //N = vec.size();
 51                     for(int i=0;i<N;i++)
 52                     {
 53                     Num[i]=vec[i];
 54                     }
 55     */
 56     cout<<"1: Quicksort  Other: Randomized_Quick"<<endl<<"Your Choice: ";
 57     cin>>choice;
 58
 59     //General Quicksort
 60     start = clock();//
 61     if(choice == 1)
 62     {
 63         Quicksort(Num,0,N-1);
 64         finish = clock();//
 65
 66         //Output to screen & ResultData.txt
 67         cout<<"Your Quciksort Result is:"<<endl;
 68         in.open("ResultData.txt",ios::trunc);
 69         for(int i=0;i<N;i++)
 70         {
 71             //cout<<Num[i]<<" ";
 72             in<<Num[i]<<" ";
 73         }
 74         cout<<endl;
 75         in.close();
 76         cout<<"number of ticks in Quicksort is: "<<(finish-start)/CLOCKS_PER_SEC<<endl;//
 77         return 0;
 78     }
 79
 80     //Randomized_Quicksort
 81     Randomized_Quicksort(Num,0,N-1);
 82
 83     finish = clock();//
 84     //clock_t finish = clock();//
 85
 86     //Output to screen
 87     cout<<"Your Randomized_Quciksort Result is:"<<endl;
 88     in.open("ResultData.txt",ios::trunc);
 89     for(int i=0;i<N;i++)
 90     {
 91         //cout<<Num[i]<<" ";
 92         in<<Num[i]<<" ";
 93     }
 94     cout<<endl;
 95     in.close();
 96     /*
 97     for(i=0;i<N;i++)
 98     {
 99     cout<<Num[i]<<" ";
100     }
101     cout<<endl;
102     */
103     cout<<"number of ticks in Randomized_Quicksort is: "<<(finish-start)/CLOCKS_PER_SEC<<endl;//
104     return 0;
105 }

main.cpp

 1 #include"Quicksort.h"
 2 int Partition(int*A,int p,int r)
 3 {
 4     int x = A[r];
 5     int i = p-1;
 6     for(int j=p;j<r;j++)
 7     {
 8         if(A[j]<=x)
 9         {
10             i+=1;
11             if(i!=j)
12             {
13                 Swap(A[i],A[j]);
14             }
15         }
16     }
17     Swap(A[i+1],A[r]);
18     return i+1;
19
20 }

Partition.cpp

 1 #include"Quicksort.h"
 2 void Quicksort(int *A,int p,int r)
 3 {
 4     if(p<r)
 5     {
 6         int q = Partition(A,p,r);
 7         Quicksort(A,p,q-1);
 8         Quicksort(A,q+1,r);
 9     }
10 }

Quicksort.cpp

 1 #include<time.h>
 2 #include<stdlib.h>
 3 #include"Quicksort.h"
 4
 5 int Randomized_Partition(int*A,int p,int r)
 6 {
 7     srand((unsigned) time(NULL));
 8     int k = -1;
 9     while(k<p)
10     {
11         k = rand() % (r+1);
12     }
13     Swap(A[k],A[r]);
14     //Partition(A,p,r);
15     int x = A[r];
16     int i = p-1;
17     for(int j=p;j<r;j++)
18     {
19         if(A[j]<=x)
20         {
21             i+=1;
22             if(i!=j)
23             {
24                 Swap(A[i],A[j]);
25             }
26         }
27     }
28     Swap(A[i+1],A[r]);
29     return i+1;
30 }

Randomized_Partition.cpp

 1 #include<iostream.h>
 2 #include"Quicksort.h"
 3 void Randomized_Quicksort(int *A,int p,int r)
 4 {
 5     if(p<r)
 6     {
 7         int q = Randomized_Partition(A,p,r);
 8         Randomized_Quicksort(A,p,q-1);
 9         Randomized_Quicksort(A,q+1,r);
10     }
11
12 }

Randomized_Quicksort.cpp

时间: 2024-10-06 19:54:16

快速排序/随机快速排序的相关文章

快速排序 与 随机快速排序 算法分析

快速排序是由东尼·霍尔所发展的一种排序算法.在平均状况下,排序 n 个项目要Ο(n log n)次比较.在最坏状况下则需要Ο(n2)次比较,但这种状况并不常见.事实上,快速排序通常明显比其他Ο(n log n) 算法更快,因为它的内部循环(inner loop)可以在大部分的架构上很有效率地被实现出来. 快速排序的优点: (1)原址排序,空间复杂度较小. (2)虽然最坏情况下(有序数组)时间复杂度为 (n*n),但是平均性能很好,期望复杂度为( nlg(n) ). 快速排序使用分治法(Divid

《github一天一道算法题》:快速排序和随机快速排序

看书.思考.写代码!!! /********************************* * [email protected] * blog: http://blog.csdn.net/hustyangju * 题目:快速排序和随机快速排序 * 思路:采用分治+原址排序,分裂函数将区间分为三个子区间:<=主元.主元和>主元区间,再在主元旁边的两个子区间递归调用排序 * 分裂函数一般将区间最后一个元素作为比较的主元,随机快排则随机选取区间内的一个元素交换到末尾作为主元 * 空间复杂度:原

Python 实现快速排序和随机快速排序

直接上代码: #快速排序 #coding: utf-8 def quicksort(a,left,right): if(left<right): mid = partition(a,left,right) quicksort(a,left,mid-1) quicksort(a,mid+1,right) def partition(a,left,right): x = a[right] i = left-1 #初始i指向一个空,保证0到i都小于等于 x for j in range(left,ri

随机快速排序

#include<iostream>#include <vector>#include <cstdlib>#include<ctime>using namespace std;/* 作用:返回一个在(min,max)之间的一个随机整数 参数:min--返回值的最小限制 max--返回值的最大限制*/int random(int min,int max){ srand((unsigned)time(NULL));//设置随机数的来源 return rand()

【算法设计-快速排序】随机快速排序算法

1.算法流程: 但是为了减少算法因为初始数据可能已经部分按大小排序,导致算法复杂性会变成o(n2)进行了随机选择方法 在random_partition中随机产生(p,r)之间的一个数字,然后交换A[i]与A[r]这样会使得快速排序算法的复杂性得到降低. 代码实现: #include<stdio.h> #include<stdlib.h> #define DataType int void FastSort(DataType A[], int left, int right);//

面试之路(22)-快速排序随机选择元素的优雅解法

关于常规解法,请参考上一篇博客,链接如下: 面试之路(19)-快速排序详解 介绍一种优雅的解法 public int partition(int data[],int length,int start,int end) throws Exception{ if(data == null || length <= 0||start < 0||end >= length){ throw new Exception("invalid data"); } //RandomIn

随机快速排序的细节和复杂度分析

0.经典快排:将数组最后位置的数值x作为划分值,将小于等于x的放在左边,大于x的放在右边, 让小于等于x区域的最后一个位置上放x值,如果有多个值等于x,中间区域放的什么值无所谓,左边区域最后一个数放x就可以,左边区域放小于等于x的值,右边放大于x的值,经典快排的时间复杂度和数据状况是有关系的.最好的时间复杂度是O(NlogN),最差情况的时间复杂度是O(N^2) 1.可以用荷兰国旗问题来改进快速排序 (1)将小于x的放在左边,等于x的放中间,大于x的放在右边,这样的话等于x的区域就不用动了,将小

C++快速排序(随机值元法)

#include <iostream> #include <stdlib.h> using namespace std; int sum(int a,int b) { return (rand()%(b-a)+a+1); } void Grial(int a[],int x,int y) { if(x>=y)return ; int i=x; int j=y; int temp; int b=sum(i,j);//求取随机值. int key=a[b]; while(i<

随机快速排序学习记录

Randomized Quicksort·running time is independent of input ordering·no assumptions about the input distribution·np specific input elict the worst-case behavior·the worst-case is determined only by a random-number generator pivot on random element Anal