Odd Even Transposition Sort / Brick Sort using pthreads

Odd-Even Transposition Sort is a parallel sorting algorithm. It is based on the Bubble Sort technique, which compares every 2 consecutive numbers in the array and swap them if first is greater than the second to get an ascending order array. It consists of 2 phases – the odd phase and even phase:

• Odd phase: Every odd indexed element is compared with the next even indexed element(considering 1-based indexing).
• Even phase: Every even indexed element is compared with the next odd indexed element.

This article uses the concept of multi-threading, specifically pthread. In each iteration, every pair of 2 consecutive elements is compared using individual threads executing in parallel as illustrated below. Examples:

```Input: { 2, 1, 4, 9, 5, 3, 6, 10 }
Output: 1, 2, 3, 4, 5, 6, 9, 10

Input: { 11, 19, 4, 20, 1, 22, 25, 8}
Output: 1, 4, 8, 11, 19, 20, 22, 25```

Note: Compile the program using following command on your Linux based system.

`g++ program_name.cpp -pthread`

Below is the implementation of the above topic:

CPP

 `// CPP Program for Odd-Even Transposition sort` `// using pthreads`   `#include ` `#include `   `using` `namespace` `std;`   `// size of array` `#define n 8`   `// maximum number of threads` `int` `max_threads = (n + 1) / 2;`   `int` `a[] = { 2, 1, 4, 9, 5, 3, 6, 10 };` `int` `tmp;`   `// Function to compare and exchange` `// the consecutive elements of the array` `void``* compare(``void``* arg)` `{`   `    ``// Each thread compares` `    ``// two consecutive elements of the array` `    ``int` `index = tmp;` `    ``tmp = tmp + 2;`   `    ``if` `((index + 1 < n) && (a[index] > a[index + 1])) {` `        ``swap(a[index], a[index + 1]);` `    ``}` `}`   `void` `oddEven(pthread_t threads[])` `{` `    ``int` `i, j;`   `    ``for` `(i = 1; i <= n; i++) {` `        ``// Odd step` `        ``if` `(i % 2 == 1) {` `            ``tmp = 0;`   `            ``// Creating threads` `            ``for` `(j = 0; j < max_threads; j++)` `                ``pthread_create(&threads[j], NULL, compare, NULL);`   `            ``// joining threads i.e. waiting` `            ``// for all the threads to complete` `            ``for` `(j = 0; j < max_threads; j++)` `                ``pthread_join(threads[j], NULL);` `        ``}`   `        ``// Even step` `        ``else` `{` `            ``tmp = 1;`   `            ``// Creating threads` `            ``for` `(j = 0; j < max_threads - 1; j++)` `                ``pthread_create(&threads[j], NULL, compare, NULL);`   `            ``// joining threads i.e. waiting` `            ``// for all the threads to complete` `            ``for` `(j = 0; j < max_threads - 1; j++)` `                ``pthread_join(threads[j], NULL);` `        ``}` `    ``}` `}`   `// Function to print an array` `void` `printArray()` `{` `    ``int` `i;` `    ``for` `(i = 0; i < n; i++)` `        ``cout << a[i] << ``" "``;` `    ``cout << endl;` `}`   `// Driver Code` `int` `main()` `{`   `    ``pthread_t threads[max_threads];`   `    ``cout << ``"Given array is: "``;` `    ``printArray();`   `    ``oddEven(threads);`   `    ``cout << ``"\nSorted array is: "``;` `    ``printArray();`   `    ``return` `0;` `}`

Python3

 `# Python3 Program for Odd-Even Transposition sort` `# using pthreads` `from` `threading ``import` `Thread`   `# Size of array` `N ``=` `8` `# maximum number of threads` `MAX_THREAD ``=` `int``((N``+``1``)``/``2``)` `arr ``=` `[``2``, ``1``, ``4``, ``9``, ``5``, ``3``, ``6``, ``10``]` `tmp ``=` `0`   `# Function to compare and exchange` `# the consecutive elements of the array` `def` `compare():` `    ``global` `tmp` `    ``# Each thread compares` `    ``# two consecutive elements of the array` `    ``index ``=` `tmp` `    ``tmp ``=` `tmp ``+` `2` `    ``if` `index``+``1` `< N ``and` `arr[index] > arr[index``+``1``]:` `        ``arr[index], arr[index``+``1``] ``=` `arr[index``+``1``], arr[index]`     `def` `createThreads():` `    ``# creating list of size MAX_THREAD` `    ``threads ``=` `list``(``range``(MAX_THREAD))` `    `  `    ``# creating MAX_THEAD number of threads` `    ``for` `index ``in` `range``(MAX_THREAD):` `        ``threads[index] ``=` `Thread(target``=``compare)` `        ``threads[index].start()` `        `  `    ``# Waiting for all threads to finish` `    ``for` `index ``in` `range``(MAX_THREAD):` `        ``threads[index].join()`     `def` `oddEven():` `    ``global` `tmp` `    ``for` `i ``in` `range``(``1``, N``+``1``):` `        ``# Odd Step` `        ``if` `i ``%` `2``:` `            ``tmp ``=` `0` `            ``createThreads()` `        ``# Even Step` `        ``else``:` `            ``tmp ``=` `1` `            ``createThreads()`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:` `    ``print``(``"Given array is : %s"` `%` `arr)` `    ``oddEven()` `    ``print``(``"Sorted array is : %s"` `%` `arr)`

Output:

```Given array is:  2 1 4 9 5 3 6 10
Sorted array is: 1 2 3 4 5 6 9 10```

Time complexity: The time complexity is reduced to O(N) due to parallel computation using threads. Work complexity: The work complexity of this program is O(N) as N/2 number of threads(resources) are being used to sort the array. So, the work-time complexity of the program is O(N^2).

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next