- Related Questions & Answers
- Java Program for Bitonic Sort
- Maximum sum bitonic subarray in C++
- Find bitonic point in given bitonic sequence in Python
- Longest Bitonic Subsequence
- Program to find length of longest bitonic subsequence in C++
- Queries on insertion of an element in a Bitonic Sequence in C++
- Sort KeyValuePairs in C#
- Insertion Sort in C#
- Heap Sort in C#
- Strand sort in C++
- Sort List in C++
- Wiggle Sort in C++
- Circle Sort in C++
- C/C++ Program for Odd-Even Sort (Brick Sort)?
- C/C++ Program for the Odd-Even Sort (Brick Sort)?

- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who

The bitonic sort is a parallel sorting algorithm that is created for best implementation and has optimum usage with hardware and *parallel processor array*.

It is not the most effective one though as compared to the merge sort. But it is good for parallel implementation. This is due to the predefined comparison sequence which makes comparisons independent of data that are to be sorted.

For bitonic sort to work effectively the number of elements should be in a specific type of quantity i.e. the order **2^n**.

One major part of the bitonic sort is the bitonic sequence which is a sequence whose elements value *first increases* and then *decreases*.

**Bitonic sequence** is an array arr[0 … (n-1)] if there is an index value i within the range 0 to n-1. For which the value of arr[i] is greatest in the array. i.e.

arr[0] <= arr[1] … <= arr[i] and arr[i] >= arr[i+1] … >= aar[n-1]

Bitonic sequence can be rotated back to bitonic sequence.

A sequence with elements in increasing and decreasing order is a bitonic sequence.

For creating a bitonic sequence, we will create two sub-sequences, one with ascending elements and other with descending elements.

For example, let’s see the sequence arr[] and convert the following sequence to a bitonic sequence.

arr[] = {3, 4, 1, 9, 2, 7, 5, 6}

First, we will make pairs of elements and then create a bitonic sequence of these in such a way that one is in ascending order and the other is in descending order and so on.

For our array, let’s create pairs in bitonic sequence.

arr[] = {(3, 4), (1, 9), (2, 7), (5, 6)} // creating bitonic sequence pairs… arr[] = {(3, 4), (9, 1), (2, 7), (6, 5)}

Then, we will create pairs of these pairs. i.e 4 elements bitonic sequence and compare elements with are a 2 distance [i.e. i with i+2].

arr[] = {(3, 4, 9, 1), (2, 7, 6, 5)}

Ascending bitonic in first set will be created as −

(3, 4, 9, 1) : comparing two distant elements. (3, 1, 9, 4) : Now, check adjacent elements. (1, 3, 4, 9) -> ascending bitonic sequence.

Descending bitonic in second set will be created as −

(2, 7, 6, 5) : comparing two distant elements. (6, 7, 2, 5) : Now, check adjacent elements. (7, 6, 5, 2) -> descending bitonic sequence.

At the end, we will get the bitonic sequence of size 8.

1, 3, 4, 9, 7, 6, 5, 2

Now, since we have learned about the bitonic sequence. We will know about the *Bitonic Sorting*.

To sort a bitonic sequence using bitonic sorting using these steps −

**Step 1** − Create a bitonic sequence.

**Step 2** − Now, we have a bitonic sequence with one part in increasing order and others in decreasing order.

**Step 3** − We will compare and swap the first elements of both halves. Then second, third, fourth elements for them.

**Step 4** − We will compare and swap, every second element of the sequence.

**Step 5** − At last, we will compare and swap adjacent elements of the sequence.

**Step 6** − After all swaps, we will get the sorted array.

Program to show the implementation of Bitonic Sort −

#include<iostream> using namespace std; void bitonicSeqMerge(int a[], int start, int BseqSize, int direction) { if (BseqSize>1){ int k = BseqSize/2; for (int i=start; i<start+k; i++) if (direction==(a[i]>a[i+k])) swap(a[i],a[i+k]); bitonicSeqMerge(a, start, k, direction); bitonicSeqMerge(a, start+k, k, direction); } } void bitonicSortrec(int a[],int start, int BseqSize, int direction) { if (BseqSize>1){ int k = BseqSize/2; bitonicSortrec(a, start, k, 1); bitonicSortrec(a, start+k, k, 0); bitonicSeqMerge(a,start, BseqSize, direction); } } void bitonicSort(int a[], int size, int up) { bitonicSortrec(a, 0, size, up); } int main() { int a[]= {5, 10, 51, 8, 1, 9, 6, 22}; int size = sizeof(a)/sizeof(a[0]); printf("Original array: \n"); for (int i=0; i<size; i++) printf("%d\t", a[i]); bitonicSort(a, size, 1); printf("\nSorted array: \n"); for (int i=0; i<size; i++) printf("%d\t", a[i]); return 0; }

Original array: 5 10 51 8 1 9 6 22 Sorted array: 1 5 6 8 9 10 22 51

Advertisements