added #3 #4 #5 Py-Contributors#7

Author: d2Anubis

C++/Algorithms/SortingAlgorithms/heapSort.cpp

@@ -5,59 +5,62 @@
 
 /* Time Complexity : O(nlogn) */
 
-#include<iostream>
+#include <iostream>
 using namespace std;
 #define MAX 100000
 
-void adjust(int a[] , int n ,int i){ // to heapify the root
-    while(2*i+1<=n){
-        int j = 2*i+1;
-        if(j+1<=n && a[j+1]>a[j])
-            j = j+1;
-        if(a[i] >= a[j])
+void adjust(int a[], int n, int i)
+{ // to heapify the root
+    while (2 * i + 1 <= n)
+    {
+        int j = 2 * i + 1;
+        if (j + 1 <= n && a[j + 1] > a[j])
+            j = j + 1;
+        if (a[i] >= a[j])
             break;
-        else{
+        else
+        {
             int temp = a[i];
             a[i] = a[j];
             a[j] = temp;
             i = j;
         }
     }
 }
-void heapsort(int a[] , int n){
-    for(int i = n/2 - 1;i>=0 ;i--){  // build heap
-        adjust(a,n-1,i);
+void heapsort(int a[], int n)
+{
+    for (int i = n / 2 - 1; i >= 0; i--)
+    { // build heap
+        adjust(a, n - 1, i);
     }
 
-    while(n>0){    //  move current root to end       
+    while (n > 0)
+    { //  move current root to end
         int t = 0;
-        t = a[0];            
-        a[0] = a[n-1];
-        a[n-1]=t;
+        t = a[0];
+        a[0] = a[n - 1];
+        a[n - 1] = t;
         n--;
-        adjust(a,n-1,0); // heapify the newly formed root
+        adjust(a, n - 1, 0); // heapify the newly formed root
     }
-
-
 }
 
-
-int main(){
+int main()
+{
     int n;
-    cout<<"Enter the number of elments in array : "; 
-    cin>>n;
+    cout << "Enter the number of elments in array : ";
+    cin >> n;
     int a[MAX];
-    cout<<"Enter the elements in heap"<<endl;        
-    for(int i=0;i<n;i++){        
-        cin>>a[i];
+    cout << "Enter the elements in heap" << endl;
+    for (int i = 0; i < n; i++)
+    {
+        cin >> a[i];
     }
-    heapsort(a,n);            
-    cout<<"Sorted array is using heapsort is"<<endl;
-    for(int i = 0;i<n;i++){
-        cout<<a[i]<<" ";
+    heapsort(a, n);
+    cout << "Sorted array is using heapsort is" << endl;
+    for (int i = 0; i < n; i++)
+    {
+        cout << a[i] << " ";
     }
-    cout<<endl;
-
+    cout << endl;
 }
-
-

C++/Algorithms/SortingAlgorithms/mergeSort.cpp

@@ -5,76 +5,83 @@
 /* Time complexity : O(nlogn) in all cases
    Space complexity: O(n) */
 
-#include<bits/stdc++.h>
+#include <bits/stdc++.h>
 using namespace std;
 #define MAX 100000
 
-void merge(int arr[],int l,int m,int r) // fn for merging the elements in sorted manner.
+void merge(int arr[], int l, int m, int r) // fn for merging the elements in sorted manner.
 {
-    int i, j, k; 
-    int n1 = m - l + 1;  // elements in LHS
-    int n2 = r - m;      // elements in RHS
-  
+    int i, j, k;
+    int n1 = m - l + 1; // elements in LHS
+    int n2 = r - m;     // elements in RHS
+
     int L[n1], R[n2]; // temporary arrays
 
-    for (i = 0; i < n1; i++) 
-        L[i] = arr[l + i]; 
-    for (j = 0; j < n2; j++) 
-        R[j] = arr[m + 1 + j]; 
-  
-    i = 0; 
-    j = 0; 
-    k = l; 
-    while (i < n1 && j < n2) { 
-        if (L[i] <= R[j]) { 
-            arr[k] = L[i]; 
-            i++; 
-        } 
-        else { 
-            arr[k] = R[j]; 
-            j++; 
-        } 
-        k++; 
-    } 
+    for (i = 0; i < n1; i++)
+        L[i] = arr[l + i];
+    for (j = 0; j < n2; j++)
+        R[j] = arr[m + 1 + j];
 
-    while (i < n1) { 
-        arr[k] = L[i]; 
-        i++; 
-        k++; 
-    }  
+    i = 0;
+    j = 0;
+    k = l;
+    while (i < n1 && j < n2)
+    {
+        if (L[i] <= R[j])
+        {
+            arr[k] = L[i];
+            i++;
+        }
+        else
+        {
+            arr[k] = R[j];
+            j++;
+        }
+        k++;
+    }
 
-    while (j < n2) { 
-        arr[k] = R[j]; 
-        j++; 
-        k++; 
-    } 
+    while (i < n1)
+    {
+        arr[k] = L[i];
+        i++;
+        k++;
+    }
+
+    while (j < n2)
+    {
+        arr[k] = R[j];
+        j++;
+        k++;
+    }
 }
-void mergeSort(int *a,int low,int high) //recursive calls for dividing array
+void mergeSort(int *a, int low, int high) //recursive calls for dividing array
 {
-if(low<high){
-    int mid= (low+high)/2;
-    mergeSort(a,low,mid);
-    mergeSort(a,mid+1,high);
-    merge(a,low,mid,high);
+    if (low < high)
+    {
+        int mid = (low + high) / 2;
+        mergeSort(a, low, mid);
+        mergeSort(a, mid + 1, high);
+        merge(a, low, mid, high);
     }
 }
 
-
-int main(){
-int a[MAX];
-int n,num;
-cout<<"Enter the number of elements in the array: ";
-cin>>n;
-cout<<"Enter the elements " ;
-for(int i=0;i<n;i++){
-    cin>>num;
-    a[i]=num;
-    }
-mergeSort(a,0,n-1);
-cout<<"The sorted elements are : ";
-for(int i=0;i<n;i++)
+int main()
 {
-    cout<<a[i]<<" ";
-}
-return 0;
+    int a[MAX];
+    int n, num;
+    cout << "Enter the number of elements in the array: ";
+    cin >> n;
+    cout << "Enter the elements ";
+    for (int i = 0; i < n; i++)
+    {
+        cin >> num;
+        a[i] = num;
+    }
+    mergeSort(a, 0, n - 1);
+    cout << "The sorted elements are : ";
+    for (int i = 0; i < n; i++)
+    {
+        cout << a[i] << " ";
+    }
+    return 0;
 }

C++/Algorithms/SortingAlgorithms/quickSort.cpp

@@ -5,58 +5,58 @@
 
 /* Time complexity: Worst case : O(n^2), Average case: O(nlogn), Best case: O(nlogn) */
 
-#include<bits/stdc++.h>
+#include <bits/stdc++.h>
 using namespace std;
 #define MAX 100000
 
-void swap(int* a,int* b) //for swapping elements
+void swap(int *a, int *b) //for swapping elements
 {
-    int t=*a;
-    *a=*b;
-    *b=t;
+    int t = *a;
+    *a = *b;
+    *b = t;
 }
 
-int partition(int arr[],int low,int high) //for chosing partitioning around pivot
+int partition(int arr[], int low, int high) //for chosing partitioning around pivot
 {
-    int pivot=arr[high];
-    int i=(low-1);
-    for(int j=low;j<=high;j++)
+    int pivot = arr[high];
+    int i = (low - 1);
+    for (int j = low; j <= high; j++)
     {
-        if(arr[j]<pivot)
+        if (arr[j] < pivot)
         {
             i++;
-            swap(&arr[i],&arr[j]);
+            swap(&arr[i], &arr[j]);
         }
     }
-    swap(&arr[i+1],&arr[high]);
-    return (i+1);
+    swap(&arr[i + 1], &arr[high]);
+    return (i + 1);
 }
 
-void quicksort(int arr[],int low,int high) // recursive calls for partitioning.
+void quicksort(int arr[], int low, int high) // recursive calls for partitioning.
 {
-    if (low<high)
+    if (low < high)
     {
-        int pi=partition(arr,low,high);
-        quicksort(arr,low,pi-1);
-        quicksort(arr,pi+1,high);
+        int pi = partition(arr, low, high);
+        quicksort(arr, low, pi - 1);
+        quicksort(arr, pi + 1, high);
     }
 }
 
 int main()
-{	
-	int n,num,x;
-	int arr[MAX];
-	cout<<"Enter the number of elements in the array : ";
-	cin>>n;
-	cout<<"Enter the elements : ";
-	for(int i=0;i<n;i++)
-    	{
-        	cin>>num;
-        	arr[i]=num;
-    	}
- 	quicksort(arr,0,n-1);
-    	cout<<"Array after sorting: ";
-    	for(int i=0;i<n;i++)
-        cout<<arr[i]<<" ";
-    	return 0;
+{
+    int n, num, x;
+    int arr[MAX];
+    cout << "Enter the number of elements in the array : ";
+    cin >> n;
+    cout << "Enter the elements : ";
+    for (int i = 0; i < n; i++)
+    {
+        cin >> num;
+        arr[i] = num;
+    }
+    quicksort(arr, 0, n - 1);
+    cout << "Array after sorting: ";
+    for (int i = 0; i < n; i++)
+        cout << arr[i] << " ";
+    return 0;
 }