Upload files to "array"

array/arraytools.h

@@ -0,0 +1,200 @@
+/*
+AUTORE: Manuel Vichi
+Array Tools
+*/
+#include <iostream>
+#include <array>
+#include <vector>
+#include <cstdlib>
+using namespace std;
+void insertionSort(int arr[], int n)
+{
+    for (int i = 1; i < n; ++i) {
+        int key = arr[i];
+        int j = i - 1;
+
+        /* Move elements of arr[0..i-1], that are
+           greater than key, to one position ahead
+           of their current position */
+        while (j >= 0 && arr[j] > key) {
+            arr[j + 1] = arr[j];
+            j = j - 1;
+        }
+        arr[j + 1] = key;
+    }
+}
+vector<int> countSort(vector<int>& inputArray)
+{
+
+    int N = inputArray.size();
+
+    // Finding the maximum element of array inputArray[].
+    int M = 0;
+
+    for (int i = 0; i < N; i++)
+        M = max(M, inputArray[i]);
+
+    // Initializing countArray[] with 0
+    vector<int> countArray(M + 1, 0);
+
+    // Mapping each element of inputArray[] as an index
+    // of countArray[] array
+
+    for (int i = 0; i < N; i++)
+        countArray[inputArray[i]]++;
+
+    // Calculating prefix sum at every index
+    // of array countArray[]
+    for (int i = 1; i <= M; i++)
+        countArray[i] += countArray[i - 1];
+
+    // Creating outputArray[] from countArray[] array
+    vector<int> outputArray(N);
+
+    for (int i = N - 1; i >= 0; i--)
+
+    {
+        outputArray[countArray[inputArray[i]] - 1]
+            = inputArray[i];
+
+        countArray[inputArray[i]]--;
+    }
+
+    return outputArray;
+}
+void selectionSort(vector<int> &arr) {
+    int n = arr.size();
+
+    for (int i = 0; i < n - 1; ++i) {
+
+        // Assume the current position holds
+        // the minimum element
+        int min_idx = i;
+
+        // Iterate through the unsorted portion
+        // to find the actual minimum
+        for (int j = i + 1; j < n; ++j) {
+            if (arr[j] < arr[min_idx]) {
+
+                // Update min_idx if a smaller
+                // element is found
+                min_idx = j; 
+            }
+        }
+
+        // Move minimum element to its
+        // correct position
+        swap(arr[i], arr[min_idx]);
+    }
+}
+int partition(vector<int>& arr, int low, int high) {
+  
+    // Choose the pivot
+    int pivot = arr[high];
+  
+    // Index of smaller element and indicates 
+    // the right position of pivot found so far
+    int i = low - 1;
+
+    // Traverse arr[;ow..high] and move all smaller
+    // elements on left side. Elements from low to 
+    // i are smaller after every iteration
+    for (int j = low; j <= high - 1; j++) {
+        if (arr[j] < pivot) {
+            i++;
+            swap(arr[i], arr[j]);
+        }
+    }
+    
+    // Move pivot after smaller elements and
+    // return its position
+    swap(arr[i + 1], arr[high]);  
+    return i + 1;
+}
+
+// The QuickSort function implementation
+void quickSort(vector<int>& arr, int low, int high) {
+  
+    if (low < high) {
+      
+        // pi is the partition return index of pivot
+        int pi = partition(arr, low, high);
+
+        // Recursion calls for smaller elements
+        // and greater or equals elements
+        quickSort(arr, low, pi - 1);
+        quickSort(arr, pi + 1, high);
+    }
+}
+void bubbleSort(vector<int>& arr) {
+    int n = arr.size();
+    bool swapped;
+  
+    for (int i = 0; i < n - 1; i++) {
+        swapped = false;
+        for (int j = 0; j < n - i - 1; j++) {
+            if (arr[j] > arr[j + 1]) {
+                swap(arr[j], arr[j + 1]);
+                swapped = true;
+            }
+        }
+      
+        // If no two elements were swapped, then break
+        if (!swapped)
+            break;
+    }
+}
+void CocktailSort(int a[], int n)
+{
+    bool swapped = true;
+    int start = 0;
+    int end = n - 1;
+ 
+    while (swapped) {
+        // reset the swapped flag on entering
+        // the loop, because it might be true from
+        // a previous iteration.
+        swapped = false;
+ 
+        // loop from left to right same as
+        // the bubble sort
+        for (int i = start; i < end; ++i) {
+            if (a[i] > a[i + 1]) {
+                swap(a[i], a[i + 1]);
+                swapped = true;
+            }
+        }
+ 
+        // if nothing moved, then array is sorted.
+        if (!swapped)
+            break;
+ 
+        // otherwise, reset the swapped flag so that it
+        // can be used in the next stage
+        swapped = false;
+ 
+        // move the end point back by one, because
+        // item at the end is in its rightful spot
+        --end;
+ 
+        // from right to left, doing the
+        // same comparison as in the previous stage
+        for (int i = end - 1; i >= start; --i) {
+            if (a[i] > a[i + 1]) {
+                swap(a[i], a[i + 1]);
+                swapped = true;
+            }
+        }
+ 
+        // increase the starting point, because
+        // the last stage would have moved the next
+        // smallest number to its rightful spot.
+        ++start;
+    }
+}
+void printArray(int a[], int n)
+{
+    for (int i = 0; i < n; i++)
+        printf("%d ", a[i]);
+    printf("\n");
+}