下面我们看看这个算法是怎么描述的，既然是奇偶，肯定跟位数有关了
1：先将待排序数组的所有奇数位与自己身后相邻的偶数位相比较，如果前者大于后者，则进行交换，直到这一趟结束。
2：然后将偶数位与自己身后相邻的奇数位相比较，如果前者大于后者，则进行交换，直到这一趟结束。
3：重复1，2的步骤，直到发现无“奇偶”，“偶奇” 交换的时候，就认为排序完毕，此时退出循环。

① 待排序数组：                                                   9  2  1  6  0  7

② 所有奇数位与身后的相邻的偶数位比较交换       2  9  1  6  0  7

③ 所有偶数位与身后的相邻的奇数位比较交换       2  1  9  0  6  7

④ 所有奇数位与身后的相邻的偶数位比较交换       1  2  0  9  6  7

⑤ 所有偶数位与身后的相邻的奇数位比较交换       1  0  2  6  9  7

⑥ 所有奇数位与身后的相邻的偶数位比较交换       0  1  2  6  7  9

    我们可以看到，经过5趟排序后，我们的数组就排序完毕了，从图中②可以看到，如果每个线程分摊一个奇数位，那交换是不是只要一次就够了呢，可以看到这个算法在多核处理下面还是很有优势的。

最后的运行代码：

#include<stdio.h>
int main()
{
    int a[10],j[10]={0},o[10]={0},m=0,n=0,temp=0,i=0,jcount=0,ocount=0;
    while(scanf("%d %d %d %d %d %d %d %d %d %d",&a[0],&a[1],&a[2],&a[3],&a[4],&a[5],&a[6],&a[7],&a[8],&a[9])!=EOF)
    {
        for(i=0,ocount=0,jcount=0;i<10;i++)
        {
            if(a[i]%2==1)
            {
                j[jcount]=a[i];
                jcount++;
            }
            else
            {
                o[ocount]=a[i];
                ocount++;
            }
        }
        for(m=0;m<jcount;m++)//冒泡
        {
           for(n=0;n<jcount-m-1;n++)
               if(j[n+1]>j[n])
               {
                   temp=j[n];
                   j[n]=j[n+1];
                   j[n+1]=temp;
               }
        }
 
        for(m=0;m<ocount;m++)
            for(n=ocount-1;n-m>0;n--)
            {
                if(o[n]<o[n-1])
                {
                    temp=o[n-1];
                    o[n-1]=o[n];
                    o[n]=temp;
                }
            }
        if(ocount>0)
        {
            for(i=0;i<jcount;i++)
            printf("%d ",j[i]);
            for(i=0;i<ocount-1;i++)
            printf("%d ",o[i]);
            printf("%d",o[ocount-1]);
        }
        else
        {
            for(i=0;i<jcount-1;i++)
            printf("%d ",j[i]);
            printf("%d",j[jcount-1]);
        }
        printf("\n");
    }
    return 0;
}