OpenMp之快速排序

#include <stdio.h>
#include<stdafx.h>
#include<iostream>
#include <stdlib.h>
#include <time.h>
#include "omp.h"
using namespace std;
//int count=0;
	void swap(int &a, int &b)//
	{
		int tmp;
		tmp = a;
		a = b;
		b = tmp;
	}
	void quicksort(int *A,int l, int u)
	{
		int i,m,k;
		if (l >= u) return;
		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]);
		quicksort(A,l, m-1);
		quicksort(A,m+1, u);
	}
	void main(int argc, char *argv)
	{
		omp_set_num_threads(2);//----------------设置线程数为2，因为是双核的CPU
		int k=0,i=0;
		int m=0,n=0;
		double cost=0;
		int len=10000;
		int short_len=len/2;
		int B[10000],C[10000],D[5000],E[5000];//--------将B[]分为两个小的数组，并行的对他们调用快速排序算法
		#pragma omp parallel default(none) shared(B,C,len) private(i)//---这个for循环是并行的
		{
			int j=50000;
		#pragma omp for
		for(i=0;i<len;i++)
			{
				B[i]=j--;
				C[i]=j--;
				//初始化B[],C[]数组
			}
		}
		clock_t begin = clock();//----------------计时开始点
		#pragma omp parallel default(none) shared(B,D,E,short_len) private(i)//---这个for循环是并行的
		{
		#pragma omp for
			for(i=0;i<short_len;i++)//---这个for循环是并行的
			{
				D[i]=B[i];//将B[]的前5000个数放入D[]
				E[i]=B[i+5000];//将B[]的后5000个数放入E[]
			}
		}
		#pragma omp parallel default(none) shared(E,D,short_len) //private(i)------快速排序的并行region
		{
			#pragma omp parallel sections
			{
				#pragma omp section
					quicksort(D, 0, short_len-1);//对D[]排序
				#pragma omp section
					quicksort(E, 0, short_len-1);//对E[]排序
			}
		}
		for(;k<len;k++)//----------将D[]和E[]进行归并排序放入B[]里面
		{
		if(m<short_len && n<short_len)
		{
			if(D[n]<=E[m])
			{
				B[k] = D[n];
				n++;
			}
			else
			{
				B[k]=E[m];
				m++;
			}
		}
			if(m==short_len || n==short_len)
			{
				if(m==short_len)
				B[k]=E[m];
				else
				B[k]=D[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]=D[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]=E[m];
			m++;
			k++;
		}
		}//----------------------------归并算法结束
		clock_t end = clock();//----------------计时结束点
		cost = (double)(end - begin);
		cout<<"并行时间"<<cost<<endl;
		//串行开始
		begin=clock();
		quicksort(C, 0, len-1);
		end = clock();
		cost = (double)(end - begin);
		cout<<"串行时间"<<cost<<endl;
		system("pause");
		}