Add files via upload

Author: anandcool678

1_BFS_DFS.cpp

@@ -0,0 +1,85 @@
+#include <iostream>
+#include <vector>
+#include <queue>
+#include <omp.h>
+
+using namespace std;
+
+// Graph class representing the adjacency list
+class Graph {
+    int V;  // Number of vertices
+    vector<vector<int>> adj;  // Adjacency list
+
+public:
+    Graph(int V) : V(V), adj(V) {}
+
+    
+    void addEdge(int v, int w) {
+        adj[v].push_back(w);
+    }
+
+    // Parallel Depth-First Search
+    void parallelDFS(int startVertex) {
+        vector<bool> visited(V, false);
+        parallelDFSUtil(startVertex, visited);
+    }
+
+    // Parallel DFS utility function
+    void parallelDFSUtil(int v, vector<bool>& visited) {
+        visited[v] = true;
+        cout << v << " ";
+
+        #pragma omp parallel for
+        for (int i = 0; i < adj[v].size(); ++i) {
+            int n = adj[v][i];
+            if (!visited[n])
+                parallelDFSUtil(n, visited);
+        }
+    }
+
+    // Parallel Breadth-First Search
+    void parallelBFS(int startVertex) {
+        vector<bool> visited(V, false);
+        queue<int> q;
+
+        visited[startVertex] = true;
+        q.push(startVertex);
+
+        while (!q.empty()) {
+            int v = q.front();
+            q.pop();
+            cout << v << " ";
+
+            #pragma omp parallel for
+            for (int i = 0; i < adj[v].size(); ++i) {
+                int n = adj[v][i];
+                if (!visited[n]) {
+                    visited[n] = true;
+                    q.push(n);
+                }
+            }
+        }
+    }
+};
+
+int main() {
+    // Create a graph
+    Graph g(7);
+    g.addEdge(0, 1);
+    g.addEdge(0, 2);
+    g.addEdge(1, 3);
+    g.addEdge(1, 4);
+    g.addEdge(2, 5);
+    g.addEdge(2, 6);
+    
+
+    cout << "Depth-First Search (DFS): ";
+    g.parallelDFS(0);
+    cout << endl;
+
+    cout << "Breadth-First Search (BFS): ";
+    g.parallelBFS(0);
+    cout << endl;
+
+    return 0;
+}

2_parallel.cpp

@@ -0,0 +1,156 @@
+#include <bits/stdc++.h>
+#include<omp.h>
+using namespace std;
+void bubble(int array[], int n){
+    for (int i = 0; i < n - 1; i++){
+        for (int j = 0; j < n - i - 1; j++){
+            if (array[j] > array[j + 1]) swap(array[j], array[j + 1]);
+        }
+    }
+}
+void parallel_bubblesort(int array[], int n) {
+    for (int i = 0; i < n; i++)
+    {
+        int first = i % 2;
+        // defining the shared data source for parallel execution.
+        #pragma omp parallel for shared (array, first) num_threads(16)
+        for (int j = first; j < n - 1; j += 2)
+            if (array[j] > array[j + 1])
+                swap(array[j], array[j + 1]);
+    }
+    return;
+}
+void merge(int arr[], int low, int mid, int high) {
+    // Create arrays of left and right partititons
+    int n1 = mid - low + 1;
+    int n2 = high - mid;
+
+    int left[n1];
+    int right[n2];
+    
+    // Copy all left elements
+    for (int i = 0; i < n1; i++) left[i] = arr[low + i];
+    
+    // Copy all right elements
+    for (int j = 0; j < n2; j++) right[j] = arr[mid + 1 + j];
+    
+    // Compare and place elements
+    int i = 0, j = 0, k = low;
+
+    while (i < n1 && j < n2) {
+        if (left[i] <= right[j]){
+            arr[k] = left[i];
+            i++;
+        } 
+        else{
+            arr[k] = right[j];
+            j++;
+        }
+        k++;
+    }
+
+    // If any elements are left out
+    while (i < n1) {
+        arr[k] = left[i];
+        i++;
+        k++;
+    }
+
+    while (j < n2) {
+        arr[k] = right[j];
+        j++;
+        k++;
+    }
+}
+void mergeSort(int arr[], int low, int high) {
+    if (low < high) {
+        int mid = (low + high) / 2;
+        mergeSort(arr, low, mid);
+        mergeSort(arr, mid + 1, high);
+        merge(arr, low, mid, high);
+    }
+}
+
+void parallelMergeSort(int arr[], int low, int high) {
+    if (low < high) {
+        int mid = (low + high) / 2;
+
+        #pragma omp parallel sections
+        {
+            #pragma omp section
+            {
+                mergeSort(arr, low, mid);
+            }
+
+            #pragma omp section
+            {
+                mergeSort(arr, mid + 1, high);
+            }
+        }
+        merge(arr, low, mid, high);
+    }
+}
+int main(){
+    // Set up variables
+    int n = 100000;
+    int arr[n];
+    int brr[n],crr[n],drr[n];
+    double start_time, end_time;
+    // Create an array with random numbers
+    for(int i = 0, j = n; i < n; i++, j--){
+    		arr[i] = 1 + (rand() % 1000);
+    		brr[i]=arr[i];
+            crr[i]=arr[i];
+            drr[i]=arr[i];
+    }
+    bool flag = true;
+    while(flag){
+        cout << "-------------------------- Menu -------------------------------\n";
+        cout << "1. Bubble Sort   \n" ;
+        cout << "2. Merge Sort \n" << endl;
+        cout << "3. Exit \n";
+        cout << "---------------------------------------------------------------\n";
+        int choice =-1;
+        cout<<"Enter your choice: ";
+        cin>>choice;
+        switch(choice)
+        {
+            case 1:
+                cout << "Bubble Sort\n";
+                // Sequential time
+                start_time = omp_get_wtime();
+                bubble(arr, n);
+                end_time = omp_get_wtime();     
+                cout << "Sequential Bubble Sort took : " << end_time - start_time << " seconds.\n";
+                
+                // Parallel time
+                start_time = omp_get_wtime();
+                parallel_bubblesort(brr, n);
+                end_time = omp_get_wtime();     
+                cout << "Parallel Bubble Sort took : " << end_time - start_time << " seconds.\n";
+                break;
+            case 2:
+                cout << "Merge Sort\n";
+                // Sequential time
+                start_time = omp_get_wtime();
+                mergeSort(crr, 0, n - 1);
+                end_time = omp_get_wtime();     
+                cout << "Sequential Merge Sort took : " << end_time - start_time << " seconds.\n";
+                
+                // Parallel time
+                start_time = omp_get_wtime();
+                parallelMergeSort(drr, 0, n - 1);
+                end_time = omp_get_wtime();     
+                cout << "Parallel Merge Sort took : " << end_time - start_time << " seconds.\n";
+                break;
+            case 3:
+                flag = false;
+                break;
+            default:
+                cout<<"Invalid choice\n";
+                break;
+        }
+    }
+    return 0;
+    
+}   

3_parallel_reduction.cpp

@@ -0,0 +1,88 @@
+
+#include<bits/stdc++.h>
+#include<omp.h>
+
+using namespace std;
+// Function to find the minimum value in the array
+int minval(int arr[], int n){
+  int minval = arr[0];
+  #pragma omp parallel for reduction(min : minval)
+    for(int i = 0; i < n; i++){
+      if(arr[i] < minval) minval = arr[i];
+    }
+  return minval;
+}
+// Function to find the maximum value in the array
+int maxval(int arr[], int n){
+  int maxval = arr[0];
+  #pragma omp parallel for reduction(max : maxval)
+    for(int i = 0; i < n; i++){
+      if(arr[i] > maxval) maxval = arr[i];
+    }
+  return maxval;
+}
+// Function to find the sum of the elements in the array
+int sum(int arr[], int n){
+  int sum = 0;
+  #pragma omp parallel for reduction(+ : sum)
+    for(int i = 0; i < n; i++){
+      sum += arr[i];
+    }
+  return sum;
+}
+// Function to find the average of the elements in the array
+int average(int arr[], int n){
+  return (double)sum(arr, n) / n;
+}
+
+int main(){
+  
+  int n;
+  cout<<"Enter the number of elements: ";
+  cin>>n;
+  int arr[n];
+  cout<<"Enter the elements: ";
+  for(int i=0;i<n;i++){
+    arr[i] = 1 + (rand() % n);
+  }
+  bool flag = true;
+  while(flag){
+     cout << "-------------------------- Menu -------------------------------"  << endl;
+      cout << "1. Sequential \n";
+      cout << "2. Parallel\n";
+      cout<< "3. Exit\n";
+      cout << "---------------------------------------------------------------"  << endl;
+      int choice =-1;
+      cout<<"Enter your choice: ";
+      cin>>choice;
+      double start_time = omp_get_wtime();
+      switch(choice){
+        case 1:
+          {cout<<"Sequential\n";
+          cout << "The minimum value is: " << *min_element(arr,arr+ n) << '\n';
+          cout<< "The maximum value is: "<< *max_element(arr,arr+n) << '\n';
+          int sum1=0;
+          for(int i=0;i<n;i++){
+            sum1+=arr[i];
+          }
+          cout<<"The summation is: "<<sum1<<'\n';
+          cout<<"The average is: "<<(double)sum1/(double)n<<'\n';
+          break;}
+        case 2:
+          {cout<<"Parallel\n";
+          cout<<"The minimum value is: "<<minval(arr,n)<<'\n';
+          cout << "The maximum value is: " << maxval(arr, n) << '\n';
+          cout << "The summation is: " << sum(arr, n) << '\n';
+          cout << "The average is: " << average(arr, n) << '\n';
+          break;}
+        case 3:
+          flag = false;
+          break;
+        default:
+          cout << "Invalid choice\n";
+      }
+      double end_time = omp_get_wtime();
+      cout<<"Time taken: "<<end_time-start_time<<" seconds\n";
+  }
+  return 0;
+}