sorting_algorithms_cpp

C++/sorting_algorithms/bubble_sort.cpp

@@ -0,0 +1,37 @@
+// C++ program for implementation
+// of Bubble sort
+#include <bits/stdc++.h>
+using namespace std;
+
+// A function to implement bubble sort
+void bubbleSort(int arr[], int n)
+{
+    int i, j;
+    for (i = 0; i < n - 1; i++)
+
+        // Last i elements are already
+        // in place
+        for (j = 0; j < n - i - 1; j++)
+            if (arr[j] > arr[j + 1])
+                swap(arr[j], arr[j + 1]);
+}
+
+// Function to print an array
+void printArray(int arr[], int size)
+{
+    int i;
+    for (i = 0; i < size; i++)
+        cout << arr[i] << " ";
+    cout << endl;
+}
+
+// Driver code
+int main()
+{
+    int arr[] = {5, 1, 4, 2, 8};
+    int N = sizeof(arr) / sizeof(arr[0]);
+    bubbleSort(arr, N);
+    cout << "Sorted array: \n";
+    printArray(arr, N);
+    return 0;
+}

C++/sorting_algorithms/counting_sort.cpp

@@ -0,0 +1,63 @@
+// C++ Program for counting sort
+#include <bits/stdc++.h>
+#include <string.h>
+using namespace std;
+#define RANGE 255
+
+// The main function that sort
+// the given string arr[] in
+// alphabetical order
+void countSort(char arr[])
+{
+    // The output character array
+    // that will have sorted arr
+    char output[strlen(arr)];
+
+    // Create a count array to store count of individual
+    // characters and initialize count array as 0
+    int count[RANGE + 1], i;
+    memset(count, 0, sizeof(count));
+
+    // Store count of each character
+    for (i = 0; arr[i]; ++i)
+        ++count[arr[i]];
+
+    // Change count[i] so that count[i] now contains actual
+    // position of this character in output array
+    for (i = 1; i <= RANGE; ++i)
+        count[i] += count[i - 1];
+
+    // Build the output character array
+    for (i = 0; arr[i]; ++i)
+    {
+        output[count[arr[i]] - 1] = arr[i];
+        --count[arr[i]];
+    }
+
+    /*
+    For Stable algorithm
+    for (i = sizeof(arr)-1; i>=0; --i)
+    {
+        output[count[arr[i]]-1] = arr[i];
+        --count[arr[i]];
+    }
+
+    For Logic : See implementation
+    */
+
+    // Copy the output array to arr, so that arr now
+    // contains sorted characters
+    for (i = 0; arr[i]; ++i)
+        arr[i] = output[i];
+}
+
+// Driver code
+int main()
+{
+    char arr[] = "geeksforgeeks";
+
+    countSort(arr);
+
+    cout << "Sorted character array is " << arr;
+    return 0;
+}

C++/sorting_algorithms/heap_sort.cpp

@@ -0,0 +1,81 @@
+// C++ program for implementation of Heap Sort
+
+#include <iostream>
+using namespace std;
+
+// To heapify a subtree rooted with node i
+// which is an index in arr[].
+// n is size of heap
+void heapify(int arr[], int N, int i)
+{
+
+    // Initialize largest as root
+    int largest = i;
+
+    // left = 2*i + 1
+    int l = 2 * i + 1;
+
+    // right = 2*i + 2
+    int r = 2 * i + 2;
+
+    // If left child is larger than root
+    if (l < N && arr[l] > arr[largest])
+        largest = l;
+
+    // If right child is larger than largest
+    // so far
+    if (r < N && arr[r] > arr[largest])
+        largest = r;
+
+    // If largest is not root
+    if (largest != i)
+    {
+        swap(arr[i], arr[largest]);
+
+        // Recursively heapify the affected
+        // sub-tree
+        heapify(arr, N, largest);
+    }
+}
+
+// Main function to do heap sort
+void heapSort(int arr[], int N)
+{
+
+    // Build heap (rearrange array)
+    for (int i = N / 2 - 1; i >= 0; i--)
+        heapify(arr, N, i);
+
+    // One by one extract an element
+    // from heap
+    for (int i = N - 1; i > 0; i--)
+    {
+
+        // Move current root to end
+        swap(arr[0], arr[i]);
+
+        // call max heapify on the reduced heap
+        heapify(arr, i, 0);
+    }
+}
+
+// A utility function to print array of size n
+void printArray(int arr[], int N)
+{
+    for (int i = 0; i < N; ++i)
+        cout << arr[i] << " ";
+    cout << "\n";
+}
+
+// Driver's code
+int main()
+{
+    int arr[] = {12, 11, 13, 5, 6, 7};
+    int N = sizeof(arr) / sizeof(arr[0]);
+
+    // Function call
+    heapSort(arr, N);
+
+    cout << "Sorted array is \n";
+    printArray(arr, N);
+}

C++/sorting_algorithms/insertion_sort.cpp

@@ -0,0 +1,49 @@
+// C++ program for insertion sort
+
+#include <bits/stdc++.h>
+using namespace std;
+
+// Function to sort an array using
+// insertion sort
+void insertionSort(int arr[], int n)
+{
+    int i, key, j;
+    for (i = 1; i < n; i++)
+    {
+        key = arr[i];
+        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;
+    }
+}
+
+// A utility function to print an array
+// of size n
+void printArray(int arr[], int n)
+{
+    int i;
+    for (i = 0; i < n; i++)
+        cout << arr[i] << " ";
+    cout << endl;
+}
+
+// Driver code
+int main()
+{
+    int arr[] = {12, 11, 13, 5, 6};
+    int N = sizeof(arr) / sizeof(arr[0]);
+
+    insertionSort(arr, N);
+    printArray(arr, N);
+
+    return 0;
+}

C++/sorting_algorithms/merge_sort.cpp

@@ -0,0 +1,99 @@
+// C++ program for Merge Sort
+#include <iostream>
+using namespace std;
+
+// Merges two subarrays of array[].
+// First subarray is arr[begin..mid]
+// Second subarray is arr[mid+1..end]
+void merge(int array[], int const left, int const mid,
+           int const right)
+{
+    auto const subArrayOne = mid - left + 1;
+    auto const subArrayTwo = right - mid;
+
+    // Create temp arrays
+    auto *leftArray = new int[subArrayOne],
+         *rightArray = new int[subArrayTwo];
+
+    // Copy data to temp arrays leftArray[] and rightArray[]
+    for (auto i = 0; i < subArrayOne; i++)
+        leftArray[i] = array[left + i];
+    for (auto j = 0; j < subArrayTwo; j++)
+        rightArray[j] = array[mid + 1 + j];
+
+    auto indexOfSubArrayOne = 0,   // Initial index of first sub-array
+        indexOfSubArrayTwo = 0;    // Initial index of second sub-array
+    int indexOfMergedArray = left; // Initial index of merged array
+
+    // Merge the temp arrays back into array[left..right]
+    while (indexOfSubArrayOne < subArrayOne && indexOfSubArrayTwo < subArrayTwo)
+    {
+        if (leftArray[indexOfSubArrayOne] <= rightArray[indexOfSubArrayTwo])
+        {
+            array[indexOfMergedArray] = leftArray[indexOfSubArrayOne];
+            indexOfSubArrayOne++;
+        }
+        else
+        {
+            array[indexOfMergedArray] = rightArray[indexOfSubArrayTwo];
+            indexOfSubArrayTwo++;
+        }
+        indexOfMergedArray++;
+    }
+    // Copy the remaining elements of
+    // left[], if there are any
+    while (indexOfSubArrayOne < subArrayOne)
+    {
+        array[indexOfMergedArray] = leftArray[indexOfSubArrayOne];
+        indexOfSubArrayOne++;
+        indexOfMergedArray++;
+    }
+    // Copy the remaining elements of
+    // right[], if there are any
+    while (indexOfSubArrayTwo < subArrayTwo)
+    {
+        array[indexOfMergedArray] = rightArray[indexOfSubArrayTwo];
+        indexOfSubArrayTwo++;
+        indexOfMergedArray++;
+    }
+    delete[] leftArray;
+    delete[] rightArray;
+}
+
+// begin is for left index and end is
+// right index of the sub-array
+// of arr to be sorted */
+void mergeSort(int array[], int const begin, int const end)
+{
+    if (begin >= end)
+        return; // Returns recursively
+
+    auto mid = begin + (end - begin) / 2;
+    mergeSort(array, begin, mid);
+    mergeSort(array, mid + 1, end);
+    merge(array, begin, mid, end);
+}
+
+// UTILITY FUNCTIONS
+// Function to print an array
+void printArray(int A[], int size)
+{
+    for (auto i = 0; i < size; i++)
+        cout << A[i] << " ";
+}
+
+// Driver code
+int main()
+{
+    int arr[] = {12, 11, 13, 5, 6, 7};
+    auto arr_size = sizeof(arr) / sizeof(arr[0]);
+
+    cout << "Given array is \n";
+    printArray(arr, arr_size);
+
+    mergeSort(arr, 0, arr_size - 1);
+
+    cout << "\nSorted array is \n";
+    printArray(arr, arr_size);
+    return 0;
+}