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 Program for Odd-Even Transpostion sort 
// using pthreads 
  
#include <bits/stdc++.h> 
#include <pthread.h> 
  
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 ((a[index] > a[index + 1]) && (index + 1 < n)) { 
        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; 
} 

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).

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

My Personal Notes

Recommended Posts: