Merge pull request #888 from ayaankhan98/master

fix: LGTM code quality and Added docs

Author: kvedala

data_structures/binaryheap.cpp

@@ -13,13 +13,16 @@ class MinHeap {
     int heap_size;  ///< Current number of elements in min heap
 
  public:
-    /** Constructor
+    /** Constructor: Builds a heap from a given array a[] of given size
      * \param[in] capacity initial heap capacity
      */
-    MinHeap(int capacity);
+    explicit MinHeap(int cap) {
+        heap_size = 0;
+        capacity = cap;
+        harr = new int[cap];
+    }
 
-    /** to heapify a subtree with the root at given index
-     */
+    /** to heapify a subtree with the root at given index */
     void MinHeapify(int);
 
     int parent(int i) { return (i - 1) / 2; }
@@ -44,14 +47,9 @@ class MinHeap {
 
     /** Inserts a new key 'k' */
     void insertKey(int k);
-};
 
-/** Constructor: Builds a heap from a given array a[] of given size */
-MinHeap::MinHeap(int cap) {
-    heap_size = 0;
-    capacity = cap;
-    harr = new int[cap];
-}
+    ~MinHeap() { delete[] harr; }
+};
 
 // Inserts a new key 'k'
 void MinHeap::insertKey(int k) {

data_structures/disjoint_set.cpp

@@ -1,43 +1,95 @@
+/**
+ *
+ * \file
+ * \brief [Disjoint Sets Data Structure
+ * (Disjoint Sets)](https://en.wikipedia.org/wiki/Disjoint-set_data_structure)
+ *
+ * \author [leoyang429](https://github.com/leoyang429)
+ *
+ * \details
+ * A disjoint set data structure (also called union find or merge find set)
+ * is a data structure that tracks a set of elements partitioned into a number
+ * of disjoint (non-overlapping) subsets.
+ * Some situations where disjoint sets can be used are-
+ * to find connected components of a graph, kruskal's algorithm for finding
+ * Minimum Spanning Tree etc.
+ * There are two operation which we perform on disjoint sets -
+ * 1) Union
+ * 2) Find
+ *
+ */
+
 #include <iostream>
 #include <vector>
 
 using std::cout;
 using std::endl;
 using std::vector;
 
-vector<int> root, rnk;
+vector<int> root, rank;
 
+/**
+ *
+ * Function to create a set
+ * @param n number of element
+ *
+ */
 void CreateSet(int n) {
     root = vector<int>(n + 1);
-    rnk = vector<int>(n + 1, 1);
+    rank = vector<int>(n + 1, 1);
     for (int i = 1; i <= n; ++i) {
         root[i] = i;
     }
 }
 
+/**
+ *
+ * Find operation takes a number x and returns the set to which this number
+ * belongs to.
+ * @param x element of some set
+ * @return set to which x belongs to
+ *
+ */
 int Find(int x) {
     if (root[x] == x) {
         return x;
     }
     return root[x] = Find(root[x]);
 }
 
+/**
+ *
+ * A utility function to check if x and y are from same set or not
+ * @param x element of some set
+ * @param y element of some set
+ *
+ */
 bool InSameUnion(int x, int y) { return Find(x) == Find(y); }
 
+/**
+ *
+ * Union operation combines two disjoint sets to make a single set
+ * in this union function we pass two elements and check if they are
+ * from different sets then combine those sets
+ * @param x element of some set
+ * @param y element of some set
+ *
+ */
 void Union(int x, int y) {
     int a = Find(x), b = Find(y);
     if (a != b) {
-        if (rnk[a] < rnk[b]) {
+        if (rank[a] < rank[b]) {
             root[a] = b;
-        } else if (rnk[a] > rnk[b]) {
+        } else if (rank[a] > rank[b]) {
             root[b] = a;
         } else {
             root[a] = b;
-            ++rnk[b];
+            ++rank[b];
         }
     }
 }
 
+/** Main function */
 int main() {
     // tests CreateSet & Find
     int n = 100;

sorting/comb_sort.cpp

@@ -1,49 +1,101 @@
-// Kind of better version of Bubble sort.
-// While Bubble sort is comparering adjacent value, Combsort is using gap larger
-// than 1 Best case: O(n) Worst case: O(n ^ 2)
+/**
+ *
+ * \file
+ * \brief [Comb Sort Algorithm
+ * (Comb Sort)](https://en.wikipedia.org/wiki/Comb_sort)
+ *
+ * \author
+ *
+ * \details
+ * - A better version of bubble sort algorithm
+ * - Bubble sort compares adjacent values whereas comb sort uses gap larger
+ *   than 1
+ * - Best case Time complexity O(n)
+ *   Worst case Time complexity O(n^2)
+ *
+ */
 
 #include <algorithm>
+#include <cassert>
 #include <iostream>
 
-int a[100005];
-int n;
+/**
+ *
+ * Find the next gap by shrinking the current gap by shrink factor of 1.3
+ * @param gap current gap
+ * @return new gap
+ *
+ */
+int FindNextGap(int gap) {
+    gap = (gap * 10) / 13;
 
-int FindNextGap(int x) {
-    x = (x * 10) / 13;
-
-    return std::max(1, x);
+    return std::max(1, gap);
 }
 
-void CombSort(int a[], int l, int r) {
-    // Init gap
-    int gap = n;
+/** Function to sort array
+ *
+ * @param arr array to be sorted
+ * @param l start index of array
+ * @param r end index of array
+ *
+ */
+void CombSort(int *arr, int l, int r) {
+    /**
+     *
+     * initial gap will be maximum and the maximum possible value is
+     * the size of the array that is n and which is equal to r in this
+     * case so to avoid passing an extra parameter n that is the size of
+     * the array we are using r to initialize the initial gap.
+     *
+     */
+    int gap = r;
 
-    // Initialize swapped as true to make sure that loop runs
+    /// Initialize swapped as true to make sure that loop runs
     bool swapped = true;
 
-    // Keep running until gap = 1 or none elements were swapped
+    /// Keep running until gap = 1 or none elements were swapped
     while (gap != 1 || swapped) {
-        // Find next gap
+        /// Find next gap
         gap = FindNextGap(gap);
 
         swapped = false;
 
-        // Compare all elements with current gap
+        /// Compare all elements with current gap
         for (int i = l; i <= r - gap; ++i) {
-            if (a[i] > a[i + gap]) {
-                std::swap(a[i], a[i + gap]);
+            if (arr[i] > arr[i + gap]) {
+                std::swap(arr[i], arr[i + gap]);
                 swapped = true;
             }
         }
     }
 }
 
-int main() {
-    std::cin >> n;
-    for (int i = 1; i <= n; ++i) std::cin >> a[i];
+void tests() {
+    /// Test 1
+    int arr1[10] = {34, 56, 6, 23, 76, 34, 76, 343, 4, 76};
+    CombSort(arr1, 0, 10);
+    assert(std::is_sorted(arr1, arr1 + 10));
+    std::cout << "Test 1 passed\n";
 
-    CombSort(a, 1, n);
+    /// Test 2
+    int arr2[8] = {-6, 56, -45, 56, 0, -1, 8, 8};
+    CombSort(arr2, 0, 8);
+    assert(std::is_sorted(arr2, arr2 + 8));
+    std::cout << "Test 2 Passed\n";
+}
 
-    for (int i = 1; i <= n; ++i) std::cout << a[i] << ' ';
+/** Main function */
+int main() {
+    /// Running predefined tests
+    tests();
+
+    /// For user interaction
+    int n;
+    std::cin >> n;
+    int *arr = new int[n];
+    for (int i = 0; i < n; ++i) std::cin >> arr[i];
+    CombSort(arr, 0, n);
+    for (int i = 0; i < n; ++i) std::cout << arr[i] << ' ';
+    delete[] arr;
     return 0;
 }