双调排序

双调排序是一种并行排序算法执行O(N 2 log n)的比较。 虽然比较的数量多于任何其他流行的排序算法，但它对并行实现的效果更好，因为元素以预定义的顺序进行比较，而这些序列不能依赖于被排序的数据。预定义的序列称为双调(Bitonic)序列。

1. 什么是双调(Bitonic)序列？

要理解双调排序，需要首先来了解双调序列。 双调序列是其中元素首先按递增顺序然后在某个特定索引之后开始递减的序列。 如果存在索引i，则数组A [0 ... i ... n-1]称为双调，

A[0] < A[1] < A[2] .... A[i-1] < A[i] > A[i+1] > A[i+2] > A[i+3] > ... >A[n-1]

其中，0 <= i <= n-1。双调排序的旋转也是双调。

如何将随机序列转换为双调序列？

考虑n个元素的序列A[0 ... n-1]。 首先通过使用序列的4个元素开始构建双调序列。 按升序对前2个元素进行排序，按降序对最后2个元素进行排序，将该对连接起来形成4个元素的双调序列。 对剩余的元素对重复此过程，直到找到双调序列。

在此步骤之后，得到给定序列的双调序列为：2,10,20,30,5,5,4,3。

2. 双调排序

双调排序主要涉及以下几个基本步骤。

• 在上述步骤中形成的给定随机序列形成一个双调序列。 可以将其视为程序的第一步。 在这一步之后，得到一个序列，其前半部分按升序排序，而第二步按降序排序。
• 将前半部分的第一个元素与后半部分的第一个元素进行比较，然后将前半部分的第二个元素与后半部分的第二个元素进行比较，依此类推。 如果发现后半部分中的任何元素较小，则交换元素。
• 在上面的步骤之后，得到的前半部分中的所有元素都小于下半部分中的所有元素。 比较和交换产生每个n/2长度的两个序列。 在第二步中递归地重复执行到每个序列的过程，直到得到长度为n的单个排序序列。

复杂性

复杂性	最好情况	平均情况	最坏情况
时间复杂性	O(log^2 n)	O(log^2 n)	O(log^2 n)
空间复杂性	-	-	O(log^2 n)

使用C语言实现双调排序的代码如下 -

//this program works when size of input is power of 2.   
#include<stdio.h>  
void exchange(int arr[], int i, int j, int d)  
{  
    int temp;  
    if (d==(arr[i]>arr[j]))  
    {  
            temp = arr[i];  
        arr[i] = arr[j];  
        arr[j] = temp;  
    }  
}  
void merge(int arr[], int l, int c, int d)  
{  
    int k,i;  
    if (c>1)  
    {  
        k = c/2;  
        for (i=l; i<l+k; i++)  
            exchange(arr, i, i+k, d);  
        merge(arr, l, k, d);  
        merge(arr, l+k, k, d);  
    }  
}  
void bitonicSort(int arr[],int l, int c, int d)  
{  
    int k;  
    if (c>1)  
    {  
        k = c/2;  
        bitonicSort(arr, l, k, 1);  
        bitonicSort(arr, l+k, k, 0);  
        merge(arr,l, c, d);  
    }  
}  

void sort(int arr[], int n, int order)  
{  
    bitonicSort(arr,0, n, order);  
}  
int main()  
{  
    int arr[]= {1, 10, 2, 3, 1, 23, 45, 21};  
    int n = sizeof(arr)/sizeof(arr[0]);  
    int i;  
    int order = 1;     
    sort(arr, n, order);  

    printf("Sorted array: \n");  
    for (i=0; i<n; i++)  
        printf("%d ", arr[i]);  
}

C

执行上面示例代码，得到以下结果：

Sorted array: 
1 1 2 3 10 21 23 45

Shell

使用Java语言实现双调排序的代码如下 -

//this program works when size of input is power of 2.   
public class BitonicSort  
{  
    static void exchange(int arr[], int i, int j, boolean d)  
    {  
        int temp;  
        if (d==(arr[i]>arr[j]))  
        {  
                temp = arr[i];  
            arr[i] = arr[j];  
            arr[j] = temp;  
        }  
    }  
    static void merge(int arr[], int l, int c, boolean d)  
    {  
        int k,i;  
        if (c>1)  
        {  
            k = c/2;  
            for (i=l; i<l+k; i++)  
                exchange(arr, i, i+k, d);  
            merge(arr, l, k, d);  
            merge(arr, l+k, k, d);  
        }  
    }  
    static void bitonicSort(int arr[],int l, int c, boolean d)  
    {  
        int k;  
        if (c>1)  
        {  
            k = c/2;  
            bitonicSort(arr, l, k, true);  
            bitonicSort(arr, l+k, k, false);  
            merge(arr,l, c, d);  
        }  
    }  

    static void sort(int arr[], int n, boolean order)  
    {  
        bitonicSort(arr,0, n, order);  
    }  
    public static void main(String[] args)  
    {  
        int arr[]= {1, 10, 2, 3, 1, 23, 45, 21};  
        int n = arr.length;  
        int i;  
        boolean order = true;     
        sort(arr, n, order);  

        System.out.println("Sorted array: \n");  
        for (i=0; i<n; i++)  
            System.out.println(arr[i]);  
    }  
}

Java

执行上面示例代码，得到以下结果：

Sorted array: 

1    1    2    3    10    21    23    45

Shell

使用C#语言实现双调排序的代码如下 -

//this program works when size of input is power of 2.   
using System;  
public class BitonicSort  
{  
    static void exchange(int[] arr, int i, int j, bool d)  
    {  
        int temp;  
        if (d==(arr[i]>arr[j]))  
        {  
                temp = arr[i];  
            arr[i] = arr[j];  
            arr[j] = temp;  
        }  
    }  
    static void merge(int[] arr, int l, int c, bool d)  
    {  
        int k,i;  
        if (c>1)  
        {  
            k = c/2;  
            for (i=l; i<l+k; i++)  
                exchange(arr, i, i+k, d);  
            merge(arr, l, k, d);  
            merge(arr, l+k, k, d);  
        }  
    }  
    static void bitonicSort(int[] arr,int l, int c, bool d)  
    {  
        int k;  
        if (c>1)  
        {  
            k = c/2;  
            bitonicSort(arr, l, k, true);  
            bitonicSort(arr, l+k, k, false);  
            merge(arr,l, c, d);  
        }  
    }  

    static void sort(int[] arr, int n, bool order)  
    {  
        bitonicSort(arr,0, n, order);  
    }  
    public void Main()  
    {  
        int[] arr= {1, 10, 2, 3, 1, 23, 45, 21};  
        int n = arr.Length;  
        int i;  
        bool order = true;     
        sort(arr, n, order);  

        Console.WriteLine("Sorted array: \n");  
        for (i=0; i<n; i++)  
            Console.WriteLine(arr[i]+"  ");  
    }  
}