Non-Repeating Elements of a given array using Multithreaded program

// C++ program to implement
// the above approach

#include <bits/stdc++.h>
#include <pthread.h>
using namespace std;

// Structure of subarray 
// of the array
struct range_info {

    // Stores start index
    // of the subarray
    int start;

    // Stores end index
    // of the subarray
    int end;

    // Stores pointer to the
    // first array element
    int* a;
};


// Declaring map, and mutex for
// thread exclusion(lock)
map<int, int> mp;
pthread_mutex_t lock1;


// Function performed by every thread to
// count the frequency of array elements
// in current subarray
void* func(void* arg)
{
    // Taking a lock so that threads
    // do not overlap each other
    pthread_mutex_lock(&lock1);
    
    
    // Initialize range_info 
    // for each thread
    struct range_info* rptr 
    = (struct range_info*)arg;


    // Thread is going through the array
    // to check and update the map
    for (int i = rptr->start; 
            i <= rptr->end; i++) {
                    
        
        // Stores iterator to the map         
        map<int, int>::iterator it;
        
        
        // Update it
        it = mp.find(rptr->a[i]);
        
        
        // If rptr->a[i] not found
        // in map mp
        if (it == mp.end()) {
            
            
            // Insert rptr->a[i] with 
            // frequency 1
            mp.insert({ rptr->a[i], 1 });
        }
        else {
            
            
            // Update frequency of
            // current element
            it->second++;
        }
    }
    

    // Thread releases the lock
    pthread_mutex_unlock(&lock1);
    return NULL;
}


// Function to find the unique
// numbers in the array
void numbers_occuring_once(int arr[],
                        int N, int T)
{
    // Stores all threads
    pthread_t threads[T];

    // Stores start index of
    // first thread
    int spos = 0;

    // Stores last index 
    // of the first thread
    int epos = spos + (N / T) - 1;

    // Traverse each thread
    for (int i = 0; i < T; i++) {

        // Initialize range_info for
        // current thread
        struct range_info* rptr
            = (struct range_info*)malloc(
                sizeof(struct range_info));

        // Update start index of
        // current subarray     
        rptr->start = spos;

        // Stores end index of
        // current subarray
        rptr->end = epos;

        // Update pointer to the first
        // element of the array
        rptr->a = arr;
        
        
        // creating each thread with 
        // appropriate parameters
        int a
        = pthread_create(&threads[i], NULL,
                        func, (void*)(rptr));
                        
                        
        // updating the parameters 
        // for the next thread
        spos = epos + 1;
        epos = spos + (N / T) - 1;
        if (i == T - 2) {
            epos = N - 1;
        }
    }

    // Waiting for threads to finish
    for (int i = 0; i < T; i++) {
        int rc 
        = pthread_join(threads[i], NULL);
    }

    // Traverse the map
    for (auto it: mp) {
                
                
                                    
    // If frequency of current 
    // element is 1                             
        if (it.second == 1) {

            // Print the element
            cout << it.first << " ";
        }
    }
}


// Drivers Code
int main()
{
    // initializing the mutex lock 
    pthread_mutex_init(&lock1, NULL);
    int T = 3;
    int arr[] = { 1, 0, 5, 5, 2, 6 };
    int N = sizeof(arr) / sizeof(arr[0]);
    numbers_occuring_once(arr, N, T);
}