利用OpenMP实现并行快速排序算法

主要利用了OpenMP里面的#omp parallel sections将对两个子数组的快速排序函数用两个线程并行化执行，至于线程的创建和销毁我们不用管，只要告诉编译器哪里的代码需要并行执行就可以了，具体请看OpenMP资料。

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

#include "omp.h"

//int count=0;

void swap(int &a, int &b)//

{

    int x;

    x = a;

    a = b;

    b = x;

}

int randint(int a,int b)

{

int e=0;

e=b-a;

return rand() % e + a;

}

void quicksort(int *A,int l, int u)

{

int i,m,k;

if (l >= u) return;

// k=randint(l, u);//

// swap(A[l],A[k]);//这两行实现了随机化

m = l;

for (i = l+1; i <= u; i++)

if (A[i] < A[l])/*不管是选第一个元素作为pivot还是最后一个作为pivot,假如我们想得到的是从小到大的序列，那么最坏的输入

             //情况就是从大到小的；如果我们想得到从大到小的序列，那个最坏的输入情况就是从小到大的序列*/

swap(A[++m], A[i]);

swap(A[l], A[m]);

// count += u-l;//用于统计比较次数，来自《代码之美》

quicksort(A,l, m-1);

quicksort(A,m+1, u);

}

void main(int argc, char *argv) 

{

omp_set_num_threads(2);//----------------设置线程数为2，因为是双核的CPU

int j=50000,k=0,i=0;

int m=0,n=0;

clock_t begin, end;

double  cost;

    srand((unsigned)time( NULL ));

int len=50000;

int short_len=len/2;

int B[50000],C[25000],D[25000];//--------将B[]分为两个小的数组，并行的对他们调用快速排序算法

#pragma omp parallel default(none) shared(B,len) private(i)//---这个for循环是并行的

{

#pragma omp for

for(i=0;i<len;i++)

{

B[i]=j--;//初始化B[]数组

}

}

    begin = clock();//----------------计时开始点

#pragma omp parallel default(none) shared(B,C,D,short_len) private(i)//---这个for循环是并行的

{

#pragma omp for

for(i=0;i<short_len;i++)//---这个for循环是并行的

{

C[i]=B[i];//将B[]的前25000个数放入C[]

D[i]=B[i+25000];//将B[]的后25000个数放入D[]

}

}

#pragma omp parallel default(none) shared(C,D,short_len) //private(i)------快速排序的并行region

{

#pragma omp parallel sections

{

#pragma omp section

quicksort(C, 0, short_len-1);//对C[]排序

#pragma omp section

quicksort(D, 0, short_len-1);//对D[]排序

}

}

printf("/n");

//    begin = clock();

for(;k<len;k++)//----------将C[]和D[]进行归并排序放入B[]里面

{

//if(C[k]<D[k])

if(m<short_len && n<short_len)

{

if(C[n]<=D[m])

{

B[k] = C[n];

n++;

}

else

{

B[k]=D[m];

m++;

}

}

if(m==short_len || n==short_len)

{

if(m==short_len)

B[k]=D[m];

else

B[k]=C[n-1];

k+=1;

break;

}

}

if(/*m==short_len &&*/ n<short_len)

{

int tem=short_len-n;

for(int p=0;p<tem;p++)

{

B[k]=C[n];

n++;

k++;

}

}

else if(/*n==short_len &&*/ m<short_len)

{

int tem=short_len-m;

for(int q=0;q<tem;q++)

{

B[k]=D[m];

m++;

k++;

}

}//----------------------------归并算法结束

    end = clock();//----------------计时结束点

cost = (double)(end - begin) / CLOCKS_PER_SEC;

printf("%lf seconds/n", cost);//输出运行interval

system("pause");

}