Added all the sorting methods mentioned in the Sorting folder (in C++/cpp extension)

Author: kritikmodi

Sorting/bubblesort.cpp

@@ -0,0 +1,38 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+void swap(int *xp, int *yp)
+{
+    int temp = *xp;
+    *xp = *yp;
+    *yp = temp;
+}
+
+// A function to implement bubble sort
+void bubbleSort(int arr[], int n)
+{
+    int i, j;
+    for (i = 0; i < n-1; i++)
+    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;
+}
+
+int main()
+{
+    int arr[] = {64, 34, 25, 12, 22, 11, 90};//array is predefined here, please take input from the user to work accordingly by modifying the code
+    int n = sizeof(arr)/sizeof(arr[0]);
+    bubbleSort(arr, n);
+    cout<<"Sorted array: \n";
+    printArray(arr, n);
+    return 0;
+}

Sorting/countsort.cpp

@@ -0,0 +1,58 @@
+#include <bits/stdc++.h> 
+#include <string.h> 
+using namespace std; 
+#define RANGE 255 
+  
+// The main function that sort 
+// the given string arr[] in 
+// alphabatical 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 inidividul 
+    // 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]];  
+    }  
+    */
+  
+    // Copy the output array to arr, so that arr now 
+    // contains sorted characters 
+    for (i = 0; arr[i]; ++i) 
+        arr[i] = output[i]; 
+} 
+  
+int main() 
+{ 
+    char arr[] = "geeksforgeeks"; 
+  
+    countSort(arr); 
+  
+    cout << "Sorted character array is " << arr; 
+    return 0; 
+}

Sorting/heapsort.cpp

@@ -0,0 +1,67 @@
+#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) 
+{ 
+    int largest = i; // Initialize largest as root 
+    int l = 2*i + 1; // left = 2*i + 1 
+    int r = 2*i + 2; // right = 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 program 
+int main() 
+{ 
+    int arr[] = {12, 11, 13, 5, 6, 7}; 
+    int n = sizeof(arr)/sizeof(arr[0]); 
+  
+    heapSort(arr, n); 
+  
+    cout << "Sorted array is \n"; 
+    printArray(arr, n); 
+}

Sorting/insertionsort.cpp

@@ -0,0 +1,34 @@
+#include<iostream>
+using namespace std;
+void display(int *array, int size) {
+   for(int i = 0; i<size; i++)
+      cout << array[i] << " ";
+   cout << endl;
+}
+void insertionSort(int *array, int size) {
+   int key, j;
+   for(int i = 1; i<size; i++) {
+      key = array[i];//take value
+      j = i;
+      while(j > 0 && array[j-1]>key) {
+         array[j] = array[j-1];
+         j--;
+      }
+      array[j] = key;   //insert in right place
+   }
+}
+int main() {
+   int n;
+   cout << "Enter the number of elements: ";
+   cin >> n;
+   int arr[n];    //create an array with given number of elements
+   cout << "Enter elements:" << endl;
+   for(int i = 0; i<n; i++) {
+      cin >> arr[i];
+   }
+   cout << "Array before Sorting: ";
+   display(arr, n);
+   insertionSort(arr, n);
+   cout << "Array after Sorting: ";
+   display(arr, n);
+}

Sorting/mergesort.cpp

@@ -0,0 +1,69 @@
+#include<iostream>
+using namespace std;
+void swapping(int &a, int &b) {     //swap the content of a and b
+   int temp;
+   temp = a;
+   a = b;
+   b = temp;
+}
+void display(int *array, int size) {
+   for(int i = 0; i<size; i++)
+      cout << array[i] << " ";
+   cout << endl;
+}
+void merge(int *array, int l, int m, int r) {
+   int i, j, k, nl, nr;
+   //size of left and right sub-arrays
+   nl = m-l+1; nr = r-m;
+   int larr[nl], rarr[nr];
+   //fill left and right sub-arrays
+   for(i = 0; i<nl; i++)
+      larr[i] = array[l+i];
+   for(j = 0; j<nr; j++)
+      rarr[j] = array[m+1+j];
+   i = 0; j = 0; k = l;
+   //marge temp arrays to real array
+   while(i < nl && j<nr) {
+      if(larr[i] <= rarr[j]) {
+         array[k] = larr[i];
+         i++;
+      }else{
+         array[k] = rarr[j];
+         j++;
+      }
+      k++;
+   }
+   while(i<nl) {       //extra element in left array
+      array[k] = larr[i];
+      i++; k++;
+   }
+   while(j<nr) {     //extra element in right array
+      array[k] = rarr[j];
+      j++; k++;
+   }
+}
+void mergeSort(int *array, int l, int r) {
+   int m;
+   if(l < r) {
+      int m = l+(r-l)/2;
+      // Sort first and second arrays
+      mergeSort(array, l, m);
+      mergeSort(array, m+1, r);
+      merge(array, l, m, r);
+   }
+}
+int main() {
+   int n;
+   cout << "Enter the number of elements: ";
+   cin >> n;
+   int arr[n];     //create an array with given number of elements
+   cout << "Enter elements:" << endl;
+   for(int i = 0; i<n; i++) {
+      cin >> arr[i];
+   }
+   cout << "Array before Sorting: ";
+   display(arr, n);
+   mergeSort(arr, 0, n-1);     //(n-1) for last index
+   cout << "Array after Sorting: ";
+   display(arr, n);
+}

Sorting/quicksort.cpp

@@ -0,0 +1,64 @@
+#include <iostream>
+using namespace std;
+// Swap two elements - Utility function  
+void swap(int* a, int* b) 
+{ 
+    int t = *a; 
+    *a = *b; 
+    *b = t; 
+} 
+   
+// partition the array using last element as pivot
+int partition (int arr[], int low, int high) 
+{ 
+    int pivot = arr[high];    // pivot 
+    int i = (low - 1);   
+   
+    for (int j = low; j <= high- 1; j++) 
+    { 
+        //if current element is smaller than pivot, increment the low element
+        //swap elements at i and j
+        if (arr[j] <= pivot) 
+        { 
+            i++;    // increment index of smaller element 
+            swap(&arr[i], &arr[j]); 
+        } 
+    } 
+    swap(&arr[i + 1], &arr[high]); 
+    return (i + 1); 
+} 
+   
+//quicksort algorithm
+void quickSort(int arr[], int low, int high) 
+{ 
+    if (low < high) 
+    { 
+        //partition the array 
+        int pivot = partition(arr, low, high); 
+   
+        //sort the sub arrays independently 
+        quickSort(arr, low, pivot - 1); 
+        quickSort(arr, pivot + 1, high); 
+    } 
+} 
+   
+void displayArray(int arr[], int size) 
+{ 
+    int i; 
+    for (i=0; i < size; i++) 
+        cout<<arr[i]<<"\t"; 
+      
+} 
+   
+int main() 
+{ 
+    int arr[] = {12,23,3,43,51,35,19,45}; 
+    int n = sizeof(arr)/sizeof(arr[0]); 
+    cout<<"Input array"<<endl;
+    displayArray(arr,n);
+    cout<<endl;
+    quickSort(arr, 0, n-1); 
+    cout<<"Array sorted with quick sort"<<endl; 
+    displayArray(arr,n); 
+    return 0; 
+}