一个有错误的并行排序算法，先存上

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "omp.h"




using namespace std;


int check(int* vals, int N)
{
    int err = 0;
    for (int i = 1; i < N; i++)
        if (vals[i - 1] > vals[i])
        {
            cout << vals[i-1] << " " << vals[i] << endl;
            err++;
        }
    return err;
}


//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);
}
int 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, j) 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[]排序
        }
    }
    cout << endl;


//    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();//----------------计时结束点
    cout << check(B, j) << endl;
    cost = (double)(end - begin) / CLOCKS_PER_SEC;
    printf("%lf seconds/n", cost);//输出运行interval
    system("pause");
    return 0;
}