formatting source-code for d7af6fdc8c

backtracking/graph_coloring.cpp

@@ -48,8 +48,7 @@ void graphColoring(bool graph[V][V], int m, int color[], int v)
 void printSolution(int color[])
 {
     printf(" Following are the assigned colors \n");
-    for (int i = 0; i < V; i++)
-        printf(" %d ", color[i]);
+    for (int i = 0; i < V; i++) printf(" %d ", color[i]);
     printf("\n");
 }
 
@@ -69,12 +68,11 @@ int main()
         {1, 1, 0, 1},
         {1, 0, 1, 0},
     };
-    int m = 3; // Number of colors
+    int m = 3;  // Number of colors
 
     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

@@ -1,68 +1,65 @@
 #include <iostream>
-# define n 8
+#define n 8
 
 /**
 A knight's tour is a sequence of moves of a knight on a chessboard
-such that the knight visits every square only once. If the knight 
-ends on a square that is one knight's move from the beginning 
-square (so that it could tour the board again immediately, following 
+such that the knight visits every square only once. If the knight
+ends on a square that is one knight's move from the beginning
+square (so that it could tour the board again immediately, following
 the same path), the tour is closed; otherwise, it is open.
 **/
 
 using namespace std;
-bool issafe(int x,int y,int sol[n][n])
+bool issafe(int x, int y, int sol[n][n])
 {
-    return (x<n && x>=0 && y<n && y>=0 && sol[x][y]==-1);
-
+    return (x < n && x >= 0 && y < n && y >= 0 && sol[x][y] == -1);
 }
-bool solve(int x,int y, int mov, int sol[n][n], int xmov[n], int ymov[n])
+bool solve(int x, int y, int mov, int sol[n][n], int xmov[n], int ymov[n])
 {
-    int k,xnext,ynext;
+    int k, xnext, ynext;
 
-    if(mov == n*n)
+    if (mov == n * n)
         return true;
 
-    for(k=0;k<8;k++)
+    for (k = 0; k < 8; k++)
     {
-        xnext=x+xmov[k];
-        ynext=y+ymov[k];
+        xnext = x + xmov[k];
+        ynext = y + ymov[k];
 
-        if(issafe(xnext,ynext,sol))
-            {
-                sol[xnext][ynext]=mov;
+        if (issafe(xnext, ynext, sol))
+        {
+            sol[xnext][ynext] = mov;
 
-                if(solve(xnext,ynext,mov+1,sol,xmov,ymov)==true)
-                    return true;
-                else
-                    sol[xnext][ynext]=-1;
-            }
+            if (solve(xnext, ynext, mov + 1, sol, xmov, ymov) == true)
+                return true;
+            else
+                sol[xnext][ynext] = -1;
+        }
     }
     return false;
 }
 int main()
 {
-    //initialize();
+    // initialize();
 
     int sol[n][n];
-    int i,j;
-    for(i=0;i<n;i++)
-        for(j=0;j<n;j++)
-            sol[i][j]=-1;
+    int i, j;
+    for (i = 0; i < n; i++)
+        for (j = 0; j < n; j++) sol[i][j] = -1;
 
-    int xmov[8] = {  2, 1, -1, -2, -2, -1,  1,  2 };
-    int ymov[8] = {  1, 2,  2,  1, -1, -2, -2, -1 };
-    sol[0][0]=0;
+    int xmov[8] = {2, 1, -1, -2, -2, -1, 1, 2};
+    int ymov[8] = {1, 2, 2, 1, -1, -2, -2, -1};
+    sol[0][0] = 0;
 
-    bool flag=solve(0,0,1,sol,xmov,ymov);
-    if(flag==false)
-        cout<<"solution doesnot exist \n";
+    bool flag = solve(0, 0, 1, sol, xmov, ymov);
+    if (flag == false)
+        cout << "solution doesnot exist \n";
     else
     {
-        for(i=0;i<n;i++)
+        for (i = 0; i < n; i++)
         {
-            for(j=0;j<n;j++)
-                cout<<sol[i][j]<<"  ";
-            cout<<"\n";
+            for (j = 0; j < n; j++) cout << sol[i][j] << "  ";
+            cout << "\n";
         }
     }
 }

backtracking/minimax.cpp

@@ -9,7 +9,8 @@ using std::min;
 using std::vector;
 
 int minimax(int depth, int node_index, bool is_max, vector<int> scores,
-            int height) {
+            int height)
+{
     if (depth == height)
         return scores[node_index];
 
@@ -19,8 +20,9 @@ int minimax(int depth, int node_index, bool is_max, vector<int> scores,
     return is_max ? max(v1, v2) : min(v1, v2);
 }
 
-int main() {
-    vector<int> scores = { 90, 23, 6, 33, 21, 65, 123, 34423 };
+int main()
+{
+    vector<int> scores = {90, 23, 6, 33, 21, 65, 123, 34423};
     int height = log2(scores.size());
 
     cout << "Optimal value: " << minimax(0, 0, true, scores, height) << endl;

backtracking/n_queens.cpp

@@ -7,8 +7,7 @@ void printSolution(int board[N][N])
     cout << "\n";
     for (int i = 0; i < N; i++)
     {
-        for (int j = 0; j < N; j++)
-            cout << "" << board[i][j];
+        for (int j = 0; j < N; j++) cout << "" << board[i][j];
         cout << "\n";
     }
 }
@@ -37,7 +36,6 @@ bool isSafe(int board[N][N], int row, int col)
 
 void solveNQ(int board[N][N], int col)
 {
-
     if (col >= N)
     {
         printSolution(board);
@@ -59,18 +57,14 @@ void solveNQ(int board[N][N], int col)
             /* recur to place rest of the queens */
             solveNQ(board, col + 1);
 
-            board[i][col] = 0; // BACKTRACK
+            board[i][col] = 0;  // BACKTRACK
         }
     }
 }
 
 int main()
 {
-
-    int board[N][N] = {{0, 0, 0, 0},
-                       {0, 0, 0, 0},
-                       {0, 0, 0, 0},
-                       {0, 0, 0, 0}};
+    int board[N][N] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};
 
     solveNQ(board, 0);
     return 0;

backtracking/n_queens_all_solution_optimised.cpp

@@ -1,50 +1,60 @@
 #include <iostream>
 #define n 4
-#define inc_loop(var, start, stop) for (int var=start; var <= stop; var++)
-#define dec_loop(var, start, stop) for (int var=start; var >= stop; var--)
-void PrintSol(int Board[n][n]) {
-    inc_loop(i, 0, n-1) {
-        inc_loop(j, 0, n-1)
-            std::cout << Board[i][j] << " ";
+#define inc_loop(var, start, stop) for (int var = start; var <= stop; var++)
+#define dec_loop(var, start, stop) for (int var = start; var >= stop; var--)
+void PrintSol(int Board[n][n])
+{
+    inc_loop(i, 0, n - 1)
+    {
+        inc_loop(j, 0, n - 1) std::cout << Board[i][j] << " ";
         std::cout << std::endl;
     }
     std::cout << std::endl;
-    if (n%2 == 0 || (n%2 == 1 && Board[n/2+1][0] != 1)) {
-        inc_loop(i, 0, n-1) {
-            dec_loop(j, n-1, 0)
-                std::cout << Board[i][j] << " ";
+    if (n % 2 == 0 || (n % 2 == 1 && Board[n / 2 + 1][0] != 1))
+    {
+        inc_loop(i, 0, n - 1)
+        {
+            dec_loop(j, n - 1, 0) std::cout << Board[i][j] << " ";
             std::cout << std::endl;
         }
         std::cout << std::endl;
     }
 }
 
-bool CanIMove(int Board[n][n], int row, int col) {
+bool CanIMove(int Board[n][n], int row, int col)
+{
     /// check in the row
-    inc_loop(i, 0, col-1) {
+    inc_loop(i, 0, col - 1)
+    {
         if (Board[row][i] == 1)
             return false;
     }
     /// check the first diagonal
-    for (int i = row, j = col; i >= 0 && j >= 0; i--, j--) {
+    for (int i = row, j = col; i >= 0 && j >= 0; i--, j--)
+    {
         if (Board[i][j] == 1)
             return false;
     }
     /// check the second diagonal
-    for (int i = row, j = col; i <= n - 1 && j >= 0; i++, j--) {
+    for (int i = row, j = col; i <= n - 1 && j >= 0; i++, j--)
+    {
         if (Board[i][j] == 1)
             return false;
     }
     return true;
 }
 
-void NQueenSol(int Board[n][n], int col) {
-    if (col >= n) {
+void NQueenSol(int Board[n][n], int col)
+{
+    if (col >= n)
+    {
         PrintSol(Board);
         return;
     }
-    inc_loop(i, 0, n-1) {
-        if (CanIMove(Board, i, col)) {
+    inc_loop(i, 0, n - 1)
+    {
+        if (CanIMove(Board, i, col))
+        {
             Board[i][col] = 1;
             NQueenSol(Board, col + 1);
             Board[i][col] = 0;
@@ -52,19 +62,27 @@ void NQueenSol(int Board[n][n], int col) {
     }
 }
 
-int main() {
+int main()
+{
     int Board[n][n] = {0};
-    if (n%2 == 0) {
-        inc_loop(i, 0, n/2-1) {
-            if (CanIMove(Board, i, 0)) {
+    if (n % 2 == 0)
+    {
+        inc_loop(i, 0, n / 2 - 1)
+        {
+            if (CanIMove(Board, i, 0))
+            {
                 Board[i][0] = 1;
                 NQueenSol(Board, 1);
                 Board[i][0] = 0;
             }
         }
-    } else {
-        inc_loop(i, 0, n/2) {
-            if (CanIMove(Board, i, 0)) {
+    }
+    else
+    {
+        inc_loop(i, 0, n / 2)
+        {
+            if (CanIMove(Board, i, 0))
+            {
                 Board[i][0] = 1;
                 NQueenSol(Board, 1);
                 Board[i][0] = 0;

backtracking/nqueen_print_all_solutions.cpp

@@ -1,9 +1,12 @@
 #include <iostream>
 #define n 4
 
-void PrintSol(int Board[n][n]) {
-    for (int i = 0; i < n; i++) {
-        for (int j = 0; j < n; j++) {
+void PrintSol(int Board[n][n])
+{
+    for (int i = 0; i < n; i++)
+    {
+        for (int j = 0; j < n; j++)
+        {
             std::cout << Board[i][j] << " ";
         }
         std::cout << std::endl;
@@ -11,32 +14,40 @@ void PrintSol(int Board[n][n]) {
     std::cout << std::endl;
 }
 
-bool CanIMove(int Board[n][n], int row, int col) {
+bool CanIMove(int Board[n][n], int row, int col)
+{
     /// check in the row
-    for (int i = 0; i < col; i++) {
+    for (int i = 0; i < col; i++)
+    {
         if (Board[row][i] == 1)
             return false;
     }
     /// check the first diagonal
-    for (int i = row, j = col; i >= 0 && j >= 0; i--, j--) {
+    for (int i = row, j = col; i >= 0 && j >= 0; i--, j--)
+    {
         if (Board[i][j] == 1)
             return false;
     }
     /// check the second diagonal
-    for (int i = row, j = col; i <= n - 1 && j >= 0; i++, j--) {
+    for (int i = row, j = col; i <= n - 1 && j >= 0; i++, j--)
+    {
         if (Board[i][j] == 1)
             return false;
     }
     return true;
 }
 
-void NQueenSol(int Board[n][n], int col) {
-    if (col >= n) {
+void NQueenSol(int Board[n][n], int col)
+{
+    if (col >= n)
+    {
         PrintSol(Board);
         return;
     }
-    for (int i = 0; i < n; i++) {
-        if (CanIMove(Board, i, col)) {
+    for (int i = 0; i < n; i++)
+    {
+        if (CanIMove(Board, i, col))
+        {
             Board[i][col] = 1;
             NQueenSol(Board, col + 1);
             Board[i][col] = 0;
@@ -44,7 +55,8 @@ void NQueenSol(int Board[n][n], int col) {
     }
 }
 
-int main() {
+int main()
+{
     int Board[n][n] = {0};
     NQueenSol(Board, 0);
 }

backtracking/rat_maze.cpp

@@ -1,73 +1,73 @@
 /*
-	A Maze is given as N*N binary matrix of blocks where source block is the upper
-	left most block i.e., maze[0][0] and destination block is lower rightmost 
-	block i.e., maze[N-1][N-1]. A rat starts from source and has to reach destination.
-	The rat can move only in two directions: forward and down. In the maze matrix, 
-	0 means the block is dead end and 1 means the block can be used in the path 
-	from source to destination.
+    A Maze is given as N*N binary matrix of blocks where source block is the
+   upper left most block i.e., maze[0][0] and destination block is lower
+   rightmost block i.e., maze[N-1][N-1]. A rat starts from source and has to
+   reach destination. The rat can move only in two directions: forward and down.
+   In the maze matrix, 0 means the block is dead end and 1 means the block can
+   be used in the path from source to destination.
 */
 #include <iostream>
 #define size 4
 
 using namespace std;
 
-int solveMaze(int currposrow, int currposcol, int maze[size][size], int soln[size][size])
+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];
-			}
-			cout << endl;
-		}
-		return 1;
-	}
-	else
-	{
-		soln[currposrow][currposcol] = 1;
+    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];
+            }
+            cout << endl;
+        }
+        return 1;
+    }
+    else
+    {
+        soln[currposrow][currposcol] = 1;
 
-		// if there exist a solution by moving one step ahead in a collumn
-		if ((currposcol < size - 1) && maze[currposrow][currposcol + 1] == 1 && solveMaze(currposrow, currposcol + 1, maze, soln))
-		{
-			return 1;
-		}
+        // if there exist a solution by moving one step ahead in a collumn
+        if ((currposcol < size - 1) && maze[currposrow][currposcol + 1] == 1 &&
+            solveMaze(currposrow, currposcol + 1, maze, soln))
+        {
+            return 1;
+        }
 
-		// if there exists a solution by moving one step ahead in a row
-		if ((currposrow < size - 1) && maze[currposrow + 1][currposcol] == 1 && solveMaze(currposrow + 1, currposcol, maze, soln))
-		{
-			return 1;
-		}
+        // if there exists a solution by moving one step ahead in a row
+        if ((currposrow < size - 1) && maze[currposrow + 1][currposcol] == 1 &&
+            solveMaze(currposrow + 1, currposcol, maze, soln))
+        {
+            return 1;
+        }
 
-		// the backtracking part
-		soln[currposrow][currposcol] = 0;
-		return 0;
-	}
+        // the backtracking part
+        soln[currposrow][currposcol] = 0;
+        return 0;
+    }
 }
 
 int main(int argc, char const *argv[])
 {
-	int maze[size][size] = {
-		{1, 0, 1, 0},
-		{1, 0, 1, 1},
-		{1, 0, 0, 1},
-		{1, 1, 1, 1}};
+    int maze[size][size] = {
+        {1, 0, 1, 0}, {1, 0, 1, 1}, {1, 0, 0, 1}, {1, 1, 1, 1}};
 
-	int soln[size][size];
+    int soln[size][size];
 
-	for (int i = 0; i < size; ++i)
-	{
-		for (int j = 0; j < size; ++j)
-		{
-			soln[i][j] = 0;
-		}
-	}
+    for (int i = 0; i < size; ++i)
+    {
+        for (int j = 0; j < size; ++j)
+        {
+            soln[i][j] = 0;
+        }
+    }
 
-	int currposrow = 0;
-	int currposcol = 0;
-	solveMaze(currposrow, currposcol, maze, soln);
-	return 0;
+    int currposrow = 0;
+    int currposcol = 0;
+    solveMaze(currposrow, currposcol, maze, soln);
+    return 0;
 }

backtracking/sudoku_solve.cpp

@@ -1,11 +1,11 @@
 #include <iostream>
 using namespace std;
-///N=9;
+/// N=9;
 int n = 9;
 
 bool isPossible(int mat[][9], int i, int j, int no)
 {
-    ///Row or col nahin hona chahiye
+    /// Row or col nahin hona chahiye
     for (int x = 0; x < n; x++)
     {
         if (mat[x][j] == no || mat[i][x] == no)
@@ -33,7 +33,6 @@ 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++)
@@ -54,60 +53,54 @@ void printMat(int mat[][9])
 
 bool solveSudoku(int mat[][9], int i, int j)
 {
-    ///Base Case
+    /// Base Case
     if (i == 9)
     {
-        ///Solve kr chuke hain for 9 rows already
+        /// Solve kr chuke hain for 9 rows already
         printMat(mat);
         return true;
     }
 
-    ///Crossed the last  Cell in the row
+    /// Crossed the last  Cell in the row
     if (j == 9)
     {
         return solveSudoku(mat, i + 1, 0);
     }
 
-    ///Blue Cell - Skip
+    /// Blue Cell - Skip
     if (mat[i][j] != 0)
     {
         return solveSudoku(mat, i, j + 1);
     }
-    ///White Cell
-    ///Try to place every possible no
+    /// White Cell
+    /// Try to place every possible no
     for (int no = 1; no <= 9; no++)
     {
         if (isPossible(mat, i, j, no))
         {
-            ///Place the no - assuming solution aa jayega
+            /// Place the no - assuming solution aa jayega
             mat[i][j] = no;
             bool aageKiSolveHui = solveSudoku(mat, i, j + 1);
             if (aageKiSolveHui)
             {
                 return true;
             }
-            ///Nahin solve hui
-            ///loop will place the next no.
+            /// Nahin solve hui
+            /// loop will place the next no.
         }
     }
-    ///Sare no try kr liey, kisi se bhi solve nahi hui
+    /// Sare no try kr liey, kisi se bhi solve nahi hui
     mat[i][j] = 0;
     return false;
 }
 
 int main()
 {
-
-    int mat[9][9] =
-        {{5, 3, 0, 0, 7, 0, 0, 0, 0},
-         {6, 0, 0, 1, 9, 5, 0, 0, 0},
-         {0, 9, 8, 0, 0, 0, 0, 6, 0},
-         {8, 0, 0, 0, 6, 0, 0, 0, 3},
-         {4, 0, 0, 8, 0, 3, 0, 0, 1},
-         {7, 0, 0, 0, 2, 0, 0, 0, 6},
-         {0, 6, 0, 0, 0, 0, 2, 8, 0},
-         {0, 0, 0, 4, 1, 9, 0, 0, 5},
-         {0, 0, 0, 0, 8, 0, 0, 7, 9}};
+    int mat[9][9] = {{5, 3, 0, 0, 7, 0, 0, 0, 0}, {6, 0, 0, 1, 9, 5, 0, 0, 0},
+                     {0, 9, 8, 0, 0, 0, 0, 6, 0}, {8, 0, 0, 0, 6, 0, 0, 0, 3},
+                     {4, 0, 0, 8, 0, 3, 0, 0, 1}, {7, 0, 0, 0, 2, 0, 0, 0, 6},
+                     {0, 6, 0, 0, 0, 0, 2, 8, 0}, {0, 0, 0, 4, 1, 9, 0, 0, 5},
+                     {0, 0, 0, 0, 8, 0, 0, 7, 9}};
 
     printMat(mat);
     cout << "Solution " << endl;

computer_oriented_statistical_methods/bisection_method.cpp

@@ -23,29 +23,36 @@
 
 /** define \f$f(x)\f$ to find root for
  */
-static double eq(double i) {
+static double eq(double i)
+{
     return (std::pow(i, 3) - (4 * i) - 9);  // original equation
 }
 
 /** get the sign of any given number */
 template <typename T>
-int sgn(T val) {
+int sgn(T val)
+{
     return (T(0) < val) - (val < T(0));
 }
 
 /** main function */
-int main() {
+int main()
+{
     double a = -1, b = 1, x, z;
     int i;
 
     // loop to find initial intervals a, b
-    for (int i = 0; i < MAX_ITERATIONS; i++) {
+    for (int i = 0; i < MAX_ITERATIONS; i++)
+    {
         z = eq(a);
         x = eq(b);
-        if (sgn(z) == sgn(x)) {  // same signs, increase interval
+        if (sgn(z) == sgn(x))
+        {  // same signs, increase interval
             b++;
             a--;
-        } else {  // if opposite signs, we got our interval
+        }
+        else
+        {  // if opposite signs, we got our interval
             break;
         }
     }
@@ -54,15 +61,19 @@ int main() {
     std::cout << "\nSecond initial: " << b;
 
     // start iterations
-    for (i = 0; i < MAX_ITERATIONS; i++) {
+    for (i = 0; i < MAX_ITERATIONS; i++)
+    {
         x = (a + b) / 2;
         z = eq(x);
         std::cout << "\n\nz: " << z << "\t[" << a << " , " << b
                   << " | Bisect: " << x << "]";
 
-        if (z < 0) {
+        if (z < 0)
+        {
             a = x;
-        } else {
+        }
+        else
+        {
             b = x;
         }
 

computer_oriented_statistical_methods/false_position.cpp

@@ -25,29 +25,36 @@
 
 /** define \f$f(x)\f$ to find root for
  */
-static double eq(double i) {
+static double eq(double i)
+{
     return (std::pow(i, 3) - (4 * i) - 9);  // origial equation
 }
 
 /** get the sign of any given number */
 template <typename T>
-int sgn(T val) {
+int sgn(T val)
+{
     return (T(0) < val) - (val < T(0));
 }
 
 /** main function */
-int main() {
+int main()
+{
     double a = -1, b = 1, x, z, m, n, c;
     int i;
 
     // loop to find initial intervals a, b
-    for (int i = 0; i < MAX_ITERATIONS; i++) {
+    for (int i = 0; i < MAX_ITERATIONS; i++)
+    {
         z = eq(a);
         x = eq(b);
-        if (sgn(z) == sgn(x)) {  // same signs, increase interval
+        if (sgn(z) == sgn(x))
+        {  // same signs, increase interval
             b++;
             a--;
-        } else {  // if opposite signs, we got our interval
+        }
+        else
+        {  // if opposite signs, we got our interval
             break;
         }
     }
@@ -55,7 +62,8 @@ int main() {
     std::cout << "\nFirst initial: " << a;
     std::cout << "\nSecond initial: " << b;
 
-    for (i = 0; i < MAX_ITERATIONS; i++) {
+    for (i = 0; i < MAX_ITERATIONS; i++)
+    {
         m = eq(a);
         n = eq(b);
 
@@ -64,7 +72,8 @@ int main() {
         a = c;
         z = eq(c);
 
-        if (std::abs(z) < EPSILON) {  // stoping criteria
+        if (std::abs(z) < EPSILON)
+        {  // stoping criteria
             break;
         }
     }

computer_oriented_statistical_methods/gaussian_elimination.cpp

@@ -6,7 +6,8 @@
 #include <iostream>
 
 /** Main function */
-int main() {
+int main()
+{
     int mat_size, i, j, step;
 
     std::cout << "Matrix size: ";
@@ -14,7 +15,8 @@ int main() {
 
     // create a 2D matrix by dynamic memory allocation
     double **mat = new double *[mat_size + 1], **x = new double *[mat_size];
-    for (i = 0; i <= mat_size; i++) {
+    for (i = 0; i <= mat_size; i++)
+    {
         mat[i] = new double[mat_size + 1];
         if (i < mat_size)
             x[i] = new double[mat_size + 1];
@@ -22,16 +24,20 @@ int main() {
 
     // get the matrix elements from user
     std::cout << std::endl << "Enter value of the matrix: " << std::endl;
-    for (i = 0; i < mat_size; i++) {
-        for (j = 0; j <= mat_size; j++) {
+    for (i = 0; i < mat_size; i++)
+    {
+        for (j = 0; j <= mat_size; j++)
+        {
             std::cin >>
                 mat[i][j];  // Enter (mat_size*mat_size) value of the matrix.
         }
     }
 
     // perform Gaussian elimination
-    for (step = 0; step < mat_size - 1; step++) {
-        for (i = step; i < mat_size - 1; i++) {
+    for (step = 0; step < mat_size - 1; step++)
+    {
+        for (i = step; i < mat_size - 1; i++)
+        {
             double a = (mat[i + 1][step] / mat[step][step]);
 
             for (j = step; j <= mat_size; j++)
@@ -41,8 +47,10 @@ int main() {
 
     std::cout << std::endl
               << "Matrix using Gaussian Elimination method: " << std::endl;
-    for (i = 0; i < mat_size; i++) {
-        for (j = 0; j <= mat_size; j++) {
+    for (i = 0; i < mat_size; i++)
+    {
+        for (j = 0; j <= mat_size; j++)
+        {
             x[i][j] = mat[i][j];
             std::cout << mat[i][j] << " ";
         }
@@ -50,9 +58,11 @@ int main() {
     }
     std::cout << std::endl
               << "Value of the Gaussian Elimination method: " << std::endl;
-    for (i = mat_size - 1; i >= 0; i--) {
+    for (i = mat_size - 1; i >= 0; i--)
+    {
         double sum = 0;
-        for (j = mat_size - 1; j > i; j--) {
+        for (j = mat_size - 1; j > i; j--)
+        {
             x[i][j] = x[j][j] * x[i][j];
             sum = x[i][j] + sum;
         }
@@ -64,7 +74,8 @@ int main() {
         std::cout << "x" << i << "= " << x[i][i] << std::endl;
     }
 
-    for (i = 0; i <= mat_size; i++) {
+    for (i = 0; i <= mat_size; i++)
+    {
         delete[] mat[i];
         if (i < mat_size)
             delete[] x[i];

computer_oriented_statistical_methods/newton_raphson_method.cpp

@@ -21,18 +21,21 @@
 
 /** define \f$f(x)\f$ to find root for
  */
-static double eq(double i) {
+static double eq(double i)
+{
     return (std::pow(i, 3) - (4 * i) - 9);  // original equation
 }
 
 /** define the derivative function \f$f'(x)\f$
  */
-static double eq_der(double i) {
+static double eq_der(double i)
+{
     return ((3 * std::pow(i, 2)) - 4);  // derivative of equation
 }
 
 /** Main function */
-int main() {
+int main()
+{
     std::srand(std::time(nullptr));  // initialize randomizer
 
     double z, c = std::rand() % 100, m, n;
@@ -41,7 +44,8 @@ int main() {
     std::cout << "\nInitial approximation: " << c;
 
     // start iterations
-    for (i = 0; i < MAX_ITERATIONS; i++) {
+    for (i = 0; i < MAX_ITERATIONS; i++)
+    {
         m = eq(c);
         n = eq_der(c);
 

computer_oriented_statistical_methods/ordinary_least_squares_regressor.cpp

@@ -16,11 +16,13 @@
  */
 template <typename T>
 std::ostream &operator<<(std::ostream &out,
-                         std::vector<std::vector<T>> const &v) {
+                         std::vector<std::vector<T>> const &v)
+{
     const int width = 10;
     const char separator = ' ';
 
-    for (size_t row = 0; row < v.size(); row++) {
+    for (size_t row = 0; row < v.size(); row++)
+    {
         for (size_t col = 0; col < v[row].size(); col++)
             out << std::left << std::setw(width) << std::setfill(separator)
                 << v[row][col];
@@ -34,7 +36,8 @@ std::ostream &operator<<(std::ostream &out,
  * operator to print a vector
  */
 template <typename T>
-std::ostream &operator<<(std::ostream &out, std::vector<T> const &v) {
+std::ostream &operator<<(std::ostream &out, std::vector<T> const &v)
+{
     const int width = 15;
     const char separator = ' ';
 
@@ -50,7 +53,8 @@ std::ostream &operator<<(std::ostream &out, std::vector<T> const &v) {
  * \returns 1 if true, 0 if false
  */
 template <typename T>
-inline bool is_square(std::vector<std::vector<T>> const &A) {
+inline bool is_square(std::vector<std::vector<T>> const &A)
+{
     // Assuming A is square matrix
     size_t N = A.size();
     for (size_t i = 0; i < N; i++)
@@ -68,7 +72,8 @@ inline bool is_square(std::vector<std::vector<T>> const &A) {
  **/
 template <typename T>
 std::vector<std::vector<T>> operator*(std::vector<std::vector<T>> const &A,
-                                      std::vector<std::vector<T>> const &B) {
+                                      std::vector<std::vector<T>> const &B)
+{
     // Number of rows in A
     size_t N_A = A.size();
     // Number of columns in B
@@ -76,15 +81,18 @@ std::vector<std::vector<T>> operator*(std::vector<std::vector<T>> const &A,
 
     std::vector<std::vector<T>> result(N_A);
 
-    if (A[0].size() != B.size()) {
+    if (A[0].size() != B.size())
+    {
         std::cerr << "Number of columns in A != Number of rows in B ("
                   << A[0].size() << ", " << B.size() << ")" << std::endl;
         return result;
     }
 
-    for (size_t row = 0; row < N_A; row++) {
+    for (size_t row = 0; row < N_A; row++)
+    {
         std::vector<T> v(N_B);
-        for (size_t col = 0; col < N_B; col++) {
+        for (size_t col = 0; col < N_B; col++)
+        {
             v[col] = static_cast<T>(0);
             for (size_t j = 0; j < B.size(); j++)
                 v[col] += A[row][j] * B[j][col];
@@ -101,19 +109,22 @@ std::vector<std::vector<T>> operator*(std::vector<std::vector<T>> const &A,
  */
 template <typename T>
 std::vector<T> operator*(std::vector<std::vector<T>> const &A,
-                         std::vector<T> const &B) {
+                         std::vector<T> const &B)
+{
     // Number of rows in A
     size_t N_A = A.size();
 
     std::vector<T> result(N_A);
 
-    if (A[0].size() != B.size()) {
+    if (A[0].size() != B.size())
+    {
         std::cerr << "Number of columns in A != Number of rows in B ("
                   << A[0].size() << ", " << B.size() << ")" << std::endl;
         return result;
     }
 
-    for (size_t row = 0; row < N_A; row++) {
+    for (size_t row = 0; row < N_A; row++)
+    {
         result[row] = static_cast<T>(0);
         for (size_t j = 0; j < B.size(); j++) result[row] += A[row][j] * B[j];
     }
@@ -126,13 +137,15 @@ std::vector<T> operator*(std::vector<std::vector<T>> const &A,
  * \returns resultant vector
  */
 template <typename T>
-std::vector<float> operator*(float const scalar, std::vector<T> const &A) {
+std::vector<float> operator*(float const scalar, std::vector<T> const &A)
+{
     // Number of rows in A
     size_t N_A = A.size();
 
     std::vector<float> result(N_A);
 
-    for (size_t row = 0; row < N_A; row++) {
+    for (size_t row = 0; row < N_A; row++)
+    {
         result[row] += A[row] * static_cast<float>(scalar);
     }
 
@@ -144,7 +157,8 @@ std::vector<float> operator*(float const scalar, std::vector<T> const &A) {
  * \returns resultant vector
  */
 template <typename T>
-std::vector<float> operator*(std::vector<T> const &A, float const scalar) {
+std::vector<float> operator*(std::vector<T> const &A, float const scalar)
+{
     // Number of rows in A
     size_t N_A = A.size();
 
@@ -161,7 +175,8 @@ std::vector<float> operator*(std::vector<T> const &A, float const scalar) {
  * \returns resultant vector
  */
 template <typename T>
-std::vector<float> operator/(std::vector<T> const &A, float const scalar) {
+std::vector<float> operator/(std::vector<T> const &A, float const scalar)
+{
     return (1.f / scalar) * A;
 }
 
@@ -170,13 +185,15 @@ std::vector<float> operator/(std::vector<T> const &A, float const scalar) {
  * \returns resultant vector
  */
 template <typename T>
-std::vector<T> operator-(std::vector<T> const &A, std::vector<T> const &B) {
+std::vector<T> operator-(std::vector<T> const &A, std::vector<T> const &B)
+{
     // Number of rows in A
     size_t N = A.size();
 
     std::vector<T> result(N);
 
-    if (B.size() != N) {
+    if (B.size() != N)
+    {
         std::cerr << "Vector dimensions shouldbe identical!" << std::endl;
         return A;
     }
@@ -191,13 +208,15 @@ std::vector<T> operator-(std::vector<T> const &A, std::vector<T> const &B) {
  * \returns resultant vector
  */
 template <typename T>
-std::vector<T> operator+(std::vector<T> const &A, std::vector<T> const &B) {
+std::vector<T> operator+(std::vector<T> const &A, std::vector<T> const &B)
+{
     // Number of rows in A
     size_t N = A.size();
 
     std::vector<T> result(N);
 
-    if (B.size() != N) {
+    if (B.size() != N)
+    {
         std::cerr << "Vector dimensions shouldbe identical!" << std::endl;
         return A;
     }
@@ -214,26 +233,30 @@ std::vector<T> operator+(std::vector<T> const &A, std::vector<T> const &B) {
  **/
 template <typename T>
 std::vector<std::vector<float>> get_inverse(
-    std::vector<std::vector<T>> const &A) {
+    std::vector<std::vector<T>> const &A)
+{
     // Assuming A is square matrix
     size_t N = A.size();
 
     std::vector<std::vector<float>> inverse(N);
-    for (size_t row = 0; row < N; row++) {
+    for (size_t row = 0; row < N; row++)
+    {
         // preallocatae a resultant identity matrix
         inverse[row] = std::vector<float>(N);
         for (size_t col = 0; col < N; col++)
             inverse[row][col] = (row == col) ? 1.f : 0.f;
     }
 
-    if (!is_square(A)) {
+    if (!is_square(A))
+    {
         std::cerr << "A must be a square matrix!" << std::endl;
         return inverse;
     }
 
     // preallocatae a temporary matrix identical to A
     std::vector<std::vector<float>> temp(N);
-    for (size_t row = 0; row < N; row++) {
+    for (size_t row = 0; row < N; row++)
+    {
         std::vector<float> v(N);
         for (size_t col = 0; col < N; col++)
             v[col] = static_cast<float>(A[row][col]);
@@ -241,22 +264,27 @@ std::vector<std::vector<float>> get_inverse(
     }
 
     // start transformations
-    for (size_t row = 0; row < N; row++) {
-        for (size_t row2 = row; row2 < N && temp[row][row] == 0; row2++) {
+    for (size_t row = 0; row < N; row++)
+    {
+        for (size_t row2 = row; row2 < N && temp[row][row] == 0; row2++)
+        {
             // this to ensure diagonal elements are not 0
             temp[row] = temp[row] + temp[row2];
             inverse[row] = inverse[row] + inverse[row2];
         }
 
-        for (size_t col2 = row; col2 < N && temp[row][row] == 0; col2++) {
+        for (size_t col2 = row; col2 < N && temp[row][row] == 0; col2++)
+        {
             // this to further ensure diagonal elements are not 0
-            for (size_t row2 = 0; row2 < N; row2++) {
+            for (size_t row2 = 0; row2 < N; row2++)
+            {
                 temp[row2][row] = temp[row2][row] + temp[row2][col2];
                 inverse[row2][row] = inverse[row2][row] + inverse[row2][col2];
             }
         }
 
-        if (temp[row][row] == 0) {
+        if (temp[row][row] == 0)
+        {
             // Probably a low-rank matrix and hence singular
             std::cerr << "Low-rank matrix, no inverse!" << std::endl;
             return inverse;
@@ -267,7 +295,8 @@ std::vector<std::vector<float>> get_inverse(
         temp[row] = temp[row] / divisor;
         inverse[row] = inverse[row] / divisor;
         // Row transformations
-        for (size_t row2 = 0; row2 < N; row2++) {
+        for (size_t row2 = 0; row2 < N; row2++)
+        {
             if (row2 == row)
                 continue;
             float factor = temp[row2][row];
@@ -284,11 +313,12 @@ std::vector<std::vector<float>> get_inverse(
  * \returns resultant matrix
  **/
 template <typename T>
-std::vector<std::vector<T>> get_transpose(
-    std::vector<std::vector<T>> const &A) {
+std::vector<std::vector<T>> get_transpose(std::vector<std::vector<T>> const &A)
+{
     std::vector<std::vector<T>> result(A[0].size());
 
-    for (size_t row = 0; row < A[0].size(); row++) {
+    for (size_t row = 0; row < A[0].size(); row++)
+    {
         std::vector<T> v(A.size());
         for (size_t col = 0; col < A.size(); col++) v[col] = A[col][row];
 
@@ -306,7 +336,8 @@ std::vector<std::vector<T>> get_transpose(
  */
 template <typename T>
 std::vector<float> fit_OLS_regressor(std::vector<std::vector<T>> const &X,
-                                     std::vector<T> const &Y) {
+                                     std::vector<T> const &Y)
+{
     // NxF
     std::vector<std::vector<T>> X2 = X;
     for (size_t i = 0; i < X2.size(); i++)
@@ -337,10 +368,12 @@ std::vector<float> fit_OLS_regressor(std::vector<std::vector<T>> const &X,
 template <typename T>
 std::vector<float> predict_OLS_regressor(std::vector<std::vector<T>> const &X,
                                          std::vector<float> const &beta /**< */
-) {
+)
+{
     std::vector<float> result(X.size());
 
-    for (size_t rows = 0; rows < X.size(); rows++) {
+    for (size_t rows = 0; rows < X.size(); rows++)
+    {
         // -> start with constant term
         result[rows] = beta[X[0].size()];
         for (size_t cols = 0; cols < X[0].size(); cols++)
@@ -353,7 +386,8 @@ std::vector<float> predict_OLS_regressor(std::vector<std::vector<T>> const &X,
 /**
  * main function
  */
-int main() {
+int main()
+{
     size_t N, F;
 
     std::cout << "Enter number of features: ";
@@ -370,7 +404,8 @@ int main() {
         << "Enter training data. Per sample, provide features ad one output."
         << std::endl;
 
-    for (size_t rows = 0; rows < N; rows++) {
+    for (size_t rows = 0; rows < N; rows++)
+    {
         std::vector<float> v(F);
         std::cout << "Sample# " << rows + 1 << ": ";
         for (size_t cols = 0; cols < F; cols++)
@@ -391,7 +426,8 @@ int main() {
     std::vector<std::vector<float>> data2(T);
     // vector<float> Y2(T);
 
-    for (size_t rows = 0; rows < T; rows++) {
+    for (size_t rows = 0; rows < T; rows++)
+    {
         std::cout << "Sample# " << rows + 1 << ": ";
         std::vector<float> v(F);
         for (size_t cols = 0; cols < F; cols++) std::cin >> v[cols];

computer_oriented_statistical_methods/successive_approximation.cpp

@@ -17,11 +17,13 @@ static float eq(float y) { return (3 * y) - cos(y) - 2; }
 static float eqd(float y) { return 0.5 * (cos(y) + 2); }
 
 /** Main function */
-int main() {
+int main()
+{
     float y, x1, x2, x3, sum, s, a, f1, f2, gd;
     int i, n;
 
-    for (i = 0; i < 10; i++) {
+    for (i = 0; i < 10; i++)
+    {
         sum = eq(y);
         std::cout << "value of equation at " << i << " " << sum << "\n";
         y++;
@@ -31,7 +33,8 @@ int main() {
     std::cout << "enter the no iteration to perform->\n";
     std::cin >> n;
 
-    for (i = 0; i <= n; i++) {
+    for (i = 0; i <= n; i++)
+    {
         x2 = eqd(x1);
         std::cout << "\nenter the x2->" << x2;
         x1 = x2;

data_structure/avltree.cpp

@@ -5,172 +5,165 @@ using namespace std;
 
 typedef struct node
 {
-	int data;
-	int height;
-	struct node *left;
-	struct node *right;
+    int data;
+    int height;
+    struct node *left;
+    struct node *right;
 } node;
 
-int max(int a, int b)
-{
-	return a > b ? a : b;
-}
+int max(int a, int b) { return a > b ? a : b; }
 
 // Returns a new Node
 
 node *createNode(int data)
 {
-	node *nn = new node();
-	nn->data = data;
-	nn->height = 0;
-	nn->left = NULL;
-	nn->right = NULL;
-	return nn;
+    node *nn = new node();
+    nn->data = data;
+    nn->height = 0;
+    nn->left = NULL;
+    nn->right = NULL;
+    return nn;
 }
 
 // Returns height of tree
 
 int height(node *root)
 {
-	if (root == NULL)
-		return 0;
-	return 1 + max(height(root->left), height(root->right));
+    if (root == NULL)
+        return 0;
+    return 1 + max(height(root->left), height(root->right));
 }
 
 // Returns difference between height of left and right subtree
 
-int getBalance(node *root)
-{
-	return height(root->left) - height(root->right);
-}
+int getBalance(node *root) { return height(root->left) - height(root->right); }
 
 // Returns Node after Right Rotation
 
 node *rightRotate(node *root)
 {
-	node *t = root->left;
-	node *u = t->right;
-	t->right = root;
-	root->left = u;
-	return t;
+    node *t = root->left;
+    node *u = t->right;
+    t->right = root;
+    root->left = u;
+    return t;
 }
 
 // Returns Node after Left Rotation
 
 node *leftRotate(node *root)
 {
-	node *t = root->right;
-	node *u = t->left;
-	t->left = root;
-	root->right = u;
-	return t;
+    node *t = root->right;
+    node *u = t->left;
+    t->left = root;
+    root->right = u;
+    return t;
 }
 
 // Returns node with minimum value in the tree
 
 node *minValue(node *root)
 {
-	if (root->left == NULL)
-		return root;
-	return minValue(root->left);
+    if (root->left == NULL)
+        return root;
+    return minValue(root->left);
 }
 
 // Balanced Insertion
 
 node *insert(node *root, int item)
 {
-	node *nn = createNode(item);
-	if (root == NULL)
-		return nn;
-	if (item < root->data)
-		root->left = insert(root->left, item);
-	else
-		root->right = insert(root->right, item);
-	int b = getBalance(root);
-	if (b > 1)
-	{
-		if (getBalance(root->left) < 0)
-			root->left = leftRotate(root->left); // Left-Right Case
-		return rightRotate(root);				 // Left-Left Case
-	}
-	else if (b < -1)
-	{
-		if (getBalance(root->right) > 0)
-			root->right = rightRotate(root->right); // Right-Left Case
-		return leftRotate(root);					// Right-Right Case
-	}
-	return root;
+    node *nn = createNode(item);
+    if (root == NULL)
+        return nn;
+    if (item < root->data)
+        root->left = insert(root->left, item);
+    else
+        root->right = insert(root->right, item);
+    int b = getBalance(root);
+    if (b > 1)
+    {
+        if (getBalance(root->left) < 0)
+            root->left = leftRotate(root->left);  // Left-Right Case
+        return rightRotate(root);                 // Left-Left Case
+    }
+    else if (b < -1)
+    {
+        if (getBalance(root->right) > 0)
+            root->right = rightRotate(root->right);  // Right-Left Case
+        return leftRotate(root);                     // Right-Right Case
+    }
+    return root;
 }
 
 // Balanced Deletion
 
 node *deleteNode(node *root, int key)
 {
-	if (root == NULL)
-		return root;
-	if (key < root->data)
-		root->left = deleteNode(root->left, key);
-	else if (key > root->data)
-		root->right = deleteNode(root->right, key);
+    if (root == NULL)
+        return root;
+    if (key < root->data)
+        root->left = deleteNode(root->left, key);
+    else if (key > root->data)
+        root->right = deleteNode(root->right, key);
 
-	else
-	{
-		// Node to be deleted is leaf node or have only one Child
-		if (!root->right)
-		{
-			node *temp = root->left;
-			delete (root);
-			root = NULL;
-			return temp;
-		}
-		else if (!root->left)
-		{
-			node *temp = root->right;
-			delete (root);
-			root = NULL;
-			return temp;
-		}
-		// Node to be deleted have both left and right subtrees
-		node *temp = minValue(root->right);
-		root->data = temp->data;
-		root->right = deleteNode(root->right, temp->data);
-	}
-	// Balancing Tree after deletion
-	return root;
+    else
+    {
+        // Node to be deleted is leaf node or have only one Child
+        if (!root->right)
+        {
+            node *temp = root->left;
+            delete (root);
+            root = NULL;
+            return temp;
+        }
+        else if (!root->left)
+        {
+            node *temp = root->right;
+            delete (root);
+            root = NULL;
+            return temp;
+        }
+        // Node to be deleted have both left and right subtrees
+        node *temp = minValue(root->right);
+        root->data = temp->data;
+        root->right = deleteNode(root->right, temp->data);
+    }
+    // Balancing Tree after deletion
+    return root;
 }
 
 // LevelOrder (Breadth First Search)
 
 void levelOrder(node *root)
 {
-	queue<node *> q;
-	q.push(root);
-	while (!q.empty())
-	{
-		root = q.front();
-		cout << root->data << " ";
-		q.pop();
-		if (root->left)
-			q.push(root->left);
-		if (root->right)
-			q.push(root->right);
-	}
+    queue<node *> q;
+    q.push(root);
+    while (!q.empty())
+    {
+        root = q.front();
+        cout << root->data << " ";
+        q.pop();
+        if (root->left)
+            q.push(root->left);
+        if (root->right)
+            q.push(root->right);
+    }
 }
 
 int main()
 {
-	// Testing AVL Tree
-	node *root = NULL;
-	int i;
-	for (i = 1; i <= 7; i++)
-		root = insert(root, i);
-	cout << "LevelOrder: ";
-	levelOrder(root);
-	root = deleteNode(root, 1); // Deleting key with value 1
-	cout << "\nLevelOrder: ";
-	levelOrder(root);
-	root = deleteNode(root, 4); // Deletin key with value 4
-	cout << "\nLevelOrder: ";
-	levelOrder(root);
-	return 0;
+    // Testing AVL Tree
+    node *root = NULL;
+    int i;
+    for (i = 1; i <= 7; i++) root = insert(root, i);
+    cout << "LevelOrder: ";
+    levelOrder(root);
+    root = deleteNode(root, 1);  // Deleting key with value 1
+    cout << "\nLevelOrder: ";
+    levelOrder(root);
+    root = deleteNode(root, 4);  // Deletin key with value 4
+    cout << "\nLevelOrder: ";
+    levelOrder(root);
+    return 0;
 }

data_structure/binary_search_tree.cpp

@@ -3,216 +3,210 @@ using namespace std;
 
 struct node
 {
-	int val;
-	node *left;
-	node *right;
+    int val;
+    node *left;
+    node *right;
 };
 
 struct queue
 {
-	node *t[100];
-	int front;
-	int rear;
+    node *t[100];
+    int front;
+    int rear;
 };
 
 queue q;
 
-void enqueue(node *n)
-{
-	q.t[q.rear++] = n;
-}
+void enqueue(node *n) { q.t[q.rear++] = n; }
 
-node *dequeue()
-{
-	return (q.t[q.front++]);
-}
+node *dequeue() { return (q.t[q.front++]); }
 
 void Insert(node *n, int x)
 {
-	if (x < n->val)
-	{
-		if (n->left == NULL)
-		{
-			node *temp = new node;
-			temp->val = x;
-			temp->left = NULL;
-			temp->right = NULL;
-			n->left = temp;
-		}
-		else
-		{
-			Insert(n->left, x);
-		}
-	}
-	else
-	{
-		if (n->right == NULL)
-		{
-			node *temp = new node;
-			temp->val = x;
-			temp->left = NULL;
-			temp->right = NULL;
-			n->left = temp;
-		}
-		else
-		{
-			Insert(n->right, x);
-		}
-	}
+    if (x < n->val)
+    {
+        if (n->left == NULL)
+        {
+            node *temp = new node;
+            temp->val = x;
+            temp->left = NULL;
+            temp->right = NULL;
+            n->left = temp;
+        }
+        else
+        {
+            Insert(n->left, x);
+        }
+    }
+    else
+    {
+        if (n->right == NULL)
+        {
+            node *temp = new node;
+            temp->val = x;
+            temp->left = NULL;
+            temp->right = NULL;
+            n->left = temp;
+        }
+        else
+        {
+            Insert(n->right, x);
+        }
+    }
 }
 
 int findMaxInLeftST(node *n)
 {
-	while (n->right != NULL)
-	{
-		n = n->right;
-	}
-	return n->val;
+    while (n->right != NULL)
+    {
+        n = n->right;
+    }
+    return n->val;
 }
 
 void Remove(node *p, node *n, int x)
 {
-	if (n->val == x)
-	{
-		if (n->right == NULL && n->left == NULL)
-		{
-			if (x < p->val)
-			{
-				p->right = NULL;
-			}
-			else
-			{
-				p->left = NULL;
-			}
-		}
-		else if (n->right == NULL)
-		{
-			if (x < p->val)
-			{
-				p->right = n->left;
-			}
-			else
-			{
-				p->left = n->left;
-			}
-		}
-		else if (n->left == NULL)
-		{
-			if (x < p->val)
-			{
-				p->right = n->right;
-			}
-			else
-			{
-				p->left = n->right;
-			}
-		}
-		else
-		{
-			int y = findMaxInLeftST(n->left);
-			n->val = y;
-			Remove(n, n->right, y);
-		}
-	}
-	else if (x < n->val)
-	{
-		Remove(n, n->left, x);
-	}
-	else
-	{
-		Remove(n, n->right, x);
-	}
+    if (n->val == x)
+    {
+        if (n->right == NULL && n->left == NULL)
+        {
+            if (x < p->val)
+            {
+                p->right = NULL;
+            }
+            else
+            {
+                p->left = NULL;
+            }
+        }
+        else if (n->right == NULL)
+        {
+            if (x < p->val)
+            {
+                p->right = n->left;
+            }
+            else
+            {
+                p->left = n->left;
+            }
+        }
+        else if (n->left == NULL)
+        {
+            if (x < p->val)
+            {
+                p->right = n->right;
+            }
+            else
+            {
+                p->left = n->right;
+            }
+        }
+        else
+        {
+            int y = findMaxInLeftST(n->left);
+            n->val = y;
+            Remove(n, n->right, y);
+        }
+    }
+    else if (x < n->val)
+    {
+        Remove(n, n->left, x);
+    }
+    else
+    {
+        Remove(n, n->right, x);
+    }
 }
 
 void BFT(node *n)
 {
-	if (n != NULL)
-	{
-		cout << n->val << "  ";
-		enqueue(n->left);
-		enqueue(n->right);
-		BFT(dequeue());
-	}
+    if (n != NULL)
+    {
+        cout << n->val << "  ";
+        enqueue(n->left);
+        enqueue(n->right);
+        BFT(dequeue());
+    }
 }
 
 void Pre(node *n)
 {
-	if (n != NULL)
-	{
-		cout << n->val << "  ";
-		Pre(n->left);
-		Pre(n->right);
-	}
+    if (n != NULL)
+    {
+        cout << n->val << "  ";
+        Pre(n->left);
+        Pre(n->right);
+    }
 }
 
 void In(node *n)
 {
-	if (n != NULL)
-	{
-		In(n->left);
-		cout << n->val << "  ";
-		In(n->right);
-	}
+    if (n != NULL)
+    {
+        In(n->left);
+        cout << n->val << "  ";
+        In(n->right);
+    }
 }
 
 void Post(node *n)
 {
-	if (n != NULL)
-	{
-		Post(n->left);
-		Post(n->right);
-		cout << n->val << "  ";
-	}
+    if (n != NULL)
+    {
+        Post(n->left);
+        Post(n->right);
+        cout << n->val << "  ";
+    }
 }
 
 int main()
 {
-	q.front = 0;
-	q.rear = 0;
-	int value;
-	int ch;
-	node *root = new node;
-	cout << "\nEnter the value of root node :";
-	cin >> value;
-	root->val = value;
-	root->left = NULL;
-	root->right = NULL;
-	do
-	{
-		cout << "\n1. Insert";
-		cout << "\n2. Delete";
-		cout << "\n3. Breadth First";
-		cout << "\n4. Preorder Depth First";
-		cout << "\n5. Inorder Depth First";
-		cout << "\n6. Postorder Depth First";
+    q.front = 0;
+    q.rear = 0;
+    int value;
+    int ch;
+    node *root = new node;
+    cout << "\nEnter the value of root node :";
+    cin >> value;
+    root->val = value;
+    root->left = NULL;
+    root->right = NULL;
+    do
+    {
+        cout << "\n1. Insert";
+        cout << "\n2. Delete";
+        cout << "\n3. Breadth First";
+        cout << "\n4. Preorder Depth First";
+        cout << "\n5. Inorder Depth First";
+        cout << "\n6. Postorder Depth First";
 
-		cout << "\nEnter Your Choice : ";
-		cin >> ch;
-		int x;
-		switch (ch)
-		{
-		case 1:
-			cout << "\nEnter the value to be Inserted : ";
-			cin >> x;
-			Insert(root, x);
-			break;
-		case 2:
-			cout << "\nEnter the value to be Deleted : ";
-			cin >> x;
-			Remove(root, root, x);
-			break;
-		case 3:
-			BFT(root);
-			break;
-		case 4:
-			Pre(root);
-			break;
-		case 5:
-			In(root);
-			break;
-		case 6:
-			Post(root);
-			break;
-		}
-	} while (ch != 0);
+        cout << "\nEnter Your Choice : ";
+        cin >> ch;
+        int x;
+        switch (ch)
+        {
+        case 1:
+            cout << "\nEnter the value to be Inserted : ";
+            cin >> x;
+            Insert(root, x);
+            break;
+        case 2:
+            cout << "\nEnter the value to be Deleted : ";
+            cin >> x;
+            Remove(root, root, x);
+            break;
+        case 3:
+            BFT(root);
+            break;
+        case 4:
+            Pre(root);
+            break;
+        case 5:
+            In(root);
+            break;
+        case 6:
+            Post(root);
+            break;
+        }
+    } while (ch != 0);
 }

data_structure/binaryheap.cpp

@@ -1,6 +1,6 @@
 // A C++ program to demonstrate common Binary Heap Operations
-#include <iostream>
 #include <climits>
+#include <iostream>
 using namespace std;
 
 // Prototype of a utility function to swap two integers
@@ -9,10 +9,10 @@ void swap(int *x, int *y);
 // A class for Min Heap
 class MinHeap
 {
-    int *harr;     // pointer to array of elements in heap
-    int capacity;  // maximum possible size of min heap
-    int heap_size; // Current number of elements in min heap
-public:
+    int *harr;      // pointer to array of elements in heap
+    int capacity;   // maximum possible size of min heap
+    int heap_size;  // Current number of elements in min heap
+ public:
     // Constructor
     MinHeap(int capacity);
 

data_structure/circular_queue_using_linked_list.cpp

@@ -11,7 +11,7 @@ class Queue
     node *front;
     node *rear;
 
-public:
+ public:
     Queue()
     {
         front = NULL;

data_structure/cll/cll.cpp

@@ -11,10 +11,7 @@ cll::cll()
     total = 0;
 }
 
-cll::~cll()
-{
-    /* Desstructure, no need to fill */
-}
+cll::~cll() { /* Desstructure, no need to fill */ }
 
 /* Display a list. and total element */
 void cll::display()
@@ -28,10 +25,10 @@ void cll::display()
         for (int i = 0; i < total; i++)
         {
             cout << current->data << " -> ";
-            current = current ->next;
+            current = current->next;
         }
         cout << head->data << endl;
-        cout << "Total element: "<< total <<endl;
+        cout << "Total element: " << total << endl;
     }
 }
 
@@ -42,12 +39,16 @@ void cll::insert_front(int new_data)
     newNode = new node;
     newNode->data = new_data;
     newNode->next = NULL;
-    if(head==NULL) {
+    if (head == NULL)
+    {
         head = newNode;
-        head -> next = head;
-    } else {
+        head->next = head;
+    }
+    else
+    {
         node *current = head;
-        while (current -> next != head) {
+        while (current->next != head)
+        {
             current = current->next;
         }
         newNode->next = head;
@@ -64,12 +65,16 @@ void cll::insert_tail(int new_data)
     newNode = new node;
     newNode->data = new_data;
     newNode->next = NULL;
-    if(head==NULL) {
+    if (head == NULL)
+    {
         head = newNode;
-        head -> next = head;
-    } else {
+        head->next = head;
+    }
+    else
+    {
         node *current = head;
-        while (current -> next != head) {
+        while (current->next != head)
+        {
             current = current->next;
         }
         current->next = newNode;
@@ -79,22 +84,22 @@ void cll::insert_tail(int new_data)
 }
 
 /* Get total element in list */
-int cll::get_size()
-{
-    return total;
-}
-
+int cll::get_size() { return total; }
 
 /* Return true if the requested item (sent in as an argument)
 is in the list, otherwise return false */
 bool cll::find_item(int item_to_find)
 {
-    if (head == NULL) {
+    if (head == NULL)
+    {
         cout << "List is empty !" << endl;
         return false;
-    } else {
+    }
+    else
+    {
         node *current = head;
-        while (current -> next != head) {
+        while (current->next != head)
+        {
             if (current->data == item_to_find)
                 return true;
             current = current->next;
@@ -104,24 +109,25 @@ bool cll::find_item(int item_to_find)
 }
 
 /* Overloading method*/
-int cll::operator*()
-{
-    return head->data;
-}
+int cll::operator*() { return head->data; }
 
 /* Overload the pre-increment operator.
    The iterator is advanced to the next node. */
 void cll::operator++()
 {
-    if (head == NULL) {
+    if (head == NULL)
+    {
         cout << "List is empty !" << endl;
-    } else {
+    }
+    else
+    {
         node *current = head;
-        while (current -> next != head) {
-            current = current -> next;
+        while (current->next != head)
+        {
+            current = current->next;
         }
-        current->next = head -> next;
-        head = head -> next;
+        current->next = head->next;
+        head = head->next;
     }
     total--;
 }

data_structure/cll/cll.h

@@ -1,45 +1,45 @@
 /*
  * Simple data structure CLL (Cicular Linear Linked List)
  * */
-#include <cstring>
 #include <cctype>
-#include <iostream>
 #include <cstdlib>
+#include <cstring>
+#include <iostream>
 
 #ifndef CLL_H
 #define CLL_H
 /*The data structure is a linear linked list of integers */
 struct node
 {
-	int  data;
-    node * next;
+    int data;
+    node* next;
 };
 
 class cll
 {
-    public:
-        cll();                       /* Construct without parameter */
-        ~cll();
-        void display();              /* Show the list */
+ public:
+    cll(); /* Construct without parameter */
+    ~cll();
+    void display(); /* Show the list */
 
-        /******************************************************
-	    * Useful method for list
-        *******************************************************/
-        void insert_front(int new_data);  /* Insert a new value at head  */
-		void insert_tail(int new_data);   /* Insert a new value at tail */
-		int get_size();              /* Get total element in list */
-        bool find_item(int item_to_find); /* Find an item in list */
+    /******************************************************
+     * Useful method for list
+     *******************************************************/
+    void insert_front(int new_data);  /* Insert a new value at head  */
+    void insert_tail(int new_data);   /* Insert a new value at tail */
+    int get_size();                   /* Get total element in list */
+    bool find_item(int item_to_find); /* Find an item in list */
 
-	    /******************************************************
-	     * Overloading method for list
-         *******************************************************/
-	     int operator*();           /* Returns the info contained in head */
-	     /* Overload the pre-increment operator.
-	        The iterator is advanced to the next node. */
-	     void operator++();
+    /******************************************************
+     * Overloading method for list
+     *******************************************************/
+    int operator*(); /* Returns the info contained in head */
+    /* Overload the pre-increment operator.
+       The iterator is advanced to the next node. */
+    void operator++();
 
-    protected:
-        node * head;
-		int total;      /* Total element in a list */
+ protected:
+    node* head;
+    int total; /* Total element in a list */
 };
 #endif

data_structure/cll/main_cll.cpp

@@ -3,42 +3,42 @@ using namespace std;
 
 int main()
 {
-	/* Test CLL */
-	cout << "----------- Test construct -----------" << endl;
-	cll list1;
-	list1.display();
-	cout << "----------- Test insert front -----------" << endl;
-	list1.insert_front(5);
-	cout << "After insert 5 at front: "<<endl;
+    /* Test CLL */
+    cout << "----------- Test construct -----------" << endl;
+    cll list1;
+    list1.display();
+    cout << "----------- Test insert front -----------" << endl;
+    list1.insert_front(5);
+    cout << "After insert 5 at front: " << endl;
+    list1.display();
+    cout << "After insert 10 3 7 at front: " << endl;
+    list1.insert_front(10);
+    list1.insert_front(3);
+    list1.insert_front(7);
+    list1.display();
+    cout << "----------- Test insert tail -----------" << endl;
+    cout << "After insert 18 19 20 at tail: " << endl;
+    list1.insert_tail(18);
+    list1.insert_tail(19);
+    list1.insert_tail(20);
+    list1.display();
+    cout << "----------- Test find item -----------" << endl;
+    if (list1.find_item(10))
+        cout << "PASS" << endl;
+    else
+        cout << "FAIL" << endl;
+    if (!list1.find_item(30))
+        cout << "PASS" << endl;
+    else
+        cout << "FAIL" << endl;
+    cout << "----------- Test * operator -----------" << endl;
+    int value = *list1;
+    cout << "Value at *list1: " << value << endl;
+    cout << "----------- Test ++ operator -----------" << endl;
+    list1.display();
+    ++list1;
+    cout << "After ++list1: " << endl;
     list1.display();
-	cout << "After insert 10 3 7 at front: "<<endl;
-	list1.insert_front(10);
-	list1.insert_front(3);
-	list1.insert_front(7);
-	list1.display();
-	cout << "----------- Test insert tail -----------" << endl;
-	cout << "After insert 18 19 20 at tail: "<<endl;
-	list1.insert_tail(18);
-	list1.insert_tail(19);
-	list1.insert_tail(20);
-	list1.display();
-	cout << "----------- Test find item -----------" << endl;
-	if (list1.find_item(10))
-		cout << "PASS" << endl;
-	else
-		cout << "FAIL" << endl;
-	if (!list1.find_item(30))
-		cout << "PASS" << endl;
-	else
-		cout << "FAIL" << endl;
-	cout << "----------- Test * operator -----------" << endl;
-	int value = *list1;
-	cout << "Value at *list1: " << value <<endl;
-	cout << "----------- Test ++ operator -----------" << endl;
-	list1.display();
-	++list1;
-	cout << "After ++list1: " <<endl;
-	list1.display();
 
-	return 0;
+    return 0;
 }

data_structure/disjoint_set.cpp

@@ -7,58 +7,72 @@ using std::vector;
 
 vector<int> root, rnk;
 
-void CreateSet(int n) {
-  root = vector<int> (n+1);
-  rnk = vector<int> (n+1, 1);
-  for (int i = 1; i <= n; ++i) {
-    root[i] = i;
-  }
-}
-
-int Find(int x) {
-  if (root[x] == x) {
-    return x;
-  }
-  return root[x] = Find(root[x]);
-}
-
-bool InSameUnion(int x, int y) {
-  return Find(x) == Find(y);
-}
-
-void Union(int x, int y) {
-  int a = Find(x), b = Find(y);
-  if (a != b) {
-    if (rnk[a] < rnk[b]) {
-      root[a] = b;
-    } else if (rnk[a] > rnk[b]) {
-      root[b] = a;
-    } else {
-      root[a] = b;
-      ++rnk[b];
+void CreateSet(int n)
+{
+    root = vector<int>(n + 1);
+    rnk = vector<int>(n + 1, 1);
+    for (int i = 1; i <= n; ++i)
+    {
+        root[i] = i;
     }
-  }
 }
 
-int main() {
-  // tests CreateSet & Find
-  int n = 100;
-  CreateSet(n);
-  for (int i = 1; i <= 100; ++i) {
-    if (root[i] != i) {
-      cout << "Fail" << endl;
-      break;
+int Find(int x)
+{
+    if (root[x] == x)
+    {
+        return x;
     }
-  }
-  // tests InSameUnion & Union
-  cout << "1 and 2 are initially not in the same subset" << endl;
-  if (InSameUnion(1, 2)) {
-    cout << "Fail" << endl;
-  }
-  Union(1, 2);
-  cout << "1 and 2 are now in the same subset" << endl;
-  if (!InSameUnion(1, 2)) {
-    cout << "Fail" << endl;
-  }
-  return 0;
+    return root[x] = Find(root[x]);
+}
+
+bool InSameUnion(int x, int y) { return Find(x) == Find(y); }
+
+void Union(int x, int y)
+{
+    int a = Find(x), b = Find(y);
+    if (a != b)
+    {
+        if (rnk[a] < rnk[b])
+        {
+            root[a] = b;
+        }
+        else if (rnk[a] > rnk[b])
+        {
+            root[b] = a;
+        }
+        else
+        {
+            root[a] = b;
+            ++rnk[b];
+        }
+    }
+}
+
+int main()
+{
+    // tests CreateSet & Find
+    int n = 100;
+    CreateSet(n);
+    for (int i = 1; i <= 100; ++i)
+    {
+        if (root[i] != i)
+        {
+            cout << "Fail" << endl;
+            break;
+        }
+    }
+    // tests InSameUnion & Union
+    cout << "1 and 2 are initially not in the same subset" << endl;
+    if (InSameUnion(1, 2))
+    {
+        cout << "Fail" << endl;
+    }
+    Union(1, 2);
+    cout << "1 and 2 are now in the same subset" << endl;
+    if (!InSameUnion(1, 2))
+    {
+        cout << "Fail" << endl;
+    }
+    return 0;
 }

data_structure/doubly_linked_list.cpp

@@ -1,138 +1,166 @@
+#include <cstdio>
+#include <cstdlib>
 #include <iostream>
-#include<cstdio>
-#include<cstdlib>
 
-struct node {
-  int val;
-  node *prev;
-  node *next;
-}*start;
+struct node
+{
+    int val;
+    node *prev;
+    node *next;
+} * start;
 
-class double_linked_list {
+class double_linked_list
+{
  public:
-  double_linked_list() {
-    start = NULL;
-  }
-  void insert(int x);
-  void remove(int x);
-  void search(int x);
-  void show();
-  void reverseShow();
+    double_linked_list() { start = NULL; }
+    void insert(int x);
+    void remove(int x);
+    void search(int x);
+    void show();
+    void reverseShow();
 };
 
-void double_linked_list::insert(int x) {
-  node *t = start;
-  if (start != NULL) {
-    while (t->next != NULL) {
-      t = t->next;
+void double_linked_list::insert(int x)
+{
+    node *t = start;
+    if (start != NULL)
+    {
+        while (t->next != NULL)
+        {
+            t = t->next;
+        }
+        node *n = new node;
+        t->next = n;
+        n->prev = t;
+        n->val = x;
+        n->next = NULL;
     }
-    node *n = new node;
-    t->next = n;
-    n->prev = t;
-    n->val = x;
-    n->next = NULL;
-  } else {
-    node *n = new node;
-    n->val = x;
-    n->prev = NULL;
-    n->next = NULL;
-    start = n;
-  }
-}
-
-void double_linked_list::remove(int x) {
-  node *t = start;
-  while (t != NULL && t->val != x) {
-    t = t-> next;
-  }
-  if (t == NULL) {
-    return;
-  }
-  if (t->prev == NULL) {
-    if (t->next == NULL) {
-      start = NULL;
-    } else {
-      start = t->next;
-      start->prev = NULL;
+    else
+    {
+        node *n = new node;
+        n->val = x;
+        n->prev = NULL;
+        n->next = NULL;
+        start = n;
     }
-  } else if (t->next == NULL) {
-    t->prev->next = NULL;
-  } else {
-    t->prev->next = t->next;
-    t->next->prev = t->prev;
-  }
-  delete t;
 }
 
-void double_linked_list::search(int x) {
-  node *t = start;
-  int found = 0;
-  while (t != NULL) {
-    if (t->val == x) {
-      std::cout << "\nFound";
-      found = 1;
-      break;
+void double_linked_list::remove(int x)
+{
+    node *t = start;
+    while (t != NULL && t->val != x)
+    {
+        t = t->next;
     }
-    t = t->next;
-  }
-  if (found == 0) {
-    std::cout << "\nNot Found";
-  }
-}
-
-void double_linked_list::show() {
-  node *t = start;
-  while (t != NULL) {
-    std::cout << t->val << "\t";
-    t = t->next;
-  }
-}
-
-void double_linked_list::reverseShow() {
-  node *t = start;
-  while (t != NULL && t->next != NULL) {
-    t = t->next;
-  }
-  while (t != NULL) {
-    std::cout << t->val << "\t";
-    t = t->prev;
-  }
-}
-
-int main() {
-  int choice, x;
-  double_linked_list ob;
-  do {
-    std::cout << "\n1. Insert";
-    std::cout << "\n2. Delete";
-    std::cout << "\n3. Search";
-    std::cout << "\n4. Forward print";
-    std::cout << "\n5. Reverse print";
-    std::cout << "\n\nEnter you choice : ";
-    std::cin >> choice;
-    switch (choice) {
-      case 1:
-        std::cout << "\nEnter the element to be inserted : ";
-        std::cin >> x;
-        ob.insert(x);
-        break;
-      case 2:
-        std::cout << "\nEnter the element to be removed : ";
-        std::cin >> x;
-        ob.remove(x);
-        break;
-      case 3:
-        std::cout << "\nEnter the element to be searched : ";
-        std::cin >> x;
-        ob.search(x);
-        break;
-      case 4:
-        ob.show();
-        break;
-      case 5:
-        ob.reverseShow();
-        break;
+    if (t == NULL)
+    {
+        return;
     }
-  } while (choice != 0);
-  return 0;
+    if (t->prev == NULL)
+    {
+        if (t->next == NULL)
+        {
+            start = NULL;
+        }
+        else
+        {
+            start = t->next;
+            start->prev = NULL;
+        }
+    }
+    else if (t->next == NULL)
+    {
+        t->prev->next = NULL;
+    }
+    else
+    {
+        t->prev->next = t->next;
+        t->next->prev = t->prev;
+    }
+    delete t;
+}
+
+void double_linked_list::search(int x)
+{
+    node *t = start;
+    int found = 0;
+    while (t != NULL)
+    {
+        if (t->val == x)
+        {
+            std::cout << "\nFound";
+            found = 1;
+            break;
+        }
+        t = t->next;
+    }
+    if (found == 0)
+    {
+        std::cout << "\nNot Found";
+    }
+}
+
+void double_linked_list::show()
+{
+    node *t = start;
+    while (t != NULL)
+    {
+        std::cout << t->val << "\t";
+        t = t->next;
+    }
+}
+
+void double_linked_list::reverseShow()
+{
+    node *t = start;
+    while (t != NULL && t->next != NULL)
+    {
+        t = t->next;
+    }
+    while (t != NULL)
+    {
+        std::cout << t->val << "\t";
+        t = t->prev;
+    }
+}
+
+int main()
+{
+    int choice, x;
+    double_linked_list ob;
+    do
+    {
+        std::cout << "\n1. Insert";
+        std::cout << "\n2. Delete";
+        std::cout << "\n3. Search";
+        std::cout << "\n4. Forward print";
+        std::cout << "\n5. Reverse print";
+        std::cout << "\n\nEnter you choice : ";
+        std::cin >> choice;
+        switch (choice)
+        {
+        case 1:
+            std::cout << "\nEnter the element to be inserted : ";
+            std::cin >> x;
+            ob.insert(x);
+            break;
+        case 2:
+            std::cout << "\nEnter the element to be removed : ";
+            std::cin >> x;
+            ob.remove(x);
+            break;
+        case 3:
+            std::cout << "\nEnter the element to be searched : ";
+            std::cin >> x;
+            ob.search(x);
+            break;
+        case 4:
+            ob.show();
+            break;
+        case 5:
+            ob.reverseShow();
+            break;
+        }
+    } while (choice != 0);
+    return 0;
 }

data_structure/linked_list.cpp

@@ -1,135 +1,160 @@
 #include <iostream>
 
-struct node {
-        int val;
-        node *next;
+struct node
+{
+    int val;
+    node *next;
 };
 
 node *start;
 
-void insert(int x) {
-        node *t = start;
-        node *n = new node;
-        n->val = x;
-        n->next = NULL;
-        if (start != NULL) {
-                while (t->next != NULL) {
-                        t = t->next;
-                }
-                t->next = n;             
-        } else {
-                start = n;
+void insert(int x)
+{
+    node *t = start;
+    node *n = new node;
+    n->val = x;
+    n->next = NULL;
+    if (start != NULL)
+    {
+        while (t->next != NULL)
+        {
+            t = t->next;
         }
-        
+        t->next = n;
+    }
+    else
+    {
+        start = n;
+    }
 }
 
-void remove(int x) {
-        if (start == NULL) {
-                std::cout << "\nLinked List is empty\n";
-                return;
-        } else if (start->val == x) {
-                node *temp = start;
-                start = start->next;
-                delete temp;
-                return;
-        }
-
-        node *temp = start, *parent = start;
-
-        while (temp != NULL && temp->val != x) {
-                parent = temp;
-                temp = temp->next;
-        }
-
-        if (temp == NULL) {
-                std::cout << std::endl << x << " not found in list\n";
-                return;
-        }
-
-        parent->next = temp->next;
+void remove(int x)
+{
+    if (start == NULL)
+    {
+        std::cout << "\nLinked List is empty\n";
+        return;
+    }
+    else if (start->val == x)
+    {
+        node *temp = start;
+        start = start->next;
         delete temp;
+        return;
+    }
+
+    node *temp = start, *parent = start;
+
+    while (temp != NULL && temp->val != x)
+    {
+        parent = temp;
+        temp = temp->next;
+    }
+
+    if (temp == NULL)
+    {
+        std::cout << std::endl << x << " not found in list\n";
+        return;
+    }
+
+    parent->next = temp->next;
+    delete temp;
 }
 
-void search(int x) {
-        node *t = start;
-        int found = 0;
-        while (t != NULL) {
-                if (t->val == x) {
-                        std::cout << "\nFound";
-                        found = 1;
-                        break;
-                }
-                t = t->next;
+void search(int x)
+{
+    node *t = start;
+    int found = 0;
+    while (t != NULL)
+    {
+        if (t->val == x)
+        {
+            std::cout << "\nFound";
+            found = 1;
+            break;
         }
-        if (found == 0) {
-                std::cout << "\nNot Found";
+        t = t->next;
+    }
+    if (found == 0)
+    {
+        std::cout << "\nNot Found";
+    }
+}
+
+void show()
+{
+    node *t = start;
+    while (t != NULL)
+    {
+        std::cout << t->val << "\t";
+        t = t->next;
+    }
+}
+
+void reverse()
+{
+    node *first = start;
+    if (first != NULL)
+    {
+        node *second = first->next;
+        while (second != NULL)
+        {
+            node *tem = second->next;
+            second->next = first;
+            first = second;
+            second = tem;
         }
+        start->next = NULL;
+        start = first;
+    }
+    else
+    {
+        std::cout << "\nEmpty list";
+    }
 }
 
-void show() {
-        node *t = start;
-        while (t != NULL) {
-                std::cout << t->val << "\t";
-                t = t->next;
+int main()
+{
+    int choice, x;
+    do
+    {
+        std::cout << "\n1. Insert";
+        std::cout << "\n2. Delete";
+        std::cout << "\n3. Search";
+        std::cout << "\n4. Print";
+        std::cout << "\n5. Reverse";
+        std::cout << "\n0. Exit";
+        std::cout << "\n\nEnter you choice : ";
+        std::cin >> choice;
+        switch (choice)
+        {
+        case 1:
+            std::cout << "\nEnter the element to be inserted : ";
+            std::cin >> x;
+            insert(x);
+            break;
+        case 2:
+            std::cout << "\nEnter the element to be removed : ";
+            std::cin >> x;
+            remove(x);
+            break;
+        case 3:
+            std::cout << "\nEnter the element to be searched : ";
+            std::cin >> x;
+            search(x);
+            break;
+        case 4:
+            show();
+            std::cout << "\n";
+            break;
+        case 5:
+            std::cout << "The reversed list: \n";
+            reverse();
+            show();
+            std::cout << "\n";
+            break;
         }
-}
+    } while (choice != 0);
 
-void reverse() {
-        node *first = start;
-        if (first != NULL) {
-                node *second = first->next;
-                while (second != NULL) {
-                        node *tem = second->next;
-                        second->next = first;
-                        first = second;
-                        second = tem;
-                }
-                start->next = NULL;
-                start = first;
-        } else {
-                std::cout << "\nEmpty list";
-        }
-}
-
-int main() {
-        int choice, x;
-        do {
-                std::cout << "\n1. Insert";
-                std::cout << "\n2. Delete";
-                std::cout << "\n3. Search";
-                std::cout << "\n4. Print";
-                std::cout << "\n5. Reverse";
-                std::cout << "\n0. Exit";
-                std::cout << "\n\nEnter you choice : ";
-                std::cin >> choice;
-                switch (choice) {
-                case 1:
-                        std::cout << "\nEnter the element to be inserted : ";
-                        std::cin >> x;
-                        insert(x);
-                        break;
-                case 2:
-                        std::cout << "\nEnter the element to be removed : ";
-                        std::cin >> x;
-                        remove(x);
-                        break;
-                 case 3:
-                        std::cout << "\nEnter the element to be searched : ";
-                        std::cin >> x;
-                        search(x);
-                        break;
-                 case 4:
-                        show();
-                        std::cout << "\n";
-                        break;
-                 case 5:
-                        std::cout << "The reversed list: \n";
-                        reverse();
-                        show();
-                        std::cout << "\n";
-                        break;
-               }
-        } while (choice != 0);
-
-        return 0;
+    return 0;
 }

data_structure/linkedlist_implentation_usingarray.cpp

@@ -1,6 +1,8 @@
-/* The difference between the pointer implementation of linked list and array implementation of linked list:
+/* The difference between the pointer implementation of linked list and array
+ implementation of linked list:
  1. The NULL is represented by -1;
- 2. Limited size. (in the following case it is 100 nodes at max). But we can reuse the nodes that are to be deleted by again linking it bacj to the list.
+ 2. Limited size. (in the following case it is 100 nodes at max). But we can
+ reuse the nodes that are to be deleted by again linking it bacj to the list.
 */
 
 #include <iostream>
@@ -10,7 +12,7 @@ struct Node
     int data;
     int next;
 };
-Node AvailArray[100]; //array that will act as nodes of a linked list.
+Node AvailArray[100];  // array that will act as nodes of a linked list.
 int head = -1;
 int avail = 0;
 void initialise_list()
@@ -19,23 +21,28 @@ void initialise_list()
     {
         AvailArray[i].next = i + 1;
     }
-    AvailArray[99].next = -1; //indicating the end of the linked list.
+    AvailArray[99].next = -1;  // indicating the end of the linked list.
 }
 
-int getnode() //This will return the index of the first free node present in the avail list
+int getnode()  // This will return the index of the first free node present in
+               // the avail list
 {
     int NodeIndexToBeReturned = avail;
     avail = AvailArray[avail].next;
     return NodeIndexToBeReturned;
 }
 
-void freeNode(int nodeToBeDeleted) //This function when called will delete the node with the index presented as an argument, and will put back that node into the array.
+void freeNode(
+    int nodeToBeDeleted)  // This function when called will delete the node with
+                          // the index presented as an argument, and will put
+                          // back that node into the array.
 {
     AvailArray[nodeToBeDeleted].next = avail;
     avail = nodeToBeDeleted;
 }
 
-void insertAtTheBeginning(int data) //The function will insert the given data into the front of the linked list.
+void insertAtTheBeginning(int data)  // The function will insert the given data
+                                     // into the front of the linked list.
 {
     int newNode = getnode();
     AvailArray[newNode].data = data;
@@ -51,7 +58,7 @@ void insertAtTheEnd(int data)
     {
         temp = AvailArray[temp].next;
     }
-    //temp is now pointing to the end node.
+    // temp is now pointing to the end node.
     AvailArray[newNode].data = data;
     AvailArray[newNode].next = -1;
     AvailArray[temp].next = newNode;
@@ -94,7 +101,8 @@ int main()
             insertAtTheEnd(y);
             break;
         case 3:
-            cout << "The linked list contains the following element in order" << endl;
+            cout << "The linked list contains the following element in order"
+                 << endl;
             display();
             break;
         case 4:

data_structure/list_array.cpp

@@ -3,186 +3,184 @@ using namespace std;
 
 struct list
 {
-	int data[50];
-	int top = 0;
-	bool isSorted = false;
+    int data[50];
+    int top = 0;
+    bool isSorted = false;
 
-	int BinarySearch(int *array, int first, int last, int x)
-	{
-		if (last < first)
-		{
-			return -1;
-		}
-		int mid = (first + last) / 2;
-		if (array[mid] == x)
-			return mid;
-		else if (x < array[mid])
-			return (BinarySearch(array, first, mid - 1, x));
-		else if (x > array[mid])
-			return (BinarySearch(array, mid + 1, last, x));
-	}
+    int BinarySearch(int *array, int first, int last, int x)
+    {
+        if (last < first)
+        {
+            return -1;
+        }
+        int mid = (first + last) / 2;
+        if (array[mid] == x)
+            return mid;
+        else if (x < array[mid])
+            return (BinarySearch(array, first, mid - 1, x));
+        else if (x > array[mid])
+            return (BinarySearch(array, mid + 1, last, x));
+    }
 
-	int LinarSearch(int *array, int x)
-	{
-		for (int i = 0; i < top; i++)
-		{
-			if (array[i] == x)
-			{
-				return i;
-			}
-		}
+    int LinarSearch(int *array, int x)
+    {
+        for (int i = 0; i < top; i++)
+        {
+            if (array[i] == x)
+            {
+                return i;
+            }
+        }
 
-		return -1;
-	}
+        return -1;
+    }
 
-	int Search(int x)
-	{
-		int pos = -1;
+    int Search(int x)
+    {
+        int pos = -1;
 
-		if (isSorted)
-		{
-			pos = BinarySearch(data, 0, top - 1, x);
-		}
+        if (isSorted)
+        {
+            pos = BinarySearch(data, 0, top - 1, x);
+        }
 
-		else
-		{
-			pos = LinarSearch(data, x);
-		}
+        else
+        {
+            pos = LinarSearch(data, x);
+        }
 
-		if (pos != -1)
-		{
-			cout << "\nElement found at position : " << pos;
-		}
-		else
-		{
-			cout << "\nElement not found";
-		}
-		return pos;
-	}
+        if (pos != -1)
+        {
+            cout << "\nElement found at position : " << pos;
+        }
+        else
+        {
+            cout << "\nElement not found";
+        }
+        return pos;
+    }
 
-	void Sort()
-	{
-		int i, j, pos;
-		for (i = 0; i < top; i++)
-		{
-			int min = data[i];
-			for (j = i + 1; j < top; j++)
-			{
-				if (data[j] < min)
-				{
-					pos = j;
-					min = data[pos];
-				}
-			}
+    void Sort()
+    {
+        int i, j, pos;
+        for (i = 0; i < top; i++)
+        {
+            int min = data[i];
+            for (j = i + 1; j < top; j++)
+            {
+                if (data[j] < min)
+                {
+                    pos = j;
+                    min = data[pos];
+                }
+            }
 
-			int temp = data[i];
-			data[i] = data[pos];
-			data[pos] = temp;
-		}
-		isSorted = true;
-	}
+            int temp = data[i];
+            data[i] = data[pos];
+            data[pos] = temp;
+        }
+        isSorted = true;
+    }
 
-	void insert(int x)
-	{
-		if (!isSorted)
-		{
+    void insert(int x)
+    {
+        if (!isSorted)
+        {
+            if (top == 49)
+            {
+                cout << "\nOverflow";
+            }
+            else
+            {
+                data[top] = x;
+                top++;
+            }
+        }
 
-			if (top == 49)
-			{
-				cout << "\nOverflow";
-			}
-			else
-			{
-				data[top] = x;
-				top++;
-			}
-		}
+        else
+        {
+            int pos = 0;
 
-		else
-		{
-			int pos = 0;
+            for (int i = 0; i < top - 1; i++)
+            {
+                if (data[i] <= x && x <= data[i + 1])
+                {
+                    pos = i + 1;
+                    break;
+                }
+            }
+            if (pos == 0)
+            {
+                pos = top - 1;
+            }
 
-			for (int i = 0; i < top - 1; i++)
-			{
-				if (data[i] <= x && x <= data[i + 1])
-				{
-					pos = i + 1;
-					break;
-				}
-			}
-			if (pos == 0)
-			{
-				pos = top - 1;
-			}
+            for (int i = top; i > pos; i--)
+            {
+                data[i] = data[i - 1];
+            }
+            top++;
+            data[pos] = x;
+        }
+    }
 
-			for (int i = top; i > pos; i--)
-			{
-				data[i] = data[i - 1];
-			}
-			top++;
-			data[pos] = x;
-		}
-	}
+    void Remove(int x)
+    {
+        int pos = Search(x);
+        cout << "\n" << data[pos] << " deleted";
+        for (int i = pos; i < top; i++)
+        {
+            data[i] = data[i + 1];
+        }
+        top--;
+    }
 
-	void Remove(int x)
-	{
-		int pos = Search(x);
-		cout << "\n"
-			 << data[pos] << " deleted";
-		for (int i = pos; i < top; i++)
-		{
-			data[i] = data[i + 1];
-		}
-		top--;
-	}
-
-	void Show()
-	{
-		for (int i = 0; i < top; i++)
-		{
-			cout << data[i] << "\t";
-		}
-	}
+    void Show()
+    {
+        for (int i = 0; i < top; i++)
+        {
+            cout << data[i] << "\t";
+        }
+    }
 };
 
 int main()
 {
-	list L;
-	int choice;
-	int x;
-	do
-	{
-		cout << "\n1.Insert";
-		cout << "\n2.Delete";
-		cout << "\n3.Search";
-		cout << "\n4.Sort";
-		cout << "\n5.Print";
-		cout << "\n\nEnter Your Choice : ";
-		cin >> choice;
-		switch (choice)
-		{
-		case 1:
-			cout << "\nEnter the element to be inserted : ";
-			cin >> x;
-			L.insert(x);
-			break;
-		case 2:
-			cout << "\nEnter the element to be removed : ";
-			cin >> x;
-			L.Remove(x);
-			break;
-		case 3:
-			cout << "\nEnter the element to be searched : ";
-			cin >> x;
-			L.Search(x);
-			break;
-		case 4:
-			L.Sort();
-			break;
-		case 5:
-			L.Show();
-			break;
-		}
-	} while (choice != 0);
-	return 0;
+    list L;
+    int choice;
+    int x;
+    do
+    {
+        cout << "\n1.Insert";
+        cout << "\n2.Delete";
+        cout << "\n3.Search";
+        cout << "\n4.Sort";
+        cout << "\n5.Print";
+        cout << "\n\nEnter Your Choice : ";
+        cin >> choice;
+        switch (choice)
+        {
+        case 1:
+            cout << "\nEnter the element to be inserted : ";
+            cin >> x;
+            L.insert(x);
+            break;
+        case 2:
+            cout << "\nEnter the element to be removed : ";
+            cin >> x;
+            L.Remove(x);
+            break;
+        case 3:
+            cout << "\nEnter the element to be searched : ";
+            cin >> x;
+            L.Search(x);
+            break;
+        case 4:
+            L.Sort();
+            break;
+        case 5:
+            L.Show();
+            break;
+        }
+    } while (choice != 0);
+    return 0;
 }

data_structure/morrisinorder.cpp

@@ -2,107 +2,107 @@
 #include <queue>
 
 /**************************
-	@author shrutisheoran
+    @author shrutisheoran
 **************************/
 
 using namespace std;
 
 struct Btree
 {
-	int data;
-	struct Btree *left;  //Pointer to left subtree
-	struct Btree *right; //Pointer to right subtree
+    int data;
+    struct Btree *left;   // Pointer to left subtree
+    struct Btree *right;  // Pointer to right subtree
 };
 
 void insert(Btree **root, int d)
 {
-	Btree *nn = new Btree(); //Creating new node
-	nn->data = d;
-	nn->left = NULL;
-	nn->right = NULL;
-	if (*root == NULL)
-	{
-		*root = nn;
-		return;
-	}
-	else
-	{
-		queue<Btree *> q;
-		// Adding root node to queue
-		q.push(*root);
-		while (!q.empty())
-		{
-			Btree *node = q.front();
-			// Removing parent node from queue
-			q.pop();
-			if (node->left)
-				// Adding left child of removed node to queue
-				q.push(node->left);
-			else
-			{
-				// Adding new node if no left child is present
-				node->left = nn;
-				return;
-			}
-			if (node->right)
-				// Adding right child of removed node to queue
-				q.push(node->right);
-			else
-			{
-				// Adding new node if no right child is present
-				node->right = nn;
-				return;
-			}
-		}
-	}
+    Btree *nn = new Btree();  // Creating new node
+    nn->data = d;
+    nn->left = NULL;
+    nn->right = NULL;
+    if (*root == NULL)
+    {
+        *root = nn;
+        return;
+    }
+    else
+    {
+        queue<Btree *> q;
+        // Adding root node to queue
+        q.push(*root);
+        while (!q.empty())
+        {
+            Btree *node = q.front();
+            // Removing parent node from queue
+            q.pop();
+            if (node->left)
+                // Adding left child of removed node to queue
+                q.push(node->left);
+            else
+            {
+                // Adding new node if no left child is present
+                node->left = nn;
+                return;
+            }
+            if (node->right)
+                // Adding right child of removed node to queue
+                q.push(node->right);
+            else
+            {
+                // Adding new node if no right child is present
+                node->right = nn;
+                return;
+            }
+        }
+    }
 }
 
 void morrisInorder(Btree *root)
 {
-	Btree *curr = root;
-	Btree *temp;
-	while (curr)
-	{
-		if (curr->left == NULL)
-		{
-			cout << curr->data << " ";
-			// If left of current node is NULL then curr is shifted to right
-			curr = curr->right;
-		}
-		else
-		{
-			// Left of current node is stored in temp
-			temp = curr->left;
-			// Moving to extreme right of temp
-			while (temp->right && temp->right != curr)
-				temp = temp->right;
-			// If extreme right is null it is made to point to currrent node (will be used for backtracking)
-			if (temp->right == NULL)
-			{
-				temp->right = curr;
-				// current node is made to point its left subtree
-				curr = curr->left;
-			}
-			// If extreme right already points to currrent node it it set to null
-			else if (temp->right == curr)
-			{
-				cout << curr->data << " ";
-				temp->right = NULL;
-				// current node is made to point its right subtree
-				curr = curr->right;
-			}
-		}
-	}
+    Btree *curr = root;
+    Btree *temp;
+    while (curr)
+    {
+        if (curr->left == NULL)
+        {
+            cout << curr->data << " ";
+            // If left of current node is NULL then curr is shifted to right
+            curr = curr->right;
+        }
+        else
+        {
+            // Left of current node is stored in temp
+            temp = curr->left;
+            // Moving to extreme right of temp
+            while (temp->right && temp->right != curr) temp = temp->right;
+            // If extreme right is null it is made to point to currrent node
+            // (will be used for backtracking)
+            if (temp->right == NULL)
+            {
+                temp->right = curr;
+                // current node is made to point its left subtree
+                curr = curr->left;
+            }
+            // If extreme right already points to currrent node it it set to
+            // null
+            else if (temp->right == curr)
+            {
+                cout << curr->data << " ";
+                temp->right = NULL;
+                // current node is made to point its right subtree
+                curr = curr->right;
+            }
+        }
+    }
 }
 
 int main()
 {
-	// Testing morrisInorder funtion
-	Btree *root = NULL;
-	int i;
-	for (i = 1; i <= 7; i++)
-		insert(&root, i);
-	cout << "Morris Inorder: ";
-	morrisInorder(root);
-	return 0;
+    // Testing morrisInorder funtion
+    Btree *root = NULL;
+    int i;
+    for (i = 1; i <= 7; i++) insert(&root, i);
+    cout << "Morris Inorder: ";
+    morrisInorder(root);
+    return 0;
 }

data_structure/queue/queue.cpp

@@ -1,6 +1,6 @@
-#include <iostream>
-#include <assert.h>
 #include "queue.h"
+#include <assert.h>
+#include <iostream>
 
 using namespace std;
 
@@ -25,11 +25,12 @@ void queue<Kind>::display()
 {
     node<Kind> *current = queueFront;
     cout << "Front --> ";
-    while(current != NULL) {
-        cout<<current->data<< "    ";
-        current = current -> next;
+    while (current != NULL)
+    {
+        cout << current->data << "    ";
+        current = current->next;
     }
-    cout <<endl;
+    cout << endl;
     cout << "Size of queue: " << size << endl;
 }
 
@@ -55,10 +56,13 @@ void queue<Kind>::enQueue(Kind item)
     newNode = new node<Kind>;
     newNode->data = item;
     newNode->next = NULL;
-    if (queueFront == NULL) {
+    if (queueFront == NULL)
+    {
         queueFront = newNode;
         queueRear = newNode;
-    } else {
+    }
+    else
+    {
         queueRear->next = newNode;
         queueRear = queueRear->next;
     }
@@ -78,13 +82,15 @@ template <class Kind>
 void queue<Kind>::deQueue()
 {
     node<Kind> *temp;
-    if(!isEmptyQueue()) {
+    if (!isEmptyQueue())
+    {
         temp = queueFront;
         queueFront = queueFront->next;
         delete temp;
         size--;
-    } else {
+    }
+    else
+    {
         cout << "Queue is empty !" << endl;
     }
 }
-

data_structure/queue/queue.h

@@ -14,21 +14,20 @@ struct node
 template <class Kind>
 class queue
 {
-    public:
-        void display();        /* Show queue */
-        queue();               /* Default constructor*/
-        ~queue();              /* Destructor */
-        bool isEmptyQueue();   /* Determine whether the queue is empty */
-        void enQueue (Kind item); /* Add new item to the queue */
-        Kind front();            /* Return the first element of the queue */
-        void deQueue();        /* Remove the top element of the queue */
-        void clear();
+ public:
+    void display();          /* Show queue */
+    queue();                 /* Default constructor*/
+    ~queue();                /* Destructor */
+    bool isEmptyQueue();     /* Determine whether the queue is empty */
+    void enQueue(Kind item); /* Add new item to the queue */
+    Kind front();            /* Return the first element of the queue */
+    void deQueue();          /* Remove the top element of the queue */
+    void clear();
 
-    private:
-        node<Kind> *queueFront;  /* Pointer to the front of the queue */
-        node<Kind> *queueRear;   /* Pointer to the rear of the queue  */
-        int size;
+ private:
+    node<Kind> *queueFront; /* Pointer to the front of the queue */
+    node<Kind> *queueRear;  /* Pointer to the rear of the queue  */
+    int size;
 };
 
 #endif
-

data_structure/queue/test_queue.cpp

@@ -1,22 +1,25 @@
 #include <iostream>
 #include <string>
-#include "queue.h"
 #include "queue.cpp"
+#include "queue.h"
 
 using namespace std;
 
 int main()
 {
     queue<string> q;
-    cout << "---------------------- Test construct ----------------------" << endl;
+    cout << "---------------------- Test construct ----------------------"
+         << endl;
     q.display();
-    cout << "---------------------- Test isEmptyQueue ----------------------" << endl;
-    if(q.isEmptyQueue())
-        cout << "PASS" <<endl;
+    cout << "---------------------- Test isEmptyQueue ----------------------"
+         << endl;
+    if (q.isEmptyQueue())
+        cout << "PASS" << endl;
     else
-        cout << "FAIL" <<endl;
-    cout << "---------------------- Test enQueue ----------------------" << endl;
-    cout << "After Hai, Jeff, Tom, Jkingston go into queue: "<<endl;
+        cout << "FAIL" << endl;
+    cout << "---------------------- Test enQueue ----------------------"
+         << endl;
+    cout << "After Hai, Jeff, Tom, Jkingston go into queue: " << endl;
     q.enQueue("Hai");
     q.enQueue("Jeff");
     q.enQueue("Tom");
@@ -25,14 +28,15 @@ int main()
     cout << "---------------------- Test front ----------------------" << endl;
     string value = q.front();
     if (value == "Hai")
-        cout << "PASS" <<endl;
+        cout << "PASS" << endl;
     else
-        cout << "FAIL" <<endl;
-    cout << "---------------------- Test deQueue ----------------------" << endl;
+        cout << "FAIL" << endl;
+    cout << "---------------------- Test deQueue ----------------------"
+         << endl;
     q.display();
     q.deQueue();
     q.deQueue();
-    cout << "After Hai, Jeff left the queue: "<< endl;
+    cout << "After Hai, Jeff left the queue: " << endl;
     q.display();
     return 0;
 }

data_structure/queue_using_array.cpp

@@ -10,13 +10,15 @@
 
 #define MAXSIZE 10
 
-class Queue_Array {
+class Queue_Array
+{
     int front;
     int rear;
     int size;
 
  public:
-    Queue_Array() {
+    Queue_Array()
+    {
         front = -1;
         rear = -1;
         size = MAXSIZE;
@@ -27,43 +29,59 @@ class Queue_Array {
     void display();
 };
 
-void Queue_Array::enqueue(int ele) {
-    if (rear == size - 1) {
+void Queue_Array::enqueue(int ele)
+{
+    if (rear == size - 1)
+    {
         std::cout << "\nStack is full";
-    } else if (front == -1 && rear == -1) {
+    }
+    else if (front == -1 && rear == -1)
+    {
         front = rear = 0;
         arr[rear] = ele;
-    } else if (rear < size) {
+    }
+    else if (rear < size)
+    {
         rear++;
         arr[rear] = ele;
     }
 }
 
-int Queue_Array::dequeue() {
+int Queue_Array::dequeue()
+{
     int d;
-    if (front == -1) {
+    if (front == -1)
+    {
         std::cout << "\nstack is empty ";
         return 0;
-    } else if (front == rear) {
+    }
+    else if (front == rear)
+    {
         d = arr[front];
         front = rear = -1;
-    } else {
+    }
+    else
+    {
         d = arr[front++];
     }
 
     return d;
 }
 
-void Queue_Array::display() {
-    if (front == -1) {
+void Queue_Array::display()
+{
+    if (front == -1)
+    {
         std::cout << "\nStack is empty";
-    } else {
-        for (int i = front; i <= rear; i++)
-            std::cout << arr[i] << " ";
+    }
+    else
+    {
+        for (int i = front; i <= rear; i++) std::cout << arr[i] << " ";
     }
 }
 
-int main() {
+int main()
+{
     int op, data;
 
     Queue_Array ob;
@@ -72,21 +90,31 @@ int main() {
     std::cout << "\n2. dequeue(Deletion)";
     std::cout << "\n3. Display";
     std::cout << "\n4. Exit";
-    while (1) {
+    while (1)
+    {
         std::cout << "\nEnter your choice ";
         std::cin >> op;
-        if (op == 1) {
+        if (op == 1)
+        {
             std::cout << "Enter data  ";
             std::cin >> data;
             ob.enqueue(data);
-        } else if (op == 2) {
+        }
+        else if (op == 2)
+        {
             data = ob.dequeue();
             std::cout << "\ndequeue element is:\t" << data;
-        } else if (op == 3) {
+        }
+        else if (op == 3)
+        {
             ob.display();
-        } else if (op == 4) {
+        }
+        else if (op == 4)
+        {
             exit(0);
-        } else {
+        }
+        else
+        {
             std::cout << "\nWrong choice ";
         }
     }

data_structure/queue_using_array2.cpp

@@ -7,69 +7,68 @@ int rear = 0;
 
 void Enque(int x)
 {
-	if (rear == 10)
-	{
-		cout << "\nOverflow";
-	}
-	else
-	{
-		queue[rear++] = x;
-	}
+    if (rear == 10)
+    {
+        cout << "\nOverflow";
+    }
+    else
+    {
+        queue[rear++] = x;
+    }
 }
 
 void Deque()
 {
-	if (front == rear)
-	{
-		cout << "\nUnderflow";
-	}
+    if (front == rear)
+    {
+        cout << "\nUnderflow";
+    }
 
-	else
-	{
-		cout << "\n"
-			 << queue[front++] << " deleted";
-		for (int i = front; i < rear; i++)
-		{
-			queue[i - front] = queue[i];
-		}
-		rear = rear - front;
-		front = 0;
-	}
+    else
+    {
+        cout << "\n" << queue[front++] << " deleted";
+        for (int i = front; i < rear; i++)
+        {
+            queue[i - front] = queue[i];
+        }
+        rear = rear - front;
+        front = 0;
+    }
 }
 
 void show()
 {
-	for (int i = front; i < rear; i++)
-	{
-		cout << queue[i] << "\t";
-	}
+    for (int i = front; i < rear; i++)
+    {
+        cout << queue[i] << "\t";
+    }
 }
 
 int main()
 {
-	int ch, x;
-	do
-	{
-		cout << "\n1. Enque";
-		cout << "\n2. Deque";
-		cout << "\n3. Print";
-		cout << "\nEnter Your Choice : ";
-		cin >> ch;
-		if (ch == 1)
-		{
-			cout << "\nInsert : ";
-			cin >> x;
-			Enque(x);
-		}
-		else if (ch == 2)
-		{
-			Deque();
-		}
-		else if (ch == 3)
-		{
-			show();
-		}
-	} while (ch != 0);
+    int ch, x;
+    do
+    {
+        cout << "\n1. Enque";
+        cout << "\n2. Deque";
+        cout << "\n3. Print";
+        cout << "\nEnter Your Choice : ";
+        cin >> ch;
+        if (ch == 1)
+        {
+            cout << "\nInsert : ";
+            cin >> x;
+            Enque(x);
+        }
+        else if (ch == 2)
+        {
+            Deque();
+        }
+        else if (ch == 3)
+        {
+            show();
+        }
+    } while (ch != 0);
 
-	return 0;
+    return 0;
 }

data_structure/queue_using_linked_list.cpp

@@ -22,7 +22,6 @@ void Enque(int x)
 
     else
     {
-
         node *n = new node;
         n->val = x;
         n->next = NULL;
@@ -40,8 +39,7 @@ void Deque()
     else
     {
         node *t = front;
-        cout << "\n"
-             << t->val << " deleted";
+        cout << "\n" << t->val << " deleted";
         front = front->next;
         delete t;
         if (front == NULL)

data_structure/queue_using_linkedlist.cpp

@@ -1,98 +1,99 @@
 /*
     Write a program to implement Queue using linkedlist.
 */
-#include<iostream>
-
-
-struct linkedlist{
-  int data;
-  linkedlist *next;
+#include <iostream>
 
+struct linkedlist
+{
+    int data;
+    linkedlist *next;
 };
-class stack_linkedList{
-  public:
+class stack_linkedList
+{
+ public:
     linkedlist *front;
     linkedlist *rear;
-    
-    stack_linkedList(){
-        front=rear=NULL;
-    }
+
+    stack_linkedList() { front = rear = NULL; }
     void enqueue(int);
     int dequeue();
     void display();
-
 };
-void stack_linkedList::enqueue(int ele){
-    
-    linkedlist *temp=new linkedlist();
-    temp->data=ele;
-    temp->next=NULL;
+void stack_linkedList::enqueue(int ele)
+{
+    linkedlist *temp = new linkedlist();
+    temp->data = ele;
+    temp->next = NULL;
 
-    if(front==NULL)
-        front=rear=temp;
-    else{
-        rear->next=temp;
-        rear=temp;
+    if (front == NULL)
+        front = rear = temp;
+    else
+    {
+        rear->next = temp;
+        rear = temp;
     }
 }
-int stack_linkedList::dequeue(){
+int stack_linkedList::dequeue()
+{
     linkedlist *temp;
     int ele;
-    if(front==NULL)
-        std::cout<<"\nStack is empty";
-    else{
-        temp=front;
-        ele=temp->data;
-        if(front==rear)                                         //if length of queue is 1;
-            rear=rear->next;
-        front=front->next;
-        delete(temp);
+    if (front == NULL)
+        std::cout << "\nStack is empty";
+    else
+    {
+        temp = front;
+        ele = temp->data;
+        if (front == rear)  // if length of queue is 1;
+            rear = rear->next;
+        front = front->next;
+        delete (temp);
     }
     return ele;
 }
-void stack_linkedList::display(){
-    
-    if(front==NULL)
-        std::cout<<"\nStack is empty";
-    
-    else {
-        
+void stack_linkedList::display()
+{
+    if (front == NULL)
+        std::cout << "\nStack is empty";
+
+    else
+    {
         linkedlist *temp;
-        temp=front;
-        while(temp!=NULL){
-            std::cout<<temp->data<<" ";
-            temp=temp->next;
+        temp = front;
+        while (temp != NULL)
+        {
+            std::cout << temp->data << " ";
+            temp = temp->next;
         }
     }
 }
 
-int main(){
-    
-    int op,data;
+int main()
+{
+    int op, data;
     stack_linkedList ob;
-    std::cout<<"\n1. enqueue(Insertion) ";
-    std::cout<<"\n2. dequeue(Deletion)";
-    std::cout<<"\n3. Display";
-    std::cout<<"\n4. Exit";
-    
-    while(1){
-        std::cout<<"\nEnter your choice ";
-        std::cin>>op;
-        if(op==1)
+    std::cout << "\n1. enqueue(Insertion) ";
+    std::cout << "\n2. dequeue(Deletion)";
+    std::cout << "\n3. Display";
+    std::cout << "\n4. Exit";
+
+    while (1)
+    {
+        std::cout << "\nEnter your choice ";
+        std::cin >> op;
+        if (op == 1)
         {
-            std::cout<<"Enter data ";
-            std::cin>>data;
+            std::cout << "Enter data ";
+            std::cin >> data;
             ob.enqueue(data);
         }
-        else if(op==2)
-            data=ob.dequeue();
-        else if(op==3)
+        else if (op == 2)
+            data = ob.dequeue();
+        else if (op == 3)
             ob.display();
-        else if(op==4)
+        else if (op == 4)
             exit(0);
         else
-            std::cout<<"\nWrong choice ";
-
+            std::cout << "\nWrong choice ";
     }
     return 0;
 }

data_structure/stack_using_array.cpp

@@ -6,74 +6,70 @@ int top = 0, size;
 
 void push(int x)
 {
-	if (top == size)
-	{
-		cout << "\nOverflow";
-	}
-	else
-	{
-		stack[top++] = x;
-	}
+    if (top == size)
+    {
+        cout << "\nOverflow";
+    }
+    else
+    {
+        stack[top++] = x;
+    }
 }
 
 void pop()
 {
-	if (top == 0)
-	{
-		cout << "\nUnderflow";
-	}
-	else
-	{
-		cout << "\n"
-			 << stack[--top] << " deleted";
-	}
+    if (top == 0)
+    {
+        cout << "\nUnderflow";
+    }
+    else
+    {
+        cout << "\n" << stack[--top] << " deleted";
+    }
 }
 
 void show()
 {
-	for (int i = 0; i < top; i++)
-	{
-		cout << stack[i] << "\n";
-	}
+    for (int i = 0; i < top; i++)
+    {
+        cout << stack[i] << "\n";
+    }
 }
 
-void topmost()
-{
-	cout << "\nTopmost element: " << stack[top - 1];
-}
+void topmost() { cout << "\nTopmost element: " << stack[top - 1]; }
 int main()
 {
-	cout << "\nEnter Size of stack : ";
-	cin >> size;
-	stack = new int[size];
-	int ch, x;
-	do
-	{
-		cout << "\n1. Push";
-		cout << "\n2. Pop";
-		cout << "\n3. Print";
-		cout << "\n4. Print topmost element:";
-		cout << "\nEnter Your Choice : ";
-		cin >> ch;
-		if (ch == 1)
-		{
-			cout << "\nInsert : ";
-			cin >> x;
-			push(x);
-		}
-		else if (ch == 2)
-		{
-			pop();
-		}
-		else if (ch == 3)
-		{
-			show();
-		}
-		else if (ch == 4)
-		{
-			topmost();
-		}
-	} while (ch != 0);
+    cout << "\nEnter Size of stack : ";
+    cin >> size;
+    stack = new int[size];
+    int ch, x;
+    do
+    {
+        cout << "\n1. Push";
+        cout << "\n2. Pop";
+        cout << "\n3. Print";
+        cout << "\n4. Print topmost element:";
+        cout << "\nEnter Your Choice : ";
+        cin >> ch;
+        if (ch == 1)
+        {
+            cout << "\nInsert : ";
+            cin >> x;
+            push(x);
+        }
+        else if (ch == 2)
+        {
+            pop();
+        }
+        else if (ch == 3)
+        {
+            show();
+        }
+        else if (ch == 4)
+        {
+            topmost();
+        }
+    } while (ch != 0);
 
-	return 0;
+    return 0;
 }

data_structure/stack_using_linked_list.cpp

@@ -3,71 +3,70 @@ using namespace std;
 
 struct node
 {
-	int val;
-	node *next;
+    int val;
+    node *next;
 };
 
 node *top;
 
 void push(int x)
 {
-	node *n = new node;
-	n->val = x;
-	n->next = top;
-	top = n;
+    node *n = new node;
+    n->val = x;
+    n->next = top;
+    top = n;
 }
 
 void pop()
 {
-	if (top == NULL)
-	{
-		cout << "\nUnderflow";
-	}
-	else
-	{
-		node *t = top;
-		cout << "\n"
-			 << t->val << " deleted";
-		top = top->next;
-		delete t;
-	}
+    if (top == NULL)
+    {
+        cout << "\nUnderflow";
+    }
+    else
+    {
+        node *t = top;
+        cout << "\n" << t->val << " deleted";
+        top = top->next;
+        delete t;
+    }
 }
 
 void show()
 {
-	node *t = top;
-	while (t != NULL)
-	{
-		cout << t->val << "\n";
-		t = t->next;
-	}
+    node *t = top;
+    while (t != NULL)
+    {
+        cout << t->val << "\n";
+        t = t->next;
+    }
 }
 
 int main()
 {
-	int ch, x;
-	do
-	{
-		cout << "\n1. Push";
-		cout << "\n2. Pop";
-		cout << "\n3. Print";
-		cout << "\nEnter Your Choice : ";
-		cin >> ch;
-		if (ch == 1)
-		{
-			cout << "\nInsert : ";
-			cin >> x;
-			push(x);
-		}
-		else if (ch == 2)
-		{
-			pop();
-		}
-		else if (ch == 3)
-		{
-			show();
-		}
-	} while (ch != 0);
+    int ch, x;
+    do
+    {
+        cout << "\n1. Push";
+        cout << "\n2. Pop";
+        cout << "\n3. Print";
+        cout << "\nEnter Your Choice : ";
+        cin >> ch;
+        if (ch == 1)
+        {
+            cout << "\nInsert : ";
+            cin >> x;
+            push(x);
+        }
+        else if (ch == 2)
+        {
+            pop();
+        }
+        else if (ch == 3)
+        {
+            show();
+        }
+    } while (ch != 0);
 
-	return 0;
+    return 0;
 }

data_structure/stk/main.cpp

@@ -8,18 +8,19 @@
  *     ./main student.txt
  ************************************************************
  * */
-#include <iostream>
-#include <iomanip>
-#include <fstream>
-#include <string>
 #include <assert.h>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <string>
 
-#include "stack.h"
 #include "stack.cpp"
+#include "stack.h"
 
 using namespace std;
 
-int main(int argc, char * argv[]) {
+int main(int argc, char* argv[])
+{
     double GPA;
     double highestGPA;
     string name;
@@ -34,19 +35,24 @@ int main(int argc, char * argv[]) {
     infile >> GPA >> name;
     highestGPA = GPA;
 
-    while (infile) {
-        if (GPA > highestGPA) {
+    while (infile)
+    {
+        if (GPA > highestGPA)
+        {
             stk.clear();
             stk.push(name);
             highestGPA = GPA;
-        } else if (GPA == highestGPA) {
+        }
+        else if (GPA == highestGPA)
+        {
             stk.push(name);
         }
         infile >> GPA >> name;
     }
-    cout << "Highest GPA: " << highestGPA <<endl;
+    cout << "Highest GPA: " << highestGPA << endl;
     cout << "Students the highest GPA are: " << endl;
-    while (!stk.isEmptyStack()) {
+    while (!stk.isEmptyStack())
+    {
         cout << stk.top() << endl;
         stk.pop();
     }

data_structure/stk/stack.cpp

@@ -1,6 +1,6 @@
-#include <iostream>
-#include <assert.h>
 #include "stack.h"
+#include <assert.h>
+#include <iostream>
 
 using namespace std;
 
@@ -24,11 +24,12 @@ void stack<Type>::display()
 {
     node<Type> *current = stackTop;
     cout << "Top --> ";
-    while(current != NULL) {
-        cout<<current->data<< "  ";
-        current = current -> next;
+    while (current != NULL)
+    {
+        cout << current->data << "  ";
+        current = current->next;
     }
-    cout <<endl;
+    cout << endl;
     cout << "Size of stack: " << size << endl;
 }
 
@@ -71,19 +72,22 @@ template <class Type>
 void stack<Type>::pop()
 {
     node<Type> *temp;
-    if(!isEmptyStack()) {
+    if (!isEmptyStack())
+    {
         temp = stackTop;
         stackTop = stackTop->next;
         delete temp;
         size--;
-    } else {
+    }
+    else
+    {
         cout << "Stack is empty !" << endl;
     }
 }
 
 /* Operator "=" */
 template <class Type>
-stack<Type> stack<Type>::operator=(stack<Type> & otherStack)
+stack<Type> stack<Type>::operator=(stack<Type> &otherStack)
 {
     node<Type> *newNode, *current, *last;
 
@@ -91,13 +95,14 @@ stack<Type> stack<Type>::operator=(stack<Type> & otherStack)
         stackTop = NULL;
     if (otherStack.stackTop == NULL)
         stackTop = NULL;
-    else {
+    else
+    {
         current = otherStack.stackTop;
         stackTop = new node<Type>;
         stackTop->data = current->data;
         stackTop->next = NULL;
         last = stackTop;
-        current = current ->next;
+        current = current->next;
         /* Copy the remaining stack */
         while (current != NULL)
         {

data_structure/stk/stack.h

@@ -14,22 +14,21 @@ struct node
 template <class Type>
 class stack
 {
-    public:
-        void display();        /* Show stack */
-        stack();               /* Default constructor*/
-        ~stack();              /* Destructor */
-        bool isEmptyStack();   /* Determine whether the stack is empty */
-        void push (Type item); /* Add new item to the stack */
-        Type top();            /* Return the top element of the stack */
-        void pop();            /* Remove the top element of the stack */
-        void clear();
+ public:
+    void display();       /* Show stack */
+    stack();              /* Default constructor*/
+    ~stack();             /* Destructor */
+    bool isEmptyStack();  /* Determine whether the stack is empty */
+    void push(Type item); /* Add new item to the stack */
+    Type top();           /* Return the top element of the stack */
+    void pop();           /* Remove the top element of the stack */
+    void clear();
 
-        stack<Type> operator=(stack<Type> & otherStack);
-        // Overload "=" the assignment operator.
-    private:
-        node<Type> *stackTop;  /* Pointer to the stack */
-        int size;
+    stack<Type> operator=(stack<Type> &otherStack);
+    // Overload "=" the assignment operator.
+ private:
+    node<Type> *stackTop; /* Pointer to the stack */
+    int size;
 };
 
 #endif
-

data_structure/stk/test_stack.cpp

@@ -1,21 +1,23 @@
 #include <iostream>
-#include "stack.h"
 #include "stack.cpp"
+#include "stack.h"
 
 using namespace std;
 
 int main()
 {
     stack<int> stk;
-    cout << "---------------------- Test construct ----------------------" << endl;
+    cout << "---------------------- Test construct ----------------------"
+         << endl;
     stk.display();
-    cout << "---------------------- Test isEmptyStack ----------------------" << endl;
-    if(stk.isEmptyStack())
-        cout << "PASS" <<endl;
+    cout << "---------------------- Test isEmptyStack ----------------------"
+         << endl;
+    if (stk.isEmptyStack())
+        cout << "PASS" << endl;
     else
-        cout << "FAIL" <<endl;
+        cout << "FAIL" << endl;
     cout << "---------------------- Test push ----------------------" << endl;
-    cout << "After pushing 10 20 30 40 into stack: "<<endl;
+    cout << "After pushing 10 20 30 40 into stack: " << endl;
     stk.push(10);
     stk.push(20);
     stk.push(30);
@@ -24,28 +26,30 @@ int main()
     cout << "---------------------- Test top ----------------------" << endl;
     int value = stk.top();
     if (value == 40)
-        cout << "PASS" <<endl;
+        cout << "PASS" << endl;
     else
-        cout << "FAIL" <<endl;
+        cout << "FAIL" << endl;
     cout << "---------------------- Test pop ----------------------" << endl;
     stk.display();
     stk.pop();
     stk.pop();
-    cout << "After popping 2 times: "<< endl;
+    cout << "After popping 2 times: " << endl;
     stk.display();
-    cout << "---------------------- Test overload = operator ----------------------" << endl;
+    cout << "---------------------- Test overload = operator "
+            "----------------------"
+         << endl;
     stack<int> stk1;
-    cout << "stk current: "<< endl;
+    cout << "stk current: " << endl;
     stk.display();
-    cout << endl << "Assign stk1 = stk "<< endl;
+    cout << endl << "Assign stk1 = stk " << endl;
     stk1 = stk;
     stk1.display();
-    cout << endl<< "After pushing 8 9 10 into stk1:" <<endl;
+    cout << endl << "After pushing 8 9 10 into stk1:" << endl;
     stk1.push(8);
     stk1.push(9);
     stk1.push(10);
     stk1.display();
-    cout << endl << "stk current: " <<endl;
+    cout << endl << "stk current: " << endl;
     stk.display();
     cout << "Assign back stk = stk1:" << endl;
     stk = stk1;

data_structure/tree.cpp

@@ -14,12 +14,12 @@ void CreateTree(node *curr, node *n, int x, char pos)
     if (n != NULL)
     {
         char ch;
-    cout << "\nLeft or Right of " << n->val << " : ";
-    cin >> ch;
-    if (ch == 'l')
-        CreateTree(n, n->left, x, ch);
-    else if (ch == 'r')
-        CreateTree(n, n->right, x, ch);
+        cout << "\nLeft or Right of " << n->val << " : ";
+        cin >> ch;
+        if (ch == 'l')
+            CreateTree(n, n->left, x, ch);
+        else if (ch == 'r')
+            CreateTree(n, n->right, x, ch);
     }
     else
     {
@@ -40,19 +40,19 @@ void CreateTree(node *curr, node *n, int x, char pos)
 
 void BFT(node *n)
 {
-    list<node*> queue;
+    list<node *> queue;
 
     queue.push_back(n);
 
-    while(!queue.empty())
+    while (!queue.empty())
     {
         n = queue.front();
         cout << n->val << "  ";
         queue.pop_front();
 
-        if(n->left != NULL)
+        if (n->left != NULL)
             queue.push_back(n->left);
-        if(n->right != NULL)
+        if (n->right != NULL)
             queue.push_back(n->right);
     }
 }

data_structure/trie_tree.cpp

@@ -1,86 +1,99 @@
-#include <stdio.h>
 #include <stdbool.h>
+#include <stdio.h>
 
 #include <iostream>
 #include <string>
 
 // structure definition
-typedef struct trie {
-    struct trie * arr[26];
+typedef struct trie
+{
+    struct trie* arr[26];
     bool isEndofWord;
 } trie;
 
 // create a new node for trie
-trie * createNode() {
-    trie * nn = new trie();
-    for (int i = 0; i < 26; i++)
-        nn -> arr[i] = NULL;
-    nn -> isEndofWord = false;
+trie* createNode()
+{
+    trie* nn = new trie();
+    for (int i = 0; i < 26; i++) nn->arr[i] = NULL;
+    nn->isEndofWord = false;
     return nn;
 }
 
 // insert string into the trie
-void insert(trie * root, std::string str) {
-    for (int i = 0; i < str.length(); i++) {
+void insert(trie* root, std::string str)
+{
+    for (int i = 0; i < str.length(); i++)
+    {
         int j = str[i] - 'a';
-        if (root -> arr[j]) {
-            root = root -> arr[j];
-        } else {
-            root -> arr[j] = createNode();
-            root = root -> arr[j];
+        if (root->arr[j])
+        {
+            root = root->arr[j];
+        }
+        else
+        {
+            root->arr[j] = createNode();
+            root = root->arr[j];
         }
     }
-    root -> isEndofWord = true;
+    root->isEndofWord = true;
 }
 
 // search a string exists inside the trie
-bool search(trie * root, std::string str, int index) {
-    if (index == str.length()) {
-        if (!root -> isEndofWord)
+bool search(trie* root, std::string str, int index)
+{
+    if (index == str.length())
+    {
+        if (!root->isEndofWord)
             return false;
         return true;
     }
     int j = str[index] - 'a';
-    if (!root -> arr[j])
+    if (!root->arr[j])
         return false;
-    return search(root -> arr[j], str, index + 1);
+    return search(root->arr[j], str, index + 1);
 }
 
 /*
-removes the string if it is not a prefix of any  other 
-string, if it is then just sets the endofword to false, else 
+removes the string if it is not a prefix of any  other
+string, if it is then just sets the endofword to false, else
 removes the given string
 */
-bool deleteString(trie * root, std::string str, int index) {
-    if (index == str.length()) {
-        if (!root -> isEndofWord)
-            return false;
-        root -> isEndofWord = false;
-        for (int i = 0; i < 26; i++)
+bool deleteString(trie* root, std::string str, int index)
+{
+    if (index == str.length())
+    {
+        if (!root->isEndofWord)
             return false;
+        root->isEndofWord = false;
+        for (int i = 0; i < 26; i++) return false;
         return true;
     }
     int j = str[index] - 'a';
-    if (!root -> arr[j])
+    if (!root->arr[j])
         return false;
-    bool
-    var = deleteString(root, str, index + 1);
-    if (var) {
-        root -> arr[j] = NULL;
-        if (root -> isEndofWord) {
+    bool var = deleteString(root, str, index + 1);
+    if (var)
+    {
+        root->arr[j] = NULL;
+        if (root->isEndofWord)
+        {
             return false;
-        } else {
+        }
+        else
+        {
             int i;
             for (i = 0; i < 26; i++)
-                if (root -> arr[i])
+                if (root->arr[i])
                     return false;
             return true;
         }
     }
 }
 
-int main() {
-    trie * root = createNode();
+int main()
+{
+    trie* root = createNode();
     insert(root, "hello");
     insert(root, "world");
     int a = search(root, "hello", 0);

dynamic_programming/0_1_knapsack.cpp

@@ -1,9 +1,9 @@
-//0-1 Knapsack problem - Dynamic programming
+// 0-1 Knapsack problem - Dynamic programming
 //#include <bits/stdc++.h>
 #include <iostream>
 using namespace std;
 
-//void Print(int res[20][20], int i, int j, int capacity)
+// void Print(int res[20][20], int i, int j, int capacity)
 //{
 //	if(i==0 || j==0)
 //	{
@@ -30,42 +30,43 @@ using namespace std;
 
 int Knapsack(int capacity, int n, int weight[], int value[])
 {
-	int res[20][20];
-	for (int i = 0; i < n + 1; ++i)
-	{
-		for (int j = 0; j < capacity + 1; ++j)
-		{
-			if (i == 0 || j == 0)
-				res[i][j] = 0;
-			else if (weight[i - 1] <= j)
-				res[i][j] = max(value[i - 1] + res[i - 1][j - weight[i - 1]], res[i - 1][j]);
-			else
-				res[i][j] = res[i - 1][j];
-		}
-	}
-	//	Print(res, n, capacity, capacity);
-	//	cout<<"\n";
-	return res[n][capacity];
+    int res[20][20];
+    for (int i = 0; i < n + 1; ++i)
+    {
+        for (int j = 0; j < capacity + 1; ++j)
+        {
+            if (i == 0 || j == 0)
+                res[i][j] = 0;
+            else if (weight[i - 1] <= j)
+                res[i][j] = max(value[i - 1] + res[i - 1][j - weight[i - 1]],
+                                res[i - 1][j]);
+            else
+                res[i][j] = res[i - 1][j];
+        }
+    }
+    //	Print(res, n, capacity, capacity);
+    //	cout<<"\n";
+    return res[n][capacity];
 }
 int main()
 {
-	int n;
-	cout << "Enter number of items: ";
-	cin >> n;
-	int weight[n], value[n];
-	cout << "Enter weights: ";
-	for (int i = 0; i < n; ++i)
-	{
-		cin >> weight[i];
-	}
-	cout << "Enter values: ";
-	for (int i = 0; i < n; ++i)
-	{
-		cin >> value[i];
-	}
-	int capacity;
-	cout << "Enter capacity: ";
-	cin >> capacity;
-	cout << Knapsack(capacity, n, weight, value);
-	return 0;
+    int n;
+    cout << "Enter number of items: ";
+    cin >> n;
+    int weight[n], value[n];
+    cout << "Enter weights: ";
+    for (int i = 0; i < n; ++i)
+    {
+        cin >> weight[i];
+    }
+    cout << "Enter values: ";
+    for (int i = 0; i < n; ++i)
+    {
+        cin >> value[i];
+    }
+    int capacity;
+    cout << "Enter capacity: ";
+    cin >> capacity;
+    cout << Knapsack(capacity, n, weight, value);
+    return 0;
 }

dynamic_programming/armstrong_number.cpp

@@ -1,21 +1,23 @@
 // Program to check whether a number is an armstrong number or not
 #include <iostream>
 
-using std::cout;
 using std::cin;
+using std::cout;
 
-int main() {
-  int n, k, d, s = 0;
-  cout << "Enter a number:";
-  cin >> n;
-  k = n;
-  while (k != 0) {
-    d = k % 10;
-    s += d * d * d;
-    k /= 10;
-  }
-  if (s == n)
-    cout << n << "is an armstrong number";
-  else
-    cout << n << "is not an armstrong number";
+int main()
+{
+    int n, k, d, s = 0;
+    cout << "Enter a number:";
+    cin >> n;
+    k = n;
+    while (k != 0)
+    {
+        d = k % 10;
+        s += d * d * d;
+        k /= 10;
+    }
+    if (s == n)
+        cout << n << "is an armstrong number";
+    else
+        cout << n << "is not an armstrong number";
 }

dynamic_programming/bellman_ford.cpp

@@ -1,128 +1,129 @@
-#include <iostream>
 #include <limits.h>
+#include <iostream>
 
 using namespace std;
 
-//Wrapper class for storing an edge
+// Wrapper class for storing an edge
 class Edge
 {
-public:
-	int src, dst, weight;
+ public:
+    int src, dst, weight;
 };
 
-//Wrapper class for storing a graph
+// Wrapper class for storing a graph
 class Graph
 {
-public:
-	int vertexNum, edgeNum;
-	Edge *edges;
+ public:
+    int vertexNum, edgeNum;
+    Edge *edges;
 
-	//Constructs a graph with V vertices and E edges
-	Graph(int V, int E)
-	{
-		this->vertexNum = V;
-		this->edgeNum = E;
-		this->edges = (Edge *)malloc(E * sizeof(Edge));
-	}
+    // Constructs a graph with V vertices and E edges
+    Graph(int V, int E)
+    {
+        this->vertexNum = V;
+        this->edgeNum = E;
+        this->edges = (Edge *)malloc(E * sizeof(Edge));
+    }
 
-	//Adds the given edge to the graph
-	void addEdge(int src, int dst, int weight)
-	{
-		static int edgeInd = 0;
-		if (edgeInd < this->edgeNum)
-		{
-			Edge newEdge;
-			newEdge.src = src;
-			newEdge.dst = dst;
-			newEdge.weight = weight;
-			this->edges[edgeInd++] = newEdge;
-		}
-	}
+    // Adds the given edge to the graph
+    void addEdge(int src, int dst, int weight)
+    {
+        static int edgeInd = 0;
+        if (edgeInd < this->edgeNum)
+        {
+            Edge newEdge;
+            newEdge.src = src;
+            newEdge.dst = dst;
+            newEdge.weight = weight;
+            this->edges[edgeInd++] = newEdge;
+        }
+    }
 };
 
-//Utility function to print distances
+// Utility function to print distances
 void print(int dist[], int V)
 {
-	cout << "\nVertex  Distance" << endl;
-	for (int i = 0; i < V; i++)
-	{
-		if (dist[i] != INT_MAX)
-			cout << i << "\t" << dist[i] << endl;
-		else
-			cout << i << "\tINF" << endl;
-	}
+    cout << "\nVertex  Distance" << endl;
+    for (int i = 0; i < V; i++)
+    {
+        if (dist[i] != INT_MAX)
+            cout << i << "\t" << dist[i] << endl;
+        else
+            cout << i << "\tINF" << endl;
+    }
 }
 
-//The main function that finds the shortest path from given source
-//to all other vertices using Bellman-Ford.It also detects negative
-//weight cycle
+// The main function that finds the shortest path from given source
+// to all other vertices using Bellman-Ford.It also detects negative
+// weight cycle
 void BellmanFord(Graph graph, int src)
 {
-	int V = graph.vertexNum;
-	int E = graph.edgeNum;
-	int dist[V];
+    int V = graph.vertexNum;
+    int E = graph.edgeNum;
+    int dist[V];
 
-	//Initialize distances array as INF for all except source
-	//Intialize source as zero
-	for (int i = 0; i < V; i++)
-		dist[i] = INT_MAX;
-	dist[src] = 0;
+    // Initialize distances array as INF for all except source
+    // Intialize source as zero
+    for (int i = 0; i < V; i++) dist[i] = INT_MAX;
+    dist[src] = 0;
 
-	//Calculate shortest path distance from source to all edges
-	//A path can contain maximum (|V|-1) edges
-	for (int i = 0; i <= V - 1; i++)
-		for (int j = 0; j < E; j++)
-		{
-			int u = graph.edges[j].src;
-			int v = graph.edges[j].dst;
-			int w = graph.edges[j].weight;
+    // Calculate shortest path distance from source to all edges
+    // A path can contain maximum (|V|-1) edges
+    for (int i = 0; i <= V - 1; i++)
+        for (int j = 0; j < E; j++)
+        {
+            int u = graph.edges[j].src;
+            int v = graph.edges[j].dst;
+            int w = graph.edges[j].weight;
 
-			if (dist[u] != INT_MAX && dist[u] + w < dist[v])
-				dist[v] = dist[u] + w;
-		}
+            if (dist[u] != INT_MAX && dist[u] + w < dist[v])
+                dist[v] = dist[u] + w;
+        }
 
-	//Iterate inner loop once more to check for negative cycle
-	for (int j = 0; j < E; j++)
-	{
-		int u = graph.edges[j].src;
-		int v = graph.edges[j].dst;
-		int w = graph.edges[j].weight;
+    // Iterate inner loop once more to check for negative cycle
+    for (int j = 0; j < E; j++)
+    {
+        int u = graph.edges[j].src;
+        int v = graph.edges[j].dst;
+        int w = graph.edges[j].weight;
 
-		if (dist[u] != INT_MAX && dist[u] + w < dist[v])
-		{
-			cout << "Graph contains negative weight cycle. Hence, shortest distance not guaranteed." << endl;
-			return;
-		}
-	}
+        if (dist[u] != INT_MAX && dist[u] + w < dist[v])
+        {
+            cout << "Graph contains negative weight cycle. Hence, shortest "
+                    "distance not guaranteed."
+                 << endl;
+            return;
+        }
+    }
 
-	print(dist, V);
+    print(dist, V);
 
-	return;
+    return;
 }
 
-//Driver Function
+// Driver Function
 int main()
 {
-	int V, E, gsrc;
-	int src, dst, weight;
-	cout << "Enter number of vertices: ";
-	cin >> V;
-	cout << "Enter number of edges: ";
-	cin >> E;
-	Graph G(V, E);
-	for (int i = 0; i < E; i++)
-	{
-		cout << "\nEdge " << i + 1 << "\nEnter source: ";
-		cin >> src;
-		cout << "Enter destination: ";
-		cin >> dst;
-		cout << "Enter weight: ";
-		cin >> weight;
-		G.addEdge(src, dst, weight);
-	}
-	cout << "\nEnter source: ";
-	cin >> gsrc;
-	BellmanFord(G, gsrc);
+    int V, E, gsrc;
+    int src, dst, weight;
+    cout << "Enter number of vertices: ";
+    cin >> V;
+    cout << "Enter number of edges: ";
+    cin >> E;
+    Graph G(V, E);
+    for (int i = 0; i < E; i++)
+    {
+        cout << "\nEdge " << i + 1 << "\nEnter source: ";
+        cin >> src;
+        cout << "Enter destination: ";
+        cin >> dst;
+        cout << "Enter weight: ";
+        cin >> weight;
+        G.addEdge(src, dst, weight);
+    }
+    cout << "\nEnter source: ";
+    cin >> gsrc;
+    BellmanFord(G, gsrc);
 
-	return 0;
+    return 0;
 }

dynamic_programming/catalan_numbers.cpp

@@ -9,7 +9,7 @@
 #include <iostream>
 using namespace std;
 
-int *cat; // global array to hold catalan numbers
+int *cat;  // global array to hold catalan numbers
 
 unsigned long int catalan_dp(int n)
 {
@@ -33,7 +33,7 @@ unsigned long int catalan_dp(int n)
     {
         cat[i] = 0;
         for (int j = 0; j < i; j++)
-            cat[i] += cat[j] * cat[i - j - 1]; // applying the definition here
+            cat[i] += cat[j] * cat[i - j - 1];  // applying the definition here
     }
 
     // Return the result

dynamic_programming/coin_change.cpp

@@ -1,50 +1,52 @@
-#include <iostream>
 #include <climits>
+#include <iostream>
 using namespace std;
 
 // Function to find the Minimum number of coins required to get Sum S
 int findMinCoins(int arr[], int n, int N)
 {
-	// dp[i] = no of coins required to get a total of i
-	int dp[N + 1];
+    // dp[i] = no of coins required to get a total of i
+    int dp[N + 1];
 
-	// 0 coins are needed for 0 sum
+    // 0 coins are needed for 0 sum
 
-	dp[0] = 0;
+    dp[0] = 0;
 
-	for (int i = 1; i <= N; i++)
-	{
-		// initialize minimum number of coins needed to infinity
-		dp[i] = INT_MAX;
-		int res = INT_MAX;
+    for (int i = 1; i <= N; i++)
+    {
+        // initialize minimum number of coins needed to infinity
+        dp[i] = INT_MAX;
+        int res = INT_MAX;
 
-		// do for each coin
-		for (int c = 0; c < n; c++)
-		{
-			if (i - arr[c] >= 0) // check if coins doesn't become negative by including it
-				res = dp[i - arr[c]];
+        // do for each coin
+        for (int c = 0; c < n; c++)
+        {
+            if (i - arr[c] >=
+                0)  // check if coins doesn't become negative by including it
+                res = dp[i - arr[c]];
 
-			// if total can be reached by including current coin c,
-			// update minimum number of coins needed dp[i]
-			if (res != INT_MAX)
-				dp[i] = min(dp[i], res + 1);
-		}
-	}
+            // if total can be reached by including current coin c,
+            // update minimum number of coins needed dp[i]
+            if (res != INT_MAX)
+                dp[i] = min(dp[i], res + 1);
+        }
+    }
 
-	// The Minimum No of Coins Required for N = dp[N]
-	return dp[N];
+    // The Minimum No of Coins Required for N = dp[N]
+    return dp[N];
 }
 
 int main()
 {
-	// No of Coins We Have
-	int arr[] = {1, 2, 3, 4};
-	int n = sizeof(arr) / sizeof(arr[0]);
+    // No of Coins We Have
+    int arr[] = {1, 2, 3, 4};
+    int n = sizeof(arr) / sizeof(arr[0]);
 
-	// Total Change Required
-	int N = 15;
+    // Total Change Required
+    int N = 15;
 
-	cout << "Minimum Number of Coins Required " << findMinCoins(arr, n, N) << "\n";
+    cout << "Minimum Number of Coins Required " << findMinCoins(arr, n, N)
+         << "\n";
 
-	return 0;
+    return 0;
 }

dynamic_programming/cut_rod.cpp

@@ -1,6 +1,6 @@
-/*Given a rod of length n inches and an array of prices that 
-contains prices of all pieces of size smaller than n. Determine 
-the maximum value obtainable by cutting up the rod and selling 
+/*Given a rod of length n inches and an array of prices that
+contains prices of all pieces of size smaller than n. Determine
+the maximum value obtainable by cutting up the rod and selling
 the pieces.*/
 
 #include <iostream>
@@ -22,7 +22,8 @@ int cutrod(int p[], int n)
 }
 int main()
 {
-    int price[] = {1, 5, 8, 9, 10, 17, 17, 20, 24, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50};
+    int price[] = {1,  5,  8,  9,  10, 17, 17, 20, 24, 30, 31, 32, 33, 34, 35,
+                   36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50};
     cout << cutrod(price, 30);
     return 0;
 }

dynamic_programming/edit_distance.cpp

@@ -7,7 +7,7 @@
  * a. Insert
  * b. Remove
  * c. Replace
- * All of the above operations are 
+ * All of the above operations are
  * of equal cost
  */
 
@@ -15,10 +15,7 @@
 #include <string>
 using namespace std;
 
-int min(int x, int y, int z)
-{
-    return min(min(x, y), z);
-}
+int min(int x, int y, int z) { return min(min(x, y), z); }
 
 /* A Naive recursive C++ program to find
  * minimum number of operations to convert
@@ -32,14 +29,14 @@ int editDist(string str1, string str2, int m, int n)
     if (n == 0)
         return m;
 
-    //If last characters are same then continue
-    //for the rest of them.
+    // If last characters are same then continue
+    // for the rest of them.
     if (str1[m - 1] == str2[n - 1])
         return editDist(str1, str2, m - 1, n - 1);
 
-    //If last not same, then 3 possibilities
-    //a.Insert b.Remove c. Replace
-    //Get min of three and continue for rest.
+    // If last not same, then 3 possibilities
+    // a.Insert b.Remove c. Replace
+    // Get min of three and continue for rest.
     return 1 + min(editDist(str1, str2, m, n - 1),
                    editDist(str1, str2, m - 1, n),
                    editDist(str1, str2, m - 1, n - 1));
@@ -50,31 +47,30 @@ int editDist(string str1, string str2, int m, int n)
  */
 int editDistDP(string str1, string str2, int m, int n)
 {
-
-    //Create Table for SubProblems
+    // Create Table for SubProblems
     int dp[m + 1][n + 1];
 
-    //Fill d[][] in bottom up manner
+    // Fill d[][] in bottom up manner
     for (int i = 0; i <= m; i++)
     {
         for (int j = 0; j <= n; j++)
         {
-            //If str1 empty. Then add all of str2
+            // If str1 empty. Then add all of str2
             if (i == 0)
                 dp[i][j] = j;
 
-            //If str2 empty. Then add all of str1
+            // If str2 empty. Then add all of str1
             else if (j == 0)
                 dp[i][j] = i;
 
-            //If character same. Recur for remaining
+            // If character same. Recur for remaining
             else if (str1[i - 1] == str2[j - 1])
                 dp[i][j] = dp[i - 1][j - 1];
 
             else
-                dp[i][j] = 1 + min(dp[i][j - 1],    //Insert
-                                   dp[i - 1][j],    //Remove
-                                   dp[i - 1][j - 1] //Replace
+                dp[i][j] = 1 + min(dp[i][j - 1],     // Insert
+                                   dp[i - 1][j],     // Remove
+                                   dp[i - 1][j - 1]  // Replace
                                );
         }
     }

dynamic_programming/egg_dropping_puzzle.cpp

@@ -1,9 +1,9 @@
-/* Function to get minimun number of trials needed 
- * in worst case with n eggs and k floors 
+/* Function to get minimun number of trials needed
+ * in worst case with n eggs and k floors
  */
 
-#include <iostream>
 #include <climits>
+#include <iostream>
 using namespace std;
 
 int eggDrop(int n, int k)
@@ -13,8 +13,8 @@ int eggDrop(int n, int k)
 
     for (int i = 1; i <= n; i++)
     {
-        eggFloor[i][1] = 1; //n eggs..1 Floor
-        eggFloor[i][0] = 0; //n eggs..0 Floor
+        eggFloor[i][1] = 1;  // n eggs..1 Floor
+        eggFloor[i][0] = 0;  // n eggs..0 Floor
     }
 
     // Only one egg available

dynamic_programming/fibonacci_bottom_up.cpp

@@ -2,23 +2,23 @@
 using namespace std;
 int fib(int n)
 {
-	int res[3];
-	res[0] = 0;
-	res[1] = 1;
-	for (int i = 2; i <= n; i++)
-	{
-		res[2] = res[1] + res[0];
-		res[0] = res[1];
-		res[1] = res[2];
-	}
-	return res[1];
+    int res[3];
+    res[0] = 0;
+    res[1] = 1;
+    for (int i = 2; i <= n; i++)
+    {
+        res[2] = res[1] + res[0];
+        res[0] = res[1];
+        res[1] = res[2];
+    }
+    return res[1];
 }
 int main(int argc, char const *argv[])
 {
-	int n;
-	cout << "Enter n: ";
-	cin >> n;
-	cout << "Fibonacci number is ";
-	cout << fib(n) << endl;
-	return 0;
+    int n;
+    cout << "Enter n: ";
+    cin >> n;
+    cout << "Fibonacci number is ";
+    cout << fib(n) << endl;
+    return 0;
 }

dynamic_programming/fibonacci_top_down.cpp

@@ -3,24 +3,24 @@ using namespace std;
 int arr[1000000];
 int fib(int n)
 {
-	if (arr[n] == -1)
-	{
-		if (n <= 1)
-			arr[n] = n;
-		else
-			arr[n] = fib(n - 1) + fib(n - 2);
-	}
-	return arr[n];
+    if (arr[n] == -1)
+    {
+        if (n <= 1)
+            arr[n] = n;
+        else
+            arr[n] = fib(n - 1) + fib(n - 2);
+    }
+    return arr[n];
 }
 int main(int argc, char const *argv[])
 {
-	int n;
-	cout << "Enter n: ";
-	cin >> n;
-	for (int i = 0; i < n + 1; ++i)
-	{
-		arr[i] = -1;
-	}
-	cout << "Fibonacci number is " << fib(n) << endl;
-	return 0;
+    int n;
+    cout << "Enter n: ";
+    cin >> n;
+    for (int i = 0; i < n + 1; ++i)
+    {
+        arr[i] = -1;
+    }
+    cout << "Fibonacci number is " << fib(n) << endl;
+    return 0;
 }

dynamic_programming/floyd_warshall.cpp

@@ -1,112 +1,110 @@
-#include <iostream>
 #include <limits.h>
 #include <string.h>
+#include <iostream>
 
 using namespace std;
 
-//Wrapper class for storing a graph
+// Wrapper class for storing a graph
 class Graph
 {
-public:
-	int vertexNum;
-	int **edges;
+ public:
+    int vertexNum;
+    int **edges;
 
-	//Constructs a graph with V vertices and E edges
-	Graph(int V)
-	{
-		this->vertexNum = V;
-		this->edges = (int **)malloc(V * sizeof(int *));
-		for (int i = 0; i < V; i++)
-		{
-			this->edges[i] = (int *)malloc(V * sizeof(int));
-			for (int j = 0; j < V; j++)
-				this->edges[i][j] = INT_MAX;
-			this->edges[i][i] = 0;
-		}
-	}
+    // Constructs a graph with V vertices and E edges
+    Graph(int V)
+    {
+        this->vertexNum = V;
+        this->edges = (int **)malloc(V * sizeof(int *));
+        for (int i = 0; i < V; i++)
+        {
+            this->edges[i] = (int *)malloc(V * sizeof(int));
+            for (int j = 0; j < V; j++) this->edges[i][j] = INT_MAX;
+            this->edges[i][i] = 0;
+        }
+    }
 
-	//Adds the given edge to the graph
-	void addEdge(int src, int dst, int weight)
-	{
-		this->edges[src][dst] = weight;
-	}
+    // Adds the given edge to the graph
+    void addEdge(int src, int dst, int weight)
+    {
+        this->edges[src][dst] = weight;
+    }
 };
 
-//Utility function to print distances
+// Utility function to print distances
 void print(int dist[], int V)
 {
-	cout << "\nThe Distance matrix for Floyd - Warshall" << endl;
-	for (int i = 0; i < V; i++)
-	{
-		for (int j = 0; j < V; j++)
-		{
-
-			if (dist[i * V + j] != INT_MAX)
-				cout << dist[i * V + j] << "\t";
-			else
-				cout << "INF"
-					 << "\t";
-		}
-		cout << endl;
-	}
+    cout << "\nThe Distance matrix for Floyd - Warshall" << endl;
+    for (int i = 0; i < V; i++)
+    {
+        for (int j = 0; j < V; j++)
+        {
+            if (dist[i * V + j] != INT_MAX)
+                cout << dist[i * V + j] << "\t";
+            else
+                cout << "INF"
+                     << "\t";
+        }
+        cout << endl;
+    }
 }
 
-//The main function that finds the shortest path from a vertex
-//to all other vertices using Floyd-Warshall Algorithm.
+// The main function that finds the shortest path from a vertex
+// to all other vertices using Floyd-Warshall Algorithm.
 void FloydWarshall(Graph graph)
 {
-	int V = graph.vertexNum;
-	int dist[V][V];
+    int V = graph.vertexNum;
+    int dist[V][V];
 
-	//Initialise distance array
-	for (int i = 0; i < V; i++)
-		for (int j = 0; j < V; j++)
-			dist[i][j] = graph.edges[i][j];
+    // Initialise distance array
+    for (int i = 0; i < V; i++)
+        for (int j = 0; j < V; j++) dist[i][j] = graph.edges[i][j];
 
-	//Calculate distances
-	for (int k = 0; k < V; k++)
-		//Choose an intermediate vertex
+    // Calculate distances
+    for (int k = 0; k < V; k++)
+        // Choose an intermediate vertex
 
-		for (int i = 0; i < V; i++)
-			//Choose a source vertex for given intermediate
+        for (int i = 0; i < V; i++)
+            // Choose a source vertex for given intermediate
 
-			for (int j = 0; j < V; j++)
-				//Choose a destination vertex for above source vertex
+            for (int j = 0; j < V; j++)
+                // Choose a destination vertex for above source vertex
 
-				if (dist[i][k] != INT_MAX && dist[k][j] != INT_MAX && dist[i][k] + dist[k][j] < dist[i][j])
-					//If the distance through intermediate vertex is less than direct edge then update value in distance array
-					dist[i][j] = dist[i][k] + dist[k][j];
+                if (dist[i][k] != INT_MAX && dist[k][j] != INT_MAX &&
+                    dist[i][k] + dist[k][j] < dist[i][j])
+                    // If the distance through intermediate vertex is less than
+                    // direct edge then update value in distance array
+                    dist[i][j] = dist[i][k] + dist[k][j];
 
-	//Convert 2d array to 1d array for print
-	int dist1d[V * V];
-	for (int i = 0; i < V; i++)
-		for (int j = 0; j < V; j++)
-			dist1d[i * V + j] = dist[i][j];
+    // Convert 2d array to 1d array for print
+    int dist1d[V * V];
+    for (int i = 0; i < V; i++)
+        for (int j = 0; j < V; j++) dist1d[i * V + j] = dist[i][j];
 
-	print(dist1d, V);
+    print(dist1d, V);
 }
 
-//Driver Function
+// Driver Function
 int main()
 {
-	int V, E;
-	int src, dst, weight;
-	cout << "Enter number of vertices: ";
-	cin >> V;
-	cout << "Enter number of edges: ";
-	cin >> E;
-	Graph G(V);
-	for (int i = 0; i < E; i++)
-	{
-		cout << "\nEdge " << i + 1 << "\nEnter source: ";
-		cin >> src;
-		cout << "Enter destination: ";
-		cin >> dst;
-		cout << "Enter weight: ";
-		cin >> weight;
-		G.addEdge(src, dst, weight);
-	}
-	FloydWarshall(G);
+    int V, E;
+    int src, dst, weight;
+    cout << "Enter number of vertices: ";
+    cin >> V;
+    cout << "Enter number of edges: ";
+    cin >> E;
+    Graph G(V);
+    for (int i = 0; i < E; i++)
+    {
+        cout << "\nEdge " << i + 1 << "\nEnter source: ";
+        cin >> src;
+        cout << "Enter destination: ";
+        cin >> dst;
+        cout << "Enter weight: ";
+        cin >> weight;
+        G.addEdge(src, dst, weight);
+    }
+    FloydWarshall(G);
 
-	return 0;
+    return 0;
 }

dynamic_programming/kadane.cpp

@@ -1,10 +1,12 @@
-#include<iostream>
-#include<climits>
+#include <climits>
+#include <iostream>
 
-int maxSubArraySum(int a[], int size) {
+int maxSubArraySum(int a[], int size)
+{
     int max_so_far = INT_MIN, max_ending_here = 0;
 
-    for (int i = 0; i < size; i++) {
+    for (int i = 0; i < size; i++)
+    {
         max_ending_here = max_ending_here + a[i];
         if (max_so_far < max_ending_here)
             max_so_far = max_ending_here;
@@ -15,13 +17,14 @@ int maxSubArraySum(int a[], int size) {
     return max_so_far;
 }
 
-
-int main() {
+int main()
+{
     int n, i;
     std::cout << "Enter the number of elements \n";
     std::cin >> n;
     int a[n];  // NOLINT
-    for (i = 0; i < n; i++) {
+    for (i = 0; i < n; i++)
+    {
         std::cin >> a[i];
     }
     int max_sum = maxSubArraySum(a, n);

dynamic_programming/longest_common_string.cpp

@@ -1,65 +1,59 @@
 #include <iosrteam>
 using namespace std;
 
-int max(int a,int b)
-{
-    return (a > b) ? a : b;
-}
+int max(int a, int b) { return (a > b) ? a : b; }
 
 int main()
 {
-    char str1[]="DEFBCD";
-    char str2[]="ABDEFJ";
-    int i,j,k;
-    int n=strlen(str1)+1;
-    int m=strlen(str2)+1;
-    //cout<<n<<" "<<m<<"\n";
+    char str1[] = "DEFBCD";
+    char str2[] = "ABDEFJ";
+    int i, j, k;
+    int n = strlen(str1) + 1;
+    int m = strlen(str2) + 1;
+    // cout<<n<<" "<<m<<"\n";
     int a[m][n];
 
-    for(i=0;i<m;i++)
+    for (i = 0; i < m; i++)
     {
-        for(j=0;j<n;j++)
+        for (j = 0; j < n; j++)
         {
-            if(i==0 || j==0)
-                a[i][j]=0;
+            if (i == 0 || j == 0)
+                a[i][j] = 0;
 
-            else if(str1[i-1] == str2[j-1])
-                    a[i][j]=a[i-1][j-1]+1;
+            else if (str1[i - 1] == str2[j - 1])
+                a[i][j] = a[i - 1][j - 1] + 1;
 
             else
-                a[i][j]=0;
+                a[i][j] = 0;
         }
     }
 
-
-/*for(i=0;i<m;i++)
-    {
-        for(j=0;j<n;j++)
-            cout<<a[i][j]<<" ";
-        cout<<"\n";
-    }*/
-
-
-int ma=-1;
-int indi,indj;
-for(i=0;i<m;i++)
-    {
-        for(j=0;j<n;j++)
+    /*for(i=0;i<m;i++)
         {
-            if(a[i][j]>ma)
+            for(j=0;j<n;j++)
+                cout<<a[i][j]<<" ";
+            cout<<"\n";
+        }*/
+
+    int ma = -1;
+    int indi, indj;
+    for (i = 0; i < m; i++)
+    {
+        for (j = 0; j < n; j++)
+        {
+            if (a[i][j] > ma)
             {
-                ma=a[i][j];
-                indi=i;
-                indj=j;
+                ma = a[i][j];
+                indi = i;
+                indj = j;
             }
         }
     }
 
-    cout<<str1<<"\n";
-    cout<<str2<<"\n";
+    cout << str1 << "\n";
+    cout << str2 << "\n";
 
-    cout<<"longest string size = "<<ma/*<<" "<<indi<<" "<<indj*/<<"\n";
-    for(i=indi-3;i<indi;i++)
-        cout<<str1[i];
-    cout<<"\n";
+    cout << "longest string size = " << ma /*<<" "<<indi<<" "<<indj*/ << "\n";
+    for (i = indi - 3; i < indi; i++) cout << str1[i];
+    cout << "\n";
 }

dynamic_programming/longest_common_subsequence.cpp

@@ -1,4 +1,4 @@
-//Longest common subsequence - Dynamic Programming
+// Longest common subsequence - Dynamic Programming
 #include <iostream>
 using namespace std;
 
@@ -52,19 +52,22 @@ int lcs(string a, string b)
             else if (a[i - 1] == b[j - 1])
             {
                 res[i][j] = 1 + res[i - 1][j - 1];
-                trace[i][j] = 1; // 1 means trace the matrix in upper left diagonal direction.
+                trace[i][j] = 1;  // 1 means trace the matrix in upper left
+                                  // diagonal direction.
             }
             else
             {
                 if (res[i - 1][j] > res[i][j - 1])
                 {
                     res[i][j] = res[i - 1][j];
-                    trace[i][j] = 2; // 2 means trace the matrix in upwards direction.
+                    trace[i][j] =
+                        2;  // 2 means trace the matrix in upwards direction.
                 }
                 else
                 {
                     res[i][j] = res[i][j - 1];
-                    trace[i][j] = 3; //  means trace the matrix in left direction.
+                    trace[i][j] =
+                        3;  //  means trace the matrix in left direction.
                 }
             }
         }

dynamic_programming/longest_increasing_subsequence.cpp

@@ -1,39 +1,39 @@
-//Program to calculate length of longest increasing subsequence in an array
+// Program to calculate length of longest increasing subsequence in an array
 #include <bits/stdc++.h>
 using namespace std;
 int LIS(int a[], int n)
 {
-	int lis[n];
-	for (int i = 0; i < n; ++i)
-	{
-		lis[i] = 1;
-	}
-	for (int i = 0; i < n; ++i)
-	{
-		for (int j = 0; j < i; ++j)
-		{
-			if (a[i] > a[j] && lis[i] < lis[j] + 1)
-				lis[i] = lis[j] + 1;
-		}
-	}
-	int res = 0;
-	for (int i = 0; i < n; ++i)
-	{
-		res = max(res, lis[i]);
-	}
-	return res;
+    int lis[n];
+    for (int i = 0; i < n; ++i)
+    {
+        lis[i] = 1;
+    }
+    for (int i = 0; i < n; ++i)
+    {
+        for (int j = 0; j < i; ++j)
+        {
+            if (a[i] > a[j] && lis[i] < lis[j] + 1)
+                lis[i] = lis[j] + 1;
+        }
+    }
+    int res = 0;
+    for (int i = 0; i < n; ++i)
+    {
+        res = max(res, lis[i]);
+    }
+    return res;
 }
 int main(int argc, char const *argv[])
 {
-	int n;
-	cout << "Enter size of array: ";
-	cin >> n;
-	int a[n];
-	cout << "Enter array elements: ";
-	for (int i = 0; i < n; ++i)
-	{
-		cin >> a[i];
-	}
-	cout << LIS(a, n) << endl;
-	return 0;
+    int n;
+    cout << "Enter size of array: ";
+    cin >> n;
+    int a[n];
+    cout << "Enter array elements: ";
+    for (int i = 0; i < n; ++i)
+    {
+        cin >> a[i];
+    }
+    cout << LIS(a, n) << endl;
+    return 0;
 }

dynamic_programming/longest_increasing_subsequence_(nlogn).cpp

@@ -1,4 +1,4 @@
-//Program to calculate length of longest increasing subsequence in an array
+// Program to calculate length of longest increasing subsequence in an array
 // in O(n log n)
 // tested on : https://cses.fi/problemset/task/1145/
 
@@ -7,30 +7,32 @@
 using namespace std;
 int LIS(int arr[], int n)
 {
-    set < int > active; // The current built LIS.
+    set<int> active;  // The current built LIS.
     active.insert(arr[0]);
     // Loop through every element.
     for (int i = 1; i < n; ++i)
     {
         auto get = active.lower_bound(arr[i]);
         if (get == active.end())
-	{
+        {
             active.insert(arr[i]);
-        } // current element is the greatest so LIS increases by 1.
+        }  // current element is the greatest so LIS increases by 1.
         else
-	{
-            int val = * get; // we find the position where arr[i] will be in the LIS. If it is in the LIS already we do nothing
+        {
+            int val = *get;  // we find the position where arr[i] will be in the
+                             // LIS. If it is in the LIS already we do nothing
             if (val > arr[i])
-	    {
-                // else we remove the bigger element and add a smaller element (which is arr[i]) and continue;
+            {
+                // else we remove the bigger element and add a smaller element
+                // (which is arr[i]) and continue;
                 active.erase(get);
                 active.insert(arr[i]);
             }
         }
     }
-    return active.size(); // size of the LIS.
+    return active.size();  // size of the LIS.
 }
-int main(int argc, char const * argv[])
+int main(int argc, char const* argv[])
 {
     int n;
     cout << "Enter size of array: ";

dynamic_programming/matrix_chain_multiplication.cpp

@@ -1,5 +1,5 @@
-#include <iostream>
 #include <climits>
+#include <iostream>
 using namespace std;
 
 #define MAX 10
@@ -7,56 +7,59 @@ using namespace std;
 // dp table to store the solution for already computed sub problems
 int dp[MAX][MAX];
 
-// Function to find the most efficient way to multiply the given sequence of matrices
+// Function to find the most efficient way to multiply the given sequence of
+// matrices
 int MatrixChainMultiplication(int dim[], int i, int j)
 {
-	// base case: one matrix
-	if (j <= i + 1)
-		return 0;
+    // base case: one matrix
+    if (j <= i + 1)
+        return 0;
 
-	// stores minimum number of scalar multiplications (i.e., cost)
-	// needed to compute the matrix M[i+1]...M[j] = M[i..j]
-	int min = INT_MAX;
+    // stores minimum number of scalar multiplications (i.e., cost)
+    // needed to compute the matrix M[i+1]...M[j] = M[i..j]
+    int min = INT_MAX;
 
-	// if dp[i][j] is not calculated (calculate it!!)
+    // if dp[i][j] is not calculated (calculate it!!)
 
-	if (dp[i][j] == 0)
-	{
-		// take the minimum over each possible position at which the
-		// sequence of matrices can be split
+    if (dp[i][j] == 0)
+    {
+        // take the minimum over each possible position at which the
+        // sequence of matrices can be split
 
-		for (int k = i + 1; k <= j - 1; k++)
-		{
-			// recur for M[i+1]..M[k] to get a i x k matrix
-			int cost = MatrixChainMultiplication(dim, i, k);
+        for (int k = i + 1; k <= j - 1; k++)
+        {
+            // recur for M[i+1]..M[k] to get a i x k matrix
+            int cost = MatrixChainMultiplication(dim, i, k);
 
-			// recur for M[k+1]..M[j] to get a k x j matrix
-			cost += MatrixChainMultiplication(dim, k, j);
+            // recur for M[k+1]..M[j] to get a k x j matrix
+            cost += MatrixChainMultiplication(dim, k, j);
 
-			// cost to multiply two (i x k) and (k x j) matrix
-			cost += dim[i] * dim[k] * dim[j];
+            // cost to multiply two (i x k) and (k x j) matrix
+            cost += dim[i] * dim[k] * dim[j];
 
-			if (cost < min)
-				min = cost; // store the minimum cost
-		}
-		dp[i][j] = min;
-	}
+            if (cost < min)
+                min = cost;  // store the minimum cost
+        }
+        dp[i][j] = min;
+    }
 
-	// return min cost to multiply M[j+1]..M[j]
-	return dp[i][j];
+    // return min cost to multiply M[j+1]..M[j]
+    return dp[i][j];
 }
 
 // main function
 int main()
 {
-	// Matrix i has Dimensions dim[i-1] & dim[i] for i=1..n
-	// input is 10 x 30 matrix, 30 x 5 matrix, 5 x 60 matrix
-	int dim[] = {10, 30, 5, 60};
-	int n = sizeof(dim) / sizeof(dim[0]);
+    // Matrix i has Dimensions dim[i-1] & dim[i] for i=1..n
+    // input is 10 x 30 matrix, 30 x 5 matrix, 5 x 60 matrix
+    int dim[] = {10, 30, 5, 60};
+    int n = sizeof(dim) / sizeof(dim[0]);
 
-	// Function Calling: MatrixChainMultiplications(dimensions_array, starting, ending);
+    // Function Calling: MatrixChainMultiplications(dimensions_array, starting,
+    // ending);
 
-	cout << "Minimum cost is " << MatrixChainMultiplication(dim, 0, n - 1) << "\n";
+    cout << "Minimum cost is " << MatrixChainMultiplication(dim, 0, n - 1)
+         << "\n";
 
-	return 0;
+    return 0;
 }

dynamic_programming/searching_of_element_in_dynamic_array.cpp

@@ -1,41 +1,42 @@
 /*
-*this program is use to find any elemet in any row with variable array size
-*aplication of pointer is use in it
-*important point start from here to:
-*the index value of array can be go to 1 to 100000
-*check till array[1000]
-*end here
-*how to work example:
-**Question:
-***number of array 2
-***quarry 3
-***array 1 is {1 2 3 4 5}
-***array 2 is {6 7}
-****i) what is 2nd element in 1st array
-****ii) what is 1st element in 2nd array
-****iii) what is 5th element in 1st array
-*****output:
-*****Enter Number of array you want to Store : 2
-*****Enter Number of Question or Quary you want to do Related to Array : 3
-*****Enter number of element in 1 rows : 5
-*****Enter the element of Array 1 2 3 4 5
-*****Enter number of element in 2 rows : 2
-*****Enter the element of Array 6 7
-*****enter the number of row which element You want to find : 1
-*****enter the position of element which You want to find : 2
-*****The element is 2
-*****enter the number of row which element You want to find : 2
-*****enter the position of element which You want to find : 1
-*****The element is 6
-*****enter the number of row which element You want to find : 1
-*****enter the position of element which You want to find : 5
-*****The element is 5
-*/
+ *this program is use to find any elemet in any row with variable array size
+ *aplication of pointer is use in it
+ *important point start from here to:
+ *the index value of array can be go to 1 to 100000
+ *check till array[1000]
+ *end here
+ *how to work example:
+ **Question:
+ ***number of array 2
+ ***quarry 3
+ ***array 1 is {1 2 3 4 5}
+ ***array 2 is {6 7}
+ ****i) what is 2nd element in 1st array
+ ****ii) what is 1st element in 2nd array
+ ****iii) what is 5th element in 1st array
+ *****output:
+ *****Enter Number of array you want to Store : 2
+ *****Enter Number of Question or Quary you want to do Related to Array : 3
+ *****Enter number of element in 1 rows : 5
+ *****Enter the element of Array 1 2 3 4 5
+ *****Enter number of element in 2 rows : 2
+ *****Enter the element of Array 6 7
+ *****enter the number of row which element You want to find : 1
+ *****enter the position of element which You want to find : 2
+ *****The element is 2
+ *****enter the number of row which element You want to find : 2
+ *****enter the position of element which You want to find : 1
+ *****The element is 6
+ *****enter the number of row which element You want to find : 1
+ *****enter the position of element which You want to find : 5
+ *****The element is 5
+ */
 #include <iostream>
 
 // this is main fuction
 // ***
-int main() {
+int main()
+{
     int64_t r, mr = 0, x, q, i, z;
     std::cout << "Enter Number of array you want to Store :";
     std::cin >> x;
@@ -46,10 +47,11 @@ int main() {
     // create a Array in run time because use can
     // change the size of each array which he/she is going to store
     // create a 2D array
-    int** ar = new int* [x]();
+    int** ar = new int*[x]();
     // this for loop is use for entering different variable size array
     // ***
-    for (r = 0; r < x; r++) {
+    for (r = 0; r < x; r++)
+    {
         std::cout << "Enter number of element in " << r + 1 << " rows :";
         std::cin >> mr;
         // creating a 1D array
@@ -57,7 +59,8 @@ int main() {
         std::cout << "Enter the element of Array ";
         // this for loop is use for storing values in array
         // ***
-        for (i = 0; i < mr; i++) {
+        for (i = 0; i < mr; i++)
+        {
             // entering the value of rows in array in Horizontal
             std::cin >> ac[i];
         }
@@ -66,7 +69,8 @@ int main() {
     }
     // this for loop is use for display result of querry
     // ***
-    for (z = 0; z < q; z++) {
+    for (z = 0; z < q; z++)
+    {
         int64_t r1 = 0, q1 = 0;
         std::cout << "enter the number of row which element you want to find :";
         std::cin >> r1;
@@ -75,6 +79,6 @@ int main() {
         std::cin >> q1;
         q1 = q1 - 1;
         // use this to find desire position of element in desire array
-        std::cout <<"The element is "<< ar[r1][q1] <<std::endl;
+        std::cout << "The element is " << ar[r1][q1] << std::endl;
     }
 }

dynamic_programming/tree_height.cpp

@@ -8,18 +8,18 @@
  * 1 2
  * 1 3
  * 2 4
- * which can be represented as                 
- *   1                      
- *  / \                     
- * 2   3                    
- * |                        
- * 4            
- * 
+ * which can be represented as
+ *   1
+ *  / \
+ * 2   3
+ * |
+ * 4
+ *
  * Height of the tree : - 2
-*/
+ */
 
-#include<iostream>
-#include<vector>
+#include <iostream>
+#include <vector>
 
 // global declarations
 // no of nodes max limit.
@@ -29,22 +29,26 @@ std::vector<int> adj[MAX];
 std::vector<bool> visited;
 std::vector<int> dp;
 
-void depth_first_search(int u) {
+void depth_first_search(int u)
+{
     visited[u] = true;
     int child_height = 1;
-    for (int v : adj[u]) {
-        if (!visited[v]) {
+    for (int v : adj[u])
+    {
+        if (!visited[v])
+        {
             depth_first_search(v);
 
             // select maximum sub-tree height from all children.
-            child_height = std::max(child_height, dp[v]+1);
+            child_height = std::max(child_height, dp[v] + 1);
         }
     }
     // assigned the max child height to current visited node.
     dp[u] = child_height;
 }
 
-int main() {
+int main()
+{
     // number of nodes
     int number_of_nodes;
     std::cout << "Enter number of nodes of the tree : " << std::endl;
@@ -54,16 +58,17 @@ int main() {
     int u, v;
     // Tree contains exactly n-1 edges where n denotes the number of nodes.
     std::cout << "Enter edges of the tree : " << std::endl;
-    for (int i = 0; i < number_of_nodes - 1; i++) {
+    for (int i = 0; i < number_of_nodes - 1; i++)
+    {
         std::cin >> u >> v;
         // undirected tree u -> v and v -> u.
         adj[u].push_back(v);
         adj[v].push_back(u);
     }
     // initialize all nodes as unvisited.
-    visited.assign(number_of_nodes+1, false);
+    visited.assign(number_of_nodes + 1, false);
     // initialize depth of all nodes to 0.
-    dp.assign(number_of_nodes+1, 0);
+    dp.assign(number_of_nodes + 1, 0);
     // function call which will initialize the height of all nodes.
     depth_first_search(1);
     std::cout << "Height of the Tree : " << dp[1] << std::endl;

graph/bfs.cpp

@@ -2,72 +2,72 @@
 using namespace std;
 class graph
 {
-	int v;
-	list<int> *adj;
+    int v;
+    list<int> *adj;
 
-public:
-	graph(int v);
-	void addedge(int src, int dest);
-	void printgraph();
-	void bfs(int s);
+ public:
+    graph(int v);
+    void addedge(int src, int dest);
+    void printgraph();
+    void bfs(int s);
 };
 graph::graph(int v)
 {
-	this->v = v;
-	this->adj = new list<int>[v];
+    this->v = v;
+    this->adj = new list<int>[v];
 }
 void graph::addedge(int src, int dest)
 {
-	src--;
-	dest--;
-	adj[src].push_back(dest);
-	//adj[dest].push_back(src);
+    src--;
+    dest--;
+    adj[src].push_back(dest);
+    // adj[dest].push_back(src);
 }
 void graph::printgraph()
 {
-	for (int i = 0; i < this->v; i++)
-	{
-		cout << "Adjacency list of vertex " << i + 1 << " is \n";
-		list<int>::iterator it;
-		for (it = adj[i].begin(); it != adj[i].end(); ++it)
-		{
-			cout << *it + 1 << " ";
-		}
-		cout << endl;
-	}
+    for (int i = 0; i < this->v; i++)
+    {
+        cout << "Adjacency list of vertex " << i + 1 << " is \n";
+        list<int>::iterator it;
+        for (it = adj[i].begin(); it != adj[i].end(); ++it)
+        {
+            cout << *it + 1 << " ";
+        }
+        cout << endl;
+    }
 }
 void graph::bfs(int s)
 {
-	bool *visited = new bool[this->v + 1];
-	memset(visited, false, sizeof(bool) * (this->v + 1));
-	visited[s] = true;
-	list<int> q;
-	q.push_back(s);
-	list<int>::iterator it;
-	while (!q.empty())
-	{
-		int u = q.front();
-		cout << u << " ";
-		q.pop_front();
-		for (it = adj[u].begin(); it != adj[u].end(); ++it)
-		{
-			if (visited[*it] == false)
-			{
-				visited[*it] = true;
-				q.push_back(*it);
-			}
-		}
-	}
+    bool *visited = new bool[this->v + 1];
+    memset(visited, false, sizeof(bool) * (this->v + 1));
+    visited[s] = true;
+    list<int> q;
+    q.push_back(s);
+    list<int>::iterator it;
+    while (!q.empty())
+    {
+        int u = q.front();
+        cout << u << " ";
+        q.pop_front();
+        for (it = adj[u].begin(); it != adj[u].end(); ++it)
+        {
+            if (visited[*it] == false)
+            {
+                visited[*it] = true;
+                q.push_back(*it);
+            }
+        }
+    }
 }
 int main()
 {
-	graph g(4);
-	g.addedge(1, 2);
-	g.addedge(2, 3);
-	g.addedge(3, 4);
-	g.addedge(1, 4);
-	g.addedge(1, 3);
-	//g.printgraph();
-	g.bfs(2);
-	return 0;
+    graph g(4);
+    g.addedge(1, 2);
+    g.addedge(2, 3);
+    g.addedge(3, 4);
+    g.addedge(1, 4);
+    g.addedge(1, 3);
+    // g.printgraph();
+    g.bfs(2);
+    return 0;
 }

graph/bridge_finding_with_tarjan_algorithm.cpp

@@ -4,28 +4,34 @@
  *  Last Modified Date: May 24, 2020
  *
  */
-#include <vector>  //  for std::vector
 #include <algorithm>  //  for min & max
-#include <iostream>  //  for cout
-using std::vector;
+#include <iostream>   //  for cout
+#include <vector>     //  for std::vector
 using std::cout;
 using std::min;
-class Solution {
-    vector < vector < int > > graph;
-    vector<int>in_time , out_time;
+using std::vector;
+class Solution
+{
+    vector<vector<int>> graph;
+    vector<int> in_time, out_time;
     int timer;
-    vector < vector < int > > bridge;
-    vector<bool>visited;
-    void dfs(int current_node , int parent) {
+    vector<vector<int>> bridge;
+    vector<bool> visited;
+    void dfs(int current_node, int parent)
+    {
         visited.at(current_node) = true;
         in_time[current_node] = out_time[current_node] = timer++;
-        for ( auto&itr : graph[current_node] ) {
-            if (itr == parent) {
+        for (auto& itr : graph[current_node])
+        {
+            if (itr == parent)
+            {
                 continue;
             }
-            if (!visited[itr]) {
-                dfs(itr , current_node);
-                if (out_time[itr] > in_time[current_node]) {
+            if (!visited[itr])
+            {
+                dfs(itr, current_node);
+                if (out_time[itr] > in_time[current_node])
+                {
                     bridge.push_back({itr, current_node});
                 }
             }
@@ -34,14 +40,16 @@ class Solution {
     }
 
  public:
-    vector <vector <int> > search_bridges(int n,
-            const vector<vector<int>>& connections) {
+    vector<vector<int>> search_bridges(int n,
+                                       const vector<vector<int>>& connections)
+    {
         timer = 0;
         graph.resize(n);
         in_time.assign(n, 0);
         visited.assign(n, false);
         out_time.assign(n, 0);
-        for (auto&itr : connections) {
+        for (auto& itr : connections)
+        {
             graph.at(itr[0]).push_back(itr[1]);
             graph.at(itr[1]).push_back(itr[0]);
         }
@@ -49,10 +57,11 @@ class Solution {
         return bridge;
     }
 };
-int main(void) {
+int main(void)
+{
     Solution s1;
     int number_of_node = 5;
-    vector< vector <int> >node;
+    vector<vector<int>> node;
     node.push_back({0, 1});
     node.push_back({1, 3});
     node.push_back({1, 2});
@@ -66,13 +75,14 @@ int main(void) {
      *            3       4
      *
      *    In this graph there are 4 bridges [0,2] , [2,4] , [3,5] , [1,2]
-     *    
+     *
      *    I assumed that the graph is bi-directional and connected.
      *
      */
-    vector< vector <int> > bridges = s1.search_bridges(number_of_node , node);
+    vector<vector<int>> bridges = s1.search_bridges(number_of_node, node);
     cout << bridges.size() << " bridges found!\n";
-    for (auto&itr : bridges) {
+    for (auto& itr : bridges)
+    {
         cout << itr[0] << " --> " << itr[1] << '\n';
     }
     return 0;

graph/connected_components.cpp

@@ -3,53 +3,62 @@
 
 using std::vector;
 
-class graph {
+class graph
+{
  private:
     vector<vector<int>> adj;
     int connected_components;
     void depth_first_search();
-    void explore(int, vector<bool>&);
+    void explore(int, vector<bool> &);
+
  public:
-    explicit graph(int n): adj(n, vector<int>()) {
-      connected_components = 0;
-    }
+    explicit graph(int n) : adj(n, vector<int>()) { connected_components = 0; }
     void addEdge(int, int);
-    int getConnectedComponents() {
-      depth_first_search();
-      return connected_components;
+    int getConnectedComponents()
+    {
+        depth_first_search();
+        return connected_components;
     }
 };
 
-void graph::addEdge(int u, int v) {
-  adj[u-1].push_back(v-1);
-  adj[v-1].push_back(u-1);
+void graph::addEdge(int u, int v)
+{
+    adj[u - 1].push_back(v - 1);
+    adj[v - 1].push_back(u - 1);
 }
 
-void graph::depth_first_search() {
-  int n = adj.size();
-  vector<bool> visited(n, false);
+void graph::depth_first_search()
+{
+    int n = adj.size();
+    vector<bool> visited(n, false);
 
-  for (int i = 0 ; i < n ; i++) {
-    if (!visited[i]) {
-      explore(i, visited);
-      connected_components++;
+    for (int i = 0; i < n; i++)
+    {
+        if (!visited[i])
+        {
+            explore(i, visited);
+            connected_components++;
+        }
     }
-  }
 }
 
-void graph::explore(int u, vector<bool> &visited) {
-  visited[u] = true;
-  for (auto v : adj[u]) {
-    if (!visited[v]) {
-      explore(v, visited);
+void graph::explore(int u, vector<bool> &visited)
+{
+    visited[u] = true;
+    for (auto v : adj[u])
+    {
+        if (!visited[v])
+        {
+            explore(v, visited);
+        }
     }
-  }
 }
 
-int main() {
-  graph g(4);
-  g.addEdge(1, 2);
-  g.addEdge(3, 2);
-  std::cout << g.getConnectedComponents();
-  return 0;
+int main()
+{
+    graph g(4);
+    g.addEdge(1, 2);
+    g.addEdge(3, 2);
+    std::cout << g.getConnectedComponents();
+    return 0;
 }

graph/connected_components_with_dsu.cpp

@@ -1,27 +1,32 @@
 #include <iostream>
-#include <vector>
 #include <set>
+#include <vector>
 
 int N;  // denotes number of nodes;
 std::vector<int> parent;
 std::vector<int> siz;
-void make_set() {  // function the initialize every node as it's own parent
-    for (int i = 1; i <= N; i++) {
+void make_set()
+{  // function the initialize every node as it's own parent
+    for (int i = 1; i <= N; i++)
+    {
         parent[i] = i;
         siz[i] = 1;
     }
 }
 // To find the component where following node belongs to
-int find_set(int v) {
+int find_set(int v)
+{
     if (v == parent[v])
         return v;
     return parent[v] = find_set(parent[v]);
 }
 
-void union_sets(int a, int b) {  // To join 2 components to belong to one
+void union_sets(int a, int b)
+{  // To join 2 components to belong to one
     a = find_set(a);
     b = find_set(b);
-    if (a != b) {
+    if (a != b)
+    {
         if (siz[a] < siz[b])
             std::swap(a, b);
         parent[b] = a;
@@ -29,23 +34,25 @@ void union_sets(int a, int b) {  // To join 2 components to belong to one
     }
 }
 
-int no_of_connected_components() {  // To find total no of connected components
+int no_of_connected_components()
+{                        // To find total no of connected components
     std::set<int> temp;  // temp set to count number of connected components
-    for (int i = 1; i <= N; i++)
-        temp.insert(find_set(i));
+    for (int i = 1; i <= N; i++) temp.insert(find_set(i));
     return temp.size();
 }
 
 // All critical/corner cases have been taken care of.
 // Input your required values: (not hardcoded)
-int main() {
+int main()
+{
     std::cin >> N;
     parent.resize(N + 1);
     siz.resize(N + 1);
     make_set();
     int edges;
     std::cin >> edges;  // no of edges in the graph
-    while (edges--) {
+    while (edges--)
+    {
         int node_a, node_b;
         std::cin >> node_a >> node_b;
         union_sets(node_a, node_b);

graph/dfs.cpp

@@ -3,29 +3,29 @@ using namespace std;
 int v = 4;
 void DFSUtil_(int graph[4][4], bool visited[], int s)
 {
-	visited[s] = true;
-	cout << s << " ";
-	for (int i = 0; i < v; i++)
-	{
-		if (graph[s][i] == 1 && visited[i] == false)
-		{
-			DFSUtil_(graph, visited, i);
-		}
-	}
+    visited[s] = true;
+    cout << s << " ";
+    for (int i = 0; i < v; i++)
+    {
+        if (graph[s][i] == 1 && visited[i] == false)
+        {
+            DFSUtil_(graph, visited, i);
+        }
+    }
 }
 
 void DFS_(int graph[4][4], int s)
 {
-	bool visited[v];
-	memset(visited, 0, sizeof(visited));
-	DFSUtil_(graph, visited, s);
+    bool visited[v];
+    memset(visited, 0, sizeof(visited));
+    DFSUtil_(graph, visited, s);
 }
 
 int main()
 {
-	int graph[4][4] = {{0, 1, 1, 0}, {0, 0, 1, 0}, {1, 0, 0, 1}, {0, 0, 0, 1}};
-	cout << "DFS: ";
-	DFS_(graph, 2);
-	cout << endl;
-	return 0;
+    int graph[4][4] = {{0, 1, 1, 0}, {0, 0, 1, 0}, {1, 0, 0, 1}, {0, 0, 0, 1}};
+    cout << "DFS: ";
+    DFS_(graph, 2);
+    cout << endl;
+    return 0;
 }

graph/dijkstra.cpp

@@ -1,14 +1,16 @@
-#include <queue>
-#include <vector>
 #include <cstdio>
 #include <iostream>
+#include <queue>
+#include <vector>
 using namespace std;
 #define INF 10000010
 vector<pair<int, int>> graph[5 * 100001];
 int dis[5 * 100001];
 int dij(vector<pair<int, int>> *v, int s, int *dis)
 {
-    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
+    priority_queue<pair<int, int>, vector<pair<int, int>>,
+                   greater<pair<int, int>>>
+        pq;
     // source distance to zero.
     pq.push(make_pair(0, s));
     dis[s] = 0;
@@ -17,7 +19,8 @@ int dij(vector<pair<int, int>> *v, int s, int *dis)
     {
         u = (pq.top()).second;
         pq.pop();
-        for (vector<pair<int, int>>::iterator it = v[u].begin(); it != v[u].end(); it++)
+        for (vector<pair<int, int>>::iterator it = v[u].begin();
+             it != v[u].end(); it++)
         {
             if (dis[u] + it->first < dis[it->second])
             {
@@ -37,13 +40,13 @@ int main()
         // input edges.
         scanf("%d%d%d", &x, &y, &l);
         graph[x].push_back(make_pair(l, y));
-        graph[y].push_back(make_pair(l, x)); // comment this line for directed graph
+        graph[y].push_back(
+            make_pair(l, x));  // comment this line for directed graph
     }
     // start node.
     scanf("%d", &s);
     // intialise all distances to infinity.
-    for (int i = 1; i <= n; i++)
-        dis[i] = INF;
+    for (int i = 1; i <= n; i++) dis[i] = INF;
     dij(graph, s, dis);
 
     for (int i = 1; i <= n; i++)

graph/kosaraju.cpp

@@ -1,134 +1,135 @@
-/* Implementation of Kosaraju's Algorithm to find out the strongly connected components (SCCs) in a graph. 
-   Author:Anirban166
-*/   
+/* Implementation of Kosaraju's Algorithm to find out the strongly connected
+   components (SCCs) in a graph. Author:Anirban166
+*/
 
-#include<iostream>
-#include<vector>
+#include <iostream>
+#include <vector>
 
 using namespace std;
 
 /**
-* Iterative function/method to print graph:
-* @param a[] : array of vectors (2D)
-* @param V : vertices
-* @return void 
-**/
-void print(vector<int> a[],int V)
+ * Iterative function/method to print graph:
+ * @param a[] : array of vectors (2D)
+ * @param V : vertices
+ * @return void
+ **/
+void print(vector<int> a[], int V)
 {
-    for(int i=0;i<V;i++)
+    for (int i = 0; i < V; i++)
     {
-        if(!a[i].empty())
-            cout<<"i="<<i<<"-->";
-        for(int j=0;j<a[i].size();j++)
-            cout<<a[i][j]<<" ";
-        if(!a[i].empty())
-            cout<<endl;
+        if (!a[i].empty())
+            cout << "i=" << i << "-->";
+        for (int j = 0; j < a[i].size(); j++) cout << a[i][j] << " ";
+        if (!a[i].empty())
+            cout << endl;
     }
 }
 
 /**
-* //Recursive function/method to push vertices into stack passed as parameter:
-* @param v : vertices
-* @param &st : stack passed by reference
-* @param vis[] : array to keep track of visited nodes (boolean type)
-* @param adj[] : array of vectors to represent graph
-* @return void 
-**/
-void push_vertex(int v,stack<int> &st,bool vis[],vector<int> adj[])
+ * //Recursive function/method to push vertices into stack passed as parameter:
+ * @param v : vertices
+ * @param &st : stack passed by reference
+ * @param vis[] : array to keep track of visited nodes (boolean type)
+ * @param adj[] : array of vectors to represent graph
+ * @return void
+ **/
+void push_vertex(int v, stack<int> &st, bool vis[], vector<int> adj[])
 {
-    vis[v]=true;
-    for(auto i=adj[v].begin();i!=adj[v].end();i++)
+    vis[v] = true;
+    for (auto i = adj[v].begin(); i != adj[v].end(); i++)
     {
-        if(vis[*i]==false)
-            push_vertex(*i,st,vis,adj);
+        if (vis[*i] == false)
+            push_vertex(*i, st, vis, adj);
     }
     st.push(v);
 }
 
-
 /**
-* //Recursive function/method to implement depth first traversal(dfs):
-* @param v : vertices
-* @param vis[] : array to keep track of visited nodes (boolean type)
-* @param grev[] : graph with reversed edges
-* @return void 
-**/
-void dfs(int v,bool vis[],vector<int> grev[])
+ * //Recursive function/method to implement depth first traversal(dfs):
+ * @param v : vertices
+ * @param vis[] : array to keep track of visited nodes (boolean type)
+ * @param grev[] : graph with reversed edges
+ * @return void
+ **/
+void dfs(int v, bool vis[], vector<int> grev[])
 {
-    vis[v]=true;
+    vis[v] = true;
     // cout<<v<<" ";
-    for(auto i=grev[v].begin();i!=grev[v].end();i++)
+    for (auto i = grev[v].begin(); i != grev[v].end(); i++)
     {
-        if(vis[*i]==false)
-            dfs(*i,vis,grev);
+        if (vis[*i] == false)
+            dfs(*i, vis, grev);
     }
 }
 
-//function/method to implement Kosaraju's Algorithm:
+// function/method to implement Kosaraju's Algorithm:
 /**
 * Info about the method
 * @param V : vertices in graph
 * @param adj[] : array of vectors that represent a graph (adjacency list/array)
-* @return int ( 0, 1, 2..and so on, only unsigned values as either there can be no SCCs i.e. none(0) or there will be x no. of SCCs (x>0))
-   i.e. it returns the count of (number of) strongly connected components (SCCs) in the graph. (variable 'count_scc' within function)
+* @return int ( 0, 1, 2..and so on, only unsigned values as either there can be
+no SCCs i.e. none(0) or there will be x no. of SCCs (x>0)) i.e. it returns the
+count of (number of) strongly connected components (SCCs) in the graph.
+(variable 'count_scc' within function)
 **/
 int kosaraju(int V, vector<int> adj[])
 {
-    bool vis[V]={};
+    bool vis[V] = {};
     stack<int> st;
-    for(int v=0;v<V;v++)
+    for (int v = 0; v < V; v++)
     {
-        if(vis[v]==false)
-            push_vertex(v,st,vis,adj);
+        if (vis[v] == false)
+            push_vertex(v, st, vis, adj);
     }
-    //making new graph (grev) with reverse edges as in adj[]:
+    // making new graph (grev) with reverse edges as in adj[]:
     vector<int> grev[V];
-    for(int i=0;i<V+1;i++)
+    for (int i = 0; i < V + 1; i++)
     {
-        for(auto j=adj[i].begin();j!=adj[i].end();j++)
+        for (auto j = adj[i].begin(); j != adj[i].end(); j++)
         {
             grev[*j].push_back(i);
         }
     }
     // cout<<"grev="<<endl; ->debug statement
     // print(grev,V);       ->debug statement
-    //reinitialise visited to 0
-    for(int i=0;i<V;i++)
-        vis[i]=false;
-    int count_scc=0;
-    while(!st.empty())
+    // reinitialise visited to 0
+    for (int i = 0; i < V; i++) vis[i] = false;
+    int count_scc = 0;
+    while (!st.empty())
     {
-        int t=st.top();
+        int t = st.top();
         st.pop();
-        if(vis[t]==false)
+        if (vis[t] == false)
         {
-            dfs(t,vis,grev);
+            dfs(t, vis, grev);
             count_scc++;
         }
     }
-    // cout<<"count_scc="<<count_scc<<endl; //in case you want to print here itself, uncomment & change return type of function to void.
+    // cout<<"count_scc="<<count_scc<<endl; //in case you want to print here
+    // itself, uncomment & change return type of function to void.
     return count_scc;
 }
 
-//All critical/corner cases have been taken care of.
-//Input your required values: (not hardcoded)
+// All critical/corner cases have been taken care of.
+// Input your required values: (not hardcoded)
 int main()
 {
     int t;
-    cin>>t; 
-    while(t--)
+    cin >> t;
+    while (t--)
     {
-        int a,b ; //a->number of nodes, b->directed edges.
-   	  cin>>a>>b;
-   	  int m,n;
-   	  vector<int> adj[a+1];
-        for(int i=0;i<b;i++) //take total b inputs of 2 vertices each required to form an edge.
+        int a, b;  // a->number of nodes, b->directed edges.
+        cin >> a >> b;
+        int m, n;
+        vector<int> adj[a + 1];
+        for (int i = 0; i < b; i++)  // take total b inputs of 2 vertices each
+                                     // required to form an edge.
         {
-            cin>>m>>n; //take input m,n denoting edge from m->n.
+            cin >> m >> n;  // take input m,n denoting edge from m->n.
             adj[m].push_back(n);
         }
-        //pass number of nodes and adjacency array as parameters to function:
-        cout<<kosaraju(a, adj)<<endl;
+        // pass number of nodes and adjacency array as parameters to function:
+        cout << kosaraju(a, adj) << endl;
     }
     return 0;
 }

graph/kruskal.cpp

@@ -1,6 +1,6 @@
 #include <iostream>
 //#include <boost/multiprecision/cpp_int.hpp>
-//using namespace boost::multiprecision;
+// using namespace boost::multiprecision;
 const int mx = 1e6 + 5;
 const long int inf = 2e9;
 typedef long long ll;
@@ -20,116 +20,114 @@ typedef long long ll;
 #define ub upper_bound
 #define endl "\n"
 #define fast                          \
-	ios_base::sync_with_stdio(false); \
-	cin.tie(NULL);                    \
-	cout.tie(NULL);
+    ios_base::sync_with_stdio(false); \
+    cin.tie(NULL);                    \
+    cout.tie(NULL);
 using namespace std;
 void in(int &x)
 {
-	register int c = gc();
-	x = 0;
-	int neg = 0;
-	for (; ((c < 48 || c > 57) && c != '-'); c = gc())
-		;
-	if (c == '-')
-	{
-		neg = 1;
-		c = gc();
-	}
-	for (; c > 47 && c < 58; c = gc())
-	{
-		x = (x << 1) + (x << 3) + c - 48;
-	}
-	if (neg)
-		x = -x;
+    register int c = gc();
+    x = 0;
+    int neg = 0;
+    for (; ((c < 48 || c > 57) && c != '-'); c = gc())
+        ;
+    if (c == '-')
+    {
+        neg = 1;
+        c = gc();
+    }
+    for (; c > 47 && c < 58; c = gc())
+    {
+        x = (x << 1) + (x << 3) + c - 48;
+    }
+    if (neg)
+        x = -x;
 }
 void out(int n)
 {
-	int N = n, rev, count = 0;
-	rev = N;
-	if (N == 0)
-	{
-		pc('0');
-		return;
-	}
-	while ((rev % 10) == 0)
-	{
-		count++;
-		rev /= 10;
-	}
-	rev = 0;
-	while (N != 0)
-	{
-		rev = (rev << 3) + (rev << 1) + N % 10;
-		N /= 10;
-	}
-	while (rev != 0)
-	{
-		pc(rev % 10 + '0');
-		rev /= 10;
-	}
-	while (count--)
-		pc('0');
+    int N = n, rev, count = 0;
+    rev = N;
+    if (N == 0)
+    {
+        pc('0');
+        return;
+    }
+    while ((rev % 10) == 0)
+    {
+        count++;
+        rev /= 10;
+    }
+    rev = 0;
+    while (N != 0)
+    {
+        rev = (rev << 3) + (rev << 1) + N % 10;
+        N /= 10;
+    }
+    while (rev != 0)
+    {
+        pc(rev % 10 + '0');
+        rev /= 10;
+    }
+    while (count--) pc('0');
 }
 ll parent[mx], arr[mx], node, edge;
 vector<pair<ll, pair<ll, ll>>> v;
 void initial()
 {
-	int i;
-	rep(i, node + edge)
-		parent[i] = i;
+    int i;
+    rep(i, node + edge) parent[i] = i;
 }
 int root(int i)
 {
-	while (parent[i] != i)
-	{
-		parent[i] = parent[parent[i]];
-		i = parent[i];
-	}
-	return i;
+    while (parent[i] != i)
+    {
+        parent[i] = parent[parent[i]];
+        i = parent[i];
+    }
+    return i;
 }
 void join(int x, int y)
 {
-	int root_x = root(x); //Disjoint set union by rank
-	int root_y = root(y);
-	parent[root_x] = root_y;
+    int root_x = root(x);  // Disjoint set union by rank
+    int root_y = root(y);
+    parent[root_x] = root_y;
 }
 ll kruskal()
 {
-	ll mincost = 0, i, x, y;
-	rep(i, edge)
-	{
-		x = v[i].second.first;
-		y = v[i].second.second;
-		if (root(x) != root(y))
-		{
-			mincost += v[i].first;
-			join(x, y);
-		}
-	}
-	return mincost;
+    ll mincost = 0, i, x, y;
+    rep(i, edge)
+    {
+        x = v[i].second.first;
+        y = v[i].second.second;
+        if (root(x) != root(y))
+        {
+            mincost += v[i].first;
+            join(x, y);
+        }
+    }
+    return mincost;
 }
 int main()
 {
-	fast;
-	while (1)
-	{
-		int i, j, from, to, cost, totalcost = 0;
-		cin >> node >> edge; //Enter the nodes and edges
-		if (node == 0 && edge == 0)
-			break; //Enter 0 0 to break out
-		initial(); //Initialise the parent array
-		rep(i, edge)
-		{
-			cin >> from >> to >> cost;
-			v.pb(mp(cost, mp(from, to)));
-			totalcost += cost;
-		}
-		sort(v.begin(), v.end());
-		// rep(i,v.size())
-		// 	cout<<v[i].first<<"  ";
-		cout << kruskal() << endl;
-		v.clear();
-	}
-	return 0;
+    fast;
+    while (1)
+    {
+        int i, j, from, to, cost, totalcost = 0;
+        cin >> node >> edge;  // Enter the nodes and edges
+        if (node == 0 && edge == 0)
+            break;  // Enter 0 0 to break out
+        initial();  // Initialise the parent array
+        rep(i, edge)
+        {
+            cin >> from >> to >> cost;
+            v.pb(mp(cost, mp(from, to)));
+            totalcost += cost;
+        }
+        sort(v.begin(), v.end());
+        // rep(i,v.size())
+        // 	cout<<v[i].first<<"  ";
+        cout << kruskal() << endl;
+        v.clear();
+    }
+    return 0;
 }

graph/lca.cpp

@@ -10,16 +10,16 @@ const int LG = log2(N) + 1;
 struct lca
 {
     int n;
-    vector<int> adj[N]; // Graph
-    int up[LG][N]; // build this table
-    int level[N]; // get the levels of all of them
+    vector<int> adj[N];  // Graph
+    int up[LG][N];       // build this table
+    int level[N];        // get the levels of all of them
 
-    lca(int n_): n(n_)
+    lca(int n_) : n(n_)
     {
         memset(up, -1, sizeof(up));
         memset(level, 0, sizeof(level));
         for (int i = 0; i < n - 1; ++i)
-	{
+        {
             int a, b;
             cin >> a >> b;
             a--;
@@ -34,15 +34,15 @@ struct lca
     void verify()
     {
         for (int i = 0; i < n; ++i)
-	{
+        {
             cout << i << " : level: " << level[i] << endl;
         }
         cout << endl;
         for (int i = 0; i < LG; ++i)
-	{
+        {
             cout << "Power:" << i << ": ";
             for (int j = 0; j < n; ++j)
-	    {
+            {
                 cout << up[i][j] << " ";
             }
             cout << endl;
@@ -52,11 +52,11 @@ struct lca
     void build()
     {
         for (int i = 1; i < LG; ++i)
-	{
+        {
             for (int j = 0; j < n; ++j)
-	    {
+            {
                 if (up[i - 1][j] != -1)
-		{
+                {
                     up[i][j] = up[i - 1][up[i - 1][j]];
                 }
             }
@@ -66,10 +66,10 @@ struct lca
     void dfs(int node, int par)
     {
         up[0][node] = par;
-        for (auto i: adj[node])
-	{
+        for (auto i : adj[node])
+        {
             if (i != par)
-	    {
+            {
                 level[i] = level[node] + 1;
                 dfs(i, node);
             }
@@ -80,28 +80,28 @@ struct lca
         u--;
         v--;
         if (level[v] > level[u])
-	{
+        {
             swap(u, v);
         }
         // u is at the bottom.
         int dist = level[u] - level[v];
         // Go up this much distance
         for (int i = LG - 1; i >= 0; --i)
-	{
+        {
             if (dist & (1 << i))
-	    {
+            {
                 u = up[i][u];
             }
         }
         if (u == v)
-	{
+        {
             return u;
         }
         assert(level[u] == level[v]);
         for (int i = LG - 1; i >= 0; --i)
-	{
+        {
             if (up[i][u] != up[i][v])
-	    {
+            {
                 u = up[i][u];
                 v = up[i][v];
             }
@@ -113,8 +113,8 @@ struct lca
 
 int main()
 {
-    int n; // number of nodes in the tree.
-    lca l(n); // will take the input in the format given
+    int n;     // number of nodes in the tree.
+    lca l(n);  // will take the input in the format given
     // n-1 edges of the form
     // a b
     // Use verify function to see.

graph/max_flow_with_ford_fulkerson_and_edmond_karp_algo.cpp

@@ -4,41 +4,47 @@
  * Copyright: 2020, Open-Source
  * Last Modified: May 25, 2020
  */
-#include <iostream>
-#include <queue>
-#include <tuple>
 #include <algorithm>
 #include <bitset>
-#include <limits>
 #include <cstring>
-#include <vector>
+#include <iostream>
+#include <limits>
+#include <queue>
+#include <tuple>
 #include <utility>
+#include <vector>
 // std::max capacity of node in graph
 const int MAXN = 505;
-class Graph {
+class Graph
+{
     int residual_capacity[MAXN][MAXN];
     int capacity[MAXN][MAXN];  //  used while checking the flow of edge
     int total_nodes;
     int total_edges, source, sink;
     int parent[MAXN];
-    std::vector <std::tuple <int, int, int> >edge_participated;
-    std::bitset <MAXN> visited;
+    std::vector<std::tuple<int, int, int> > edge_participated;
+    std::bitset<MAXN> visited;
     int max_flow = 0;
-    bool bfs(int source, int sink) {  //  to find the augmented - path
+    bool bfs(int source, int sink)
+    {  //  to find the augmented - path
         memset(parent, -1, sizeof(parent));
         visited.reset();
-        std::queue<int>q;
+        std::queue<int> q;
         q.push(source);
         bool is_path_found = false;
-        while (q.empty() == false && is_path_found == false) {
+        while (q.empty() == false && is_path_found == false)
+        {
             int current_node = q.front();
             visited.set(current_node);
             q.pop();
-            for (int i = 0; i < total_nodes; ++i) {
-                if (residual_capacity[current_node][i] > 0 && !visited[i]) {
+            for (int i = 0; i < total_nodes; ++i)
+            {
+                if (residual_capacity[current_node][i] > 0 && !visited[i])
+                {
                     visited.set(i);
                     parent[i] = current_node;
-                    if (i == sink) {
+                    if (i == sink)
+                    {
                         return true;
                     }
                     q.push(i);
@@ -49,29 +55,33 @@ class Graph {
     }
 
  public:
-    Graph() {
-        memset(residual_capacity, 0, sizeof(residual_capacity));
-    }
-    void set_graph(void) {
+    Graph() { memset(residual_capacity, 0, sizeof(residual_capacity)); }
+    void set_graph(void)
+    {
         std::cin >> total_nodes >> total_edges >> source >> sink;
-        for (int start, destination, capacity_, i = 0; i < total_edges; ++i) {
+        for (int start, destination, capacity_, i = 0; i < total_edges; ++i)
+        {
             std::cin >> start >> destination >> capacity_;
             residual_capacity[start][destination] = capacity_;
             capacity[start][destination] = capacity_;
         }
     }
-    void ford_fulkerson(void) {
-        while (bfs(source, sink)) {
+    void ford_fulkerson(void)
+    {
+        while (bfs(source, sink))
+        {
             int current_node = sink;
             int flow = std::numeric_limits<int>::max();
-            while (current_node != source) {
+            while (current_node != source)
+            {
                 int parent_ = parent[current_node];
                 flow = std::min(flow, residual_capacity[parent_][current_node]);
                 current_node = parent_;
             }
             current_node = sink;
             max_flow += flow;
-            while ( current_node != source ) {
+            while (current_node != source)
+            {
                 int parent_ = parent[current_node];
                 residual_capacity[parent_][current_node] -= flow;
                 residual_capacity[current_node][parent_] += flow;
@@ -79,31 +89,34 @@ class Graph {
             }
         }
     }
-    void print_flow_info(void) {
-        for (int i = 0; i < total_nodes; ++i) {
-            for (int j = 0; j < total_nodes; ++j) {
-                if (capacity[i][j] &&
-                        residual_capacity[i][j] < capacity[i][j]) {
-                    edge_participated.push_back(
-                            std::make_tuple(i, j,
-                                capacity[i][j]-residual_capacity[i][j]));
+    void print_flow_info(void)
+    {
+        for (int i = 0; i < total_nodes; ++i)
+        {
+            for (int j = 0; j < total_nodes; ++j)
+            {
+                if (capacity[i][j] && residual_capacity[i][j] < capacity[i][j])
+                {
+                    edge_participated.push_back(std::make_tuple(
+                        i, j, capacity[i][j] - residual_capacity[i][j]));
                 }
             }
         }
-        std::cout << "\nNodes : " << total_nodes
-            << "\nMax flow: " << max_flow
-            << "\nEdge present in flow: " << edge_participated.size()
-            << '\n';
-        std::cout<< "\nSource\tDestination\tCapacity\total_nodes";
-        for (auto&edge_data : edge_participated) {
+        std::cout << "\nNodes : " << total_nodes << "\nMax flow: " << max_flow
+                  << "\nEdge present in flow: " << edge_participated.size()
+                  << '\n';
+        std::cout << "\nSource\tDestination\tCapacity\total_nodes";
+        for (auto& edge_data : edge_participated)
+        {
             int source, destination, capacity_;
             std::tie(source, destination, capacity_) = edge_data;
-            std::cout << source << "\t" << destination << "\t\t"
-                      << capacity_ <<'\t';
+            std::cout << source << "\t" << destination << "\t\t" << capacity_
+                      << '\t';
         }
     }
 };
-int main(void) {
+int main(void)
+{
     /*
        Input Graph: (for testing )
         4 5 0 3
@@ -119,4 +132,3 @@ int main(void) {
     graph.print_flow_info();
     return 0;
 }
-

graph/prim.cpp

@@ -1,23 +1,25 @@
 // C++ program to implement Prim's Algorithm
 #include <iostream>
-#include <vector>
 #include <queue>
+#include <vector>
 
 const int MAX = 1e4 + 5;
-typedef std:: pair<int, int> PII;
+typedef std::pair<int, int> PII;
 
 bool marked[MAX];
-std:: vector <PII> adj[MAX];
+std::vector<PII> adj[MAX];
 
-int prim(int x) {
+int prim(int x)
+{
     // priority queue to maintain edges with respect to weights
-    std:: priority_queue<PII, std:: vector<PII>, std:: greater<PII> > Q;
+    std::priority_queue<PII, std::vector<PII>, std::greater<PII> > Q;
     int y;
     int minimumCost = 0;
     PII p;
 
-    Q.push(std:: make_pair(0, x));
-    while (!Q.empty()) {
+    Q.push(std::make_pair(0, x));
+    while (!Q.empty())
+    {
         // Select the edge with minimum weight
         p = Q.top();
         Q.pop();
@@ -27,7 +29,8 @@ int prim(int x) {
             continue;
         minimumCost += p.first;
         marked[x] = true;
-        for (int i = 0; i < adj[x].size(); ++i) {
+        for (int i = 0; i < adj[x].size(); ++i)
+        {
             y = adj[x][i].second;
             if (marked[y] == false)
                 Q.push(adj[x][i]);
@@ -36,23 +39,25 @@ int prim(int x) {
     return minimumCost;
 }
 
-int main() {
+int main()
+{
     int nodes, edges, x, y;
     int weight, minimumCost;
 
-    std:: cin >> nodes >> edges;  // number of nodes & edges in graph
+    std::cin >> nodes >> edges;  // number of nodes & edges in graph
     if (nodes == 0 || edges == 0)
         return 0;
 
     // Edges with their nodes & weight
-    for (int i = 0; i < edges; ++i) {
+    for (int i = 0; i < edges; ++i)
+    {
         std::cin >> x >> y >> weight;
-        adj[x].push_back(std:: make_pair(weight, y));
-        adj[y].push_back(std:: make_pair(weight, x));
+        adj[x].push_back(std::make_pair(weight, y));
+        adj[y].push_back(std::make_pair(weight, x));
     }
 
     // Selecting 1 as the starting node
     minimumCost = prim(1);
-    std:: cout << minimumCost << std:: endl;
+    std::cout << minimumCost << std::endl;
     return 0;
 }

graph/topological_sort.cpp

@@ -1,53 +1,54 @@
+#include <algorithm>
 #include <iostream>
 #include <vector>
-#include <algorithm>
 using namespace std;
 
-int n, m; // For number of Vertices (V) and number of edges (E)
+int n, m;  // For number of Vertices (V) and number of edges (E)
 vector<vector<int>> G;
 vector<bool> visited;
 vector<int> ans;
 
 void dfs(int v)
 {
-  visited[v] = true;
-  for (int u : G[v])
-  {
-    if (!visited[u])
-      dfs(u);
-  }
-  ans.push_back(v);
+    visited[v] = true;
+    for (int u : G[v])
+    {
+        if (!visited[u])
+            dfs(u);
+    }
+    ans.push_back(v);
 }
 
 void topological_sort()
 {
-  visited.assign(n, false);
-  ans.clear();
-  for (int i = 0; i < n; ++i)
-  {
-    if (!visited[i])
-      dfs(i);
-  }
-  reverse(ans.begin(), ans.end());
+    visited.assign(n, false);
+    ans.clear();
+    for (int i = 0; i < n; ++i)
+    {
+        if (!visited[i])
+            dfs(i);
+    }
+    reverse(ans.begin(), ans.end());
 }
 int main()
 {
-  cout << "Enter the number of vertices and the number of directed edges\n";
-  cin >> n >> m;
-  int x, y;
-  G.resize(n, vector<int>());
-  for (int i = 0; i < n; ++i)
-  {
-    cin >> x >> y;
-    x--, y--; // to convert 1-indexed to 0-indexed
-    G[x].push_back(y);
-  }
-  topological_sort();
-  cout << "Topological Order : \n";
-  for (int v : ans)
-  {
-    cout << v + 1 << ' '; // converting zero based indexing back to one based.
-  }
-  cout << '\n';
-  return 0;
+    cout << "Enter the number of vertices and the number of directed edges\n";
+    cin >> n >> m;
+    int x, y;
+    G.resize(n, vector<int>());
+    for (int i = 0; i < n; ++i)
+    {
+        cin >> x >> y;
+        x--, y--;  // to convert 1-indexed to 0-indexed
+        G[x].push_back(y);
+    }
+    topological_sort();
+    cout << "Topological Order : \n";
+    for (int v : ans)
+    {
+        cout << v + 1
+             << ' ';  // converting zero based indexing back to one based.
+    }
+    cout << '\n';
+    return 0;
 }

graph/topological_sort_by_kahns_algo.cpp

@@ -1,63 +1,75 @@
 #include <stdio.h>
 #include <string.h>
 #include <iostream>
-#include <vector>
 #include <queue>
+#include <vector>
 
 int *topoSortKahn(int N, std::vector<int> adj[]);
 
-int main() {
+int main()
+{
     int nodes, edges;
     std::cin >> edges >> nodes;
     if (edges == 0 || nodes == 0)
         return 0;
     int u, v;
 
-    std::vector<int>graph[nodes];
+    std::vector<int> graph[nodes];
     // create graph
     // example
     // 6 6
     // 5 0 5 2 2 3 4 0 4 1 1 3
 
-    for (int i = 0; i < edges; i++) {
+    for (int i = 0; i < edges; i++)
+    {
         std::cin >> u >> v;
         graph[u].push_back(v);
     }
 
     int *topo = topoSortKahn(nodes, graph);
     // topologically sorted nodes
-    for (int i = 0; i < nodes; i++) {
+    for (int i = 0; i < nodes; i++)
+    {
         std::cout << topo[i] << " ";
     }
 }
 
-int* topoSortKahn(int V, std::vector<int> adj[]) {
-    std::vector<bool>vis(V+1, false);
-    std::vector<int>deg(V+1, 0);
-    for (int i = 0; i < V; i++) {
-        for (int j = 0; j < adj[i].size(); j++) {
+int *topoSortKahn(int V, std::vector<int> adj[])
+{
+    std::vector<bool> vis(V + 1, false);
+    std::vector<int> deg(V + 1, 0);
+    for (int i = 0; i < V; i++)
+    {
+        for (int j = 0; j < adj[i].size(); j++)
+        {
             deg[adj[i][j]]++;
         }
     }
-    std::queue<int>q;
-    for (int i = 0; i < V; i++) {
-        if (deg[i] == 0) {
+    std::queue<int> q;
+    for (int i = 0; i < V; i++)
+    {
+        if (deg[i] == 0)
+        {
             q.push(i);
             vis[i] = true;
         }
     }
-    int *arr = new int[V+1];
-    memset(arr, 0, V+1);
+    int *arr = new int[V + 1];
+    memset(arr, 0, V + 1);
     int count = 0;
-    while (!q.empty()) {
+    while (!q.empty())
+    {
         int cur = q.front();
         q.pop();
         arr[count] = cur;
         count++;
-        for (int i = 0; i < adj[cur].size(); i++) {
-            if (!vis[adj[cur][i]]) {
+        for (int i = 0; i < adj[cur].size(); i++)
+        {
+            if (!vis[adj[cur][i]])
+            {
                 deg[adj[cur][i]]--;
-                if (deg[adj[cur][i]] == 0) {
+                if (deg[adj[cur][i]] == 0)
+                {
                     q.push(adj[cur][i]);
                     vis[adj[cur][i]] = true;
                 }

greedy_algorithms/dijkstra.cpp

@@ -1,19 +1,18 @@
-#include <iostream>
 #include <limits.h>
+#include <iostream>
 
 using namespace std;
 
-//Wrapper class for storing a graph
+// Wrapper class for storing a graph
 class Graph
 {
-public:
+ public:
     int vertexNum;
     int **edges;
 
-    //Constructs a graph with V vertices and E edges
+    // Constructs a graph with V vertices and E edges
     Graph(const int V)
     {
-
         // initializes the array edges.
         this->edges = new int *[V];
         for (int i = 0; i < V; i++)
@@ -33,13 +32,13 @@ public:
         this->vertexNum = V;
     }
 
-    //Adds the given edge to the graph
+    // Adds the given edge to the graph
     void addEdge(int src, int dst, int weight)
     {
         this->edges[src][dst] = weight;
     }
 };
-//Utility function to find minimum distance vertex in mdist
+// Utility function to find minimum distance vertex in mdist
 int minDistance(int mdist[], bool vset[], int V)
 {
     int minVal = INT_MAX, minInd = 0;
@@ -55,7 +54,7 @@ int minDistance(int mdist[], bool vset[], int V)
     return minInd;
 }
 
-//Utility function to print distances
+// Utility function to print distances
 void print(int dist[], int V)
 {
     cout << "\nVertex  Distance" << endl;
@@ -68,17 +67,17 @@ void print(int dist[], int V)
     }
 }
 
-//The main function that finds the shortest path from given source
-//to all other vertices using Dijkstra's Algorithm.It doesn't work on negative
-//weights
+// The main function that finds the shortest path from given source
+// to all other vertices using Dijkstra's Algorithm.It doesn't work on negative
+// weights
 void Dijkstra(Graph graph, int src)
 {
     int V = graph.vertexNum;
-    int mdist[V]; //Stores updated distances to vertex
-    bool vset[V]; // vset[i] is true if the vertex i included
+    int mdist[V];  // Stores updated distances to vertex
+    bool vset[V];  // vset[i] is true if the vertex i included
     // in the shortest path tree
 
-    //Initialise mdist and vset. Set distance of source as zero
+    // Initialise mdist and vset. Set distance of source as zero
     for (int i = 0; i < V; i++)
     {
         mdist[i] = INT_MAX;
@@ -87,7 +86,7 @@ void Dijkstra(Graph graph, int src)
 
     mdist[src] = 0;
 
-    //iterate to find shortest path
+    // iterate to find shortest path
     for (int count = 0; count < V - 1; count++)
     {
         int u = minDistance(mdist, vset, V);
@@ -96,7 +95,8 @@ void Dijkstra(Graph graph, int src)
 
         for (int v = 0; v < V; v++)
         {
-            if (!vset[v] && graph.edges[u][v] && mdist[u] + graph.edges[u][v] < mdist[v])
+            if (!vset[v] && graph.edges[u][v] &&
+                mdist[u] + graph.edges[u][v] < mdist[v])
             {
                 mdist[v] = mdist[u] + graph.edges[u][v];
             }
@@ -106,7 +106,7 @@ void Dijkstra(Graph graph, int src)
     print(mdist, V);
 }
 
-//Driver Function
+// Driver Function
 int main()
 {
     int V, E, gsrc;

greedy_algorithms/huffman.cpp

@@ -1,109 +1,106 @@
-// C++ program for Huffman Coding 
+// C++ program for Huffman Coding
 #include <iostream>
-#include <queue> 
-using namespace std; 
-  
-// A Huffman tree node 
-struct MinHeapNode { 
-  
-    // One of the input characters 
-    char data; 
-  
-    // Frequency of the character 
-    unsigned freq; 
-  
-    // Left and right child 
-    MinHeapNode *left, *right; 
-  
-    MinHeapNode(char data, unsigned freq) 
-  
-    { 
-  
-        left = right = NULL; 
-        this->data = data; 
-        this->freq = freq; 
-    } 
-}; 
-  
-// For comparison of 
-// two heap nodes (needed in min heap) 
-struct compare { 
-  
-    bool operator()(MinHeapNode* l, MinHeapNode* r) 
-  
-    { 
-        return (l->freq > r->freq); 
-    } 
-}; 
-  
-// Prints huffman codes from 
-// the root of Huffman Tree. 
-void printCodes(struct MinHeapNode* root, string str) 
-{ 
-  
-    if (!root) 
-        return; 
-  
-    if (root->data != '$') 
-        cout << root->data << ": " << str << "\n"; 
-  
-    printCodes(root->left, str + "0"); 
-    printCodes(root->right, str + "1"); 
-} 
-  
-// The main function that builds a Huffman Tree and 
-// print codes by traversing the built Huffman Tree 
-void HuffmanCodes(char data[], int freq[], int size) 
-{ 
-    struct MinHeapNode *left, *right, *top; 
-  
-    // Create a min heap & inserts all characters of data[] 
-    priority_queue<MinHeapNode*, vector<MinHeapNode*>, compare> minHeap; 
-  
-    for (int i = 0; i < size; ++i) 
-        minHeap.push(new MinHeapNode(data[i], freq[i])); 
-  
-    // Iterate while size of heap doesn't become 1 
-    while (minHeap.size() != 1) { 
-  
-        // Extract the two minimum 
-        // freq items from min heap 
-        left = minHeap.top(); 
-        minHeap.pop(); 
-  
-        right = minHeap.top(); 
-        minHeap.pop(); 
-  
-        // Create a new internal node with 
-        // frequency equal to the sum of the 
-        // two nodes frequencies. Make the 
-        // two extracted node as left and right children 
-        // of this new node. Add this node 
-        // to the min heap '$' is a special value 
-        // for internal nodes, not used 
-        top = new MinHeapNode('$', left->freq + right->freq); 
-  
-        top->left = left; 
-        top->right = right; 
-  
-        minHeap.push(top); 
-    } 
-  
-    // Print Huffman codes using 
-    // the Huffman tree built above 
-    printCodes(minHeap.top(), ""); 
-} 
-  
-// Driver program to test above functions 
-int main() 
-{ 
-  
-    char arr[] = { 'a', 'b', 'c', 'd', 'e', 'f' }; 
-    int freq[] = { 5, 9, 12, 13, 16, 45 }; 
-  
-    int size = sizeof(arr) / sizeof(arr[0]); 
-  
-    HuffmanCodes(arr, freq, size); 
-  
-    return 0; 
-} 
+#include <queue>
+using namespace std;
+
+// A Huffman tree node
+struct MinHeapNode
+{
+    // One of the input characters
+    char data;
+
+    // Frequency of the character
+    unsigned freq;
+
+    // Left and right child
+    MinHeapNode *left, *right;
+
+    MinHeapNode(char data, unsigned freq)
+
+    {
+        left = right = NULL;
+        this->data = data;
+        this->freq = freq;
+    }
+};
+
+// For comparison of
+// two heap nodes (needed in min heap)
+struct compare
+{
+    bool operator()(MinHeapNode* l, MinHeapNode* r)
+
+    {
+        return (l->freq > r->freq);
+    }
+};
+
+// Prints huffman codes from
+// the root of Huffman Tree.
+void printCodes(struct MinHeapNode* root, string str)
+{
+    if (!root)
+        return;
+
+    if (root->data != '$')
+        cout << root->data << ": " << str << "\n";
+
+    printCodes(root->left, str + "0");
+    printCodes(root->right, str + "1");
+}
+
+// The main function that builds a Huffman Tree and
+// print codes by traversing the built Huffman Tree
+void HuffmanCodes(char data[], int freq[], int size)
+{
+    struct MinHeapNode *left, *right, *top;
+
+    // Create a min heap & inserts all characters of data[]
+    priority_queue<MinHeapNode*, vector<MinHeapNode*>, compare> minHeap;
+
+    for (int i = 0; i < size; ++i)
+        minHeap.push(new MinHeapNode(data[i], freq[i]));
+
+    // Iterate while size of heap doesn't become 1
+    while (minHeap.size() != 1)
+    {
+        // Extract the two minimum
+        // freq items from min heap
+        left = minHeap.top();
+        minHeap.pop();
+
+        right = minHeap.top();
+        minHeap.pop();
+
+        // Create a new internal node with
+        // frequency equal to the sum of the
+        // two nodes frequencies. Make the
+        // two extracted node as left and right children
+        // of this new node. Add this node
+        // to the min heap '$' is a special value
+        // for internal nodes, not used
+        top = new MinHeapNode('$', left->freq + right->freq);
+
+        top->left = left;
+        top->right = right;
+
+        minHeap.push(top);
+    }
+
+    // Print Huffman codes using
+    // the Huffman tree built above
+    printCodes(minHeap.top(), "");
+}
+
+// Driver program to test above functions
+int main()
+{
+    char arr[] = {'a', 'b', 'c', 'd', 'e', 'f'};
+    int freq[] = {5, 9, 12, 13, 16, 45};
+
+    int size = sizeof(arr) / sizeof(arr[0]);
+
+    HuffmanCodes(arr, freq, size);
+
+    return 0;
+}

greedy_algorithms/knapsack.cpp

@@ -3,90 +3,88 @@ using namespace std;
 
 struct Item
 {
-	int weight;
-	int profit;
+    int weight;
+    int profit;
 };
 
-float profitPerUnit(Item x)
-{
-	return (float)x.profit / (float)x.weight;
-}
+float profitPerUnit(Item x) { return (float)x.profit / (float)x.weight; }
 
 int partition(Item arr[], int low, int high)
 {
-	Item pivot = arr[high]; // pivot
-	int i = (low - 1);		// Index of smaller element
+    Item pivot = arr[high];  // pivot
+    int i = (low - 1);       // Index of smaller element
 
-	for (int j = low; j < high; j++)
-	{
-		// If current element is smaller than or
-		// equal to pivot
-		if (profitPerUnit(arr[j]) <= profitPerUnit(pivot))
-		{
-			i++; // increment index of smaller element
-			Item temp = arr[i];
-			arr[i] = arr[j];
-			arr[j] = temp;
-		}
-	}
-	Item temp = arr[i + 1];
-	arr[i + 1] = arr[high];
-	arr[high] = temp;
-	return (i + 1);
+    for (int j = low; j < high; j++)
+    {
+        // If current element is smaller than or
+        // equal to pivot
+        if (profitPerUnit(arr[j]) <= profitPerUnit(pivot))
+        {
+            i++;  // increment index of smaller element
+            Item temp = arr[i];
+            arr[i] = arr[j];
+            arr[j] = temp;
+        }
+    }
+    Item temp = arr[i + 1];
+    arr[i + 1] = arr[high];
+    arr[high] = temp;
+    return (i + 1);
 }
 
 void quickSort(Item arr[], int low, int high)
 {
-	if (low < high)
-	{
+    if (low < high)
+    {
+        int p = partition(arr, low, high);
 
-		int p = partition(arr, low, high);
-
-		quickSort(arr, low, p - 1);
-		quickSort(arr, p + 1, high);
-	}
+        quickSort(arr, low, p - 1);
+        quickSort(arr, p + 1, high);
+    }
 }
 
 int main()
 {
-	cout << "\nEnter the capacity of the knapsack : ";
-	float capacity;
-	cin >> capacity;
-	cout << "\n Enter the number of Items : ";
-	int n;
-	cin >> n;
-	Item itemArray[n];
-	for (int i = 0; i < n; i++)
-	{
-		cout << "\nEnter the weight and profit of item " << i + 1 << " : ";
-		cin >> itemArray[i].weight;
-		cin >> itemArray[i].profit;
-	}
+    cout << "\nEnter the capacity of the knapsack : ";
+    float capacity;
+    cin >> capacity;
+    cout << "\n Enter the number of Items : ";
+    int n;
+    cin >> n;
+    Item itemArray[n];
+    for (int i = 0; i < n; i++)
+    {
+        cout << "\nEnter the weight and profit of item " << i + 1 << " : ";
+        cin >> itemArray[i].weight;
+        cin >> itemArray[i].profit;
+    }
 
-	quickSort(itemArray, 0, n - 1);
+    quickSort(itemArray, 0, n - 1);
 
-	// show(itemArray, n);
+    // show(itemArray, n);
 
-	float maxProfit = 0;
-	int i = n;
-	while (capacity > 0 && --i >= 0)
-	{
-		if (capacity >= itemArray[i].weight)
-		{
-			maxProfit += itemArray[i].profit;
-			capacity -= itemArray[i].weight;
-			cout << "\n\t" << itemArray[i].weight << "\t" << itemArray[i].profit;
-		}
-		else
-		{
-			maxProfit += profitPerUnit(itemArray[i]) * capacity;
-			cout << "\n\t" << capacity << "\t" << profitPerUnit(itemArray[i]) * capacity;
-			capacity = 0;
-			break;
-		}
-	}
+    float maxProfit = 0;
+    int i = n;
+    while (capacity > 0 && --i >= 0)
+    {
+        if (capacity >= itemArray[i].weight)
+        {
+            maxProfit += itemArray[i].profit;
+            capacity -= itemArray[i].weight;
+            cout << "\n\t" << itemArray[i].weight << "\t"
+                 << itemArray[i].profit;
+        }
+        else
+        {
+            maxProfit += profitPerUnit(itemArray[i]) * capacity;
+            cout << "\n\t" << capacity << "\t"
+                 << profitPerUnit(itemArray[i]) * capacity;
+            capacity = 0;
+            break;
+        }
+    }
 
-	cout << "\nMax Profit : " << maxProfit;
+    cout << "\nMax Profit : " << maxProfit;
 
-	return 0;
+    return 0;
 }

greedy_algorithms/kruskals_minimum_spanning_tree.cpp

@@ -4,34 +4,33 @@ using namespace std;
 #define V 6
 #define INFINITY 99999
 
-int graph[V][V] = {
-	{0, 4, 1, 4, INFINITY, INFINITY},
-	{4, 0, 3, 8, 3, INFINITY},
-	{1, 3, 0, INFINITY, 1, INFINITY},
-	{4, 8, INFINITY, 0, 5, 7},
-	{INFINITY, 3, 1, 5, 0, INFINITY},
-	{INFINITY, INFINITY, INFINITY, 7, INFINITY, 0}};
+int graph[V][V] = {{0, 4, 1, 4, INFINITY, INFINITY},
+                   {4, 0, 3, 8, 3, INFINITY},
+                   {1, 3, 0, INFINITY, 1, INFINITY},
+                   {4, 8, INFINITY, 0, 5, 7},
+                   {INFINITY, 3, 1, 5, 0, INFINITY},
+                   {INFINITY, INFINITY, INFINITY, 7, INFINITY, 0}};
 
 void findMinimumEdge()
 {
-	for (int i = 0; i < V; i++)
-	{
-		int min = INFINITY;
-		int minIndex = 0;
-		for (int j = 0; j < V; j++)
-		{
-			if (graph[i][j] != 0 && graph[i][j] < min)
-			{
-				min = graph[i][j];
-				minIndex = j;
-			}
-		}
-		cout << i << "  -  " << minIndex << "\t" << graph[i][minIndex] << "\n";
-	}
+    for (int i = 0; i < V; i++)
+    {
+        int min = INFINITY;
+        int minIndex = 0;
+        for (int j = 0; j < V; j++)
+        {
+            if (graph[i][j] != 0 && graph[i][j] < min)
+            {
+                min = graph[i][j];
+                minIndex = j;
+            }
+        }
+        cout << i << "  -  " << minIndex << "\t" << graph[i][minIndex] << "\n";
+    }
 }
 
 int main()
 {
-	findMinimumEdge();
-	return 0;
+    findMinimumEdge();
+    return 0;
 }

greedy_algorithms/prims_minimum_spanning_tree.cpp

@@ -4,76 +4,74 @@ using namespace std;
 #define V 4
 #define INFINITY 99999
 
-int graph[V][V] = {
-	{0, 5, 1, 2},
-	{5, 0, 3, 3},
-	{1, 3, 0, 4},
-	{2, 3, 4, 0}};
+int graph[V][V] = {{0, 5, 1, 2}, {5, 0, 3, 3}, {1, 3, 0, 4}, {2, 3, 4, 0}};
 
 struct mst
 {
-	bool visited;
-	int key;
-	int near;
+    bool visited;
+    int key;
+    int near;
 };
 
 mst MST_Array[V];
 
 void initilize()
 {
-	for (int i = 0; i < V; i++)
-	{
-		MST_Array[i].visited = false;
-		MST_Array[i].key = INFINITY; // considering INFINITY as inifinity
-		MST_Array[i].near = i;
-	}
+    for (int i = 0; i < V; i++)
+    {
+        MST_Array[i].visited = false;
+        MST_Array[i].key = INFINITY;  // considering INFINITY as inifinity
+        MST_Array[i].near = i;
+    }
 
-	MST_Array[0].key = 0;
+    MST_Array[0].key = 0;
 }
 
 void updateNear()
 {
-	for (int v = 0; v < V; v++)
-	{
-		int min = INFINITY;
-		int minIndex = 0;
-		for (int i = 0; i < V; i++)
-		{
-			if (MST_Array[i].key < min && MST_Array[i].visited == false && MST_Array[i].key != INFINITY)
-			{
-				min = MST_Array[i].key;
-				minIndex = i;
-			}
-		}
+    for (int v = 0; v < V; v++)
+    {
+        int min = INFINITY;
+        int minIndex = 0;
+        for (int i = 0; i < V; i++)
+        {
+            if (MST_Array[i].key < min && MST_Array[i].visited == false &&
+                MST_Array[i].key != INFINITY)
+            {
+                min = MST_Array[i].key;
+                minIndex = i;
+            }
+        }
 
-		MST_Array[minIndex].visited = true;
+        MST_Array[minIndex].visited = true;
 
-		for (int i = 0; i < V; i++)
-		{
-			if (graph[minIndex][i] != 0 && graph[minIndex][i] < INFINITY)
-			{
-				if (graph[minIndex][i] < MST_Array[i].key)
-				{
-					MST_Array[i].key = graph[minIndex][i];
-					MST_Array[i].near = minIndex;
-				}
-			}
-		}
-	}
+        for (int i = 0; i < V; i++)
+        {
+            if (graph[minIndex][i] != 0 && graph[minIndex][i] < INFINITY)
+            {
+                if (graph[minIndex][i] < MST_Array[i].key)
+                {
+                    MST_Array[i].key = graph[minIndex][i];
+                    MST_Array[i].near = minIndex;
+                }
+            }
+        }
+    }
 }
 
 void show()
 {
-	for (int i = 0; i < V; i++)
-	{
-		cout << i << "  -  " << MST_Array[i].near << "\t" << graph[i][MST_Array[i].near] << "\n";
-	}
+    for (int i = 0; i < V; i++)
+    {
+        cout << i << "  -  " << MST_Array[i].near << "\t"
+             << graph[i][MST_Array[i].near] << "\n";
+    }
 }
 
 int main()
 {
-	initilize();
-	updateNear();
-	show();
-	return 0;
+    initilize();
+    updateNear();
+    show();
+    return 0;
 }

hashing/chaining.cpp

@@ -1,140 +1,134 @@
-#include <iostream>
 #include <math.h>
+#include <iostream>
 using namespace std;
 
 struct Node
 {
-	int data;
-	struct Node *next;
+    int data;
+    struct Node *next;
 } * head[100], *curr;
 
 void init()
 {
-	for (int i = 0; i < 100; i++)
-		head[i] = NULL;
+    for (int i = 0; i < 100; i++) head[i] = NULL;
 }
 
 void add(int x, int h)
 {
-	struct Node *temp = new Node;
-	temp->data = x;
-	temp->next = NULL;
-	if (!head[h])
-	{
-		head[h] = temp;
-		curr = head[h];
-	}
-	else
-	{
-		curr = head[h];
-		while (curr->next)
-			curr = curr->next;
-		curr->next = temp;
-	}
+    struct Node *temp = new Node;
+    temp->data = x;
+    temp->next = NULL;
+    if (!head[h])
+    {
+        head[h] = temp;
+        curr = head[h];
+    }
+    else
+    {
+        curr = head[h];
+        while (curr->next) curr = curr->next;
+        curr->next = temp;
+    }
 }
 
 void display(int mod)
 {
-	struct Node *temp;
-	int i;
-	for (i = 0; i < mod; i++)
-	{
-		if (!head[i])
-		{
-			cout << "Key " << i << " is empty" << endl;
-		}
-		else
-		{
-			cout << "Key " << i << " has values = ";
-			temp = head[i];
-			while (temp->next)
-			{
-				cout << temp->data << " ";
-				temp = temp->next;
-			}
-			cout << temp->data;
-			cout << endl;
-		}
-	}
+    struct Node *temp;
+    int i;
+    for (i = 0; i < mod; i++)
+    {
+        if (!head[i])
+        {
+            cout << "Key " << i << " is empty" << endl;
+        }
+        else
+        {
+            cout << "Key " << i << " has values = ";
+            temp = head[i];
+            while (temp->next)
+            {
+                cout << temp->data << " ";
+                temp = temp->next;
+            }
+            cout << temp->data;
+            cout << endl;
+        }
+    }
 }
 
-int hash(int x, int mod)
-{
-	return x % mod;
-}
+int hash(int x, int mod) { return x % mod; }
 
 void find(int x, int h)
 {
-	struct Node *temp = head[h];
-	if (!head[h])
-	{
-		cout << "Element not found";
-		return;
-	}
-	while (temp->data != x && temp->next)
-		temp = temp->next;
-	if (temp->next)
-		cout << "Element found";
-	else
-	{
-		if (temp->data == x)
-			cout << "Element found";
-		else
-			cout << "Element not found";
-	}
+    struct Node *temp = head[h];
+    if (!head[h])
+    {
+        cout << "Element not found";
+        return;
+    }
+    while (temp->data != x && temp->next) temp = temp->next;
+    if (temp->next)
+        cout << "Element found";
+    else
+    {
+        if (temp->data == x)
+            cout << "Element found";
+        else
+            cout << "Element not found";
+    }
 }
 
 int main(void)
 {
-	init();
-	int c, x, mod, h;
-	cout << "Enter the size of Hash Table. = ";
-	cin >> mod;
-	bool loop = true;
-	while (loop)
-	{
-		cout << endl;
-		cout << "PLEASE CHOOSE -" << endl;
-		cout << "1. Add element." << endl;
-		cout << "2. Find element." << endl;
-		cout << "3. Generate Hash." << endl;
-		cout << "4. Display Hash table." << endl;
-		cout << "5. Exit." << endl;
-		cin >> c;
-		switch (c)
-		{
-		case 1:
-			cout << "Enter element to add = ";
-			cin >> x;
-			h = hash(x, mod);
-			h = fabs(h);
-			add(x, h);
-			break;
-		case 2:
-			cout << "Enter element to search = ";
-			cin >> x;
-			h = hash(x, mod);
-			find(x, h);
-			break;
-		case 3:
-			cout << "Enter element to generate hash = ";
-			cin >> x;
-			cout << "Hash of " << x << " is = " << hash(x, mod);
-			break;
-		case 4:
-			display(mod);
-			break;
-		default:
-			loop = false;
-			break;
-		}
-		cout << endl;
-	}
-	/*add(1,&head1);
-	add(2,&head1);
-	add(3,&head2);
-	add(5,&head1);
-	display(&head1);
-	display(&head2);*/
-	return 0;
+    init();
+    int c, x, mod, h;
+    cout << "Enter the size of Hash Table. = ";
+    cin >> mod;
+    bool loop = true;
+    while (loop)
+    {
+        cout << endl;
+        cout << "PLEASE CHOOSE -" << endl;
+        cout << "1. Add element." << endl;
+        cout << "2. Find element." << endl;
+        cout << "3. Generate Hash." << endl;
+        cout << "4. Display Hash table." << endl;
+        cout << "5. Exit." << endl;
+        cin >> c;
+        switch (c)
+        {
+        case 1:
+            cout << "Enter element to add = ";
+            cin >> x;
+            h = hash(x, mod);
+            h = fabs(h);
+            add(x, h);
+            break;
+        case 2:
+            cout << "Enter element to search = ";
+            cin >> x;
+            h = hash(x, mod);
+            find(x, h);
+            break;
+        case 3:
+            cout << "Enter element to generate hash = ";
+            cin >> x;
+            cout << "Hash of " << x << " is = " << hash(x, mod);
+            break;
+        case 4:
+            display(mod);
+            break;
+        default:
+            loop = false;
+            break;
+        }
+        cout << endl;
+    }
+    /*add(1,&head1);
+    add(2,&head1);
+    add(3,&head2);
+    add(5,&head1);
+    display(&head1);
+    display(&head2);*/
+    return 0;
 }

hashing/double_hash_hash_table.cpp

@@ -1,13 +1,13 @@
 // Copyright 2019
 
-#include<stdlib.h>
-#include<iostream>
-#include<functional>
-#include<string>
+#include <stdlib.h>
+#include <functional>
+#include <iostream>
+#include <string>
 
-using std::endl;
-using std::cout;
 using std::cin;
+using std::cout;
+using std::endl;
 using std::string;
 
 // fwd declarations
@@ -25,53 +25,70 @@ int size;
 bool rehashing;
 
 // Node that holds key
-struct Entry {
+struct Entry
+{
     explicit Entry(int key = notPresent) : key(key) {}
     int key;
 };
 
 // Hash a key
-int hashFxn(int key) {
+int hashFxn(int key)
+{
     std::hash<int> hash;
     return hash(key);
 }
 
 // Used for second hash function
-int otherHashFxn(int key) {
+int otherHashFxn(int key)
+{
     std::hash<int> hash;
     return 1 + (7 - (hash(key) % 7));
 }
 
 // Performs double hashing to resolve collisions
-int doubleHash(int key, bool searching) {
+int doubleHash(int key, bool searching)
+{
     int hash = static_cast<int>(fabs(hashFxn(key)));
     int i = 0;
     Entry entry;
-    do {
-        int index = static_cast<int>(fabs((hash +
-            (i * otherHashFxn(key))))) % totalSize;
+    do
+    {
+        int index = static_cast<int>(fabs((hash + (i * otherHashFxn(key))))) %
+                    totalSize;
         entry = table[index];
-        if (searching) {
-            if (entry.key == notPresent) {
+        if (searching)
+        {
+            if (entry.key == notPresent)
+            {
                 return notPresent;
             }
-            if (searchingProber(entry, key)) {
+            if (searchingProber(entry, key))
+            {
                 cout << "Found key!" << endl;
                 return index;
             }
             cout << "Found tombstone or equal hash, checking next" << endl;
             i++;
-        } else {
-            if (putProber(entry, key)) {
-                if (!rehashing) cout << "Spot found!" << endl;
+        }
+        else
+        {
+            if (putProber(entry, key))
+            {
+                if (!rehashing)
+                    cout << "Spot found!" << endl;
                 return index;
             }
-            if (!rehashing) cout << "Spot taken, looking at next (next index:"
-                << " " << static_cast<int>(fabs((hash +
-                (i * otherHashFxn(key))))) % totalSize << ")" << endl;
+            if (!rehashing)
+                cout << "Spot taken, looking at next (next index:"
+                     << " "
+                     << static_cast<int>(
+                            fabs((hash + (i * otherHashFxn(key))))) %
+                            totalSize
+                     << ")" << endl;
             i++;
         }
-        if (i == totalSize * 100) {
+        if (i == totalSize * 100)
+        {
             cout << "DoubleHash probe failed" << endl;
             return notPresent;
         }
@@ -80,27 +97,38 @@ int doubleHash(int key, bool searching) {
 }
 
 // Finds empty spot
-bool putProber(Entry entry, int key) {
-    if (entry.key == notPresent || entry.key == tomb) {
+bool putProber(Entry entry, int key)
+{
+    if (entry.key == notPresent || entry.key == tomb)
+    {
         return true;
     }
     return false;
 }
 
 // Looks for a matching key
-bool searchingProber(Entry entry, int key) {
-    if (entry.key == key) return true;
+bool searchingProber(Entry entry, int key)
+{
+    if (entry.key == key)
+        return true;
     return false;
 }
 
 // Displays the table
-void display() {
-    for (int i = 0; i < totalSize; i++) {
-        if (table[i].key == notPresent) {
+void display()
+{
+    for (int i = 0; i < totalSize; i++)
+    {
+        if (table[i].key == notPresent)
+        {
             cout << " Empty ";
-        } else if (table[i].key == tomb) {
+        }
+        else if (table[i].key == tomb)
+        {
             cout << " Tomb ";
-        } else {
+        }
+        else
+        {
             cout << " ";
             cout << table[i].key;
             cout << " ";
@@ -110,7 +138,8 @@ void display() {
 }
 
 // Rehashes the table into a bigger table
-void rehash() {
+void rehash()
+{
     // Necessary so wall of add info isn't printed all at once
     rehashing = true;
     int oldSize = totalSize;
@@ -118,8 +147,10 @@ void rehash() {
     // Really this should use the next prime number greater than totalSize * 2
     table = new Entry[totalSize * 2];
     totalSize *= 2;
-    for (int i = 0; i < oldSize; i++) {
-        if (oldTable[i].key != -1 && oldTable[i].key != notPresent) {
+    for (int i = 0; i < oldSize; i++)
+    {
+        if (oldTable[i].key != -1 && oldTable[i].key != notPresent)
+        {
             size--;  // Size stays the same (add increments size)
             add(oldTable[i].key);
         }
@@ -130,21 +161,25 @@ void rehash() {
 }
 
 // Checks for load factor here
-void add(int key) {
-    Entry * entry = new Entry();
+void add(int key)
+{
+    Entry* entry = new Entry();
     entry->key = key;
     int index = doubleHash(key, false);
     table[index] = *entry;
     // Load factor greater than 0.5 causes resizing
-    if (++size/ static_cast<double>(totalSize) >= 0.5) {
+    if (++size / static_cast<double>(totalSize) >= 0.5)
+    {
         rehash();
     }
 }
 
 // Removes key. Leaves tombstone upon removal.
-void remove(int key) {
+void remove(int key)
+{
     int index = doubleHash(key, true);
-    if (index == notPresent) {
+    if (index == notPresent)
+    {
         cout << "key not found" << endl;
     }
     table[index].key = tomb;
@@ -153,12 +188,13 @@ void remove(int key) {
 }
 
 // Information about the adding process
-void addInfo(int key) {
+void addInfo(int key)
+{
     cout << "Initial table: ";
     display();
     cout << endl;
-    cout << "hash of " << key << " is " << hashFxn(key)
-        << " % " << totalSize << " == " << fabs(hashFxn(key) % totalSize);
+    cout << "hash of " << key << " is " << hashFxn(key) << " % " << totalSize
+         << " == " << fabs(hashFxn(key) % totalSize);
     cout << endl;
     add(key);
     cout << "New table: ";
@@ -166,12 +202,13 @@ void addInfo(int key) {
 }
 
 // Information about removal process
-void removalInfo(int key) {
+void removalInfo(int key)
+{
     cout << "Initial table: ";
     display();
     cout << endl;
-    cout << "hash of " << key << " is " << hashFxn(key)
-        << " % " << totalSize << " == " << hashFxn(key) % totalSize;
+    cout << "hash of " << key << " is " << hashFxn(key) << " % " << totalSize
+         << " == " << hashFxn(key) % totalSize;
     cout << endl;
     remove(key);
     cout << "New table: ";
@@ -179,13 +216,15 @@ void removalInfo(int key) {
 }
 
 // I/O
-int main(void) {
+int main(void)
+{
     int cmd, hash, key;
     cout << "Enter the initial size of Hash Table. = ";
     cin >> totalSize;
     table = new Entry[totalSize];
     bool loop = true;
-    while (loop) {
+    while (loop)
+    {
         system("pause");
         cout << endl;
         cout << "PLEASE CHOOSE -" << endl;
@@ -196,7 +235,8 @@ int main(void) {
         cout << "5. Display Hash table." << endl;
         cout << "6. Exit." << endl;
         cin >> cmd;
-        switch (cmd) {
+        switch (cmd)
+        {
         case 1:
             cout << "Enter key to add = ";
             cin >> key;
@@ -207,11 +247,13 @@ int main(void) {
             cin >> key;
             removalInfo(key);
             break;
-        case 3: {
+        case 3:
+        {
             cout << "Enter key to search = ";
             cin >> key;
             Entry entry = table[doubleHash(key, true)];
-            if (entry.key == notPresent) {
+            if (entry.key == notPresent)
+            {
                 cout << "Key not present";
             }
             break;

hashing/linear_probing_hash_table.cpp

@@ -1,13 +1,13 @@
 // Copyright 2019
 
-#include<stdlib.h>
-#include<iostream>
-#include<functional>
-#include<string>
+#include <stdlib.h>
+#include <functional>
+#include <iostream>
+#include <string>
 
-using std::endl;
-using std::cout;
 using std::cin;
+using std::cout;
+using std::endl;
 using std::string;
 
 // fwd declarations
@@ -25,44 +25,57 @@ int size;
 bool rehashing;
 
 // Node that holds key
-struct Entry {
+struct Entry
+{
     explicit Entry(int key = notPresent) : key(key) {}
     int key;
 };
 
 // Hash a key
-int hashFxn(int key) {
+int hashFxn(int key)
+{
     std::hash<int> hash;
     return hash(key);
 }
 
 // Performs linear probing to resolve collisions
-int linearProbe(int key, bool searching) {
+int linearProbe(int key, bool searching)
+{
     int hash = static_cast<int>(fabs(hashFxn(key)));
     int i = 0;
     Entry entry;
-    do {
+    do
+    {
         int index = static_cast<int>(fabs((hash + i) % totalSize));
         entry = table[index];
-        if (searching) {
-            if (entry.key == notPresent) {
+        if (searching)
+        {
+            if (entry.key == notPresent)
+            {
                 return notPresent;
             }
-            if (searchingProber(entry, key)) {
+            if (searchingProber(entry, key))
+            {
                 cout << "Found key!" << endl;
                 return index;
             }
             cout << "Found tombstone or equal hash, checking next" << endl;
             i++;
-        } else {
-            if (putProber(entry, key)) {
-                if (!rehashing) cout << "Spot found!" << endl;
+        }
+        else
+        {
+            if (putProber(entry, key))
+            {
+                if (!rehashing)
+                    cout << "Spot found!" << endl;
                 return index;
             }
-            if (!rehashing) cout << "Spot taken, looking at next" << endl;
+            if (!rehashing)
+                cout << "Spot taken, looking at next" << endl;
             i++;
         }
-        if (i == totalSize) {
+        if (i == totalSize)
+        {
             cout << "Linear probe failed" << endl;
             return notPresent;
         }
@@ -71,27 +84,38 @@ int linearProbe(int key, bool searching) {
 }
 
 // Finds empty spot
-bool putProber(Entry entry, int key) {
-    if (entry.key == notPresent || entry.key == tomb) {
+bool putProber(Entry entry, int key)
+{
+    if (entry.key == notPresent || entry.key == tomb)
+    {
         return true;
     }
     return false;
 }
 
 // Looks for a matching key
-bool searchingProber(Entry entry, int key) {
-    if (entry.key == key) return true;
+bool searchingProber(Entry entry, int key)
+{
+    if (entry.key == key)
+        return true;
     return false;
 }
 
 // Displays the table
-void display() {
-    for (int i = 0; i < totalSize; i++) {
-        if (table[i].key == notPresent) {
+void display()
+{
+    for (int i = 0; i < totalSize; i++)
+    {
+        if (table[i].key == notPresent)
+        {
             cout << " Empty ";
-        } else if (table[i].key == tomb) {
+        }
+        else if (table[i].key == tomb)
+        {
             cout << " Tomb ";
-        } else {
+        }
+        else
+        {
             cout << " ";
             cout << table[i].key;
             cout << " ";
@@ -101,7 +125,8 @@ void display() {
 }
 
 // Rehashes the table into a bigger table
-void rehash() {
+void rehash()
+{
     // Necessary so wall of add info isn't printed all at once
     rehashing = true;
     int oldSize = totalSize;
@@ -109,8 +134,10 @@ void rehash() {
     // Really this should use the next prime number greater than totalSize * 2
     table = new Entry[totalSize * 2];
     totalSize *= 2;
-    for (int i = 0; i < oldSize; i++) {
-        if (oldTable[i].key != -1 && oldTable[i].key != notPresent) {
+    for (int i = 0; i < oldSize; i++)
+    {
+        if (oldTable[i].key != -1 && oldTable[i].key != notPresent)
+        {
             size--;  // Size stays the same (add increments size)
             add(oldTable[i].key);
         }
@@ -121,21 +148,25 @@ void rehash() {
 }
 
 // Adds entry using linear probing. Checks for load factor here
-void add(int key) {
-    Entry * entry = new Entry();
+void add(int key)
+{
+    Entry* entry = new Entry();
     entry->key = key;
     int index = linearProbe(key, false);
     table[index] = *entry;
     // Load factor greater than 0.5 causes resizing
-    if (++size/ static_cast<double>(totalSize) >= 0.5) {
+    if (++size / static_cast<double>(totalSize) >= 0.5)
+    {
         rehash();
     }
 }
 
 // Removes key. Leaves tombstone upon removal.
-void remove(int key) {
+void remove(int key)
+{
     int index = linearProbe(key, true);
-    if (index == notPresent) {
+    if (index == notPresent)
+    {
         cout << "key not found" << endl;
     }
     cout << "Removal Successful, leaving tomb" << endl;
@@ -144,12 +175,13 @@ void remove(int key) {
 }
 
 // Information about the adding process
-void addInfo(int key) {
+void addInfo(int key)
+{
     cout << "Initial table: ";
     display();
     cout << endl;
-    cout << "hash of " << key << " is " << hashFxn(key) << " % "
-        << totalSize << " == " << fabs(hashFxn(key) % totalSize);
+    cout << "hash of " << key << " is " << hashFxn(key) << " % " << totalSize
+         << " == " << fabs(hashFxn(key) % totalSize);
     cout << endl;
     add(key);
     cout << "New table: ";
@@ -157,12 +189,13 @@ void addInfo(int key) {
 }
 
 // Information about removal process
-void removalInfo(int key) {
+void removalInfo(int key)
+{
     cout << "Initial table: ";
     display();
     cout << endl;
-    cout << "hash of " << key << " is " << hashFxn(key)
-        << " % " << totalSize << " == " << hashFxn(key) % totalSize;
+    cout << "hash of " << key << " is " << hashFxn(key) << " % " << totalSize
+         << " == " << hashFxn(key) % totalSize;
     cout << endl;
     remove(key);
     cout << "New table: ";
@@ -170,13 +203,15 @@ void removalInfo(int key) {
 }
 
 // I/O
-int main(void) {
+int main(void)
+{
     int cmd, hash, key;
     cout << "Enter the initial size of Hash Table. = ";
     cin >> totalSize;
     table = new Entry[totalSize];
     bool loop = true;
-    while (loop) {
+    while (loop)
+    {
         system("pause");
         cout << endl;
         cout << "PLEASE CHOOSE -" << endl;
@@ -187,7 +222,8 @@ int main(void) {
         cout << "5. Display Hash table." << endl;
         cout << "6. Exit." << endl;
         cin >> cmd;
-        switch (cmd) {
+        switch (cmd)
+        {
         case 1:
             cout << "Enter key to add = ";
             cin >> key;
@@ -198,11 +234,13 @@ int main(void) {
             cin >> key;
             removalInfo(key);
             break;
-        case 3: {
+        case 3:
+        {
             cout << "Enter key to search = ";
             cin >> key;
             Entry entry = table[linearProbe(key, true)];
-            if (entry.key == notPresent) {
+            if (entry.key == notPresent)
+            {
                 cout << "Key not present";
             }
             break;

hashing/quadratic_probing_hash_table.cpp

@@ -1,14 +1,14 @@
 // Copyright 2019
 
-#include<stdlib.h>
-#include<iostream>
-#include<functional>
-#include<string>
-#include<cmath>
+#include <stdlib.h>
+#include <cmath>
+#include <functional>
+#include <iostream>
+#include <string>
 
-using std::endl;
-using std::cout;
 using std::cin;
+using std::cout;
+using std::endl;
 using std::string;
 
 // fwd declarations
@@ -26,49 +26,64 @@ int size;
 bool rehashing;
 
 // Node that holds key
-struct Entry {
+struct Entry
+{
     explicit Entry(int key = notPresent) : key(key) {}
     int key;
 };
 
 // Hash a key
-int hashFxn(int key) {
+int hashFxn(int key)
+{
     std::hash<int> hash;
     return hash(key);
 }
 
 // Performs quadratic probing to resolve collisions
-int quadraticProbe(int key, bool searching) {
+int quadraticProbe(int key, bool searching)
+{
     int hash = static_cast<int>(fabs(hashFxn(key)));
     int i = 0;
     Entry entry;
-    do {
-        int index = std::round(fabs((hash +
-            static_cast<int>(std::round(std::pow(i, 2)))) % totalSize));
+    do
+    {
+        int index = std::round(fabs(
+            (hash + static_cast<int>(std::round(std::pow(i, 2)))) % totalSize));
         entry = table[index];
-        if (searching) {
-            if (entry.key == notPresent) {
+        if (searching)
+        {
+            if (entry.key == notPresent)
+            {
                 return notPresent;
             }
-            if (searchingProber(entry, key)) {
+            if (searchingProber(entry, key))
+            {
                 cout << "Found key!" << endl;
                 return index;
             }
             cout << "Found tombstone or equal hash, checking next" << endl;
             i++;
-        } else {
-            if (putProber(entry, key)) {
-                if (!rehashing) cout << "Spot found!" << endl;
+        }
+        else
+        {
+            if (putProber(entry, key))
+            {
+                if (!rehashing)
+                    cout << "Spot found!" << endl;
                 return index;
             }
-            if (!rehashing) {
-                cout << "Spot taken, looking at next (next index = " <<
-                    std::round(fabs((hash + static_cast<int>(std::round(
-                        std::pow(i + 1, 2)))) % totalSize)) << endl;
+            if (!rehashing)
+            {
+                cout << "Spot taken, looking at next (next index = "
+                     << std::round(fabs((hash + static_cast<int>(std::round(
+                                                    std::pow(i + 1, 2)))) %
+                                        totalSize))
+                     << endl;
             }
             i++;
         }
-        if (i == totalSize * 100) {
+        if (i == totalSize * 100)
+        {
             cout << "Quadratic probe failed (infinite loop)" << endl;
             return notPresent;
         }
@@ -77,34 +92,47 @@ int quadraticProbe(int key, bool searching) {
 }
 
 // Finds empty spot
-bool putProber(Entry entry, int key) {
-    if (entry.key == notPresent || entry.key == tomb) {
+bool putProber(Entry entry, int key)
+{
+    if (entry.key == notPresent || entry.key == tomb)
+    {
         return true;
     }
     return false;
 }
 
 // Looks for a matching key
-bool searchingProber(Entry entry, int key) {
-    if (entry.key == key) return true;
+bool searchingProber(Entry entry, int key)
+{
+    if (entry.key == key)
+        return true;
     return false;
 }
 
 // Helper
-Entry find(int key) {
+Entry find(int key)
+{
     int index = quadraticProbe(key, true);
-    if (index == notPresent) return Entry();
+    if (index == notPresent)
+        return Entry();
     return table[index];
 }
 
 // Displays the table
-void display() {
-    for (int i = 0; i < totalSize; i++) {
-        if (table[i].key == notPresent) {
+void display()
+{
+    for (int i = 0; i < totalSize; i++)
+    {
+        if (table[i].key == notPresent)
+        {
             cout << " Empty ";
-        } else if (table[i].key == tomb) {
+        }
+        else if (table[i].key == tomb)
+        {
             cout << " Tomb ";
-        } else {
+        }
+        else
+        {
             cout << " ";
             cout << table[i].key;
             cout << " ";
@@ -114,7 +142,8 @@ void display() {
 }
 
 // Rehashes the table into a bigger table
-void rehash() {
+void rehash()
+{
     // Necessary so wall of add info isn't printed all at once
     rehashing = true;
     int oldSize = totalSize;
@@ -122,8 +151,10 @@ void rehash() {
     // Really this should use the next prime number greater than totalSize * 2
     table = new Entry[totalSize * 2];
     totalSize *= 2;
-    for (int i = 0; i < oldSize; i++) {
-        if (oldTable[i].key != -1 && oldTable[i].key != notPresent) {
+    for (int i = 0; i < oldSize; i++)
+    {
+        if (oldTable[i].key != -1 && oldTable[i].key != notPresent)
+        {
             size--;  // Size stays the same (add increments size)
             add(oldTable[i].key);
         }
@@ -134,21 +165,25 @@ void rehash() {
 }
 
 // Checks for load factor here
-void add(int key) {
-    Entry * entry = new Entry();
+void add(int key)
+{
+    Entry* entry = new Entry();
     entry->key = key;
     int index = quadraticProbe(key, false);
     table[index] = *entry;
     // Load factor greater than 0.5 causes resizing
-    if (++size/ static_cast<double>(totalSize) >= 0.5) {
+    if (++size / static_cast<double>(totalSize) >= 0.5)
+    {
         rehash();
     }
 }
 
 // Removes key. Leaves tombstone upon removal.
-void remove(int key) {
+void remove(int key)
+{
     int index = quadraticProbe(key, true);
-    if (index == notPresent) {
+    if (index == notPresent)
+    {
         cout << "key not found" << endl;
     }
     table[index].key = tomb;
@@ -157,12 +192,13 @@ void remove(int key) {
 }
 
 // Information about the adding process
-void addInfo(int key) {
+void addInfo(int key)
+{
     cout << "Initial table: ";
     display();
     cout << endl;
-    cout << "hash of " << key << " is " << hashFxn(key) << " % "
-        << totalSize << " == " << fabs(hashFxn(key) % totalSize);
+    cout << "hash of " << key << " is " << hashFxn(key) << " % " << totalSize
+         << " == " << fabs(hashFxn(key) % totalSize);
     cout << endl;
     add(key);
     cout << "New table: ";
@@ -170,12 +206,13 @@ void addInfo(int key) {
 }
 
 // Information about removal process
-void removalInfo(int key) {
+void removalInfo(int key)
+{
     cout << "Initial table: ";
     display();
     cout << endl;
-    cout << "hash of " << key << " is " << hashFxn(key)
-        << " % " << totalSize << " == " << hashFxn(key) % totalSize;
+    cout << "hash of " << key << " is " << hashFxn(key) << " % " << totalSize
+         << " == " << hashFxn(key) % totalSize;
     cout << endl;
     remove(key);
     cout << "New table: ";
@@ -183,13 +220,15 @@ void removalInfo(int key) {
 }
 
 // I/O
-int main(void) {
+int main(void)
+{
     int cmd, hash, key;
     cout << "Enter the initial size of Hash Table. = ";
     cin >> totalSize;
     table = new Entry[totalSize];
     bool loop = true;
-    while (loop) {
+    while (loop)
+    {
         system("pause");
         cout << endl;
         cout << "PLEASE CHOOSE -" << endl;
@@ -200,7 +239,8 @@ int main(void) {
         cout << "5. Display Hash table." << endl;
         cout << "6. Exit." << endl;
         cin >> cmd;
-        switch (cmd) {
+        switch (cmd)
+        {
         case 1:
             cout << "Enter key to add = ";
             cin >> key;
@@ -211,11 +251,13 @@ int main(void) {
             cin >> key;
             removalInfo(key);
             break;
-        case 3: {
+        case 3:
+        {
             cout << "Enter key to search = ";
             cin >> key;
             Entry entry = table[quadraticProbe(key, true)];
-            if (entry.key == notPresent) {
+            if (entry.key == notPresent)
+            {
                 cout << "Key not present";
             }
             break;

math/binary_exponent.cpp

@@ -25,24 +25,32 @@
 
 /// Recursive function to calculate exponent in \f$O(\log(n))\f$ using binary
 /// exponent.
-int binExpo(int a, int b) {
-    if (b == 0) {
+int binExpo(int a, int b)
+{
+    if (b == 0)
+    {
         return 1;
     }
     int res = binExpo(a, b / 2);
-    if (b % 2) {
+    if (b % 2)
+    {
         return res * res * a;
-    } else {
+    }
+    else
+    {
         return res * res;
     }
 }
 
 /// Iterative function to calculate exponent in \f$O(\log(n))\f$ using binary
 /// exponent.
-int binExpo_alt(int a, int b) {
+int binExpo_alt(int a, int b)
+{
     int res = 1;
-    while (b > 0) {
-        if (b % 2) {
+    while (b > 0)
+    {
+        if (b % 2)
+        {
             res = res * a;
         }
         a = a * a;
@@ -52,15 +60,21 @@ int binExpo_alt(int a, int b) {
 }
 
 /// Main function
-int main() {
+int main()
+{
     int a, b;
     /// Give two numbers a, b
     std::cin >> a >> b;
-    if (a == 0 && b == 0) {
+    if (a == 0 && b == 0)
+    {
         std::cout << "Math error" << std::endl;
-    } else if (b < 0) {
+    }
+    else if (b < 0)
+    {
         std::cout << "Exponent must be positive !!" << std::endl;
-    } else {
+    }
+    else
+    {
         int resRecurse = binExpo(a, b);
         /// int resIterate = binExpo_alt(a, b);
 

math/double_factorial.cpp

@@ -13,10 +13,13 @@
 
 /** Compute double factorial using iterative method
  */
-uint64_t double_factorial_iterative(uint64_t n) {
+uint64_t double_factorial_iterative(uint64_t n)
+{
     uint64_t res = 1;
-    for (uint64_t i = n;; i -= 2) {
-        if (i == 0 || i == 1) return res;
+    for (uint64_t i = n;; i -= 2)
+    {
+        if (i == 0 || i == 1)
+            return res;
         res *= i;
     }
     return res;
@@ -25,13 +28,16 @@ uint64_t double_factorial_iterative(uint64_t n) {
 /** Compute double factorial using resursive method.
  * <br/>Recursion can be costly for large numbers.
  */
-uint64_t double_factorial_recursive(uint64_t n) {
-    if (n <= 1) return 1;
+uint64_t double_factorial_recursive(uint64_t n)
+{
+    if (n <= 1)
+        return 1;
     return n * double_factorial_recursive(n - 2);
 }
 
 /// main function
-int main() {
+int main()
+{
     uint64_t n;
     std::cin >> n;
     assert(n >= 0);

math/eulers_totient_function.cpp

@@ -29,26 +29,35 @@
 
 /** Function to caculate Euler's totient phi
  */
-uint64_t phiFunction(uint64_t n) {
+uint64_t phiFunction(uint64_t n)
+{
     uint64_t result = n;
-    for (uint64_t i = 2; i * i <= n; i++) {
-        if (n % i == 0) {
-            while (n % i == 0) {
+    for (uint64_t i = 2; i * i <= n; i++)
+    {
+        if (n % i == 0)
+        {
+            while (n % i == 0)
+            {
                 n /= i;
             }
             result -= result / i;
         }
     }
-    if (n > 1) result -= result / n;
+    if (n > 1)
+        result -= result / n;
     return result;
 }
 
 /// Main function
-int main(int argc, char *argv[]) {
+int main(int argc, char *argv[])
+{
     uint64_t n;
-    if (argc < 2) {
+    if (argc < 2)
+    {
         std::cout << "Enter the number: ";
-    } else {
+    }
+    else
+    {
         n = strtoull(argv[1], nullptr, 10);
     }
     std::cin >> n;

math/extended_euclid_algorithm.cpp

@@ -21,7 +21,8 @@
  * @param[in] quotient  unsigned
  */
 template <typename T, typename T2>
-inline void update_step(T *r, T *r0, const T2 quotient) {
+inline void update_step(T *r, T *r0, const T2 quotient)
+{
     T temp = *r;
     *r = *r0 - (quotient * temp);
     *r0 = temp;
@@ -38,14 +39,17 @@ inline void update_step(T *r, T *r0, const T2 quotient) {
  * @param[out] y signed
  */
 template <typename T1, typename T2>
-void extendedEuclid_1(T1 A, T1 B, T1 *GCD, T2 *x, T2 *y) {
-    if (B > A) std::swap(A, B);  // Ensure that A >= B
+void extendedEuclid_1(T1 A, T1 B, T1 *GCD, T2 *x, T2 *y)
+{
+    if (B > A)
+        std::swap(A, B);  // Ensure that A >= B
 
     T2 s = 0, s0 = 1;
     T2 t = 1, t0 = 0;
     T1 r = B, r0 = A;
 
-    while (r != 0) {
+    while (r != 0)
+    {
         T1 quotient = r0 / r;
         update_step(&r, &r0, quotient);
         update_step(&s, &s0, quotient);
@@ -66,14 +70,19 @@ void extendedEuclid_1(T1 A, T1 B, T1 *GCD, T2 *x, T2 *y) {
  * @param[in,out] y signed
  */
 template <typename T, typename T2>
-void extendedEuclid(T A, T B, T *GCD, T2 *x, T2 *y) {
-    if (B > A) std::swap(A, B);  // Ensure that A >= B
+void extendedEuclid(T A, T B, T *GCD, T2 *x, T2 *y)
+{
+    if (B > A)
+        std::swap(A, B);  // Ensure that A >= B
 
-    if (B == 0) {
+    if (B == 0)
+    {
         *GCD = A;
         *x = 1;
         *y = 0;
-    } else {
+    }
+    else
+    {
         extendedEuclid(B, A % B, GCD, x, y);
         T2 temp = *x;
         *x = *y;
@@ -82,7 +91,8 @@ void extendedEuclid(T A, T B, T *GCD, T2 *x, T2 *y) {
 }
 
 /// Main function
-int main() {
+int main()
+{
     uint32_t a, b, gcd;
     int32_t x, y;
     std::cin >> a >> b;

math/factorial.cpp

@@ -5,14 +5,16 @@
 #include <iostream>
 
 /** function to find factorial of given number */
-unsigned int factorial(unsigned int n) {
+unsigned int factorial(unsigned int n)
+{
     if (n == 0)
         return 1;
     return n * factorial(n - 1);
 }
 
 /** Main function */
-int main() {
+int main()
+{
     int num = 5;
     std::cout << "Factorial of " << num << " is " << factorial(num)
               << std::endl;

math/fast_power.cpp

@@ -23,11 +23,14 @@
  * algorithm implementation for \f$a^b\f$
  */
 template <typename T>
-double fast_power_recursive(T a, T b) {
+double fast_power_recursive(T a, T b)
+{
     // negative power. a^b = 1 / (a^-b)
-    if (b < 0) return 1.0 / fast_power_recursive(a, -b);
+    if (b < 0)
+        return 1.0 / fast_power_recursive(a, -b);
 
-    if (b == 0) return 1;
+    if (b == 0)
+        return 1;
     T bottom = fast_power_recursive(a, b >> 1);
     // Since it is integer division b/2 = (b-1)/2 where b is odd.
     // Therefore, case2 is easily solved by integer division.
@@ -45,13 +48,17 @@ double fast_power_recursive(T a, T b) {
     It still calculates in \f$O(\log N)\f$
 */
 template <typename T>
-double fast_power_linear(T a, T b) {
+double fast_power_linear(T a, T b)
+{
     // negative power. a^b = 1 / (a^-b)
-    if (b < 0) return 1.0 / fast_power_linear(a, -b);
+    if (b < 0)
+        return 1.0 / fast_power_linear(a, -b);
 
     double result = 1;
-    while (b) {
-        if (b & 1) result = result * a;
+    while (b)
+    {
+        if (b & 1)
+            result = result * a;
         a = a * a;
         b = b >> 1;
     }
@@ -61,12 +68,14 @@ double fast_power_linear(T a, T b) {
 /**
  * Main function
  */
-int main() {
+int main()
+{
     std::srand(std::time(nullptr));
     std::ios_base::sync_with_stdio(false);
 
     std::cout << "Testing..." << std::endl;
-    for (int i = 0; i < 20; i++) {
+    for (int i = 0; i < 20; i++)
+    {
         int a = std::rand() % 20 - 10;
         int b = std::rand() % 20 - 10;
         std::cout << std::endl << "Calculating " << a << "^" << b << std::endl;

math/fibonacci.cpp

@@ -14,7 +14,8 @@
 /**
  * Recursively compute sequences
  */
-int fibonacci(unsigned int n) {
+int fibonacci(unsigned int n)
+{
     /* If the input is 0 or 1 just return the same
        This will set the first 2 values of the sequence */
     if (n <= 1)
@@ -25,7 +26,8 @@ int fibonacci(unsigned int n) {
 }
 
 /// Main function
-int main() {
+int main()
+{
     int n;
     std::cin >> n;
     assert(n >= 0);

math/fibonacci_fast.cpp

@@ -26,7 +26,8 @@ const uint64_t MAX = 93;
 uint64_t f[MAX] = {0};
 
 /** Algorithm */
-uint64_t fib(uint64_t n) {
+uint64_t fib(uint64_t n)
+{
     if (n == 0)
         return 0;
     if (n == 1 || n == 2)
@@ -43,9 +44,11 @@ uint64_t fib(uint64_t n) {
 }
 
 /** Main function */
-int main() {
+int main()
+{
     // Main Function
-    for (uint64_t i = 1; i < 93; i++) {
+    for (uint64_t i = 1; i < 93; i++)
+    {
         std::cout << i << " th fibonacci number is " << fib(i) << std::endl;
     }
     return 0;

math/fibonacci_large.cpp

@@ -20,11 +20,13 @@
  * \f[f(n)=f(n-1)+f(n-2)\f]
  * and returns the result as a large_number type.
  */
-large_number fib(uint64_t n) {
+large_number fib(uint64_t n)
+{
     large_number f0(1);
     large_number f1(1);
 
-    do {
+    do
+    {
         large_number f2 = f1;
         f1 += f0;
         f0 = f2;
@@ -34,11 +36,15 @@ large_number fib(uint64_t n) {
     return f1;
 }
 
-int main(int argc, char *argv[]) {
+int main(int argc, char *argv[])
+{
     uint64_t N;
-    if (argc == 2) {
+    if (argc == 2)
+    {
         N = strtoull(argv[1], NULL, 10);
-    } else {
+    }
+    else
+    {
         std::cout << "Enter N: ";
         std::cin >> N;
     }

math/gcd_iterative_euclidean.cpp

@@ -12,27 +12,34 @@
 /**
  * algorithm
  */
-int gcd(int num1, int num2) {
-    if (num1 <= 0 | num2 <= 0) {
+int gcd(int num1, int num2)
+{
+    if (num1 <= 0 | num2 <= 0)
+    {
         throw std::domain_error("Euclidean algorithm domain is for ints > 0");
     }
 
-    if (num1 == num2) {
+    if (num1 == num2)
+    {
         return num1;
     }
 
     int base_num = 0;
     int previous_remainder = 1;
 
-    if (num1 > num2) {
+    if (num1 > num2)
+    {
         base_num = num1;
         previous_remainder = num2;
-    } else {
+    }
+    else
+    {
         base_num = num2;
         previous_remainder = num1;
     }
 
-    while ((base_num % previous_remainder) != 0) {
+    while ((base_num % previous_remainder) != 0)
+    {
         int old_base = base_num;
         base_num = previous_remainder;
         previous_remainder = old_base % previous_remainder;
@@ -44,11 +51,15 @@ int gcd(int num1, int num2) {
 /**
  * Main function
  */
-int main() {
+int main()
+{
     std::cout << "gcd of 120,7 is " << (gcd(120, 7)) << std::endl;
-    try {
+    try
+    {
         std::cout << "gcd of -120,10 is " << gcd(-120, 10) << std::endl;
-    } catch (const std::domain_error &e) {
+    }
+    catch (const std::domain_error &e)
+    {
         std::cout << "Error handling was successful" << std::endl;
     }
     std::cout << "gcd of 312,221 is " << (gcd(312, 221)) << std::endl;

math/gcd_of_n_numbers.cpp

@@ -12,10 +12,12 @@
  * @param[in] a array of integers to compute GCD for
  * @param[in] n number of integers in array `a`
  */
-int gcd(int *a, int n) {
+int gcd(int *a, int n)
+{
     int j = 1;  // to access all elements of the array starting from 1
     int gcd = a[0];
-    while (j < n) {
+    while (j < n)
+    {
         if (a[j] % gcd == 0)  // value of gcd is as needed so far
             j++;              // so we check for next element
         else
@@ -25,7 +27,8 @@ int gcd(int *a, int n) {
 }
 
 /** Main function */
-int main() {
+int main()
+{
     int n;
     std::cout << "Enter value of n:" << std::endl;
     std::cin >> n;

math/gcd_recursive_euclidean.cpp

@@ -11,12 +11,15 @@
 /**
  * algorithm
  */
-int gcd(int num1, int num2) {
-    if (num1 <= 0 | num2 <= 0) {
+int gcd(int num1, int num2)
+{
+    if (num1 <= 0 | num2 <= 0)
+    {
         throw std::domain_error("Euclidean algorithm domain is for ints > 0");
     }
 
-    if (num1 == num2) {
+    if (num1 == num2)
+    {
         return num1;
     }
 
@@ -39,11 +42,15 @@ int gcd(int num1, int num2) {
 /**
  * Main function
  */
-int main() {
+int main()
+{
     std::cout << "gcd of 120,7 is " << (gcd(120, 7)) << std::endl;
-    try {
+    try
+    {
         std::cout << "gcd of -120,10 is " << gcd(-120, 10) << std::endl;
-    } catch (const std::domain_error &e) {
+    }
+    catch (const std::domain_error &e)
+    {
         std::cout << "Error handling was successful" << std::endl;
     }
     std::cout << "gcd of 312,221 is " << (gcd(312, 221)) << std::endl;

math/large_factorial.cpp

@@ -13,7 +13,8 @@
 /** Test implementation for 10! Result must be 3628800.
  * @returns True if test pass else False
  */
-bool test1() {
+bool test1()
+{
     std::cout << "---- Check 1\t";
     unsigned int i, number = 10;
     large_number result;
@@ -23,15 +24,18 @@ bool test1() {
     const char *known_reslt = "3628800";
 
     /* check 1 */
-    if (strlen(known_reslt) != result.num_digits()) {
+    if (strlen(known_reslt) != result.num_digits())
+    {
         std::cerr << "Result lengths dont match! " << strlen(known_reslt)
                   << " != " << result.num_digits() << std::endl;
         return false;
     }
 
     const size_t N = result.num_digits();
-    for (i = 0; i < N; i++) {
-        if (known_reslt[i] != result.digit_char(i)) {
+    for (i = 0; i < N; i++)
+    {
+        if (known_reslt[i] != result.digit_char(i))
+        {
             std::cerr << i << "^th digit mismatch! " << known_reslt[i]
                       << " != " << result.digit_char(i) << std::endl;
             return false;
@@ -50,7 +54,8 @@ bool test1() {
  * ```
  * @returns True if test pass else False
  */
-bool test2() {
+bool test2()
+{
     std::cout << "---- Check 2\t";
     unsigned int i, number = 100;
     large_number result;
@@ -63,15 +68,18 @@ bool test2() {
         "000000000000000000";
 
     /* check 1 */
-    if (strlen(known_reslt) != result.num_digits()) {
+    if (strlen(known_reslt) != result.num_digits())
+    {
         std::cerr << "Result lengths dont match! " << strlen(known_reslt)
                   << " != " << result.num_digits() << std::endl;
         return false;
     }
 
     const size_t N = result.num_digits();
-    for (i = 0; i < N; i++) {
-        if (known_reslt[i] != result.digit_char(i)) {
+    for (i = 0; i < N; i++)
+    {
+        if (known_reslt[i] != result.digit_char(i))
+        {
             std::cerr << i << "^th digit mismatch! " << known_reslt[i]
                       << " != " << result.digit_char(i) << std::endl;
             return false;
@@ -85,12 +93,16 @@ bool test2() {
 /**
  * Main program
  **/
-int main(int argc, char *argv[]) {
+int main(int argc, char *argv[])
+{
     int number, i;
 
-    if (argc == 2) {
+    if (argc == 2)
+    {
         number = atoi(argv[1]);
-    } else {
+    }
+    else
+    {
         std::cout << "Enter the value of n(n starts from 0 ): ";
         std::cin >> number;
     }

math/large_number.h

@@ -20,7 +20,8 @@
  * digit to the number, perform multiplication of
  * large number with long unsigned integers.
  **/
-class large_number {
+class large_number
+{
  public:
     /**< initializer with value = 1 */
     large_number() { _digits.push_back(1); }
@@ -35,9 +36,11 @@ class large_number {
     // }
 
     /**< initializer from an integer */
-    explicit large_number(int n) {
+    explicit large_number(int n)
+    {
         int carry = n;
-        do {
+        do
+        {
             add_digit(carry % 10);
             carry /= 10;
         } while (carry != 0);
@@ -50,8 +53,10 @@ class large_number {
     explicit large_number(std::vector<unsigned char> &vec) : _digits(vec) {}
 
     /**< initializer from a string */
-    explicit large_number(char const *number_str) {
-        for (size_t i = strlen(number_str); i > 0; i--) {
+    explicit large_number(char const *number_str)
+    {
+        for (size_t i = strlen(number_str); i > 0; i--)
+        {
             unsigned char a = number_str[i - 1] - '0';
             if (a >= 0 && a <= 9)
                 _digits.push_back(a);
@@ -61,48 +66,55 @@ class large_number {
     /**
      * Function to check implementation
      **/
-    static bool test() {
+    static bool test()
+    {
         std::cout << "------ Checking `large_number` class implementations\t"
                   << std::endl;
         large_number a(40);
         // 1. test multiplication
         a *= 10;
-        if (a != large_number(400)) {
+        if (a != large_number(400))
+        {
             std::cerr << "\tFailed 1/6 (" << a << "!=400)" << std::endl;
             return false;
         }
         std::cout << "\tPassed 1/6...";
         // 2. test compound addition with integer
         a += 120;
-        if (a != large_number(520)) {
+        if (a != large_number(520))
+        {
             std::cerr << "\tFailed 2/6 (" << a << "!=520)" << std::endl;
             return false;
         }
         std::cout << "\tPassed 2/6...";
         // 3. test compound multiplication again
         a *= 10;
-        if (a != large_number(5200)) {
+        if (a != large_number(5200))
+        {
             std::cerr << "\tFailed 3/6 (" << a << "!=5200)" << std::endl;
             return false;
         }
         std::cout << "\tPassed 3/6...";
         // 4. test increment (prefix)
         ++a;
-        if (a != large_number(5201)) {
+        if (a != large_number(5201))
+        {
             std::cerr << "\tFailed 4/6 (" << a << "!=5201)" << std::endl;
             return false;
         }
         std::cout << "\tPassed 4/6...";
         // 5. test increment (postfix)
         a++;
-        if (a != large_number(5202)) {
+        if (a != large_number(5202))
+        {
             std::cerr << "\tFailed 5/6 (" << a << "!=5202)" << std::endl;
             return false;
         }
         std::cout << "\tPassed 5/6...";
         // 6. test addition with another large number
         a = a + large_number("7000000000000000000000000000000");
-        if (a != large_number("7000000000000000000000000005202")) {
+        if (a != large_number("7000000000000000000000000005202"))
+        {
             std::cerr << "\tFailed 6/6 (" << a
                       << "!=7000000000000000000000000005202)" << std::endl;
             return false;
@@ -114,8 +126,10 @@ class large_number {
     /**
      * add a digit at MSB to the large number
      **/
-    void add_digit(unsigned int value) {
-        if (value > 9) {
+    void add_digit(unsigned int value)
+    {
+        if (value > 9)
+        {
             std::cerr << "digit > 9!!\n";
             exit(EXIT_FAILURE);
         }
@@ -135,14 +149,16 @@ class large_number {
      **/
     inline unsigned char &operator[](size_t n) { return this->_digits[n]; }
 
-    inline const unsigned char &operator[](size_t n) const {
+    inline const unsigned char &operator[](size_t n) const
+    {
         return this->_digits[n];
     }
 
     /**
      * operator overload to compare two numbers
      **/
-    friend std::ostream &operator<<(std::ostream &out, const large_number &a) {
+    friend std::ostream &operator<<(std::ostream &out, const large_number &a)
+    {
         for (size_t i = a.num_digits(); i > 0; i--)
             out << static_cast<int>(a[i - 1]);
         return out;
@@ -151,7 +167,8 @@ class large_number {
     /**
      * operator overload to compare two numbers
      **/
-    friend bool operator==(large_number const &a, large_number const &b) {
+    friend bool operator==(large_number const &a, large_number const &b)
+    {
         size_t N = a.num_digits();
         if (N != b.num_digits())
             return false;
@@ -164,14 +181,16 @@ class large_number {
     /**
      * operator overload to compare two numbers
      **/
-    friend bool operator!=(large_number const &a, large_number const &b) {
+    friend bool operator!=(large_number const &a, large_number const &b)
+    {
         return !(a == b);
     }
 
     /**
      * operator overload to increment (prefix)
      **/
-    large_number &operator++() {
+    large_number &operator++()
+    {
         (*this) += 1;
         return *this;
     }
@@ -179,7 +198,8 @@ class large_number {
     /**
      * operator overload to increment (postfix)
      **/
-    large_number &operator++(int) {
+    large_number &operator++(int)
+    {
         static large_number tmp(_digits);
         ++(*this);
         return tmp;
@@ -188,13 +208,15 @@ class large_number {
     /**
      * operator overload to add
      **/
-    large_number &operator+=(large_number n) {
+    large_number &operator+=(large_number n)
+    {
         // if adding with another large_number
         large_number *b = reinterpret_cast<large_number *>(&n);
         const size_t max_L = std::max(this->num_digits(), b->num_digits());
         unsigned int carry = 0;
         size_t i;
-        for (i = 0; i < max_L || carry != 0; i++) {
+        for (i = 0; i < max_L || carry != 0; i++)
+        {
             if (i < b->num_digits())
                 carry += (*b)[i];
             if (i < this->num_digits())
@@ -216,7 +238,8 @@ class large_number {
      * operator overload to perform addition
      **/
     template <class T>
-    friend large_number &operator+(const large_number &a, const T &b) {
+    friend large_number &operator+(const large_number &a, const T &b)
+    {
         static large_number c = a;
         c += b;
         return c;
@@ -225,7 +248,8 @@ class large_number {
     /**
      * assignment operator
      **/
-    large_number &operator=(const large_number &b) {
+    large_number &operator=(const large_number &b)
+    {
         this->_digits = b._digits;
         return *this;
     }
@@ -234,7 +258,8 @@ class large_number {
      * operator overload to increment
      **/
     template <class T>
-    large_number &operator*=(const T n) {
+    large_number &operator*=(const T n)
+    {
         static_assert(std::is_integral<T>::value,
                       "Must be integer addition unsigned integer types.");
         this->multiply(n);
@@ -244,7 +269,8 @@ class large_number {
     /**
      * returns i^th digit as an ASCII character
      **/
-    const char digit_char(size_t i) const {
+    const char digit_char(size_t i) const
+    {
         return _digits[num_digits() - i - 1] + '0';
     }
 
@@ -254,7 +280,8 @@ class large_number {
      * store the result in the same large number
      **/
     template <class T>
-    void multiply(const T n) {
+    void multiply(const T n)
+    {
         static_assert(std::is_integral<T>::value,
                       "Can only have integer types.");
         // assert(!(std::is_signed<T>::value)); //, "Implemented only for
@@ -262,19 +289,24 @@ class large_number {
 
         size_t i;
         uint64_t carry = 0, temp;
-        for (i = 0; i < this->num_digits(); i++) {
+        for (i = 0; i < this->num_digits(); i++)
+        {
             temp = (*this)[i] * n;
             temp += carry;
-            if (temp < 10) {
+            if (temp < 10)
+            {
                 carry = 0;
-            } else {
+            }
+            else
+            {
                 carry = temp / 10;
                 temp = temp % 10;
             }
             (*this)[i] = temp;
         }
 
-        while (carry != 0) {
+        while (carry != 0)
+        {
             this->add_digit(carry % 10);
             carry /= 10;
         }

math/modular_inverse_fermat_little_theorem.cpp

@@ -49,11 +49,14 @@
 /** Recursive function to calculate exponent in \f$O(\log n)\f$ using binary
  * exponent.
  */
-int64_t binExpo(int64_t a, int64_t b, int64_t m) {
+int64_t binExpo(int64_t a, int64_t b, int64_t m)
+{
     a %= m;
     int64_t res = 1;
-    while (b > 0) {
-        if (b % 2) {
+    while (b > 0)
+    {
+        if (b % 2)
+        {
             res = res * a % m;
         }
         a = a * a % m;
@@ -65,12 +68,18 @@ int64_t binExpo(int64_t a, int64_t b, int64_t m) {
 
 /** Prime check in \f$O(\sqrt{m})\f$ time.
  */
-bool isPrime(int64_t m) {
-    if (m <= 1) {
+bool isPrime(int64_t m)
+{
+    if (m <= 1)
+    {
         return false;
-    } else {
-        for (int64_t i = 2; i * i <= m; i++) {
-            if (m % i == 0) {
+    }
+    else
+    {
+        for (int64_t i = 2; i * i <= m; i++)
+        {
+            if (m % i == 0)
+            {
                 return false;
             }
         }
@@ -81,17 +90,21 @@ bool isPrime(int64_t m) {
 /**
  * Main function
  */
-int main() {
+int main()
+{
     int64_t a, m;
     // Take input of  a and m.
     std::cout << "Computing ((a^(-1))%(m)) using Fermat's Little Theorem";
     std::cout << std::endl << std::endl;
     std::cout << "Give input 'a' and 'm' space separated : ";
     std::cin >> a >> m;
-    if (isPrime(m)) {
+    if (isPrime(m))
+    {
         std::cout << "The modular inverse of a with mod m is (a^(m-2)) : ";
         std::cout << binExpo(a, m - 2, m) << std::endl;
-    } else {
+    }
+    else
+    {
         std::cout << "m must be a prime number.";
         std::cout << std::endl;
     }

math/number_of_positive_divisors.cpp

@@ -31,25 +31,31 @@ respectively.
 /**
  * Algorithm
  */
-int number_of_positive_divisors(int n) {
+int number_of_positive_divisors(int n)
+{
     std::vector<int> prime_exponent_count;
-    for (int i = 2; i * i <= n; i++) {
+    for (int i = 2; i * i <= n; i++)
+    {
         int prime_count = 0;
-        while (n % i == 0) {
+        while (n % i == 0)
+        {
             prime_count += 1;
             n /= i;
         }
-        if (prime_count != 0) {
+        if (prime_count != 0)
+        {
             prime_exponent_count.push_back(prime_count);
         }
     }
-    if (n > 1) {
+    if (n > 1)
+    {
         prime_exponent_count.push_back(1);
     }
 
     int divisors_count = 1;
 
-    for (int i = 0; i < prime_exponent_count.size(); i++) {
+    for (int i = 0; i < prime_exponent_count.size(); i++)
+    {
         divisors_count = divisors_count * (prime_exponent_count[i] + 1);
     }
 
@@ -59,15 +65,20 @@ int number_of_positive_divisors(int n) {
 /**
  * Main function
  */
-int main() {
+int main()
+{
     int n;
     std::cin >> n;
-    if (n < 0) {
+    if (n < 0)
+    {
         n = -n;
     }
-    if (n == 0) {
+    if (n == 0)
+    {
         std::cout << "All non-zero numbers are divisors of 0 !" << std::endl;
-    } else {
+    }
+    else
+    {
         std::cout << "Number of positive divisors is : ";
         std::cout << number_of_positive_divisors(n) << std::endl;
     }

math/power_for_huge_numbers.cpp

@@ -22,13 +22,15 @@
  * @param res large number representation using array
  * @param res_size number of digits in `res`
  */
-int multiply(int x, int res[], int res_size) {
+int multiply(int x, int res[], int res_size)
+{
     // Initialize carry
     int carry = 0;
 
     // One by one multiply n with
     // individual digits of res[]
-    for (int i = 0; i < res_size; i++) {
+    for (int i = 0; i < res_size; i++)
+    {
         int prod = res[i] * x + carry;
 
         // Store last digit of
@@ -41,7 +43,8 @@ int multiply(int x, int res[], int res_size) {
 
     // Put carry in res and
     // increase result size
-    while (carry) {
+    while (carry)
+    {
         res[res_size] = carry % 10;
         carry = carry / 10;
         res_size++;
@@ -53,9 +56,11 @@ int multiply(int x, int res[], int res_size) {
  * @param x base
  * @param n exponent
  */
-void power(int x, int n) {
+void power(int x, int n)
+{
     // printing value "1" for power = 0
-    if (n == 0) {
+    if (n == 0)
+    {
         std::cout << "1";
         return;
     }
@@ -65,7 +70,8 @@ void power(int x, int n) {
     int temp = x;
 
     // Initialize result
-    while (temp != 0) {
+    while (temp != 0)
+    {
         res[res_size++] = temp % 10;
         temp = temp / 10;
     }
@@ -79,7 +85,8 @@ void power(int x, int n) {
 }
 
 /** Main function */
-int main() {
+int main()
+{
     int exponent, base;
     std::cout << "Enter base ";
     std::cin >> base;