Demonstration/explanation of Bitonic Sort Algorithm

is a comparison-based parallel algorithm for
sorting. It’s basically based on what is called
the Bitonic seuence.
Bitonic Sort Algorithm

Advantages include its parallelism
and suitability for large datasets.
Limitations include the requirement for
input sizes to be powers (2n
) of two and
its potentially slower performance on
regular CPUs compared to other sorting
algorithms.
Bitonic Sort Algorithm

Parallel Sorting algorithms are designed
to Perform many comparisons in
parallel, Data distributed among multiple
processors.
They can be used to solve a wide range
of problems, including sorting,
searching, matrix multiplication, and
more.
Parallel Algorithms

l . Concurrency
2. Divide and Conquer
3. Efﬁcient Scaling with more
processing units
Key Features

deﬁnition: series of numbers that is ﬁrst increasing, and then decreasing
Bitonic Sort relies on the concept of Bitonic Sequences as its fundamental building block.
The sorting process in Bitonic Sort works by repeatedly merging or sorting smaller Bitonic
Sequences.
Examples:
Ascending Bitonic Sequence: [1, 3, 5, 7, 9, 8, 6, 4, 2]
Descending Bitonic Sequence: [8, 6, 4, 2, 1
, 3, 5, 7, 9]
Bitonic Sequence with Multiple Bitonic Points: [2, 5, 8, 7, 6, 9, 10, 4, 3, 1
]
Bitonic Sequence

Initialization (Divide into smaller
bitonic sequences)
Bitonic Merge (compare and swap
elements to ensure the bitonic
pattern) Final Merge (Perform a ﬁnal
bitonic merge to create a fully sorted
sequence.
Steps of the Algorithm

Example:
Array: [8 3 4 9 6 2 1 7]
Divide: [[8 3 4 9]a [6 2 1 7]d]a
Divide [[[8 3]a [4 9]d]a [[6 2]a [1 7]d]d]a
Divide [[[[8] [3]]a [[4] [9]]d]a [[[6] [2]]a [[1] [7]]d]d]a
Merge each 2: [[[3 8]a [9 4]d]a [[2 6]a [7 1]d]d]a
Merge each 4: [[[3 4] [9 8]]a [[7 6] [2 1]]d]a
Merge the whole: [[3 4 8 9]a [7 6 2 1]d]a
Result: [[3 4 2 1] [7 6 8 9]]a
Merge each 4: [[[2 1] [3 4]] [[7 6] [8 9]]]a
Merge each 2: [[[1 2] [3 4]] [[6 7] [8 9]]]a
Result: [1 2 3 4 6 7 8 9]a

Pseudo Code
function BitonicSort(arr, low, cnt, direction):
if cnt > 1:
k = cnt / 2
Async BitonicSort(arr, low, k, true)
Async BitonicSort(arr, low + k, k, false)
BitonicMerge(arr, low, cnt, direction)
function BitonicMerge(arr, low, cnt, direction):
if cnt > 1:
k = cnt / 2
for i in range(low, low + k):
if (arr[i] > arr[i + k]) ==
direction:
swap(arr[i], arr[i +
k])
Async BitonicMerge(arr, low, k, direction)

Analysis
function BitonicSort(arr, low, cnt, direction): // T(n)
if cnt > 1:
k = cnt / 2;
BitonicSort(arr, low, k, true); //T(n/2)
BitonicSort(arr, low + k, k, false); //T(n/2)
BitonicMerge(arr, low, cnt, direction); //C(n)

Analysis
function BitonicMerge(arr, low, cnt, direction): // C(n)
if cnt > 1: k = cnt / 2;
for i in range(low, low + k): // n/2
if (arr[i] > arr[i + k]) == direction:
swap(arr[i], arr[i + k]);
BitonicMerge(arr, low, k, direction); // C(n/2)
BitonicMerge(arr, low + k, k, direction); // C(n/2)

Analysis
Basic Operation: Key Comparison, T(n) = # of key comparisons
Input Size: n
T(n) = T(n/2) + T(n/2) + C(n) // n > 1, for n = 1 -> T(n) = 0
T(n) = 2T(n/2) + n/2 * log(n) // n/2 comparisons occurs log(n) times
Let n = 2k
, take the log -> k = log(n)
T(2k
) = 2T(2k
/ 2) + (2k
/ 2) * k
= 2T(2k-1
) + (2k-1
) * k
= 2[2T(2k-2
) + (2k-2
) * k] + (2k-1
) * k
= 22
T(2k-2
) + (2k-1
) * k + (2k-1
) * k
= 22
T(2k-2
) + 2 * [(2k-1
) * k]

Analysis
T(2k
) = 22
T(2k-2
) + 2 * [(2k-1
) * k]
= 22
[2T(2k-3
) + (2k-3
) * k] + 2 * [(2k-1
) * k]
= 23
T(2k-3
) + (2k-1
) * k + 2 * [(2k-1
) * k]
= 23
T(2k-3
) + 3 * [(2k-1
) * k]
= 2i
T(2k-i
) + i * [(2k-1
) * k]
Let i = k =>
= 2k
T(1) + k2
* 2k-1
// for T(1) no comparisons, T(1) = 0
= k2
* 2k-1

Analysis
T(2k
) = k2
* 2k-1
T(n) = log2
(n) * n/2 // from [Let n = 2k
-> k = log(n)]
T(n) = O(n*log2
(n)) // in best, average and worst

BitonicSort: comparison-based
sorting algorithm which sorts a
data-set by converting the list of
numbers into a bitonic sequence.
A series of numbers which
monotonically increases,
then decreases
The list is then sorted using
a merge
Conclusion

Demonstration/explanation of Bitonic Sort Algorithm

Recommended

More Related Content

Similar to Demonstration/explanation of Bitonic Sort Algorithm (20)

Recently uploaded (20)

Demonstration/explanation of Bitonic Sort Algorithm