[feat/fix/docs]: Various improvements

Forgot to split commits per change, apologizes!

Author: Panquesito7

backtracking/graph_coloring.cpp

@@ -1,49 +1,57 @@
-#include <stdio.h>
+#include <iostream>
 
-// Number of vertices in the graph
+/*
+ * Number of vertices in the graph
+ */
 #define V 4
 
+/**
+ * Prototypes
+ */
 void printSolution(int color[]);
 
 /* A utility function to check if the current color assignment
    is safe for vertex v */
 bool isSafe(int v, bool graph[V][V], int color[], int c) {
     for (int i = 0; i < V; i++)
-        if (graph[v][i] && c == color[i])
+        if (graph[v][i] && c == color[i]) {
             return false;
+        }
     return true;
 }
 
 /* A recursive utility function to solve m coloring problem */
 void graphColoring(bool graph[V][V], int m, int color[], int v) {
-    /* base case: If all vertices are assigned a color then
-       return true */
+    // base case: 
+    // If all vertices are assigned a color then return true
     if (v == V) {
         printSolution(color);
         return;
     }
 
-    /* Consider this vertex v and try different colors */
+    // Consider this vertex v and try different colors
     for (int c = 1; c <= m; c++) {
-        /* Check if assignment of color c to v is fine*/
+        // Check if assignment of color c to v is fine
         if (isSafe(v, graph, color, c)) {
             color[v] = c;
 
-            /* recur to assign colors to rest of the vertices */
+            // recur to assign colors to rest of the vertices
             graphColoring(graph, m, color, v + 1);
 
-            /* If assigning color c doesn't lead to a solution
-               then remove it */
+            // If assigning color c doesn't lead to a solution then remove it
             color[v] = 0;
         }
     }
 }
 
 /* A utility function to print solution */
 void printSolution(int color[]) {
-    printf(" Following are the assigned colors \n");
-    for (int i = 0; i < V; i++) printf(" %d ", color[i]);
-    printf("\n");
+    std::cout << "Following are the assigned colors\n");
+    for (int i = 0; i < V; i++) {
+        std::cout << color[i];
+    }
+
+    std::cout << "\n";
 }
 
 // driver program to test above function
@@ -65,7 +73,7 @@ int main() {
 
     int color[V];
 
-    for (int i = 0; i < V; i++) color[i] = 0;
+    for (int i = 0; i < V; i++) { color[i] = 0 };
 
     graphColoring(graph, m, color, 0);
     return 0;

backtracking/knight_tour.cpp

@@ -36,6 +36,10 @@ bool solve(int x, int y, int mov, int sol[n][n], int xmov[n], int ymov[n]) {
     }
     return false;
 }
+
+/**
+ * Main function
+ */
 int main() {
     // initialize();
 
@@ -49,11 +53,11 @@ int main() {
     sol[0][0] = 0;
 
     bool flag = solve(0, 0, 1, sol, xmov, ymov);
-    if (flag == false)
+    if (flag == false) {
         cout << "solution doesnot exist \n";
-    else {
+    } else {
         for (i = 0; i < n; i++) {
-            for (j = 0; j < n; j++) cout << sol[i][j] << "  ";
+            for (j = 0; j < n; j++) { cout << sol[i][j] << "  " };
             cout << "\n";
         }
     }

backtracking/n_queens.cpp

@@ -1,32 +1,38 @@
 #include <iostream>
 #define N 4
-using namespace std;
 
 void printSolution(int board[N][N]) {
-    cout << "\n";
+    std::cout << "\n";
     for (int i = 0; i < N; i++) {
-        for (int j = 0; j < N; j++) cout << "" << board[i][j];
-        cout << "\n";
+        for (int j = 0; j < N; j++) { 
+            std::cout << "" << board[i][j];
+        }
+        std::cout << "\n";
     }
 }
 
 bool isSafe(int board[N][N], int row, int col) {
     int i, j;
 
-    /* Check this row on left side */
+    // Check this row on left side
     for (i = 0; i < col; i++)
-        if (board[row][i])
+        if (board[row][i]) {
             return false;
+        }
 
-    /* Check upper diagonal on left side */
-    for (i = row, j = col; i >= 0 && j >= 0; i--, j--)
-        if (board[i][j])
+    // Check upper diagonal on left side
+    for (i = row, j = col; i >= 0 && j >= 0; i--, j--) {
+        if (board[i][j]) {
             return false;
+        }
+    }
 
-    /* Check lower diagonal on left side */
-    for (i = row, j = col; j >= 0 && i < N; i++, j--)
-        if (board[i][j])
+    // Check lower diagonal on left side
+    for (i = row, j = col; j >= 0 && i < N; i++, j--) {
+        if (board[i][j]) {
             return false;
+        }
+    }
 
     return true;
 }
@@ -37,20 +43,18 @@ void solveNQ(int board[N][N], int col) {
         return;
     }
 
-    /* Consider this column and try placing
-       this queen in all rows one by one */
+    // Consider this column and try placing
+    // this queen in all rows one by one
     for (int i = 0; i < N; i++) {
-        /* Check if queen can be placed on
-          board[i][col] */
+        // Check if queen can be placed on board[i][col]
         if (isSafe(board, i, col)) {
-            /* Place this queen in board[i][col] */
-            //            cout<<"\n"<<col<<"can place"<<i;
+            // Place this queen in board[i][col]
+            //            std::cout<<"\n"<<col<<"can place"<<i;
             board[i][col] = 1;
 
-            /* recur to place rest of the queens */
+            // recur to place rest of the queens
             solveNQ(board, col + 1);
-
-            board[i][col] = 0;  // BACKTRACK
+            board[i][col] = 0; // BACKTRACK
         }
     }
 }

backtracking/n_queens_all_solution_optimised.cpp

@@ -50,6 +50,9 @@ void NQueenSol(int Board[n][n], int col) {
     }
 }
 
+/**
+ * Main function
+ */
 int main() {
     int Board[n][n] = {0};
     if (n % 2 == 0) {

backtracking/rat_maze.cpp

@@ -9,17 +9,15 @@
 #include <iostream>
 #define size 4
 
-using namespace std;
-
 int solveMaze(int currposrow, int currposcol, int maze[size][size],
               int soln[size][size]) {
     if ((currposrow == size - 1) && (currposcol == size - 1)) {
         soln[currposrow][currposcol] = 1;
         for (int i = 0; i < size; ++i) {
             for (int j = 0; j < size; ++j) {
-                cout << soln[i][j];
+                std::cout << soln[i][j];
             }
-            cout << endl;
+            std::cout << std::endl;
         }
         return 1;
     } else {

backtracking/sudoku_solve.cpp

@@ -1,6 +1,4 @@
 #include <iostream>
-using namespace std;
-/// N=9;
 int n = 9;
 
 bool isPossible(int mat[][9], int i, int j, int no) {
@@ -28,15 +26,15 @@ bool isPossible(int mat[][9], int i, int j, int no) {
 void printMat(int mat[][9]) {
     for (int i = 0; i < n; i++) {
         for (int j = 0; j < n; j++) {
-            cout << mat[i][j] << " ";
+            std::cout << mat[i][j] << " ";
             if ((j + 1) % 3 == 0) {
-                cout << '\t';
+                std::cout << '\t';
             }
         }
         if ((i + 1) % 3 == 0) {
-            cout << endl;
+            std::cout << std::endl;
         }
-        cout << endl;
+        std::cout << std::endl;
     }
 }
 

data_structures/avltree.cpp

@@ -22,15 +22,16 @@ node *createNode(int data) {
     node *nn = new node();
     nn->data = data;
     nn->height = 0;
-    nn->left = NULL;
-    nn->right = NULL;
+    nn->left = nullptr;
+    nn->right = nullptr;
     return nn;
 }
 
 /** Returns height of tree */
 int height(node *root) {
-    if (root == NULL)
+    if (root == nullptr) {
         return 0;
+    }
     return 1 + std::max(height(root->left), height(root->right));
 }
 
@@ -57,15 +58,15 @@ node *leftRotate(node *root) {
 
 /** Returns node with minimum value in the tree */
 node *minValue(node *root) {
-    if (root->left == NULL)
+    if (root->left == nullptr)
         return root;
     return minValue(root->left);
 }
 
 /** Balanced Insertion */
 node *insert(node *root, int item) {
     node *nn = createNode(item);
-    if (root == NULL)
+    if (root == nullptr)
         return nn;
     if (item < root->data)
         root->left = insert(root->left, item);
@@ -86,24 +87,25 @@ node *insert(node *root, int item) {
 
 /** Balanced Deletion */
 node *deleteNode(node *root, int key) {
-    if (root == NULL)
+    if (root == nullptr) {
         return root;
-    if (key < root->data)
+    }
+
+    if (key < root->data) {
         root->left = deleteNode(root->left, key);
-    else if (key > root->data)
+    } else if (key > root->data) {
         root->right = deleteNode(root->right, key);
-
-    else {
+    } else {
         // Node to be deleted is leaf node or have only one Child
         if (!root->right) {
             node *temp = root->left;
             delete (root);
-            root = NULL;
+            root = nullptr;
             return temp;
         } else if (!root->left) {
             node *temp = root->right;
             delete (root);
-            root = NULL;
+            root = nullptr;
             return temp;
         }
         // Node to be deleted have both left and right subtrees
@@ -133,7 +135,7 @@ void levelOrder(node *root) {
 /** Main function */
 int main() {
     // Testing AVL Tree
-    node *root = NULL;
+    node *root = nullptr;
     int i;
     for (i = 1; i <= 7; i++) root = insert(root, i);
     std::cout << "LevelOrder: ";