formatting source-code for b388e4a309

client_server/UDP_Client.c

@@ -1,25 +1,27 @@
 // Client side implementation of UDP client-server model
-#include <stdio.h> 
-#include <stdlib.h> 
-#include <unistd.h> 
-#include <string.h> 
-#include <sys/types.h> 
-#include <sys/socket.h> 
 #include <arpa/inet.h>
 #include <netinet/in.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <unistd.h>
 
 #define PORT 8080
 #define MAXLINE 1024
 
 // Driver code
-int main() { 
+int main()
+{
     int sockfd;
     char buffer[MAXLINE];
     char *hello = "Hello from client";
     struct sockaddr_in servaddr;
 
     // Creating socket file descriptor
-	if ( (sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0 ) { 
+    if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
+    {
         perror("socket creation failed");
         exit(EXIT_FAILURE);
     }
@@ -33,14 +35,12 @@ int main() {
 
     int n, len;
 
-	sendto(sockfd, (const char *)hello, strlen(hello), 
-		MSG_CONFIRM, (const struct sockaddr *) &servaddr, 
-			sizeof(servaddr)); 
+    sendto(sockfd, (const char *)hello, strlen(hello), MSG_CONFIRM,
+           (const struct sockaddr *)&servaddr, sizeof(servaddr));
     printf("Hello message sent.\n");
 
-	n = recvfrom(sockfd, (char *)buffer, MAXLINE, 
-				MSG_WAITALL, (struct sockaddr *) &servaddr, 
-				&len); 
+    n = recvfrom(sockfd, (char *)buffer, MAXLINE, MSG_WAITALL,
+                 (struct sockaddr *)&servaddr, &len);
     buffer[n] = '\0';
     printf("Server : %s\n", buffer);
 

client_server/UDP_Server.c

@@ -1,25 +1,27 @@
 // Server side implementation of UDP client-server model
-#include <stdio.h> 
-#include <stdlib.h> 
-#include <unistd.h> 
-#include <string.h> 
-#include <sys/types.h> 
-#include <sys/socket.h> 
 #include <arpa/inet.h>
 #include <netinet/in.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <unistd.h>
 
 #define PORT 8080
 #define MAXLINE 1024
 
 // Driver code
-int main() { 
+int main()
+{
     int sockfd;
     char buffer[MAXLINE];
     char *hello = "Hello from server";
     struct sockaddr_in servaddr, cliaddr;
 
     // Creating socket file descriptor
-	if ( (sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0 ) { 
+    if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
+    {
         perror("socket creation failed");
         exit(EXIT_FAILURE);
     }
@@ -33,22 +35,19 @@ int main() {
     servaddr.sin_port = htons(PORT);
 
     // Bind the socket with the server address
-	if ( bind(sockfd, (const struct sockaddr *)&servaddr, 
-			sizeof(servaddr)) < 0 ) 
+    if (bind(sockfd, (const struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)
     {
         perror("bind failed");
         exit(EXIT_FAILURE);
     }
 
     int len, n;
-	n = recvfrom(sockfd, (char *)buffer, MAXLINE, 
-				MSG_WAITALL, ( struct sockaddr *) &cliaddr, 
-				&len); 
+    n = recvfrom(sockfd, (char *)buffer, MAXLINE, MSG_WAITALL,
+                 (struct sockaddr *)&cliaddr, &len);
     buffer[n] = '\0';
     printf("Client : %s\n", buffer);
-	sendto(sockfd, (const char *)hello, strlen(hello), 
-		MSG_CONFIRM, (const struct sockaddr *) &cliaddr, 
-			len); 
+    sendto(sockfd, (const char *)hello, strlen(hello), MSG_CONFIRM,
+           (const struct sockaddr *)&cliaddr, len);
     printf("Hello message sent.\n");
 
     return 0;

client_server/client.c

@@ -1,11 +1,11 @@
 // Write CPP code here
+#include <arpa/inet.h>
 #include <netdb.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <unistd.h>
 #include <string.h>
 #include <sys/socket.h>
-#include <arpa/inet.h>
+#include <unistd.h>
 #define MAX 80
 #define PORT 8080
 #define SA struct sockaddr

client_server/server.c

@@ -1,11 +1,11 @@
 #include <netdb.h>
 #include <netinet/in.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <unistd.h>
-#include <stdio.h>
 #include <sys/socket.h>
 #include <sys/types.h>
+#include <unistd.h>
 #define MAX 80
 #define PORT 8080
 #define SA struct sockaddr
@@ -16,7 +16,8 @@ void func(int sockfd)
     char buff[MAX];
     int n;
     // infinite loop for chat
-    for (;;) { 
+    for (;;)
+    {
         bzero(buff, MAX);
 
         // read the message from client and copy it in buffer
@@ -33,7 +34,8 @@ void func(int sockfd)
         write(sockfd, buff, sizeof(buff));
 
         // if msg contains "Exit" then server exit and chat ended.
-        if (strncmp("exit", buff, 4) == 0) { 
+        if (strncmp("exit", buff, 4) == 0)
+        {
             printf("Server Exit...\n");
             break;
         }
@@ -48,7 +50,8 @@ int main()
 
     // socket create and verification
     sockfd = socket(AF_INET, SOCK_STREAM, 0);
-    if (sockfd == -1) { 
+    if (sockfd == -1)
+    {
         printf("socket creation failed...\n");
         exit(0);
     }
@@ -62,7 +65,8 @@ int main()
     servaddr.sin_port = htons(PORT);
 
     // Binding newly created socket to given IP and verification
-    if ((bind(sockfd, (SA*)&servaddr, sizeof(servaddr))) != 0) { 
+    if ((bind(sockfd, (SA *)&servaddr, sizeof(servaddr))) != 0)
+    {
         printf("socket bind failed...\n");
         exit(0);
     }
@@ -70,7 +74,8 @@ int main()
         printf("Socket successfully binded..\n");
 
     // Now server is ready to listen and verification
-    if ((listen(sockfd, 5)) != 0) { 
+    if ((listen(sockfd, 5)) != 0)
+    {
         printf("Listen failed...\n");
         exit(0);
     }
@@ -79,8 +84,9 @@ int main()
     len = sizeof(cli);
 
     // Accept the data packet from client and verification
-    connfd = accept(sockfd, (SA*)&cli, &len); 
-    if (connfd < 0) { 
+    connfd = accept(sockfd, (SA *)&cli, &len);
+    if (connfd < 0)
+    {
         printf("server acccept failed...\n");
         exit(0);
     }

conversions/binary_to_decimal.c

@@ -5,20 +5,21 @@
 
 #include <stdio.h>
 
-int main() {
+int main()
+{
 
     int remainder, number = 0, decimal_number = 0, temp = 1;
     printf("/n Enter any binary number= ");
     scanf("%d", &number);
 
     // Iterate over the number until the end.
-	while(number > 0) {
+    while (number > 0)
+    {
 
         remainder = number % 10;
         number = number / 10;
         decimal_number += remainder * temp;
-		temp = temp*2;		//used as power of 2
-	
+        temp = temp * 2; // used as power of 2
     }
 
     printf("%d\n", decimal_number);

conversions/binary_to_octal.c

@@ -1,14 +1,14 @@
 // Binary number to octal number conversion
-#include<stdio.h>
+#include <stdio.h>
 
-//Function that returns the last three digits
+// Function that returns the last three digits
 int three_digits(int n)
 {
-    int r, d = 0, p=1;
+    int r, d = 0, p = 1;
 
-    for(int i=0; i<3; i++)
+    for (int i = 0; i < 3; i++)
     {
-        r = n%10;
+        r = n % 10;
         d += r * p;
         p *= 10;
         n /= 10;
@@ -18,24 +18,26 @@ int three_digits(int n)
 
 int main(void)
 {
-    int binary_num, d=0, base=1, remainder, td, res=0, ord=1;
+    int binary_num, d = 0, base = 1, remainder, td, res = 0, ord = 1;
 
     printf("Enter the binary no: ");
     scanf("%d", &binary_num);
 
-    while(binary_num > 0)
+    while (binary_num > 0)
     {
-        if(binary_num > 111) //Checking if binary number is greater than three digits
+        if (binary_num >
+            111) // Checking if binary number is greater than three digits
             td = three_digits(binary_num);
 
-        else td = binary_num;
+        else
+            td = binary_num;
 
         binary_num /= 1000;
 
-        d = 0, base =1;
+        d = 0, base = 1;
 
         // Converting the last three digits to decimal
-        while(td > 0)
+        while (td > 0)
         {
             remainder = td % 10;
             td /= 10;

conversions/decimal_to_binary.c

@@ -17,13 +17,13 @@ int main()
 
     // for the loops
     int j;
-    int i=0;
+    int i = 0;
 
     printf("\t\tConverter decimal --> binary\n\n");
 
     // reads a decimal number from the user.
     printf("\nenter a positive integer number: ");
-    scanf("%d",&inputNumber);
+    scanf("%d", &inputNumber);
 
     // make sure the input number is a positive integer.
     if (inputNumber < 0)
@@ -33,7 +33,7 @@ int main()
     }
 
     // actual processing
-    while(inputNumber>0)
+    while (inputNumber > 0)
     {
 
         // computes the remainder by modulo 2
@@ -44,15 +44,14 @@ int main()
 
         bits[i] = re;
         i++;
-
     }
 
     printf("\n the number in binary is: ");
 
     // iterates backwards over all bits
-    for(j=i-1; j>=0; j--)
+    for (j = i - 1; j >= 0; j--)
     {
-        printf("%d",bits[j]);
+        printf("%d", bits[j]);
     }
 
     // for the case the input number is 0
@@ -63,4 +62,3 @@ int main()
 
     return 0;
 }
-

conversions/decimal_to_hexa.c

@@ -2,8 +2,8 @@
 #include <stdio.h>
 void decimal2Hexadecimal(long num);
 
- 
-int main(){
+int main()
+{
 
     long decimalnum;
 
@@ -12,20 +12,23 @@ int main(){
 
     decimal2Hexadecimal(decimalnum);
 
-return 0;
+    return 0;
 }
 
-/********function for convert decimal number to hexadecimal number****************/
-void decimal2Hexadecimal(long num){
+/********function for convert decimal number to hexadecimal
+ * number****************/
+void decimal2Hexadecimal(long num)
+{
 
-long decimalnum=num;
-long quotient, remainder;
-int i, j = 0;
-char hexadecimalnum[100];
+    long decimalnum = num;
+    long quotient, remainder;
+    int i, j = 0;
+    char hexadecimalnum[100];
 
     quotient = decimalnum;
 
-	while (quotient != 0){
+    while (quotient != 0)
+    {
 
         remainder = quotient % 16;
         if (remainder < 10)
@@ -34,13 +37,15 @@ char hexadecimalnum[100];
         else
             hexadecimalnum[j++] = 55 + remainder;
 
-			quotient = quotient / 16;}
+        quotient = quotient / 16;
+    }
 
     // print the hexadecimal number
 
-    for (i = j; i >= 0; i--){
-            printf("%c", hexadecimalnum[i]);}
+    for (i = j; i >= 0; i--)
+    {
+        printf("%c", hexadecimalnum[i]);
+    }
 
     printf("\n");
 }
-

conversions/decimal_to_octal.c

@@ -2,7 +2,8 @@
 #include <stdio.h>
 void decimal2Octal(long decimalnum);
 
-int main(){
+int main()
+{
 
     long decimalnum;
 
@@ -11,17 +12,19 @@ int main(){
 
     decimal2Octal(decimalnum);
 
-return 0;
+    return 0;
 }
 
 /********function for convert decimal numbers to octal numbers************/
-void decimal2Octal(long decimalnum){
+void decimal2Octal(long decimalnum)
+{
     long remainder, quotient;
 
     int octalNumber[100], i = 1, j;
     quotient = decimalnum;
 
-    while (quotient != 0){
+    while (quotient != 0)
+    {
         octalNumber[i++] = quotient % 8;
 
         quotient = quotient / 8;

conversions/decimal_to_octal_recursion.c

@@ -1,6 +1,6 @@
-//Program to convert decimal number to octal (Using Reccursion)
-//This program only works for integer decimals
-//Created by Aromal Anil
+// Program to convert decimal number to octal (Using Reccursion)
+// This program only works for integer decimals
+// Created by Aromal Anil
 
 #include <stdio.h>
 int decimal_to_octal(int decimal)

conversions/octal_to_decimal.c

@@ -2,15 +2,15 @@
 #include <stdio.h>
 
 // Converts octal number to decimal
-int convertValue(int num, int i) {
-    return num * pow(8, i);
-}
+int convertValue(int num, int i) { return num * pow(8, i); }
 
-long long toDecimal(int octal_value) {
+long long toDecimal(int octal_value)
+{
 
     int decimal_value = 0, i = 0;
 
-    while (octal_value) {
+    while (octal_value)
+    {
 
         // Extracts right-most digit and then multiplies by 8^i
         decimal_value += convertValue(octal_value % 10, i++);
@@ -22,7 +22,8 @@ long long toDecimal(int octal_value) {
     return decimal_value;
 }
 
-int main() {
+int main()
+{
 
     printf("Enter octal value: ");
 

conversions/to_decimal.c

@@ -2,10 +2,11 @@
  * convert from any base to decimal
  */
 
-#include <stdio.h>
 #include <ctype.h>
+#include <stdio.h>
 
-int main(void) {
+int main(void)
+{
     int base, i, j;
     char number[100];
     unsigned long decimal = 0;
@@ -15,7 +16,8 @@ int main(void) {
     printf("Enter the number: ");
     scanf("%s", &number[0]);
 
-	for (i = 0; number[i] != '\0'; i++) {
+    for (i = 0; number[i] != '\0'; i++)
+    {
         if (isdigit(number[i]))
             number[i] -= '0';
         else if (isupper(number[i]))
@@ -25,13 +27,15 @@ int main(void) {
         else
             number[i] = base + 1;
 
-		if (number[i] >= base){
+        if (number[i] >= base)
+        {
             printf("invalid number\n");
             return 0;
         }
     }
 
-	for (j = 0; j < i; j++) {
+    for (j = 0; j < i; j++)
+    {
         decimal *= base;
         decimal += number[j];
     }

data_structures/Array/CArray.c

@@ -13,33 +13,34 @@
  *
  */
 
- /*
- Return Codes
+/*
+Return Codes
 
- -1 - Array Erased
- 0 - Success
- 1 - Invalid Position
- 2 - Position already initialized (use update function)
- 3 - Position not initialized (use insert function)
- 4 - Position already empty
- 5 - Array is full
+-1 - Array Erased
+0 - Success
+1 - Invalid Position
+2 - Position already initialized (use update function)
+3 - Position not initialized (use insert function)
+4 - Position already empty
+5 - Array is full
 
- */
+*/
 
+#include "CArray.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
-#include "CArray.h"
 
 void swap(CArray *array, int position1, int position2);
 
-CArray * getCArray(int size)
+CArray *getCArray(int size)
 {
-	CArray *array = (CArray *) malloc(sizeof(CArray));
-	array->array = (int *) malloc(sizeof(int) * size);
+    CArray *array = (CArray *)malloc(sizeof(CArray));
+    array->array = (int *)malloc(sizeof(int) * size);
     array->size = size;
     int i;
-	for (i = 0; i < size; i++) {
+    for (i = 0; i < size; i++)
+    {
         array->array[i] = 0;
     }
     return array;
@@ -47,23 +48,29 @@ CArray * getCArray(int size)
 
 int insertValueCArray(CArray *array, int position, int value)
 {
-	if (position >= 0 && position < array->size) {
-		if (array->array[position] == 0) {
+    if (position >= 0 && position < array->size)
+    {
+        if (array->array[position] == 0)
+        {
             array->array[position] = value;
             return SUCCESS;
         }
-		else return POSITION_INIT; 
+        else
+            return POSITION_INIT;
     }
     return INVALID_POSITION;
 }
 
 int removeValueCArray(CArray *array, int position)
 {
-	if (position >= 0 && position < array->size) {
-		if (array->array[position] != 0) {
+    if (position >= 0 && position < array->size)
+    {
+        if (array->array[position] != 0)
+        {
             array->array[position] = 0;
         }
-		else return POSITION_EMPTY; 
+        else
+            return POSITION_EMPTY;
     }
     return INVALID_POSITION;
 }
@@ -72,25 +79,31 @@ int pushValueCArray(CArray *array, int value)
 {
     int i;
     int ok = 0;
-	for (i = 0; i < array->size; i++) {
-		if (array->array[i] == 0) {
+    for (i = 0; i < array->size; i++)
+    {
+        if (array->array[i] == 0)
+        {
             array->array[i] = value;
             ok = 1;
             break;
         }
     }
-	if (ok == 1) return SUCCESS;
-	else return ARRAY_FULL;
+    if (ok == 1)
+        return SUCCESS;
+    else
+        return ARRAY_FULL;
 }
 
 int updateValueCArray(CArray *array, int position, int value)
 {
-	if (position >= 0 && position < array->size) {
-		if (array->array[position] != 0) {
-
+    if (position >= 0 && position < array->size)
+    {
+        if (array->array[position] != 0)
+        {
         }
 
-		else return POSITION_NOT_INIT;
+        else
+            return POSITION_NOT_INIT;
     }
     return INVALID_POSITION;
 }
@@ -98,7 +111,8 @@ int updateValueCArray(CArray *array, int position, int value)
 int eraseCArray(CArray *array)
 {
     int i;
-	for (i = 0; i < array->size; i++) {
+    for (i = 0; i < array->size; i++)
+    {
         array->array[i] = 0;
     }
     return 0;
@@ -106,8 +120,9 @@ int eraseCArray(CArray *array)
 
 int switchValuesCArray(CArray *array, int position1, int position2)
 {
-	if (position1 >= 0 && position1 < array->size 
-		&& position2 >= 0 && position2 < array->size) {
+    if (position1 >= 0 && position1 < array->size && position2 >= 0 &&
+        position2 < array->size)
+    {
         int temp = array->array[position1];
         array->array[position1] = array->array[position2];
         array->array[position2] = temp;
@@ -118,7 +133,8 @@ int switchValuesCArray(CArray *array, int position1, int position2)
 int reverseCArray(CArray *array)
 {
     int i;
-	for (i = 0; i < array->size / 2; i++) {
+    for (i = 0; i < array->size / 2; i++)
+    {
         swap(array, i, array->size - i - 1);
     }
     return SUCCESS;
@@ -128,7 +144,8 @@ int displayCArray(CArray *array)
 {
     int i;
     printf("\nC ARRAY\n");
-	for (i = 0; i < array->size; i++) {
+    for (i = 0; i < array->size; i++)
+    {
         printf("%d ", array->array[i]);
     }
     printf("\n");
@@ -140,19 +157,21 @@ int blenderCArray(CArray *array)
     srand(time(NULL) * array->size);
     int i;
     int total = array->size * 100;
-	for (i = 0; i < total; i++) {
+    for (i = 0; i < total; i++)
+    {
         swap(array, rand() % array->size, rand() % array->size);
     }
     return 0;
 }
 
-CArray * getCopyCArray(CArray *arr)
+CArray *getCopyCArray(CArray *arr)
 {
     CArray *array = (CArray *)malloc(sizeof(CArray));
     array->array = (int *)malloc(sizeof(int) * arr->size);
     array->size = arr->size;
     int i;
-	for (i = 0; i < arr->size; i++) {
+    for (i = 0; i < arr->size; i++)
+    {
         array->array[i] = arr->array[i];
     }
     return array;
@@ -168,9 +187,12 @@ void swap(CArray *array, int position1, int position2)
 int bubbleSortCArray(CArray *array)
 {
     int i, j;
-	for (i = 0; i < array->size - 1; i++) {
-		for (j = 0; j < array->size - i - 1; j++) {
-			if (array->array[j] > array->array[j + 1]) {
+    for (i = 0; i < array->size - 1; i++)
+    {
+        for (j = 0; j < array->size - i - 1; j++)
+        {
+            if (array->array[j] > array->array[j + 1])
+            {
                 swap(array, j, j + 1);
             }
         }
@@ -181,10 +203,12 @@ int bubbleSortCArray(CArray *array)
 int selectionSortCArray(CArray *array)
 {
     int i, j, min;
-	for (i = 0; i < array->size - 1; i++) {
+    for (i = 0; i < array->size - 1; i++)
+    {
         min = i;
         for (j = i + 1; j < array->size; j++)
-			if (array->array[j] < array->array[min]) min = j;
+            if (array->array[j] < array->array[min])
+                min = j;
         swap(array, min, i);
     }
     return 0;
@@ -193,7 +217,8 @@ int selectionSortCArray(CArray *array)
 int insertionSortCArray(CArray *array)
 {
     int i, j, num;
-	for (i = 1; i < array->size; i++) {
+    for (i = 1; i < array->size; i++)
+    {
         num = array->array[i];
         j = i - 1;
         while (j >= 0 && array->array[j] > num)
@@ -209,19 +234,23 @@ int insertionSortCArray(CArray *array)
 int valueOcurranceCArray(CArray *array, int value)
 {
     int i, total = 0;
-	for (i = 0; i < array->size; i++) {
-		if (array->array[i] == value) total++;
+    for (i = 0; i < array->size; i++)
+    {
+        if (array->array[i] == value)
+            total++;
     }
     return total;
 }
 
-CArray * valuePositionsCArray(CArray *array, int value)
+CArray *valuePositionsCArray(CArray *array, int value)
 {
     int i, j = 0;
     int total = valueOcurranceCArray(array, value);
     CArray *resultArray = getCArray(total);
-	for (i = 0; i < array->size; i++) {
-		if (array->array[i] == value) {
+    for (i = 0; i < array->size; i++)
+    {
+        if (array->array[i] == value)
+        {
             // Hopefully this won't overflow
             resultArray->array[j] = i;
             j++;
@@ -234,8 +263,10 @@ int findMinCArray(CArray *array)
 {
     int i;
     int min = array->array[0];
-	for (i = 1; i < array->size; i++) {
-		if (array->array[i] < min) {
+    for (i = 1; i < array->size; i++)
+    {
+        if (array->array[i] < min)
+        {
             min = array->array[i];
         }
     }
@@ -246,8 +277,10 @@ int findMaxCArray(CArray *array)
 {
     int i;
     int max = array->array[0];
-	for (i = 1; i < array->size; i++) {
-		if (array->array[i] > max) {
+    for (i = 1; i < array->size; i++)
+    {
+        if (array->array[i] > max)
+        {
             max = array->array[i];
         }
     }

data_structures/Array/CArray.h

@@ -16,18 +16,20 @@
 #pragma once
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-	#define ARRAY_ERASED -1
-	#define SUCCESS 0
-	#define INVALID_POSITION 1
-	#define POSITION_INIT 2
-	#define POSITION_NOT_INIT 3
-	#define POSITION_EMPTY 4
-	#define ARRAY_FULL 5
+#define ARRAY_ERASED -1
+#define SUCCESS 0
+#define INVALID_POSITION 1
+#define POSITION_INIT 2
+#define POSITION_NOT_INIT 3
+#define POSITION_EMPTY 4
+#define ARRAY_FULL 5
 
-	typedef struct CArray {
+    typedef struct CArray
+    {
         int *array;
         int size;
     } CArray;
@@ -35,8 +37,8 @@ extern "C" {
     // +-------------------------------------+
     // |           Returns array             |
     // +-------------------------------------+
-	CArray * getCArray(int size);
-	CArray * getCopyCArray(CArray *array);
+    CArray *getCArray(int size);
+    CArray *getCopyCArray(CArray *array);
 
     // +-------------------------------------+
     // |           Input / Output            |
@@ -69,7 +71,7 @@ extern "C" {
     // |             Searching               |
     // +-------------------------------------+
     int valueOcurranceCArray(CArray *array, int value);
-	CArray * valuePositionsCArray(CArray *array, int value);
+    CArray *valuePositionsCArray(CArray *array, int value);
     int findMaxCArray(CArray *array);
     int findMinCArray(CArray *array);
 
@@ -78,7 +80,6 @@ extern "C" {
     // +-------------------------------------+
     int displayCArray(CArray *array);
 
-
 #ifdef __cplusplus
 }
 #endif

data_structures/Array/CArrayTests.c

@@ -13,10 +13,10 @@
  *
  */
 
+#include "CArray.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
-#include "CArray.h"
 
 int CArrayTests()
 {
@@ -31,14 +31,16 @@ int CArrayTests()
     CArray *array = getCArray(10);
 
     int i;
-	for (i = 0; i < array->size; i++) {
-		insertValueCArray(array, i, i+1);
+    for (i = 0; i < array->size; i++)
+    {
+        insertValueCArray(array, i, i + 1);
     }
     printf("Entered array is:\n");
     displayCArray(array);
     printf("\nCode: %d\n", pushValueCArray(array, 11)); // 5
 
-	for (i = 0; i < array->size; i++) {
+    for (i = 0; i < array->size; i++)
+    {
         removeValueCArray(array, i);
     }
 
@@ -48,7 +50,8 @@ int CArrayTests()
     printf("\nCode: %d\n", insertValueCArray(array, -1, 1)); // 1
 
     // Erase
-	for (i = 0; i < array->size; i++) {
+    for (i = 0; i < array->size; i++)
+    {
         insertValueCArray(array, i, i + 1);
     }
     eraseCArray(array);
@@ -56,11 +59,13 @@ int CArrayTests()
 
     // Switching
     CArray *arr = getCArray(13);
-	for (i = 0; i < arr->size; i++) {
+    for (i = 0; i < arr->size; i++)
+    {
         insertValueCArray(arr, i, i + 1);
     }
     displayCArray(arr);
-	for (i = 0; i < arr->size / 2; i++) {
+    for (i = 0; i < arr->size / 2; i++)
+    {
         switchValuesCArray(arr, i, arr->size - i - 1);
     }
 
@@ -74,7 +79,8 @@ int CArrayTests()
     // Sorting
     srand(time(NULL));
     CArray *barray = getCArray(20);
-	for (i = 0; i < barray->size; i++) {
+    for (i = 0; i < barray->size; i++)
+    {
         insertValueCArray(barray, i, rand());
     }
     CArray *carray = getCopyCArray(barray);
@@ -110,9 +116,9 @@ int CArrayTests()
     reverseCArray(barray);
     // displayCArray(barray);
 
-//	printf("\nBlender:");
-//	blenderCArray(barray);
-//	displayCArray(barray);
+    //	printf("\nBlender:");
+    //	blenderCArray(barray);
+    //	displayCArray(barray);
 
     printf("\nTotal time spent for bubble sort: %lf seconds", time_spent1);
     printf("\nTotal time spent for selection sort: %lf seconds", time_spent2);
@@ -120,7 +126,8 @@ int CArrayTests()
 
     // Searching
     CArray *aarray = getCArray(1000);
-	for (i = 0; i < aarray->size; i++) {
+    for (i = 0; i < aarray->size; i++)
+    {
         insertValueCArray(aarray, i, rand() % 100);
     }
 
@@ -132,9 +139,10 @@ int CArrayTests()
     displayCArray(positions);
     // This should all give value of j
     printf("\nAll %d s", j);
-	for (i = 0; i < positions->size; i++) {
-		printf("\nPosition %d has a value of %d", 
-			positions->array[i], aarray->array[positions->array[i]]);
+    for (i = 0; i < positions->size; i++)
+    {
+        printf("\nPosition %d has a value of %d", positions->array[i],
+               aarray->array[positions->array[i]]);
     }
     printf("\nThe list has a minimum value of %d and a maximum value of %d",
            findMinCArray(aarray), findMaxCArray(aarray));

data_structures/binary_trees/avl.c

@@ -10,16 +10,13 @@ struct AVLnode
 };
 typedef struct AVLnode avlNode;
 
-int max(int a, int b)
-{
-	return (a > b)? a : b;
-}
+int max(int a, int b) { return (a > b) ? a : b; }
 
 avlNode *newNode(int key)
 {
-	avlNode *node = (avlNode*)malloc(sizeof(avlNode));
+    avlNode *node = (avlNode *)malloc(sizeof(avlNode));
 
-	if(node == NULL)
+    if (node == NULL)
         printf("!! Out of Space !!\n");
     else
     {
@@ -34,18 +31,18 @@ avlNode *newNode(int key)
 
 int nodeHeight(avlNode *node)
 {
-	if(node == NULL)
+    if (node == NULL)
         return -1;
     else
-		return(node->height);
+        return (node->height);
 }
 
 int heightDiff(avlNode *node)
 {
-	if(node == NULL)
+    if (node == NULL)
         return 0;
     else
-		return(nodeHeight(node->left) - nodeHeight(node->right));
+        return (nodeHeight(node->left) - nodeHeight(node->right));
 }
 
 /* Returns the node with min key in the left subtree*/
@@ -53,7 +50,7 @@ avlNode *minNode(avlNode *node)
 {
     avlNode *temp = node;
 
-	while(temp->left != NULL)
+    while (temp->left != NULL)
         temp = temp->left;
 
     return temp;
@@ -62,17 +59,17 @@ avlNode *minNode(avlNode *node)
 void printAVL(avlNode *node, int level)
 {
     int i;
-	if(node!=NULL)
+    if (node != NULL)
     {
-		printAVL(node->right, level+1);
+        printAVL(node->right, level + 1);
         printf("\n\n");
 
-		for(i=0; i<level; i++)
+        for (i = 0; i < level; i++)
             printf("\t");
 
         printf("%d", node->key);
 
-		printAVL(node->left, level+1);
+        printAVL(node->left, level + 1);
     }
 }
 
@@ -121,67 +118,67 @@ avlNode *RightLeftRotate(avlNode *z)
 avlNode *insert(avlNode *node, int key)
 {
 
-	if(node == NULL)
+    if (node == NULL)
         return (newNode(key));
 
     /*Binary Search Tree insertion*/
 
-	if(key < node->key)
-		node->left = insert(node->left, key);		/*Recursive insertion in L subtree*/
-	else if(key > node->key)
-		node->right = insert(node->right, key); 	/*Recursive insertion in R subtree*/
+    if (key < node->key)
+        node->left =
+            insert(node->left, key); /*Recursive insertion in L subtree*/
+    else if (key > node->key)
+        node->right =
+            insert(node->right, key); /*Recursive insertion in R subtree*/
 
     /* Node  Height as per the AVL formula*/
     node->height = (max(nodeHeight(node->left), nodeHeight(node->right)) + 1);
 
-
     /*Checking for the balance condition*/
     int balance = heightDiff(node);
 
     /*Left Left */
-	if(balance>1 && key < (node->left->key))
+    if (balance > 1 && key < (node->left->key))
         return rightRotate(node);
 
     /*Right Right */
-	if(balance<-1 && key > (node->right->key))
+    if (balance < -1 && key > (node->right->key))
         return leftRotate(node);
 
     /*Left Right */
-	if (balance>1 && key > (node->left->key))
+    if (balance > 1 && key > (node->left->key))
     {
         node = LeftRightRotate(node);
     }
 
     /*Right Left */
-	if (balance<-1 && key < (node->right->key))
+    if (balance < -1 && key < (node->right->key))
     {
         node = RightLeftRotate(node);
     }
 
     return node;
-
 }
 
-avlNode *delete(avlNode *node, int queryNum)
+avlNode *delete (avlNode *node, int queryNum)
 {
-	if(node == NULL)
+    if (node == NULL)
         return node;
 
-	if(queryNum < node->key)
-		node->left = delete(node->left, queryNum);			/*Recursive deletion in L subtree*/
-	else if(queryNum > node->key)
-		node->right = delete(node->right, queryNum);		/*Recursive deletion in R subtree*/
+    if (queryNum < node->key)
+        node->left =
+            delete (node->left, queryNum); /*Recursive deletion in L subtree*/
+    else if (queryNum > node->key)
+        node->right =
+            delete (node->right, queryNum); /*Recursive deletion in R subtree*/
     else
     {
         /*Single or No Child*/
-		if((node->left == NULL) || (node->right==NULL))
+        if ((node->left == NULL) || (node->right == NULL))
         {
-			avlNode *temp = node->left ?
-										node->left :
-										node->right;
+            avlNode *temp = node->left ? node->left : node->right;
 
             /* No Child*/
-			if(temp == NULL)
+            if (temp == NULL)
             {
                 temp = node;
                 node = NULL;
@@ -198,51 +195,51 @@ avlNode *delete(avlNode *node, int queryNum)
             /*Get the smallest key in the R subtree*/
             avlNode *temp = minNode(node->right);
             node->key = temp->key; /*Copy that to the root*/
-			node->right = delete(node->right, temp->key); /*Delete the smallest in the R subtree.*/
+            node->right =
+                delete (node->right,
+                        temp->key); /*Delete the smallest in the R subtree.*/
         }
     }
 
     /*single node in tree*/
-	if(node == NULL)
+    if (node == NULL)
         return node;
 
-
     /*Update height*/
     node->height = (max(nodeHeight(node->left), nodeHeight(node->right)) + 1);
 
     int balance = heightDiff(node);
 
     /*Left Left */
-	if((balance>1) && (heightDiff(node->left) >= 0))
+    if ((balance > 1) && (heightDiff(node->left) >= 0))
         return rightRotate(node);
 
     /*Left Right */
-	if ((balance>1) && (heightDiff(node->left) < 0))
+    if ((balance > 1) && (heightDiff(node->left) < 0))
     {
         node = LeftRightRotate(node);
     }
 
     /*Right Right */
-	if((balance<-1) && (heightDiff(node->right) >= 0))
+    if ((balance < -1) && (heightDiff(node->right) >= 0))
         return leftRotate(node);
 
     /*Right Left */
-	if ((balance<-1) && (heightDiff(node->right) < 0))
+    if ((balance < -1) && (heightDiff(node->right) < 0))
     {
         node = RightLeftRotate(node);
     }
 
     return node;
-
 }
 
 avlNode *findNode(avlNode *node, int queryNum)
 {
-	if(node!=NULL)
+    if (node != NULL)
     {
-		if(queryNum < node->key)
+        if (queryNum < node->key)
             node = findNode(node->left, queryNum);
-		else if(queryNum > node->key)
+        else if (queryNum > node->key)
             node = findNode(node->right, queryNum);
     }
 
@@ -251,7 +248,7 @@ avlNode *findNode(avlNode *node, int queryNum)
 
 void printPreOrder(avlNode *node)
 {
-	if(node == NULL)
+    if (node == NULL)
         return;
 
     printf("  %d  ", (node->key));
@@ -261,7 +258,7 @@ void printPreOrder(avlNode *node)
 
 void printInOrder(avlNode *node)
 {
-	if(node == NULL)
+    if (node == NULL)
         return;
     printInOrder(node->left);
     printf("  %d  ", (node->key));
@@ -270,7 +267,7 @@ void printInOrder(avlNode *node)
 
 void printPostOrder(avlNode *node)
 {
-	if(node == NULL)
+    if (node == NULL)
         return;
     printPostOrder(node->left);
     printPostOrder(node->right);
@@ -280,14 +277,14 @@ void printPostOrder(avlNode *node)
 int main()
 {
     int choice;
-	int flag=1;
+    int flag = 1;
     int insertNum;
     int queryNum;
 
     avlNode *root = NULL;
     avlNode *tempNode;
 
-	while(flag == 1)
+    while (flag == 1)
     {
         printf("\n\nEnter the Step to Run : \n");
 
@@ -302,11 +299,11 @@ int main()
         printf("\t0: EXIT\n");
         scanf("%d", &choice);
 
-		switch(choice)
+        switch (choice)
         {
         case 0:
         {
-					flag=0;
+            flag = 0;
             printf("\n\t\tExiting, Thank You !!\n");
             break;
         }
@@ -319,7 +316,7 @@ int main()
 
             tempNode = findNode(root, insertNum);
 
-					if(tempNode!=NULL)
+            if (tempNode != NULL)
                 printf("\n\t %d Already exists in the tree\n", insertNum);
             else
             {
@@ -343,14 +340,14 @@ int main()
 
             tempNode = findNode(root, queryNum);
 
-					if(tempNode==NULL)
+            if (tempNode == NULL)
                 printf("\n\t %d Does not exist in the tree\n", queryNum);
             else
             {
                 printf("\n\tPrinting AVL Tree\n");
                 printAVL(root, 1);
                 printf("\n");
-						root = delete(root, queryNum);
+                root = delete (root, queryNum);
 
                 printf("\n\tPrinting AVL Tree\n");
                 printAVL(root, 1);
@@ -367,12 +364,12 @@ int main()
 
             tempNode = findNode(root, queryNum);
 
-
-					if(tempNode == NULL)
+            if (tempNode == NULL)
                 printf("\n\t %d : Not Found\n", queryNum);
             else
             {
-						printf("\n\t %d : Found at height %d \n", queryNum, tempNode->height);
+                printf("\n\t %d : Found at height %d \n", queryNum,
+                       tempNode->height);
 
                 printf("\n\tPrinting AVL Tree\n");
                 printAVL(root, 1);
@@ -416,16 +413,12 @@ int main()
 
         default:
         {
-					flag=0;
+            flag = 0;
             printf("\n\t\tExiting, Thank You !!\n");
             break;
         }
-
         }
-
-
     }
 
-
     return 0;
 }

data_structures/binary_trees/binary_search_tree.c

@@ -1,7 +1,8 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-/* A basic unbalanced binary search tree implementation in C, with the following functionalities implemented:
+/* A basic unbalanced binary search tree implementation in C, with the following
+ functionalities implemented:
  - Insertion
  - Deletion
  - Search by key value
@@ -9,23 +10,26 @@
 */
 
 // Node, the basic data structure in the tree
-typedef struct node{
+typedef struct node
+{
 
     // left child
-	struct node* left;
+    struct node *left;
 
     // right child
-	struct node* right;
+    struct node *right;
 
     // data of the node
     int data;
 } node;
 
-// The node constructor, which receives the key value input and returns a node pointer
-node* newNode(int data){
+// The node constructor, which receives the key value input and returns a node
+// pointer
+node *newNode(int data)
+{
 
     // creates a slug
-	node* tmp = (node*)malloc(sizeof(node));
+    node *tmp = (node *)malloc(sizeof(node));
 
     // initializes the slug
     tmp->data = data;
@@ -36,14 +40,17 @@ node* newNode(int data){
 }
 
 // Insertion procedure, which inserts the input key in a new node in the tree
-node* insert(node* root, int data){
+node *insert(node *root, int data)
+{
     // If the root of the subtree is null, insert key here
     if (root == NULL)
         root = newNode(data);
-	// If it isn't null and the input key is greater than the root key, insert in the right leaf
+    // If it isn't null and the input key is greater than the root key, insert
+    // in the right leaf
     else if (data > root->data)
         root->right = insert(root->right, data);
-	// If it isn't null and the input key is lower than the root key, insert in the left leaf
+    // If it isn't null and the input key is lower than the root key, insert in
+    // the left leaf
     else if (data < root->data)
         root->left = insert(root->left, data);
     // Returns the modified tree
@@ -51,7 +58,8 @@ node* insert(node* root, int data){
 }
 
 // Utilitary procedure to find the greatest key in the left subtree
-node* getMax(node* root){
+node *getMax(node *root)
+{
     // If there's no leaf to the right, then this is the maximum key value
     if (root->right == NULL)
         return root;
@@ -59,54 +67,66 @@ node* getMax(node* root){
         root->right = getMax(root->right);
 }
 
-// Deletion procedure, which searches for the input key in the tree and removes it if present
-node* delete(node* root, int data){
+// Deletion procedure, which searches for the input key in the tree and removes
+// it if present
+node *delete (node *root, int data)
+{
     // If the root is null, nothing to be done
     if (root == NULL)
         return root;
     // If the input key is greater than the root's, search in the right subtree
     else if (data > root->data)
-		root->right = delete(root->right, data);
+        root->right = delete (root->right, data);
     // If the input key is lower than the root's, search in the left subtree
     else if (data < root->data)
-		root->left = delete(root->left, data);
+        root->left = delete (root->left, data);
     // If the input key matches the root's, check the following cases
     // termination condition
-	else if (data == root->data){
+    else if (data == root->data)
+    {
         // Case 1: the root has no leaves, remove the node
-		if ((root->left == NULL) && (root->right == NULL)){
+        if ((root->left == NULL) && (root->right == NULL))
+        {
             free(root);
             return NULL;
         }
-		// Case 2: the root has one leaf, make the leaf the new root and remove the old root
-		else if (root->left == NULL){
-			node* tmp = root;
+        // Case 2: the root has one leaf, make the leaf the new root and remove
+        // the old root
+        else if (root->left == NULL)
+        {
+            node *tmp = root;
             root = root->right;
             free(tmp);
             return root;
         }
-		else if (root->right == NULL){
-			node* tmp = root;
+        else if (root->right == NULL)
+        {
+            node *tmp = root;
             root = root->left;
             free(tmp);
             return root;
         }
-		// Case 3: the root has 2 leaves, find the greatest key in the left subtree and switch with the root's
-		else {
+        // Case 3: the root has 2 leaves, find the greatest key in the left
+        // subtree and switch with the root's
+        else
+        {
 
             // finds the biggest node in the left branch.
-			node* tmp = getMax(root->left);
+            node *tmp = getMax(root->left);
 
-			// sets the data of this node equal to the data of the biggest node (lefts)
+            // sets the data of this node equal to the data of the biggest node
+            // (lefts)
             root->data = tmp->data;
-			root->left = delete(root->left, tmp->data);
+            root->left = delete (root->left, tmp->data);
         }
     }
     return root;
 }
 
-// Search procedure, which looks for the input key in the tree and returns 1 if it's present or 0 if it's not in the tree
-int find(node* root, int data){
+// Search procedure, which looks for the input key in the tree and returns 1 if
+// it's present or 0 if it's not in the tree
+int find(node *root, int data)
+{
     // If the root is null, the key's not present
     if (root == NULL)
         return 0;
@@ -122,16 +142,20 @@ int find(node* root, int data){
 }
 
 // Utilitary procedure to measure the height of the binary tree
-int height(node* root){
+int height(node *root)
+{
     // If the root is null, this is the bottom of the tree (height 0)
     if (root == NULL)
         return 0;
-	else{
-		// Get the height from both left and right subtrees to check which is the greatest
+    else
+    {
+        // Get the height from both left and right subtrees to check which is
+        // the greatest
         int right_h = height(root->right);
         int left_h = height(root->left);
 
-		// The final height is the height of the greatest subtree(left or right) plus 1(which is the root's level)
+        // The final height is the height of the greatest subtree(left or right)
+        // plus 1(which is the root's level)
         if (right_h > left_h)
             return (right_h + 1);
         else
@@ -140,8 +164,10 @@ int height(node* root){
 }
 
 // Utilitary procedure to free all nodes in a tree
-void purge(node* root){
-	if (root != NULL){
+void purge(node *root)
+{
+    if (root != NULL)
+    {
         if (root->left != NULL)
             purge(root->left);
         if (root->right != NULL)
@@ -150,53 +176,67 @@ void purge(node* root){
     }
 }
 
-// Traversal procedure to list the current keys in the tree in order of value (from the left to the right)
-void inOrder(node* root){
-	if(root != NULL){
+// Traversal procedure to list the current keys in the tree in order of value
+// (from the left to the right)
+void inOrder(node *root)
+{
+    if (root != NULL)
+    {
         inOrder(root->left);
         printf("\t[ %d ]\t", root->data);
         inOrder(root->right);
     }
 }
 
-void main(){
+void main()
+{
 
     // this reference don't change.
     // only the tree changes.
-	node* root = NULL;
+    node *root = NULL;
     int opt = -1;
     int data = 0;
 
     // event-loop.
-	while (opt != 0){
-		printf("\n\n[1] Insert Node\n[2] Delete Node\n[3] Find a Node\n[4] Get current Height\n[5] Print Tree in Crescent Order\n[0] Quit\n");
-		scanf("%d",&opt); // reads the choice of the user
+    while (opt != 0)
+    {
+        printf("\n\n[1] Insert Node\n[2] Delete Node\n[3] Find a Node\n[4] Get "
+               "current Height\n[5] Print Tree in Crescent Order\n[0] Quit\n");
+        scanf("%d", &opt); // reads the choice of the user
 
         // processes the choice
-		switch(opt){
-			case 1:	printf("Enter the new node's value:\n");
-				scanf("%d",&data);
-				root = insert(root,data);
+        switch (opt)
+        {
+        case 1:
+            printf("Enter the new node's value:\n");
+            scanf("%d", &data);
+            root = insert(root, data);
             break;
 
-			case 2: printf("Enter the value to be removed:\n");
-				if (root != NULL){
-					scanf("%d",&data);
-					root = delete(root,data);
+        case 2:
+            printf("Enter the value to be removed:\n");
+            if (root != NULL)
+            {
+                scanf("%d", &data);
+                root = delete (root, data);
             }
             else
                 printf("Tree is already empty!\n");
             break;
 
-			case 3: printf("Enter the searched value:\n");
-				scanf("%d",&data);
-				find(root,data) ? printf("The value is in the tree.\n") : printf("The value is not in the tree.\n");
+        case 3:
+            printf("Enter the searched value:\n");
+            scanf("%d", &data);
+            find(root, data) ? printf("The value is in the tree.\n")
+                             : printf("The value is not in the tree.\n");
             break;
 
-			case 4: printf("Current height of the tree is: %d\n", height(root));
+        case 4:
+            printf("Current height of the tree is: %d\n", height(root));
             break;
 
-			case 5: inOrder(root);
+        case 5:
+            inOrder(root);
             break;
         }
     }

data_structures/binary_trees/recursive_traversals.c

@@ -7,7 +7,7 @@
 
 void inOrderTraversal(struct node *node)
 {
-    if(node == NULL) //if tree is empty
+    if (node == NULL) // if tree is empty
         return;
 
     inOrderTraversal(node->leftNode);
@@ -17,7 +17,7 @@ void inOrderTraversal(struct node *node)
 
 void preOrderTraversal(struct node *node)
 {
-    if(node == NULL) //if tree is empty
+    if (node == NULL) // if tree is empty
         return;
 
     printf("\t%d\t", node->data);
@@ -27,12 +27,12 @@ void preOrderTraversal(struct node *node)
 
 void postOrderTraversal(struct node *node)
 {
-    if(node == NULL) //if tree is empty
+    if (node == NULL) // if tree is empty
         return;
 
     postOrderTraversal(node->leftNode);
     postOrderTraversal(node->rightNode);
-    printf("\t%d\t",node->data);
+    printf("\t%d\t", node->data);
 }
 
 int main(void)

data_structures/binary_trees/redBlackTree.c

@@ -1,18 +1,20 @@
+#include <math.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <math.h>
 
-typedef struct node{
+typedef struct node
+{
     int val;
-    struct node* par;
-    struct node* left;
-    struct node* right;
+    struct node *par;
+    struct node *left;
+    struct node *right;
     int color;
-}Node;
+} Node;
 
 // Create a new node
-Node* newNode(int val, Node* par){
-    Node* create = (Node*)(malloc(sizeof(Node)));
+Node *newNode(int val, Node *par)
+{
+    Node *create = (Node *)(malloc(sizeof(Node)));
     create->val = val;
     create->par = par;
     create->left = NULL;
@@ -21,30 +23,37 @@ Node* newNode(int val, Node* par){
 }
 
 // Check if the node is the leaf
-int isLeaf(Node* n){
-    if(n->left == NULL && n->right == NULL){
+int isLeaf(Node *n)
+{
+    if (n->left == NULL && n->right == NULL)
+    {
         return 1;
     }
     return 0;
 }
 
 // Left Rotate
-Node* leftRotate(Node* node){
-    Node* parent = node->par;
-    Node* grandParent = parent->par;
+Node *leftRotate(Node *node)
+{
+    Node *parent = node->par;
+    Node *grandParent = parent->par;
 
     parent->right = node->left;
-    if(node->left != NULL){
+    if (node->left != NULL)
+    {
         node->left->par = parent;
     }
     node->par = grandParent;
     parent->par = node;
     node->left = parent;
-    if(grandParent != NULL){
-        if(grandParent->right == parent){
+    if (grandParent != NULL)
+    {
+        if (grandParent->right == parent)
+        {
             grandParent->right = node;
         }
-        else{
+        else
+        {
             grandParent->left = node;
         }
     }
@@ -52,73 +61,86 @@ Node* leftRotate(Node* node){
 }
 
 // Right Rotate
-Node* rightRotate(Node* node){
-    Node* parent = node->par;
-    Node* grandParent = parent->par;
+Node *rightRotate(Node *node)
+{
+    Node *parent = node->par;
+    Node *grandParent = parent->par;
 
     parent->left = node->right;
-    if(node->right != NULL){
+    if (node->right != NULL)
+    {
         node->right->par = parent;
     }
     node->par = grandParent;
     parent->par = node;
     node->right = parent;
-    if(grandParent != NULL){
-        if(grandParent->right == parent){
+    if (grandParent != NULL)
+    {
+        if (grandParent->right == parent)
+        {
             grandParent->right = node;
         }
-        else{
+        else
+        {
             grandParent->left = node;
         }
     }
     return node;
 }
 
-
 // Check the node after the insertion step
-void checkNode(Node* node){
+void checkNode(Node *node)
+{
 
     // If the node is the root
-    if(node == NULL || node->par == NULL){
+    if (node == NULL || node->par == NULL)
+    {
         return;
     }
-    Node* child = node;
-    //If it is a black node or its parent is a black node
-    if(node->color == 0 || (node->par)->color == 0){
+    Node *child = node;
+    // If it is a black node or its parent is a black node
+    if (node->color == 0 || (node->par)->color == 0)
+    {
         // Dont Do Anything
         return;
     }
 
     // Both parent and child are red
     // Check For Uncle
-    Node* parent = node->par;
-    Node* grandParent = parent->par;
+    Node *parent = node->par;
+    Node *grandParent = parent->par;
 
     // If grandParent is NULL, then parent is the root.
     // Just make the root black.
-    if(grandParent == NULL){
+    if (grandParent == NULL)
+    {
         parent->color = 0;
         return;
     }
 
-
     // If both the children of the grandParent are red
-    if(grandParent->right != NULL && (grandParent->right)->color == 1 && grandParent->left != NULL && (grandParent->left)->color == 1){
+    if (grandParent->right != NULL && (grandParent->right)->color == 1 &&
+        grandParent->left != NULL && (grandParent->left)->color == 1)
+    {
         // Make the grandParent red and both of its children black
         (grandParent->right)->color = 0;
         (grandParent->left)->color = 0;
         grandParent->color = 1;
         return;
     }
-    else{
+    else
+    {
         // The only option left is rotation.
-        Node* greatGrandParent = grandParent->par;
+        Node *greatGrandParent = grandParent->par;
         // Right Case
-        if(grandParent->right == parent){
-            //Right Right Case
-            if(parent->right == node){
+        if (grandParent->right == parent)
+        {
+            // Right Right Case
+            if (parent->right == node)
+            {
                 grandParent->right = parent->left;
-                if(parent->left != NULL){
+                if (parent->left != NULL)
+                {
                     (parent->left)->par = grandParent;
                 }
                 parent->left = grandParent;
@@ -126,11 +148,15 @@ void checkNode(Node* node){
 
                 // Attach to existing Tree;
                 parent->par = greatGrandParent;
-                if(greatGrandParent != NULL){
-                    if(greatGrandParent->left != NULL && greatGrandParent->left == grandParent){
+                if (greatGrandParent != NULL)
+                {
+                    if (greatGrandParent->left != NULL &&
+                        greatGrandParent->left == grandParent)
+                    {
                         greatGrandParent->left = parent;
                     }
-                    else{
+                    else
+                    {
                         greatGrandParent->right = parent;
                     }
                 }
@@ -139,10 +165,12 @@ void checkNode(Node* node){
                 parent->color = 0;
                 grandParent->color = 1;
             }
-            else{   // Right Left Case
+            else
+            { // Right Left Case
                 // First step -> Parent Child Rotation
                 parent->left = child->right;
-                if(child->right != NULL){
+                if (child->right != NULL)
+                {
                     (child->right)->par = parent;
                 }
                 child->right = parent;
@@ -150,7 +178,8 @@ void checkNode(Node* node){
 
                 // Second step -> Child and GrandParent Rotation
                 grandParent->right = child->left;
-                if(child->left != NULL){
+                if (child->left != NULL)
+                {
                     (child->left)->par = grandParent;
                 }
                 child->left = grandParent;
@@ -158,11 +187,15 @@ void checkNode(Node* node){
 
                 // Attach to the existing tree
                 child->par = greatGrandParent;
-                if(greatGrandParent != NULL){
-                    if(greatGrandParent->left != NULL && greatGrandParent->left == grandParent){
+                if (greatGrandParent != NULL)
+                {
+                    if (greatGrandParent->left != NULL &&
+                        greatGrandParent->left == grandParent)
+                    {
                         greatGrandParent->left = child;
                     }
-                    else{
+                    else
+                    {
                         greatGrandParent->right = child;
                     }
                 }
@@ -172,11 +205,14 @@ void checkNode(Node* node){
                 grandParent->color = 1;
             }
         }
-        else{   // Left Case
-            //Left Left Case
-            if(parent->left == node){
+        else
+        { // Left Case
+            // Left Left Case
+            if (parent->left == node)
+            {
                 grandParent->left = parent->right;
-                if(parent->right != NULL){
+                if (parent->right != NULL)
+                {
                     (parent->right)->par = grandParent;
                 }
                 parent->right = grandParent;
@@ -184,11 +220,15 @@ void checkNode(Node* node){
 
                 // Attach to existing Tree;
                 parent->par = greatGrandParent;
-                if(greatGrandParent != NULL){
-                    if(greatGrandParent->left != NULL && greatGrandParent->left == grandParent){
+                if (greatGrandParent != NULL)
+                {
+                    if (greatGrandParent->left != NULL &&
+                        greatGrandParent->left == grandParent)
+                    {
                         greatGrandParent->left = parent;
                     }
-                    else{
+                    else
+                    {
                         greatGrandParent->right = parent;
                     }
                 }
@@ -197,11 +237,13 @@ void checkNode(Node* node){
                 parent->color = 0;
                 grandParent->color = 1;
             }
-            else{   //Left Right Case
+            else
+            { // Left Right Case
 
                 // First step -> Parent Child Rotation
                 parent->right = child->left;
-                if(child->left != NULL){
+                if (child->left != NULL)
+                {
                     (child->left)->par = parent;
                 }
                 child->left = parent;
@@ -209,7 +251,8 @@ void checkNode(Node* node){
 
                 // Second step -> Child and GrandParent Rotation
                 grandParent->left = child->right;
-                if(child->right != NULL){
+                if (child->right != NULL)
+                {
                     (child->right)->par = grandParent;
                 }
                 child->right = grandParent;
@@ -217,11 +260,15 @@ void checkNode(Node* node){
 
                 // Attach to the existing tree
                 child->par = greatGrandParent;
-                if(greatGrandParent != NULL){
-                    if(greatGrandParent->left != NULL && greatGrandParent->left == grandParent){
+                if (greatGrandParent != NULL)
+                {
+                    if (greatGrandParent->left != NULL &&
+                        greatGrandParent->left == grandParent)
+                    {
                         greatGrandParent->left = child;
                     }
-                    else{
+                    else
+                    {
                         greatGrandParent->right = child;
                     }
                 }
@@ -235,71 +282,88 @@ void checkNode(Node* node){
 }
 
 // To insert a node in the existing tree
-void insertNode(int val, Node** root){
-    Node* buffRoot = *root;
-    while(buffRoot){
-        if(buffRoot->val > val){
+void insertNode(int val, Node **root)
+{
+    Node *buffRoot = *root;
+    while (buffRoot)
+    {
+        if (buffRoot->val > val)
+        {
             // Go left
-            if(buffRoot->left != NULL){
+            if (buffRoot->left != NULL)
+            {
                 buffRoot = buffRoot->left;
             }
-            else{
-                //Insert The Node
-                Node* toInsert = newNode(val, buffRoot);
+            else
+            {
+                // Insert The Node
+                Node *toInsert = newNode(val, buffRoot);
                 buffRoot->left = toInsert;
                 buffRoot = toInsert;
 
-                //Check For Double Red Problems
+                // Check For Double Red Problems
                 break;
             }
         }
-        else{
+        else
+        {
 
             // Go right
-            if(buffRoot->right != NULL){
+            if (buffRoot->right != NULL)
+            {
                 buffRoot = buffRoot->right;
             }
-            else{
-                //Insert The Node
-                Node* toInsert = newNode(val, buffRoot);
+            else
+            {
+                // Insert The Node
+                Node *toInsert = newNode(val, buffRoot);
                 buffRoot->right = toInsert;
                 buffRoot = toInsert;
 
-                //Check For Double Red Problems
+                // Check For Double Red Problems
                 break;
             }
         }
     }
 
-
-    while(buffRoot != *root){
+    while (buffRoot != *root)
+    {
         checkNode(buffRoot);
-        if(buffRoot->par == NULL){
+        if (buffRoot->par == NULL)
+        {
             *root = buffRoot;
             break;
         }
         buffRoot = buffRoot->par;
-        if(buffRoot == *root){
+        if (buffRoot == *root)
+        {
             buffRoot->color = 0;
         }
     }
 }
 
-void checkForCase2(Node* toDelete, int delete, int fromDirection, Node** root){
+void checkForCase2(Node *toDelete, int delete, int fromDirection, Node **root)
+{
 
-    if(toDelete == (*root)){
+    if (toDelete == (*root))
+    {
         (*root)->color = 0;
         return;
     }
 
-    if(!delete && toDelete->color == 1){
-        if(!fromDirection){
-            if(toDelete->right != NULL){
+    if (!delete &&toDelete->color == 1)
+    {
+        if (!fromDirection)
+        {
+            if (toDelete->right != NULL)
+            {
                 toDelete->right->color = 1;
             }
         }
-        else{
-            if(toDelete->left != NULL){
+        else
+        {
+            if (toDelete->left != NULL)
+            {
                 toDelete->left->color = 1;
             }
         }
@@ -307,25 +371,30 @@ void checkForCase2(Node* toDelete, int delete, int fromDirection, Node** root){
         return;
     }
 
-
     // Get the sibling for further inspection
-    Node* sibling;
-    Node* parent = toDelete->par;
+    Node *sibling;
+    Node *parent = toDelete->par;
     int locateChild = 0; // 0 if toDeleted is left of its parent else 1
-    if(parent->right == toDelete){
+    if (parent->right == toDelete)
+    {
         sibling = parent->left;
         locateChild = 1;
     }
-    else{
+    else
+    {
         sibling = parent->right;
     }
 
-    //Case 2.1. i.e. if the any children of the sibling is red
-    if((sibling->right != NULL && sibling->right->color == 1) || (sibling->left != NULL && sibling->left->color == 1)){
-        if(sibling->right != NULL && sibling->right->color == 1){
+    // Case 2.1. i.e. if the any children of the sibling is red
+    if ((sibling->right != NULL && sibling->right->color == 1) ||
+        (sibling->left != NULL && sibling->left->color == 1))
+    {
+        if (sibling->right != NULL && sibling->right->color == 1)
+        {
 
             // Sibling is left and child is right. i.e. LEFT RIGHT ROTATION
-            if(locateChild == 1){
+            if (locateChild == 1)
+            {
 
                 int parColor = parent->color;
 
@@ -336,7 +405,8 @@ void checkForCase2(Node* toDelete, int delete, int fromDirection, Node** root){
                 parent = rightRotate(sibling);
 
                 // Check if the root is rotated
-                if(parent->par == NULL){
+                if (parent->par == NULL)
+                {
                     *root = parent;
                 }
 
@@ -346,16 +416,19 @@ void checkForCase2(Node* toDelete, int delete, int fromDirection, Node** root){
                 parent->right->color = 0;
 
                 // Delete the node (present at parent->right->right)
-                if(delete){
-                    if(toDelete->left != NULL){
+                if (delete)
+                {
+                    if (toDelete->left != NULL)
+                    {
                         toDelete->left->par = parent->right;
                     }
                     parent->right->right = toDelete->left;
                     free(toDelete);
                 }
-
             }
-            else{   // Sibling is right and child is also right. i.e. LEFT LEFT ROTATION    
+            else
+            { // Sibling is right and child is also right. i.e. LEFT LEFT
+              // ROTATION
 
                 int parColor = parent->color;
 
@@ -363,7 +436,8 @@ void checkForCase2(Node* toDelete, int delete, int fromDirection, Node** root){
                 parent = leftRotate(sibling);
 
                 // Check if the root is rotated
-                if(parent->par == NULL){
+                if (parent->par == NULL)
+                {
                     *root = parent;
                 }
 
@@ -373,20 +447,23 @@ void checkForCase2(Node* toDelete, int delete, int fromDirection, Node** root){
                 parent->right->color = 0;
 
                 // Delete the node (present at parent->left->left)
-                if(delete){
-                    if(toDelete->right != NULL){
+                if (delete)
+                {
+                    if (toDelete->right != NULL)
+                    {
                         toDelete->right->par = parent->left;
                     }
                     parent->left->left = toDelete->left;
                     free(toDelete);
                 }
-
             }
         }
-        else{
+        else
+        {
 
             // Sibling is right and child is left. i.e. RIGHT LEFT ROTATION
-            if(locateChild == 0){
+            if (locateChild == 0)
+            {
 
                 int parColor = parent->color;
 
@@ -400,7 +477,8 @@ void checkForCase2(Node* toDelete, int delete, int fromDirection, Node** root){
                 parent = leftRotate(sibling);
 
                 // Check if the root is rotated
-                if(parent->par == NULL){
+                if (parent->par == NULL)
+                {
                     *root = parent;
                 }
 
@@ -410,17 +488,19 @@ void checkForCase2(Node* toDelete, int delete, int fromDirection, Node** root){
                 parent->right->color = 0;
 
                 // Delete the node (present at parent->left->left)
-                if(delete){
-                    if(toDelete->right != NULL){
+                if (delete)
+                {
+                    if (toDelete->right != NULL)
+                    {
                         toDelete->right->par = parent->left;
                     }
                     parent->left->left = toDelete->right;
                     free(toDelete);
                 }
-
-
             }
-            else{   // Sibling is left and child is also left. i.e. RIGHT RIGHT ROTATION
+            else
+            { // Sibling is left and child is also left. i.e. RIGHT RIGHT
+              // ROTATION
 
                 int parColor = parent->color;
 
@@ -428,7 +508,8 @@ void checkForCase2(Node* toDelete, int delete, int fromDirection, Node** root){
                 parent = rightRotate(sibling);
 
                 // Check if the root is rotated
-                if(parent->par == NULL){
+                if (parent->par == NULL)
+                {
                     *root = parent;
                 }
 
@@ -438,33 +519,40 @@ void checkForCase2(Node* toDelete, int delete, int fromDirection, Node** root){
                 parent->right->color = 0;
 
                 // Delete the node (present at parent->right->right)
-                if(delete){
-                    if(toDelete->left != NULL){
+                if (delete)
+                {
+                    if (toDelete->left != NULL)
+                    {
                         toDelete->left->par = parent->right;
                     }
                     parent->right->right = toDelete->left;
                     free(toDelete);
                 }
-
             }
         }
     }
-    else if(sibling->color == 0){   //Make the sibling red and recur for its parent
+    else if (sibling->color == 0)
+    { // Make the sibling red and recur for its parent
 
         // Recolor the sibling
         sibling->color = 1;
 
         // Delete if necessary
-        if(delete){
-            if(locateChild){
+        if (delete)
+        {
+            if (locateChild)
+            {
                 toDelete->par->right = toDelete->left;
-                if(toDelete->left != NULL){
+                if (toDelete->left != NULL)
+                {
                     toDelete->left->par = toDelete->par;
                 }
             }
-            else{
+            else
+            {
                 toDelete->par->left = toDelete->right;
-                if(toDelete->right != NULL){
+                if (toDelete->right != NULL)
+                {
                     toDelete->right->par = toDelete->par;
                 }
             }
@@ -472,18 +560,22 @@ void checkForCase2(Node* toDelete, int delete, int fromDirection, Node** root){
 
         checkForCase2(parent, 0, locateChild, root);
     }
-    else{   // Bring the sibling on top and apply 2.1 or 2.2 accordingly
-        if(locateChild){    //Right Rotate
+    else
+    { // Bring the sibling on top and apply 2.1 or 2.2 accordingly
+        if (locateChild)
+        { // Right Rotate
 
             toDelete->par->right = toDelete->left;
-            if(toDelete->left != NULL){
+            if (toDelete->left != NULL)
+            {
                 toDelete->left->par = toDelete->par;
             }
 
             parent = rightRotate(sibling);
 
             // Check if the root is rotated
-            if(parent->par == NULL){
+            if (parent->par == NULL)
+            {
                 *root = parent;
             }
 
@@ -491,16 +583,19 @@ void checkForCase2(Node* toDelete, int delete, int fromDirection, Node** root){
             parent->right->color = 1;
             checkForCase2(parent->right, 0, 1, root);
         }
-        else{   // Left Rotate
+        else
+        { // Left Rotate
 
             toDelete->par->left = toDelete->right;
-            if(toDelete->right != NULL){
+            if (toDelete->right != NULL)
+            {
                 toDelete->right->par = toDelete->par;
             }
             parent = leftRotate(sibling);
 
             // Check if the root is rotated
-            if(parent->par == NULL){
+            if (parent->par == NULL)
+            {
                 *root = parent;
             }
 
@@ -511,58 +606,71 @@ void checkForCase2(Node* toDelete, int delete, int fromDirection, Node** root){
             checkForCase2(parent->left, 0, 0, root);
         }
     }
-
 }
 
 // To delete a node from the tree
-void deleteNode(int val, Node** root){
-    Node* buffRoot = *root;
+void deleteNode(int val, Node **root)
+{
+    Node *buffRoot = *root;
 
-    //Search for the element in the tree
-    while(1){
+    // Search for the element in the tree
+    while (1)
+    {
 
-        if(val == buffRoot->val){
+        if (val == buffRoot->val)
+        {
             // Node Found
             break;
         }
 
-        if(val > buffRoot->val){
-            if(buffRoot->right != NULL){
+        if (val > buffRoot->val)
+        {
+            if (buffRoot->right != NULL)
+            {
                 buffRoot = buffRoot->right;
             }
-            else{
+            else
+            {
                 printf("Node Not Found!!!");
                 return;
             }
         }
-        else{
-            if(buffRoot->left != NULL){
+        else
+        {
+            if (buffRoot->left != NULL)
+            {
                 buffRoot = buffRoot->left;
             }
-            else{
+            else
+            {
                 printf("Node Not Found!!!");
                 return;
             }
         }
     }
 
-    Node* toDelete = buffRoot;
+    Node *toDelete = buffRoot;
 
     // Look for the leftmost of right node or right most of left node
-    if(toDelete->left != NULL){
+    if (toDelete->left != NULL)
+    {
         toDelete = toDelete->left;
-        while(toDelete->right != NULL){
+        while (toDelete->right != NULL)
+        {
             toDelete = toDelete->right;
         }
     }
-    else if(toDelete->right != NULL){
+    else if (toDelete->right != NULL)
+    {
         toDelete = toDelete->right;
-        while(toDelete->left != NULL){
+        while (toDelete->left != NULL)
+        {
             toDelete = toDelete->left;
         }
     }
 
-    if(toDelete == *root){
+    if (toDelete == *root)
+    {
         *root = NULL;
         return;
     }
@@ -572,28 +680,37 @@ void deleteNode(int val, Node** root){
     toDelete->val = val;
 
     // Checking for case 1
-    if(toDelete->color == 1 || (toDelete->left != NULL && toDelete->left->color == 1) || (toDelete->right != NULL  && toDelete->right->color == 1)){
+    if (toDelete->color == 1 ||
+        (toDelete->left != NULL && toDelete->left->color == 1) ||
+        (toDelete->right != NULL && toDelete->right->color == 1))
+    {
 
         // if it is a leaf
-        if(toDelete->left == NULL && toDelete->right == NULL){
+        if (toDelete->left == NULL && toDelete->right == NULL)
+        {
             // Delete instantly
-            if(toDelete->par->left == toDelete){
+            if (toDelete->par->left == toDelete)
+            {
                 toDelete->par->left = NULL;
             }
-            else{
+            else
+            {
                 toDelete->par->right = NULL;
             }
         }
-        else{   // else its child should be red
+        else
+        { // else its child should be red
 
             // Check for the exitstence of left node
-            if(toDelete->left != NULL){
+            if (toDelete->left != NULL)
+            {
                 // The node should be right to its parent
                 toDelete->par->right = toDelete->left;
                 toDelete->left->par = toDelete->par;
                 toDelete->left->color = 1;
             }
-            else{   // else the right node should be red
+            else
+            { // else the right node should be red
                 toDelete->par->left = toDelete->right;
                 toDelete->right->par = toDelete->par;
                 toDelete->right->color = 1;
@@ -603,49 +720,58 @@ void deleteNode(int val, Node** root){
         // Remove the node from memory
         free(toDelete);
     }
-    else{   // Case 2
+    else
+    { // Case 2
         checkForCase2(toDelete, 1, ((toDelete->par->right == toDelete)), root);
     }
-
-    
-
 }
 
-void printInorder(Node* root){
-    if(root != NULL){
+void printInorder(Node *root)
+{
+    if (root != NULL)
+    {
         printInorder(root->left);
         printf("%d c-%d ", root->val, root->color);
         printInorder(root->right);
     }
 }
 
-void checkBlack(Node* temp,int c){
-    if (temp==NULL){
-        printf("%d ",c);
-        return ;
+void checkBlack(Node *temp, int c)
+{
+    if (temp == NULL)
+    {
+        printf("%d ", c);
+        return;
     }
-    if (temp->color==0){
+    if (temp->color == 0)
+    {
         c++;
     }
-    checkBlack(temp->left,c);
-    checkBlack(temp->right,c);
+    checkBlack(temp->left, c);
+    checkBlack(temp->right, c);
 }
 
-int main(){
-    Node* root = NULL;
+int main()
+{
+    Node *root = NULL;
     int scanValue, choice = 1;
-    printf("1 - Input\n2 - Delete\n3 - Inorder Traversel\n0 - Quit\n\nPlease Enter the Choice - ");
+    printf("1 - Input\n2 - Delete\n3 - Inorder Traversel\n0 - Quit\n\nPlease "
+           "Enter the Choice - ");
     scanf("%d", &choice);
-    while(choice){
-        switch(choice){
+    while (choice)
+    {
+        switch (choice)
+        {
         case 1:
             printf("\n\nPlease Enter A Value to insert - ");
             scanf("%d", &scanValue);
-                if(root == NULL){
+            if (root == NULL)
+            {
                 root = newNode(scanValue, NULL);
                 root->color = 0;
             }
-                else{
+            else
+            {
                 insertNode(scanValue, &root);
             }
             printf("\nSuccessfully Inserted %d in the tree\n\n", scanValue);
@@ -664,15 +790,15 @@ int main(){
             // printf("\n");
             break;
         default:
-                if(root != NULL){
+            if (root != NULL)
+            {
                 printf("Root - %d\n", root->val);
             }
         }
-        printf("1 - Input\n2 - Delete\n3 - Inorder Traversel\n0 - Quit\n\nPlease Enter the Choice - ");
+        printf("1 - Input\n2 - Delete\n3 - Inorder Traversel\n0 - "
+               "Quit\n\nPlease Enter the Choice - ");
         scanf("%d", &choice);
     }
 }
 
-
-
 // 32 12 50 53 1 2 3 4 5 6 7 8 9

data_structures/dictionary/dict.c

@@ -1,12 +1,11 @@
+#include "dict.h"
 #include <stdio.h>
 #include <stdlib.h>
-#include "dict.h"
-
 
 /* simple constructor */
-Dictionary * create_dict(void)
+Dictionary *create_dict(void)
 {
-    Dictionary * p_dic = malloc(sizeof (Dictionary));
+    Dictionary *p_dic = malloc(sizeof(Dictionary));
     if (p_dic)
     {
         p_dic->number_of_elements = 0;
@@ -26,7 +25,6 @@ Dictionary * create_dict(void)
     }
 }
 
-
 /*
     utility function
     sdbm hash algorithm
@@ -37,18 +35,18 @@ int get_hash(char s[])
     unsigned int hash_code = 0;
 
     /* iterates over string at each character */
-    for (int counter = 0; s[counter]!='\0'; counter++)
+    for (int counter = 0; s[counter] != '\0'; counter++)
     {
         /* actual computing of the hash code */
-        hash_code = s[counter] + (hash_code << 6) + (hash_code << 16) - hash_code;
+        hash_code =
+            s[counter] + (hash_code << 6) + (hash_code << 16) - hash_code;
     }
 
     /* % modulo is for fitting the index in array. */
     return hash_code % MAXELEMENTS;
 }
 
-
-int add_item_label(Dictionary * dic,char label[],void * item)
+int add_item_label(Dictionary *dic, char label[], void *item)
 {
     unsigned int index = get_hash(label);
 
@@ -63,8 +61,7 @@ int add_item_label(Dictionary * dic,char label[],void * item)
     return -1;
 }
 
-
-int add_item_index(Dictionary * dic , int index, void * item)
+int add_item_index(Dictionary *dic, int index, void *item)
 {
     /* make sure whether this place is already given */
     if (!dic->elements[index])
@@ -77,8 +74,7 @@ int add_item_index(Dictionary * dic , int index, void * item)
     return -1;
 }
 
-
-void * get_element_label(Dictionary * dict, char s[])
+void *get_element_label(Dictionary *dict, char s[])
 {
     int index = get_hash(s);
     if (dict->elements[index])
@@ -90,8 +86,7 @@ void * get_element_label(Dictionary * dict, char s[])
     return NULL;
 }
 
-
-void * get_element_index(Dictionary * dict, int index)
+void *get_element_index(Dictionary *dict, int index)
 {
     if (index >= 0 && index < MAXELEMENTS)
     {
@@ -102,8 +97,4 @@ void * get_element_index(Dictionary * dict, int index)
     return NULL;
 }
 
-
-void destroy(Dictionary * dict)
-{
-    free(dict);
-}
+void destroy(Dictionary *dict) { free(dict); }

data_structures/dictionary/dict.h

@@ -20,7 +20,7 @@ typedef struct Dict
         void* array for generic use of the dictionary.
         there actual saves the entries.
     */
-    void * elements[MAXELEMENTS];
+    void *elements[MAXELEMENTS];
 
     /* contains the number of elements in this dictionary */
     int number_of_elements;
@@ -33,13 +33,13 @@ typedef struct Dict
                 member field 'number_of_elements'
                 and prepares the inner array 'elements'
 */
-Dictionary * create_dict(void);
+Dictionary *create_dict(void);
 
 /*
     add_item_label: adds item (void*) to the dictionary at given label
     returns 0 if adding was sucessful otherwise -1
 */
-int add_item_label(Dictionary *,char label[],void *);
+int add_item_label(Dictionary *, char label[], void *);
 
 /*
     add_item_index: adds item (void*) to the dictionary at given index (int)
@@ -47,22 +47,19 @@ int add_item_label(Dictionary *,char label[],void *);
 */
 int add_item_index(Dictionary *, int index, void *);
 
-
 /*
     get_element: returns the element at given label
 */
-void * get_element_label(Dictionary *, char []);
-
+void *get_element_label(Dictionary *, char[]);
 
 /*
     get_element: returns the element at given index
 */
-void * get_element_index(Dictionary *, int );
+void *get_element_index(Dictionary *, int);
 
 /*
     simple destrcutor function
 */
 void destroy(Dictionary *);
 
-
 #endif

data_structures/dictionary/test_program.c

@@ -10,17 +10,16 @@
 
 int main(void)
 {
-    Dictionary * testObj1;
-    Dictionary * testObj2;
+    Dictionary *testObj1;
+    Dictionary *testObj2;
 
     int value = 28;
 
     testObj1 = create_dict();
     testObj2 = create_dict();
 
-    add_item_label(testObj1,"age",&value);
-    add_item_label(testObj2,"name","Christian");
-   
+    add_item_label(testObj1, "age", &value);
+    add_item_label(testObj2, "name", "Christian");
 
     /*
         test for function add_item_label
@@ -29,13 +28,14 @@ int main(void)
         The void* pointer must be convert into an int* pointer.
         After that you can dereference it.
     */
-    printf("My age is %d\n",*((int *)get_element_label(testObj1,"age")));
-    printf("My name is %s\n",get_element_label(testObj2,"name"));
+    printf("My age is %d\n", *((int *)get_element_label(testObj1, "age")));
+    printf("My name is %s\n", get_element_label(testObj2, "name"));
 
     /* test for function add_item_index */
-    if (!add_item_index(testObj1,0,&value))
+    if (!add_item_index(testObj1, 0, &value))
     {
-        printf("My age at index %d is %d\n",0,*((int *)get_element_index(testObj1,0)));
+        printf("My age at index %d is %d\n", 0,
+               *((int *)get_element_index(testObj1, 0)));
     }
 
     /* error scenario */

data_structures/dynamic_array/dynamic_array.c

@@ -1,7 +1,7 @@
-#include <string.h>
-#include <stdlib.h>
-#include <stdio.h>
 #include "dynamic_array.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
 dynamic_array_t *init_dynamic_array()
 {
@@ -14,8 +14,10 @@ dynamic_array_t *init_dynamic_array()
 
 void *add(dynamic_array_t *da, const void *value)
 {
-    if (da->size >= da->capacity) {
-        void **newItems = realloc(da->items, (da->capacity <<= 1) * sizeof(void **));
+    if (da->size >= da->capacity)
+    {
+        void **newItems =
+            realloc(da->items, (da->capacity <<= 1) * sizeof(void **));
         free(da->items);
 
         da->items = newItems;
@@ -52,7 +54,8 @@ void delete (dynamic_array_t *da, const unsigned index)
     if (!contains(da->size, index))
         return;
 
-    for (unsigned i = index; i < da->size; i++) {
+    for (unsigned i = index; i < da->size; i++)
+    {
         da->items[i] = da->items[i + 1];
     }
 

data_structures/dynamic_array/dynamic_array.h

@@ -3,7 +3,8 @@
 #define DEFAULT_CAPACITY 1 << 4
 #define INDEX_OUT_OF_BOUNDS NULL
 
-typedef struct dynamic_array {
+typedef struct dynamic_array
+{
     void **items;
     unsigned size;
     unsigned capacity;

data_structures/dynamic_array/main.c

@@ -6,7 +6,8 @@ int main()
 {
     dynamic_array_t *da = init_dynamic_array();
 
-    for (int i = 1; i <= 50; i++) {
+    for (int i = 1; i <= 50; i++)
+    {
         add(da, &i);
     }
 
@@ -22,7 +23,8 @@ int main()
 
     add(da, &another_value);
 
-    for (int i = 0; i < da->size; i++) {
+    for (int i = 0; i < da->size; i++)
+    {
         printf("value %d\n", *(int *)get(da, i));
     }
 

data_structures/graphs/BFS.c

@@ -1,63 +1,64 @@
 #include <stdio.h>
 #include <stdlib.h>
 #define SIZE 40
-//Assume max size of graph is 40 nodes
-struct queue {
+// Assume max size of graph is 40 nodes
+struct queue
+{
     int items[SIZE];
     int front;
     int rear;
 };
 
-//Some declarations
-struct queue* createQueue();
-void enqueue(struct queue* q, int);
-int dequeue(struct queue* q);
-void display(struct queue* q);
-int isEmpty(struct queue* q);
-int pollQueue(struct queue* q);
+// Some declarations
+struct queue *createQueue();
+void enqueue(struct queue *q, int);
+int dequeue(struct queue *q);
+void display(struct queue *q);
+int isEmpty(struct queue *q);
+int pollQueue(struct queue *q);
 
-//Structure to create a graph node
+// Structure to create a graph node
 struct node
 {
     int vertex;
-    struct node* next;
+    struct node *next;
 };
 
-struct node* createNode(int);
+struct node *createNode(int);
 
-//Graph data structure
+// Graph data structure
 struct Graph
 {
     int numVertices;
-    struct node** adjLists;
-    int* visited;
+    struct node **adjLists;
+    int *visited;
 };
-struct Graph* createGraph(int vertices);
-void addEdge(struct Graph* graph, int src, int dest);
-void printGraph(struct Graph* graph);
-void bfs(struct Graph* graph, int startVertex);
+struct Graph *createGraph(int vertices);
+void addEdge(struct Graph *graph, int src, int dest);
+void printGraph(struct Graph *graph);
+void bfs(struct Graph *graph, int startVertex);
 
 int main()
 {
-	int vertices,edges,source,i,src,dst;
+    int vertices, edges, source, i, src, dst;
     printf("Enter the number of vertices\n");
-	scanf("%d",&vertices);
-	struct Graph* graph = createGraph(vertices);
+    scanf("%d", &vertices);
+    struct Graph *graph = createGraph(vertices);
     printf("Enter the number of edges\n");
-	scanf("%d",&edges);
-	for(i=0; i<edges; i++)
+    scanf("%d", &edges);
+    for (i = 0; i < edges; i++)
     {
-		printf("Edge %d \nEnter source: ",i+1);
-		scanf("%d",&src);
+        printf("Edge %d \nEnter source: ", i + 1);
+        scanf("%d", &src);
         printf("Enter destination: ");
-		scanf("%d",&dst);
+        scanf("%d", &dst);
         addEdge(graph, src, dst);
     }
     printf("Enter source of bfs\n");
-	scanf("%d",&source);
+    scanf("%d", &source);
     bfs(graph, source);
 
-	//Uncomment below part to get a ready-made example
+    // Uncomment below part to get a ready-made example
     /*struct Graph* graph = createGraph(6);
     addEdge(graph, 0, 1);
     addEdge(graph, 0, 2);
@@ -70,26 +71,30 @@ int main()
 
     return 0;
 }
-void bfs(struct Graph* graph, int startVertex)
- {
-    struct queue* q = createQueue();
+void bfs(struct Graph *graph, int startVertex)
+{
+    struct queue *q = createQueue();
 
-    //Add to visited list and put in queue
+    // Add to visited list and put in queue
     graph->visited[startVertex] = 1;
     enqueue(q, startVertex);
-    printf("Breadth first traversal from vertex %d is:\n",startVertex);
+    printf("Breadth first traversal from vertex %d is:\n", startVertex);
 
-    //Iterate while queue not empty
-    while(!isEmpty(q)){
-        printf("%d ",pollQueue(q));
+    // Iterate while queue not empty
+    while (!isEmpty(q))
+    {
+        printf("%d ", pollQueue(q));
         int currentVertex = dequeue(q);
 
-        struct node* temp = graph->adjLists[currentVertex];
-        //Add all unvisited neighbours of current vertex to queue to be printed next
-        while(temp) {
+        struct node *temp = graph->adjLists[currentVertex];
+        // Add all unvisited neighbours of current vertex to queue to be printed
+        // next
+        while (temp)
+        {
             int adjVertex = temp->vertex;
-            //Only add if neighbour is unvisited
-            if(graph->visited[adjVertex] == 0){
+            // Only add if neighbour is unvisited
+            if (graph->visited[adjVertex] == 0)
+            {
                 graph->visited[adjVertex] = 1;
                 enqueue(q, adjVertex);
             }
@@ -97,36 +102,37 @@ void bfs(struct Graph* graph, int startVertex)
         }
     }
 }
-//Memory for a graph node 
-struct node* createNode(int v)
+// Memory for a graph node
+struct node *createNode(int v)
 {
-    struct node* newNode = malloc(sizeof(struct node));
+    struct node *newNode = malloc(sizeof(struct node));
     newNode->vertex = v;
     newNode->next = NULL;
     return newNode;
 }
-//Allocates memory for graph data structure, in adjacency list format
-struct Graph* createGraph(int vertices)
+// Allocates memory for graph data structure, in adjacency list format
+struct Graph *createGraph(int vertices)
 {
-    struct Graph* graph = malloc(sizeof(struct Graph));
+    struct Graph *graph = malloc(sizeof(struct Graph));
     graph->numVertices = vertices;
 
-    graph->adjLists = malloc(vertices * sizeof(struct node*));
+    graph->adjLists = malloc(vertices * sizeof(struct node *));
     graph->visited = malloc(vertices * sizeof(int));
 
     int i;
-    for (i = 0; i < vertices; i++) {
+    for (i = 0; i < vertices; i++)
+    {
         graph->adjLists[i] = NULL;
         graph->visited[i] = 0;
     }
 
     return graph;
 }
-//Adds bidirectional edge to graph 
-void addEdge(struct Graph* graph, int src, int dest)
+// Adds bidirectional edge to graph
+void addEdge(struct Graph *graph, int src, int dest)
 {
     // Add edge from src to dest
-    struct node* newNode = createNode(dest);
+    struct node *newNode = createNode(dest);
     newNode->next = graph->adjLists[src];
     graph->adjLists[src] = newNode;
 
@@ -135,54 +141,55 @@ void addEdge(struct Graph* graph, int src, int dest)
     newNode->next = graph->adjLists[dest];
     graph->adjLists[dest] = newNode;
 }
-//Allocates memory for our queue data structure
-struct queue* createQueue() 
+// Allocates memory for our queue data structure
+struct queue *createQueue()
 {
-    struct queue* q = malloc(sizeof(struct queue));
+    struct queue *q = malloc(sizeof(struct queue));
     q->front = -1;
     q->rear = -1;
     return q;
 }
-//Checks for empty queue
-int isEmpty(struct queue* q) 
+// Checks for empty queue
+int isEmpty(struct queue *q)
 {
-    if(q->rear == -1) 
+    if (q->rear == -1)
         return 1;
     else
         return 0;
 }
-//Inserts item at start of queue
-void enqueue(struct queue* q, int value)
+// Inserts item at start of queue
+void enqueue(struct queue *q, int value)
 {
-    if(q->rear == SIZE-1)
+    if (q->rear == SIZE - 1)
         printf("\nQueue is Full!!");
-    else {
-        if(q->front == -1)
+    else
+    {
+        if (q->front == -1)
             q->front = 0;
         q->rear++;
         q->items[q->rear] = value;
     }
 }
-//Returns item at front of queue and removes it from queue
-int dequeue(struct queue* q)
+// Returns item at front of queue and removes it from queue
+int dequeue(struct queue *q)
 {
     int item;
-    if(isEmpty(q)){
+    if (isEmpty(q))
+    {
         printf("Queue is empty");
         item = -1;
     }
-    else{
+    else
+    {
         item = q->items[q->front];
         q->front++;
-        if(q->front > q->rear){
+        if (q->front > q->rear)
+        {
             q->front = q->rear = -1;
         }
     }
     return item;
 }
 
-//Returns element at front of queue
-int pollQueue(struct queue *q)
-{
-	return q->items[q->front];
-}  
+// Returns element at front of queue
+int pollQueue(struct queue *q) { return q->items[q->front]; }

data_structures/graphs/Bellman-Ford.c

@@ -1,43 +1,48 @@
-#include<stdio.h>
-#include<stdlib.h>
-#include<limits.h>
-#include<string.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
-//Structure for storing edge
-struct Edge{
-int src,dst,weight;
+// Structure for storing edge
+struct Edge
+{
+    int src, dst, weight;
 };
 
-//Structure for storing a graph
-struct Graph{
+// Structure for storing a graph
+struct Graph
+{
     int vertexNum;
     int edgeNum;
-	struct Edge* edges;
+    struct Edge *edges;
 };
 
-//Constructs a graph with V vertices and E edges
-void createGraph(struct Graph* G,int V,int E){
+// Constructs a graph with V vertices and E edges
+void createGraph(struct Graph *G, int V, int E)
+{
     G->vertexNum = V;
     G->edgeNum = E;
-		G->edges = (struct Edge*) malloc(E * sizeof(struct Edge));		
+    G->edges = (struct Edge *)malloc(E * sizeof(struct Edge));
 }
 
-//Adds the given edge to the graph 
-void addEdge(struct Graph* G, int src, int dst, int weight){
+// Adds the given edge to the graph
+void addEdge(struct Graph *G, int src, int dst, int weight)
+{
     static int ind;
     struct Edge newEdge;
     newEdge.src = src;
     newEdge.dst = dst;
     newEdge.weight = weight;
-	G->edges[ind++]= newEdge;
+    G->edges[ind++] = newEdge;
 }
 
-
-//Utility function to find minimum distance vertex in mdist
-int minDistance(int mdist[], int vset[], int V){
-	int minVal = INT_MAX, minInd ;
-	for(int i=0; i<V;i++)
-		if(vset[i] == 0 && mdist[i] < minVal){
+// Utility function to find minimum distance vertex in mdist
+int minDistance(int mdist[], int vset[], int V)
+{
+    int minVal = INT_MAX, minInd;
+    for (int i = 0; i < V; i++)
+        if (vset[i] == 0 && mdist[i] < minVal)
+        {
             minVal = mdist[i];
             minInd = i;
         }
@@ -45,51 +50,58 @@ int minDistance(int mdist[], int vset[], int V){
     return minInd;
 }
 
-//Utility function to print distances
-void print(int dist[], int V){
+// Utility function to print distances
+void print(int dist[], int V)
+{
     printf("\nVertex  Distance\n");
-	for(int i = 0; i < V; i++){
-		if(dist[i] != INT_MAX)
-			printf("%d\t%d\n",i,dist[i]);
+    for (int i = 0; i < V; i++)
+    {
+        if (dist[i] != INT_MAX)
+            printf("%d\t%d\n", i, dist[i]);
         else
-			printf("%d\tINF",i);
+            printf("%d\tINF", i);
     }
 }
 
-//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(struct Graph* graph, int src){
+// 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(struct Graph *graph, int src)
+{
     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++)
+    // 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++){
+    // 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])
+            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++){
+    // 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]){
-			printf("Graph contains negative weight cycle. Hence, shortest distance not guaranteed.");
+        if (dist[u] != INT_MAX && dist[u] + w < dist[v])
+        {
+            printf("Graph contains negative weight cycle. Hence, shortest "
+                   "distance not guaranteed.");
             return;
         }
     }
@@ -99,32 +111,30 @@ void BellmanFord(struct Graph* graph, int src){
     return;
 }
 
-
-
-//Driver Function
-int main(){
-	int V,E,gsrc;
-	int src,dst,weight;
+// Driver Function
+int main()
+{
+    int V, E, gsrc;
+    int src, dst, weight;
     struct Graph G;
     printf("Enter number of vertices: ");
-	scanf("%d",&V);
+    scanf("%d", &V);
     printf("Enter number of edges: ");
-	scanf("%d",&E);
-	createGraph(&G,V,E);
-	for(int i=0; i<E; i++){
-		printf("\nEdge %d \nEnter source: ",i+1);
-		scanf("%d",&src);
+    scanf("%d", &E);
+    createGraph(&G, V, E);
+    for (int i = 0; i < E; i++)
+    {
+        printf("\nEdge %d \nEnter source: ", i + 1);
+        scanf("%d", &src);
         printf("Enter destination: ");
-		scanf("%d",&dst);
+        scanf("%d", &dst);
         printf("Enter weight: ");
-		scanf("%d",&weight);
+        scanf("%d", &weight);
         addEdge(&G, src, dst, weight);
     }
     printf("\nEnter source:");
-	scanf("%d",&gsrc);
-	BellmanFord(&G,gsrc);
+    scanf("%d", &gsrc);
+    BellmanFord(&G, gsrc);
 
     return 0;
 }
-
-

data_structures/graphs/DFS.c

@@ -1,48 +1,50 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-//A vertex of the graph 
+// A vertex of the graph
 struct node
 {
     int vertex;
-    struct node* next;
+    struct node *next;
 };
-//Some declarations
-struct node* createNode(int v);
+// Some declarations
+struct node *createNode(int v);
 struct Graph
 {
     int numVertices;
-    int* visited;
-    struct node** adjLists; // we need int** to store a two dimensional array. Similary, we need struct node** to store an array of Linked lists
+    int *visited;
+    struct node *
+        *adjLists; // we need int** to store a two dimensional array. Similary,
+                   // we need struct node** to store an array of Linked lists
 };
-struct Graph* createGraph(int);
-void addEdge(struct Graph*, int, int);
-void printGraph(struct Graph*);
-void dfs(struct Graph*, int);
+struct Graph *createGraph(int);
+void addEdge(struct Graph *, int, int);
+void printGraph(struct Graph *);
+void dfs(struct Graph *, int);
 
 int main()
 {
-	int vertices,edges,source,i,src,dst;
+    int vertices, edges, source, i, src, dst;
     printf("Enter the number of vertices\n");
-	scanf("%d",&vertices);
-	struct Graph* graph = createGraph(vertices);
+    scanf("%d", &vertices);
+    struct Graph *graph = createGraph(vertices);
     printf("Enter the number of edges\n");
-	scanf("%d",&edges);
-	for(i=0; i<edges; i++)
+    scanf("%d", &edges);
+    for (i = 0; i < edges; i++)
     {
-		printf("Edge %d \nEnter source: ",i+1);
-		scanf("%d",&src);
+        printf("Edge %d \nEnter source: ", i + 1);
+        scanf("%d", &src);
         printf("Enter destination: ");
-		scanf("%d",&dst);
+        scanf("%d", &dst);
         addEdge(graph, src, dst);
     }
     printf("Enter source of DFS\n");
-	scanf("%d",&source);
-	printf("DFS from %d is:\n",source);
+    scanf("%d", &source);
+    printf("DFS from %d is:\n", source);
     dfs(graph, source);
     printf("\n");
 
-	//Uncomment below part to get a ready-made example
+    // Uncomment below part to get a ready-made example
     /*struct Graph* graph = createGraph(4);
     addEdge(graph, 0, 1);
     addEdge(graph, 0, 2);
@@ -54,54 +56,58 @@ int main()
 
     return 0;
 }
-//Recursive dfs approach
-void dfs(struct Graph* graph, int vertex) {
-        struct node* adjList = graph->adjLists[vertex];
-        struct node* temp = adjList;
+// Recursive dfs approach
+void dfs(struct Graph *graph, int vertex)
+{
+    struct node *adjList = graph->adjLists[vertex];
+    struct node *temp = adjList;
 
-        //Add vertex to visited list and print it
+    // Add vertex to visited list and print it
     graph->visited[vertex] = 1;
     printf("%d ", vertex);
 
-        //Recursively call the dfs function on all unvisited neighbours
-        while(temp!=NULL) {
+    // Recursively call the dfs function on all unvisited neighbours
+    while (temp != NULL)
+    {
         int connectedVertex = temp->vertex;
-            if(graph->visited[connectedVertex] == 0) {
+        if (graph->visited[connectedVertex] == 0)
+        {
             dfs(graph, connectedVertex);
         }
         temp = temp->next;
     }
 }
- //Allocate memory for a node
-struct node* createNode(int v)
+// Allocate memory for a node
+struct node *createNode(int v)
 {
-    struct node* newNode = malloc(sizeof(struct node));
+    struct node *newNode = malloc(sizeof(struct node));
     newNode->vertex = v;
     newNode->next = NULL;
     return newNode;
 }
-//Allocate memory for the entire graph structure
-struct Graph* createGraph(int vertices)
+// Allocate memory for the entire graph structure
+struct Graph *createGraph(int vertices)
 {
-    struct Graph* graph = malloc(sizeof(struct Graph));
+    struct Graph *graph = malloc(sizeof(struct Graph));
     graph->numVertices = vertices;
 
-    graph->adjLists = malloc(vertices * sizeof(struct node*));
+    graph->adjLists = malloc(vertices * sizeof(struct node *));
 
     graph->visited = malloc(vertices * sizeof(int));
 
     int i;
-    for (i = 0; i < vertices; i++) {
+    for (i = 0; i < vertices; i++)
+    {
         graph->adjLists[i] = NULL;
         graph->visited[i] = 0;
     }
     return graph;
 }
-//Creates a bidirectional graph
-void addEdge(struct Graph* graph, int src, int dest)
+// Creates a bidirectional graph
+void addEdge(struct Graph *graph, int src, int dest)
 {
     // Add edge from src to dest
-    struct node* newNode = createNode(dest);
+    struct node *newNode = createNode(dest);
     newNode->next = graph->adjLists[src];
     graph->adjLists[src] = newNode;
 
@@ -110,13 +116,13 @@ void addEdge(struct Graph* graph, int src, int dest)
     newNode->next = graph->adjLists[dest];
     graph->adjLists[dest] = newNode;
 }
-//Utility function to see state of graph at a given time 
-void printGraph(struct Graph* graph)
+// Utility function to see state of graph at a given time
+void printGraph(struct Graph *graph)
 {
     int v;
     for (v = 0; v < graph->numVertices; v++)
     {
-        struct node* temp = graph->adjLists[v];
+        struct node *temp = graph->adjLists[v];
         printf("\n Adjacency list of vertex %d\n ", v);
         while (temp)
         {

data_structures/graphs/Dijkstra.c

@@ -1,38 +1,42 @@
-#include<stdio.h>
-#include<stdlib.h>
-#include<limits.h>
-#include<string.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
-
-//Structure for storing a graph
-struct Graph{
+// Structure for storing a graph
+struct Graph
+{
     int vertexNum;
-	int** edges;
+    int **edges;
 };
 
-//Constructs a graph with V vertices and E edges
-void createGraph(struct Graph* G,int V){
+// Constructs a graph with V vertices and E edges
+void createGraph(struct Graph *G, int V)
+{
     G->vertexNum = V;
-		G->edges =(int**) malloc(V * sizeof(int*));
-		for(int i=0; i<V; i++){
-			G->edges[i] = (int*) malloc(V * sizeof(int));
-			for(int j=0; j<V; j++)
+    G->edges = (int **)malloc(V * sizeof(int *));
+    for (int i = 0; i < V; i++)
+    {
+        G->edges[i] = (int *)malloc(V * sizeof(int));
+        for (int j = 0; j < V; j++)
             G->edges[i][j] = INT_MAX;
         G->edges[i][i] = 0;
     }
 }
 
-//Adds the given edge to the graph 
-void addEdge(struct Graph* G, int src, int dst, int weight){
+// Adds the given edge to the graph
+void addEdge(struct Graph *G, int src, int dst, int weight)
+{
     G->edges[src][dst] = weight;
 }
 
-
-//Utility function to find minimum distance vertex in mdist
-int minDistance(int mdist[], int vset[], int V){
-	int minVal = INT_MAX, minInd ;
-	for(int i=0; i<V;i++)
-		if(vset[i] == 0 && mdist[i] < minVal){
+// Utility function to find minimum distance vertex in mdist
+int minDistance(int mdist[], int vset[], int V)
+{
+    int minVal = INT_MAX, minInd;
+    for (int i = 0; i < V; i++)
+        if (vset[i] == 0 && mdist[i] < minVal)
+        {
             minVal = mdist[i];
             minInd = i;
         }
@@ -40,41 +44,46 @@ int minDistance(int mdist[], int vset[], int V){
     return minInd;
 }
 
-//Utility function to print distances
-void print(int dist[], int V){
+// Utility function to print distances
+void print(int dist[], int V)
+{
     printf("\nVertex  Distance\n");
-	for(int i = 0; i < V; i++){
-		if(dist[i] != INT_MAX)
-			printf("%d\t%d\n",i,dist[i]);
+    for (int i = 0; i < V; i++)
+    {
+        if (dist[i] != INT_MAX)
+            printf("%d\t%d\n", i, dist[i]);
         else
-			printf("%d\tINF",i);
+            printf("%d\tINF", i);
     }
 }
 
-//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(struct Graph* graph, int src){
+// 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(struct Graph *graph, int src)
+{
     int V = graph->vertexNum;
-	int mdist[V];   //Stores updated distances to vertex
+    int mdist[V]; // Stores updated distances to vertex
     int 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
-	for(int i=0; i<V; i++)
+    // Initialise mdist and vset. Set distance of source as zero
+    for (int i = 0; i < V; i++)
         mdist[i] = INT_MAX, vset[i] = 0;
 
     mdist[src] = 0;
 
-	//iterate to find shortest path
-	for(int count = 0; count<V-1; count++){
-		int u = minDistance(mdist,vset,V);
+    // iterate to find shortest path
+    for (int count = 0; count < V - 1; count++)
+    {
+        int u = minDistance(mdist, vset, V);
         vset[u] = 1;
 
-		for(int v=0; v<V; v++){
-			if(!vset[v] && graph->edges[u][v]!=INT_MAX && mdist[u] + graph->edges[u][v] < mdist[v])
+        for (int v = 0; v < V; v++)
+        {
+            if (!vset[v] && graph->edges[u][v] != INT_MAX &&
+                mdist[u] + graph->edges[u][v] < mdist[v])
                 mdist[v] = mdist[u] + graph->edges[u][v];
-				
         }
     }
 
@@ -83,32 +92,30 @@ void Dijkstra(struct Graph* graph, int src){
     return;
 }
 
-
-
-//Driver Function
-int main(){
-	int V,E,gsrc;
-	int src,dst,weight;
+// Driver Function
+int main()
+{
+    int V, E, gsrc;
+    int src, dst, weight;
     struct Graph G;
     printf("Enter number of vertices: ");
-	scanf("%d",&V);
+    scanf("%d", &V);
     printf("Enter number of edges: ");
-	scanf("%d",&E);
-	createGraph(&G,V);
-	for(int i=0; i<E; i++){
-		printf("\nEdge %d \nEnter source: ",i+1);
-		scanf("%d",&src);
+    scanf("%d", &E);
+    createGraph(&G, V);
+    for (int i = 0; i < E; i++)
+    {
+        printf("\nEdge %d \nEnter source: ", i + 1);
+        scanf("%d", &src);
         printf("Enter destination: ");
-		scanf("%d",&dst);
+        scanf("%d", &dst);
         printf("Enter weight: ");
-		scanf("%d",&weight);
+        scanf("%d", &weight);
         addEdge(&G, src, dst, weight);
     }
     printf("\nEnter source:");
-	scanf("%d",&gsrc);
-	Dijkstra(&G,gsrc);
+    scanf("%d", &gsrc);
+    Dijkstra(&G, gsrc);
 
     return 0;
 }
-
-

data_structures/graphs/Floyd-Warshall.c

@@ -1,41 +1,46 @@
-#include<stdio.h>
-#include<stdlib.h>
-#include<limits.h>
-#include<string.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
-
-//Structure for storing a graph
-struct Graph{
+// Structure for storing a graph
+struct Graph
+{
     int vertexNum;
-	int** edges;
+    int **edges;
 };
 
-//Constructs a graph with V vertices and E edges
-void createGraph(struct Graph* G,int V){
+// Constructs a graph with V vertices and E edges
+void createGraph(struct Graph *G, int V)
+{
     G->vertexNum = V;
-		G->edges =(int**) malloc(V * sizeof(int*));
-		for(int i=0; i<V; i++){
-			G->edges[i] = (int*) malloc(V * sizeof(int));
-			for(int j=0; j<V; j++)
+    G->edges = (int **)malloc(V * sizeof(int *));
+    for (int i = 0; i < V; i++)
+    {
+        G->edges[i] = (int *)malloc(V * sizeof(int));
+        for (int j = 0; j < V; j++)
             G->edges[i][j] = INT_MAX;
         G->edges[i][i] = 0;
     }
 }
 
-//Adds the given edge to the graph 
-void addEdge(struct Graph* G, int src, int dst, int weight){
+// Adds the given edge to the graph
+void addEdge(struct Graph *G, int src, int dst, int weight)
+{
     G->edges[src][dst] = weight;
 }
 
-
-//Utility function to print distances
-void print(int dist[], int V){
+// Utility function to print distances
+void print(int dist[], int V)
+{
     printf("\nThe Distance matrix for Floyd - Warshall\n");
-	for(int i = 0; i < V; i++){
-		for(int j=0; j<V; j++){
+    for (int i = 0; i < V; i++)
+    {
+        for (int j = 0; j < V; j++)
+        {
 
-		if(dist[i*V+j] != INT_MAX)	
-			printf("%d\t",dist[i*V+j]);
+            if (dist[i * V + j] != INT_MAX)
+                printf("%d\t", dist[i * V + j]);
             else
                 printf("INF\t");
         }
@@ -43,59 +48,62 @@ void print(int dist[], int V){
     }
 }
 
-//The main function that finds the shortest path from a vertex
-//to all other vertices using Floyd-Warshall Algorithm.
-void FloydWarshall(struct Graph* graph){
+// The main function that finds the shortest path from a vertex
+// to all other vertices using Floyd-Warshall Algorithm.
+void FloydWarshall(struct Graph *graph)
+{
     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++)
+    // 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
+                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
-int main(){
-	int V,E;
-	int src,dst,weight;
+// Driver Function
+int main()
+{
+    int V, E;
+    int src, dst, weight;
     struct Graph G;
     printf("Enter number of vertices: ");
-	scanf("%d",&V);
+    scanf("%d", &V);
     printf("Enter number of edges: ");
-	scanf("%d",&E);
-	createGraph(&G,V);
-	for(int i=0; i<E; i++){
-		printf("\nEdge %d \nEnter source: ",i+1);
-		scanf("%d",&src);
+    scanf("%d", &E);
+    createGraph(&G, V);
+    for (int i = 0; i < E; i++)
+    {
+        printf("\nEdge %d \nEnter source: ", i + 1);
+        scanf("%d", &src);
         printf("Enter destination: ");
-		scanf("%d",&dst);
+        scanf("%d", &dst);
         printf("Enter weight: ");
-		scanf("%d",&weight);
+        scanf("%d", &weight);
         addEdge(&G, src, dst, weight);
     }
     FloydWarshall(&G);

data_structures/graphs/Graph.c

@@ -2,16 +2,18 @@
 // Adjacency Matrix Representation
 #include "Graph.h"
 #include <assert.h>
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
 
-typedef struct GraphRep {
+typedef struct GraphRep
+{
     int **edges; // adjacency matrix
     int nV;      // #vertices
     int nE;      // #edges
 } GraphRep;
 
-Graph newGraph(int V) {
+Graph newGraph(int V)
+{
     assert(V >= 0);
     int i;
 
@@ -24,7 +26,8 @@ Graph newGraph(int V) {
     g->edges = malloc(V * sizeof(int *));
     assert(g->edges != NULL);
     // allocate memory for each column and initialise with 0
-   for (i = 0; i < V; i++) {
+    for (i = 0; i < V; i++)
+    {
         g->edges[i] = calloc(V, sizeof(int));
         assert(g->edges[i] != NULL);
     }
@@ -33,49 +36,54 @@ Graph newGraph(int V) {
 }
 
 // check if vertex is valid in a graph
-bool validV(Graph g, Vertex v) {
-   return (g != NULL && v >= 0 && v < g->nV);
-}
+bool validV(Graph g, Vertex v) { return (g != NULL && v >= 0 && v < g->nV); }
 
-void insertEdge(Graph g, Edge e) {
-   assert(g != NULL && validV(g,e.v) && validV(g,e.w));
+void insertEdge(Graph g, Edge e)
+{
+    assert(g != NULL && validV(g, e.v) && validV(g, e.w));
 
-   if (!g->edges[e.v][e.w]) {  // edge e not in graph
+    if (!g->edges[e.v][e.w])
+    { // edge e not in graph
         g->edges[e.v][e.w] = 1;
         g->edges[e.w][e.v] = 1;
         g->nE++;
     }
 }
 
-void removeEdge(Graph g, Edge e) {
-   assert(g != NULL && validV(g,e.v) && validV(g,e.w));
+void removeEdge(Graph g, Edge e)
+{
+    assert(g != NULL && validV(g, e.v) && validV(g, e.w));
 
-   if (g->edges[e.v][e.w]) {   // edge e in graph
+    if (g->edges[e.v][e.w])
+    { // edge e in graph
         g->edges[e.v][e.w] = 0;
         g->edges[e.w][e.v] = 0;
         g->nE--;
     }
 }
 
-bool adjacent(Graph g, Vertex v, Vertex w) {
-   assert(g != NULL && validV(g,v) && validV(g,w));
+bool adjacent(Graph g, Vertex v, Vertex w)
+{
+    assert(g != NULL && validV(g, v) && validV(g, w));
 
     return (g->edges[v][w] != 0);
 }
 
-void showGraph(Graph g) {
+void showGraph(Graph g)
+{
     assert(g != NULL);
     int i, j;
 
     printf("Number of vertices: %d\n", g->nV);
     printf("Number of edges: %d\n", g->nE);
     for (i = 0; i < g->nV; i++)
-       for (j = i+1; j < g->nV; j++)
+        for (j = i + 1; j < g->nV; j++)
             if (g->edges[i][j])
                 printf("Edge %d - %d\n", i, j);
 }
 
-void freeGraph(Graph g) {
+void freeGraph(Graph g)
+{
     assert(g != NULL);
 
     int i;
@@ -86,17 +94,25 @@ void freeGraph(Graph g) {
 }
 
 // By
-//  .----------------.  .----------------.  .----------------.  .-----------------.  .----------------.  .----------------. 
-// | .--------------. || .--------------. || .--------------. || .--------------. | | .--------------. || .--------------. |
-// | |  _________   | || | _____  _____ | || |      __      | || | ____  _____  | | | |  ____  ____  | || |     ____     | |
-// | | |  _   _  |  | || ||_   _||_   _|| || |     /  \     | || ||_   \|_   _| | | | | |_   ||   _| | || |   .'    `.   | |
-// | | |_/ | | \_|  | || |  | |    | |  | || |    / /\ \    | || |  |   \ | |   | | | |   | |__| |   | || |  /  .--.  \  | |
-// | |     | |      | || |  | '    ' |  | || |   / ____ \   | || |  | |\ \| |   | | | |   |  __  |   | || |  | |    | |  | |
-// | |    _| |_     | || |   \ `--' /   | || | _/ /    \ \_ | || | _| |_\   |_  | | | |  _| |  | |_  | || |  \  `--'  /  | |
-// | |   |_____|    | || |    `.__.'    | || ||____|  |____|| || ||_____|\____| | | | | |____||____| | || |   `.____.'   | |
-// | |              | || |              | || |              | || |              | | | |              | || |              | |
-// | '--------------' || '--------------' || '--------------' || '--------------' | | '--------------' || '--------------' |
-//  '----------------'  '----------------'  '----------------'  '----------------'   '----------------'  '----------------' 
+//  .----------------.  .----------------.  .----------------.
+//  .-----------------.  .----------------.  .----------------.
+// | .--------------. || .--------------. || .--------------. ||
+// .--------------. | | .--------------. || .--------------. | | |  _________ |
+// || | _____  _____ | || |      __      | || | ____  _____  | | | |  ____  ____
+// | || |     ____     | | | | |  _   _  |  | || ||_   _||_   _|| || |     /  \
+// | || ||_   \|_   _| | | | | |_   ||   _| | || |   .'    `.   | | | | |_/ | |
+// \_|  | || |  | |    | |  | || |    / /\ \    | || |  |   \ | |   | | | |   |
+// |__| |   | || |  /  .--.  \  | | | |     | |      | || |  | '    ' |  | || |
+// / ____ \   | || |  | |\ \| |   | | | |   |  __  |   | || |  | |    | |  | |
+// | |    _| |_     | || |   \ `--' /   | || | _/ /    \ \_ | || | _| |_\   |_
+// | | | |  _| |  | |_  | || |  \  `--'  /  | | | |   |_____|    | || | `.__.'
+// | || ||____|  |____|| || ||_____|\____| | | | | |____||____| | || | `.____.'
+// | | | |              | || |              | || |              | || | | | | |
+// | || |              | | | '--------------' || '--------------' ||
+// '--------------' || '--------------' | | '--------------' || '--------------'
+// |
+//  '----------------'  '----------------'  '----------------'
+//  '----------------'   '----------------'  '----------------'
 
 //  Email :    z5261243@unsw.edu.au
 //             hhoanhtuann@gmail.com

data_structures/graphs/Graph.h

@@ -7,7 +7,8 @@ typedef struct GraphRep *Graph;
 typedef int Vertex;
 
 // edges are pairs of vertices (end-points)
-typedef struct Edge {
+typedef struct Edge
+{
     Vertex v;
     Vertex w;
 } Edge;
@@ -19,19 +20,26 @@ bool  adjacent(Graph, Vertex, Vertex);
 void showGraph(Graph);
 void freeGraph(Graph);
 
-
 // By
-//  .----------------.  .----------------.  .----------------.  .-----------------.  .----------------.  .----------------. 
-// | .--------------. || .--------------. || .--------------. || .--------------. | | .--------------. || .--------------. |
-// | |  _________   | || | _____  _____ | || |      __      | || | ____  _____  | | | |  ____  ____  | || |     ____     | |
-// | | |  _   _  |  | || ||_   _||_   _|| || |     /  \     | || ||_   \|_   _| | | | | |_   ||   _| | || |   .'    `.   | |
-// | | |_/ | | \_|  | || |  | |    | |  | || |    / /\ \    | || |  |   \ | |   | | | |   | |__| |   | || |  /  .--.  \  | |
-// | |     | |      | || |  | '    ' |  | || |   / ____ \   | || |  | |\ \| |   | | | |   |  __  |   | || |  | |    | |  | |
-// | |    _| |_     | || |   \ `--' /   | || | _/ /    \ \_ | || | _| |_\   |_  | | | |  _| |  | |_  | || |  \  `--'  /  | |
-// | |   |_____|    | || |    `.__.'    | || ||____|  |____|| || ||_____|\____| | | | | |____||____| | || |   `.____.'   | |
-// | |              | || |              | || |              | || |              | | | |              | || |              | |
-// | '--------------' || '--------------' || '--------------' || '--------------' | | '--------------' || '--------------' |
-//  '----------------'  '----------------'  '----------------'  '----------------'   '----------------'  '----------------' 
+//  .----------------.  .----------------.  .----------------.
+//  .-----------------.  .----------------.  .----------------.
+// | .--------------. || .--------------. || .--------------. ||
+// .--------------. | | .--------------. || .--------------. | | |  _________ |
+// || | _____  _____ | || |      __      | || | ____  _____  | | | |  ____  ____
+// | || |     ____     | | | | |  _   _  |  | || ||_   _||_   _|| || |     /  \
+// | || ||_   \|_   _| | | | | |_   ||   _| | || |   .'    `.   | | | | |_/ | |
+// \_|  | || |  | |    | |  | || |    / /\ \    | || |  |   \ | |   | | | |   |
+// |__| |   | || |  /  .--.  \  | | | |     | |      | || |  | '    ' |  | || |
+// / ____ \   | || |  | |\ \| |   | | | |   |  __  |   | || |  | |    | |  | |
+// | |    _| |_     | || |   \ `--' /   | || | _/ /    \ \_ | || | _| |_\   |_
+// | | | |  _| |  | |_  | || |  \  `--'  /  | | | |   |_____|    | || | `.__.'
+// | || ||____|  |____|| || ||_____|\____| | | | | |____||____| | || | `.____.'
+// | | | |              | || |              | || |              | || | | | | |
+// | || |              | | | '--------------' || '--------------' ||
+// '--------------' || '--------------' | | '--------------' || '--------------'
+// |
+//  '----------------'  '----------------'  '----------------'
+//  '----------------'   '----------------'  '----------------'
 
 //  Email :    z5261243@unsw.edu.au
 //             hhoanhtuann@gmail.com

data_structures/graphs/bfsQueue.c

@@ -1,14 +1,15 @@
-#include <stdio.h>
-#include <stdbool.h>
-#include "queue.h"
 #include "Graph.h"
+#include "queue.h"
+#include <stdbool.h>
+#include <stdio.h>
 
 #define MAX_NODES 1000
 
 int visited[MAX_NODES]; // array to store visiting order
                         // indexed by vertex 0..nV-1
 
-bool findPathBFS(Graph g, int nV, Vertex src, Vertex dest) {
+bool findPathBFS(Graph g, int nV, Vertex src, Vertex dest)
+{
     Vertex v;
     for (v = 0; v < nV; v++)
         visited[v] = -1;
@@ -16,11 +17,13 @@ bool findPathBFS(Graph g, int nV, Vertex src, Vertex dest) {
     visited[src] = src;
     queue Q = newQueue();
     QueueEnqueue(Q, src);
-   while (!QueueIsEmpty(Q)) {
+    while (!QueueIsEmpty(Q))
+    {
         v = QueueDequeue(Q);
         Vertex w;
         for (w = 0; w < nV; w++)
-      if (adjacent(g, v, w) && visited[w] == -1) {
+            if (adjacent(g, v, w) && visited[w] == -1)
+            {
                 visited[w] = v;
                 if (w == dest)
                     return true;
@@ -31,31 +34,64 @@ bool findPathBFS(Graph g, int nV, Vertex src, Vertex dest) {
     return false;
 }
 
-int main(void) {
+int main(void)
+{
     int V = 10;
     Graph g = newGraph(V);
 
     Edge e;
-   e.v = 0; e.w = 1; insertEdge(g, e);
-   e.v = 0; e.w = 2; insertEdge(g, e);
-   e.v = 0; e.w = 5; insertEdge(g, e);
-   e.v = 1; e.w = 5; insertEdge(g, e);
-   e.v = 2; e.w = 3; insertEdge(g, e);
-   e.v = 3; e.w = 4; insertEdge(g, e);
-   e.v = 3; e.w = 5; insertEdge(g, e);
-   e.v = 3; e.w = 8; insertEdge(g, e);
-   e.v = 4; e.w = 5; insertEdge(g, e);
-   e.v = 4; e.w = 7; insertEdge(g, e);
-   e.v = 4; e.w = 8; insertEdge(g, e);
-   e.v = 5; e.w = 6; insertEdge(g, e);
-   e.v = 7; e.w = 8; insertEdge(g, e);
-   e.v = 7; e.w = 9; insertEdge(g, e);
-   e.v = 8; e.w = 9; insertEdge(g, e);
+    e.v = 0;
+    e.w = 1;
+    insertEdge(g, e);
+    e.v = 0;
+    e.w = 2;
+    insertEdge(g, e);
+    e.v = 0;
+    e.w = 5;
+    insertEdge(g, e);
+    e.v = 1;
+    e.w = 5;
+    insertEdge(g, e);
+    e.v = 2;
+    e.w = 3;
+    insertEdge(g, e);
+    e.v = 3;
+    e.w = 4;
+    insertEdge(g, e);
+    e.v = 3;
+    e.w = 5;
+    insertEdge(g, e);
+    e.v = 3;
+    e.w = 8;
+    insertEdge(g, e);
+    e.v = 4;
+    e.w = 5;
+    insertEdge(g, e);
+    e.v = 4;
+    e.w = 7;
+    insertEdge(g, e);
+    e.v = 4;
+    e.w = 8;
+    insertEdge(g, e);
+    e.v = 5;
+    e.w = 6;
+    insertEdge(g, e);
+    e.v = 7;
+    e.w = 8;
+    insertEdge(g, e);
+    e.v = 7;
+    e.w = 9;
+    insertEdge(g, e);
+    e.v = 8;
+    e.w = 9;
+    insertEdge(g, e);
 
     int src = 0, dest = 6;
-   if (findPathBFS(g, V, src, dest)) {
+    if (findPathBFS(g, V, src, dest))
+    {
         Vertex v = dest;
-      while (v != src) {
+        while (v != src)
+        {
             printf("%d - ", v);
             v = visited[v];
         }
@@ -65,17 +101,25 @@ int main(void) {
 }
 
 // By
-//  .----------------.  .----------------.  .----------------.  .-----------------.  .----------------.  .----------------. 
-// | .--------------. || .--------------. || .--------------. || .--------------. | | .--------------. || .--------------. |
-// | |  _________   | || | _____  _____ | || |      __      | || | ____  _____  | | | |  ____  ____  | || |     ____     | |
-// | | |  _   _  |  | || ||_   _||_   _|| || |     /  \     | || ||_   \|_   _| | | | | |_   ||   _| | || |   .'    `.   | |
-// | | |_/ | | \_|  | || |  | |    | |  | || |    / /\ \    | || |  |   \ | |   | | | |   | |__| |   | || |  /  .--.  \  | |
-// | |     | |      | || |  | '    ' |  | || |   / ____ \   | || |  | |\ \| |   | | | |   |  __  |   | || |  | |    | |  | |
-// | |    _| |_     | || |   \ `--' /   | || | _/ /    \ \_ | || | _| |_\   |_  | | | |  _| |  | |_  | || |  \  `--'  /  | |
-// | |   |_____|    | || |    `.__.'    | || ||____|  |____|| || ||_____|\____| | | | | |____||____| | || |   `.____.'   | |
-// | |              | || |              | || |              | || |              | | | |              | || |              | |
-// | '--------------' || '--------------' || '--------------' || '--------------' | | '--------------' || '--------------' |
-//  '----------------'  '----------------'  '----------------'  '----------------'   '----------------'  '----------------' 
+//  .----------------.  .----------------.  .----------------.
+//  .-----------------.  .----------------.  .----------------.
+// | .--------------. || .--------------. || .--------------. ||
+// .--------------. | | .--------------. || .--------------. | | |  _________ |
+// || | _____  _____ | || |      __      | || | ____  _____  | | | |  ____  ____
+// | || |     ____     | | | | |  _   _  |  | || ||_   _||_   _|| || |     /  \
+// | || ||_   \|_   _| | | | | |_   ||   _| | || |   .'    `.   | | | | |_/ | |
+// \_|  | || |  | |    | |  | || |    / /\ \    | || |  |   \ | |   | | | |   |
+// |__| |   | || |  /  .--.  \  | | | |     | |      | || |  | '    ' |  | || |
+// / ____ \   | || |  | |\ \| |   | | | |   |  __  |   | || |  | |    | |  | |
+// | |    _| |_     | || |   \ `--' /   | || | _/ /    \ \_ | || | _| |_\   |_
+// | | | |  _| |  | |_  | || |  \  `--'  /  | | | |   |_____|    | || | `.__.'
+// | || ||____|  |____|| || ||_____|\____| | | | | |____||____| | || | `.____.'
+// | | | |              | || |              | || |              | || | | | | |
+// | || |              | | | '--------------' || '--------------' ||
+// '--------------' || '--------------' | | '--------------' || '--------------'
+// |
+//  '----------------'  '----------------'  '----------------'
+//  '----------------'   '----------------'  '----------------'
 
 //  Email :    z5261243@unsw.edu.au
 //             hhoanhtuann@gmail.com

data_structures/graphs/dfsRecursive.c

@@ -1,16 +1,18 @@
-#include <stdio.h>
-#include <stdbool.h>
 #include "Graph.h"
+#include <stdbool.h>
+#include <stdio.h>
 
 #define MAX_NODES 1000
 
 int visited[MAX_NODES]; // array to store visiting order
                         // indexed by vertex 0..nV-1
 
-bool dfsPathCheck(Graph g, int nV, Vertex v, Vertex dest) {
+bool dfsPathCheck(Graph g, int nV, Vertex v, Vertex dest)
+{
     Vertex w;
     for (w = 0; w < nV; w++)
-      if (adjacent(g, v, w) && visited[w] == -1) {
+        if (adjacent(g, v, w) && visited[w] == -1)
+        {
             visited[w] = v;
             if (w == dest)
                 return true;
@@ -20,7 +22,8 @@ bool dfsPathCheck(Graph g, int nV, Vertex v, Vertex dest) {
     return false;
 }
 
-bool findPathDFS(Graph g, int nV, Vertex src, Vertex dest) {
+bool findPathDFS(Graph g, int nV, Vertex src, Vertex dest)
+{
     Vertex v;
     for (v = 0; v < nV; v++)
         visited[v] = -1;
@@ -28,25 +31,46 @@ bool findPathDFS(Graph g, int nV, Vertex src, Vertex dest) {
     return dfsPathCheck(g, nV, src, dest);
 }
 
-int main(void) {
+int main(void)
+{
     int V = 6;
     Graph g = newGraph(V);
 
     Edge e;
-   e.v = 0; e.w = 1; insertEdge(g, e);
-   e.v = 0; e.w = 4; insertEdge(g, e);
-   e.v = 0; e.w = 5; insertEdge(g, e);
-   e.v = 5; e.w = 4; insertEdge(g, e);
-   e.v = 4; e.w = 2; insertEdge(g, e);
-   e.v = 4; e.w = 3; insertEdge(g, e);
-   e.v = 5; e.w = 3; insertEdge(g, e);
-   e.v = 1; e.w = 2; insertEdge(g, e);
-   e.v = 3; e.w = 2; insertEdge(g, e);
+    e.v = 0;
+    e.w = 1;
+    insertEdge(g, e);
+    e.v = 0;
+    e.w = 4;
+    insertEdge(g, e);
+    e.v = 0;
+    e.w = 5;
+    insertEdge(g, e);
+    e.v = 5;
+    e.w = 4;
+    insertEdge(g, e);
+    e.v = 4;
+    e.w = 2;
+    insertEdge(g, e);
+    e.v = 4;
+    e.w = 3;
+    insertEdge(g, e);
+    e.v = 5;
+    e.w = 3;
+    insertEdge(g, e);
+    e.v = 1;
+    e.w = 2;
+    insertEdge(g, e);
+    e.v = 3;
+    e.w = 2;
+    insertEdge(g, e);
 
     int src = 0, dest = 5;
-   if (findPathDFS(g, V, src, dest)) {
+    if (findPathDFS(g, V, src, dest))
+    {
         Vertex v = dest;
-      while (v != src) {
+        while (v != src)
+        {
             printf("%d - ", v);
             v = visited[v];
         }
@@ -55,20 +79,26 @@ int main(void) {
     return 0;
 }
 
-
 // By
-//  .----------------.  .----------------.  .----------------.  .-----------------.  .----------------.  .----------------. 
-// | .--------------. || .--------------. || .--------------. || .--------------. | | .--------------. || .--------------. |
-// | |  _________   | || | _____  _____ | || |      __      | || | ____  _____  | | | |  ____  ____  | || |     ____     | |
-// | | |  _   _  |  | || ||_   _||_   _|| || |     /  \     | || ||_   \|_   _| | | | | |_   ||   _| | || |   .'    `.   | |
-// | | |_/ | | \_|  | || |  | |    | |  | || |    / /\ \    | || |  |   \ | |   | | | |   | |__| |   | || |  /  .--.  \  | |
-// | |     | |      | || |  | '    ' |  | || |   / ____ \   | || |  | |\ \| |   | | | |   |  __  |   | || |  | |    | |  | |
-// | |    _| |_     | || |   \ `--' /   | || | _/ /    \ \_ | || | _| |_\   |_  | | | |  _| |  | |_  | || |  \  `--'  /  | |
-// | |   |_____|    | || |    `.__.'    | || ||____|  |____|| || ||_____|\____| | | | | |____||____| | || |   `.____.'   | |
-// | |              | || |              | || |              | || |              | | | |              | || |              | |
-// | '--------------' || '--------------' || '--------------' || '--------------' | | '--------------' || '--------------' |
-//  '----------------'  '----------------'  '----------------'  '----------------'   '----------------'  '----------------' 
+//  .----------------.  .----------------.  .----------------.
+//  .-----------------.  .----------------.  .----------------.
+// | .--------------. || .--------------. || .--------------. ||
+// .--------------. | | .--------------. || .--------------. | | |  _________ |
+// || | _____  _____ | || |      __      | || | ____  _____  | | | |  ____  ____
+// | || |     ____     | | | | |  _   _  |  | || ||_   _||_   _|| || |     /  \
+// | || ||_   \|_   _| | | | | |_   ||   _| | || |   .'    `.   | | | | |_/ | |
+// \_|  | || |  | |    | |  | || |    / /\ \    | || |  |   \ | |   | | | |   |
+// |__| |   | || |  /  .--.  \  | | | |     | |      | || |  | '    ' |  | || |
+// / ____ \   | || |  | |\ \| |   | | | |   |  __  |   | || |  | |    | |  | |
+// | |    _| |_     | || |   \ `--' /   | || | _/ /    \ \_ | || | _| |_\   |_
+// | | | |  _| |  | |_  | || |  \  `--'  /  | | | |   |_____|    | || | `.__.'
+// | || ||____|  |____|| || ||_____|\____| | | | | |____||____| | || | `.____.'
+// | | | |              | || |              | || |              | || | | | | |
+// | || |              | | | '--------------' || '--------------' ||
+// '--------------' || '--------------' | | '--------------' || '--------------'
+// |
+//  '----------------'  '----------------'  '----------------'
+//  '----------------'   '----------------'  '----------------'
 
 //  Email :    z5261243@unsw.edu.au
 //             hhoanhtuann@gmail.com
-

data_structures/graphs/euler.c

@@ -1,10 +1,11 @@
-#include <stdio.h>
-#include <stdbool.h>
 #include "Graph.h"
+#include <stdbool.h>
+#include <stdio.h>
 
 // Return the number of vertices that v is
 // connected to
-int degree(Graph g, int nV, Vertex v) {
+int degree(Graph g, int nV, Vertex v)
+{
     int deg = 0;
     Vertex w;
     for (w = 0; w < nV; w++)
@@ -15,11 +16,15 @@ int degree(Graph g, int nV, Vertex v) {
 
 // If start from vertex v, decide if the
 // graph has euler path
-bool hasEulerPath(Graph g, int nV, Vertex v, Vertex w) {
-   if (v != w) {
+bool hasEulerPath(Graph g, int nV, Vertex v, Vertex w)
+{
+    if (v != w)
+    {
         if (degree(g, nV, v) % 2 == 0 || degree(g, nV, w) % 2 == 0)
             return false;
-   } else if (degree(g, nV, v) % 2 != 0) {
+    }
+    else if (degree(g, nV, v) % 2 != 0)
+    {
         return false;
     }
     Vertex x;
@@ -29,7 +34,8 @@ bool hasEulerPath(Graph g, int nV, Vertex v, Vertex w) {
     return true;
 }
 
-int main(void) {
+int main(void)
+{
     Edge e;
     int n;
 
@@ -44,7 +50,8 @@ int main(void) {
     scanf("%d", &dest);
 
     printf("Enter an edge (from): ");
-   while (scanf("%d", &e.v) == 1) {
+    while (scanf("%d", &e.v) == 1)
+    {
         printf("Enter an edge (to): ");
         scanf("%d", &e.w);
         insertEdge(g, e);
@@ -63,20 +70,26 @@ int main(void) {
     return 0;
 }
 
-
-
 // By
-//  .----------------.  .----------------.  .----------------.  .-----------------.  .----------------.  .----------------. 
-// | .--------------. || .--------------. || .--------------. || .--------------. | | .--------------. || .--------------. |
-// | |  _________   | || | _____  _____ | || |      __      | || | ____  _____  | | | |  ____  ____  | || |     ____     | |
-// | | |  _   _  |  | || ||_   _||_   _|| || |     /  \     | || ||_   \|_   _| | | | | |_   ||   _| | || |   .'    `.   | |
-// | | |_/ | | \_|  | || |  | |    | |  | || |    / /\ \    | || |  |   \ | |   | | | |   | |__| |   | || |  /  .--.  \  | |
-// | |     | |      | || |  | '    ' |  | || |   / ____ \   | || |  | |\ \| |   | | | |   |  __  |   | || |  | |    | |  | |
-// | |    _| |_     | || |   \ `--' /   | || | _/ /    \ \_ | || | _| |_\   |_  | | | |  _| |  | |_  | || |  \  `--'  /  | |
-// | |   |_____|    | || |    `.__.'    | || ||____|  |____|| || ||_____|\____| | | | | |____||____| | || |   `.____.'   | |
-// | |              | || |              | || |              | || |              | | | |              | || |              | |
-// | '--------------' || '--------------' || '--------------' || '--------------' | | '--------------' || '--------------' |
-//  '----------------'  '----------------'  '----------------'  '----------------'   '----------------'  '----------------' 
+//  .----------------.  .----------------.  .----------------.
+//  .-----------------.  .----------------.  .----------------.
+// | .--------------. || .--------------. || .--------------. ||
+// .--------------. | | .--------------. || .--------------. | | |  _________ |
+// || | _____  _____ | || |      __      | || | ____  _____  | | | |  ____  ____
+// | || |     ____     | | | | |  _   _  |  | || ||_   _||_   _|| || |     /  \
+// | || ||_   \|_   _| | | | | |_   ||   _| | || |   .'    `.   | | | | |_/ | |
+// \_|  | || |  | |    | |  | || |    / /\ \    | || |  |   \ | |   | | | |   |
+// |__| |   | || |  /  .--.  \  | | | |     | |      | || |  | '    ' |  | || |
+// / ____ \   | || |  | |\ \| |   | | | |   |  __  |   | || |  | |    | |  | |
+// | |    _| |_     | || |   \ `--' /   | || | _/ /    \ \_ | || | _| |_\   |_
+// | | | |  _| |  | |_  | || |  \  `--'  /  | | | |   |_____|    | || | `.__.'
+// | || ||____|  |____|| || ||_____|\____| | | | | |____||____| | || | `.____.'
+// | | | |              | || |              | || |              | || | | | | |
+// | || |              | | | '--------------' || '--------------' ||
+// '--------------' || '--------------' | | '--------------' || '--------------'
+// |
+//  '----------------'  '----------------'  '----------------'
+//  '----------------'   '----------------'  '----------------'
 
 //  Email :    z5261243@unsw.edu.au
 //             hhoanhtuann@gmail.com

data_structures/graphs/hamiltonian.c

@@ -1,24 +1,31 @@
-#include <stdio.h>
-#include <stdbool.h>
 #include "Graph.h"
+#include <stdbool.h>
+#include <stdio.h>
 
 #define MAX_NODES 1000
 
 bool visited[MAX_NODES];
 
-bool hamiltonR(Graph g, int nV, Vertex v, Vertex dest, int d) {
-// v = current vertex considered
-// dest = destination vertex
-// d = distance "remaining" until path found
+bool hamiltonR(Graph g, int nV, Vertex v, Vertex dest, int d)
+{
+    // v = current vertex considered
+    // dest = destination vertex
+    // d = distance "remaining" until path found
 
     Vertex w;
-   if (v == dest) {
+    if (v == dest)
+    {
         return (d == 0);
-   } else {
+    }
+    else
+    {
         visited[v] = true;
-      for (w = 0; w < nV; w++) {
-	 if (adjacent(g, v, w) && !visited[w]) {
-	    if (hamiltonR(g, nV, w, dest, d-1)) {
+        for (w = 0; w < nV; w++)
+        {
+            if (adjacent(g, v, w) && !visited[w])
+            {
+                if (hamiltonR(g, nV, w, dest, d - 1))
+                {
                     return true;
                 }
             }
@@ -28,14 +35,16 @@ bool hamiltonR(Graph g, int nV, Vertex v, Vertex dest, int d) {
     return false;
 }
 
-bool hasHamiltonianPath(Graph g, int nV, Vertex src, Vertex dest) {
+bool hasHamiltonianPath(Graph g, int nV, Vertex src, Vertex dest)
+{
     Vertex v;
     for (v = 0; v < nV; v++)
         visited[v] = false;
-   return hamiltonR(g, nV, src, dest, nV-1);
+    return hamiltonR(g, nV, src, dest, nV - 1);
 }
 
-int main(void) {
+int main(void)
+{
     Edge e;
     int n;
 
@@ -50,7 +59,8 @@ int main(void) {
     scanf("%d", &dest);
 
     printf("Enter an edge (from): ");
-   while (scanf("%d", &e.v) == 1) {
+    while (scanf("%d", &e.v) == 1)
+    {
         printf("Enter an edge (to): ");
         scanf("%d", &e.w);
         insertEdge(g, e);
@@ -69,19 +79,26 @@ int main(void) {
     return 0;
 }
 
-
 // By
-//  .----------------.  .----------------.  .----------------.  .-----------------.  .----------------.  .----------------. 
-// | .--------------. || .--------------. || .--------------. || .--------------. | | .--------------. || .--------------. |
-// | |  _________   | || | _____  _____ | || |      __      | || | ____  _____  | | | |  ____  ____  | || |     ____     | |
-// | | |  _   _  |  | || ||_   _||_   _|| || |     /  \     | || ||_   \|_   _| | | | | |_   ||   _| | || |   .'    `.   | |
-// | | |_/ | | \_|  | || |  | |    | |  | || |    / /\ \    | || |  |   \ | |   | | | |   | |__| |   | || |  /  .--.  \  | |
-// | |     | |      | || |  | '    ' |  | || |   / ____ \   | || |  | |\ \| |   | | | |   |  __  |   | || |  | |    | |  | |
-// | |    _| |_     | || |   \ `--' /   | || | _/ /    \ \_ | || | _| |_\   |_  | | | |  _| |  | |_  | || |  \  `--'  /  | |
-// | |   |_____|    | || |    `.__.'    | || ||____|  |____|| || ||_____|\____| | | | | |____||____| | || |   `.____.'   | |
-// | |              | || |              | || |              | || |              | | | |              | || |              | |
-// | '--------------' || '--------------' || '--------------' || '--------------' | | '--------------' || '--------------' |
-//  '----------------'  '----------------'  '----------------'  '----------------'   '----------------'  '----------------' 
+//  .----------------.  .----------------.  .----------------.
+//  .-----------------.  .----------------.  .----------------.
+// | .--------------. || .--------------. || .--------------. ||
+// .--------------. | | .--------------. || .--------------. | | |  _________ |
+// || | _____  _____ | || |      __      | || | ____  _____  | | | |  ____  ____
+// | || |     ____     | | | | |  _   _  |  | || ||_   _||_   _|| || |     /  \
+// | || ||_   \|_   _| | | | | |_   ||   _| | || |   .'    `.   | | | | |_/ | |
+// \_|  | || |  | |    | |  | || |    / /\ \    | || |  |   \ | |   | | | |   |
+// |__| |   | || |  /  .--.  \  | | | |     | |      | || |  | '    ' |  | || |
+// / ____ \   | || |  | |\ \| |   | | | |   |  __  |   | || |  | |    | |  | |
+// | |    _| |_     | || |   \ `--' /   | || | _/ /    \ \_ | || | _| |_\   |_
+// | | | |  _| |  | |_  | || |  \  `--'  /  | | | |   |_____|    | || | `.__.'
+// | || ||____|  |____|| || ||_____|\____| | | | | |____||____| | || | `.____.'
+// | | | |              | || |              | || |              | || | | | | |
+// | || |              | | | '--------------' || '--------------' ||
+// '--------------' || '--------------' | | '--------------' || '--------------'
+// |
+//  '----------------'  '----------------'  '----------------'
+//  '----------------'   '----------------'  '----------------'
 
 //  Email :    z5261243@unsw.edu.au
 //             hhoanhtuann@gmail.com

data_structures/graphs/kruskal.c

@@ -21,13 +21,13 @@ struct Graph
     // Since the graph is undirected, the edge
     // from src to dest is also edge from dest
     // to src. Both are counted as 1 edge here.
-	struct Edge* edge; 
+    struct Edge *edge;
 };
 
 // Creates a graph with V vertices and E edges
-struct Graph* createGraph(int V, int E) 
+struct Graph *createGraph(int V, int E)
 {
-	struct Graph* graph = new Graph(); 
+    struct Graph *graph = new Graph();
     graph->V = V;
     graph->E = E;
 
@@ -80,15 +80,15 @@ void Union(struct subset subsets[], int x, int y)
 
 // Compare two edges according to their weights.
 // Used in qsort() for sorting an array of edges
-int myComp(const void* a, const void* b) 
+int myComp(const void *a, const void *b)
 {
-	struct Edge* a1 = (struct Edge*)a; 
-	struct Edge* b1 = (struct Edge*)b; 
+    struct Edge *a1 = (struct Edge *)a;
+    struct Edge *b1 = (struct Edge *)b;
     return a1->weight > b1->weight;
 }
 
 // The main function to construct MST using Kruskal's algorithm
-void KruskalMST(struct Graph* graph) 
+void KruskalMST(struct Graph *graph)
 {
     int V = graph->V;
     struct Edge result[V]; // Tnis will store the resultant MST
@@ -102,8 +102,7 @@ void KruskalMST(struct Graph* graph)
     qsort(graph->edge, graph->E, sizeof(graph->edge[0]), myComp);
 
     // Allocate memory for creating V ssubsets
-	struct subset *subsets = 
-		(struct subset*) malloc( V * sizeof(struct subset) ); 
+    struct subset *subsets = (struct subset *)malloc(V * sizeof(struct subset));
 
     // Create V subsets with single elements
     for (int v = 0; v < V; ++v)
@@ -155,8 +154,7 @@ int main()
             4	 */
     int V = 4; // Number of vertices in graph
     int E = 5; // Number of edges in graph
-	struct Graph* graph = createGraph(V, E); 
-
+    struct Graph *graph = createGraph(V, E);
 
     // add edge 0-1
     graph->edge[0].src = 0;

data_structures/graphs/queue.c

@@ -1,22 +1,25 @@
 // Queue ADT implementation ... COMP2521
 
-#include <stdlib.h>
-#include <assert.h>
 #include "queue.h"
+#include <assert.h>
+#include <stdlib.h>
 
-typedef struct node {
+typedef struct node
+{
     int data;
     struct node *next;
 } NodeT;
 
-typedef struct QueueRep {
+typedef struct QueueRep
+{
     int length;
     NodeT *head;
     NodeT *tail;
 } QueueRep;
 
 // set up empty queue
-queue newQueue() {
+queue newQueue()
+{
     queue Q = malloc(sizeof(QueueRep));
     Q->length = 0;
     Q->head = NULL;
@@ -25,9 +28,11 @@ queue newQueue() {
 }
 
 // remove unwanted queue
-void dropQueue(queue Q) {
+void dropQueue(queue Q)
+{
     NodeT *curr = Q->head;
-   while (curr != NULL) {
+    while (curr != NULL)
+    {
         NodeT *temp = curr->next;
         free(curr);
         curr = temp;
@@ -36,20 +41,22 @@ void dropQueue(queue Q) {
 }
 
 // check whether queue is empty
-int QueueIsEmpty(queue Q) {
-   return (Q->length == 0);
-}
+int QueueIsEmpty(queue Q) { return (Q->length == 0); }
 
 // insert an int at end of queue
-void QueueEnqueue(queue Q, int v) {
+void QueueEnqueue(queue Q, int v)
+{
     NodeT *new = malloc(sizeof(NodeT));
     assert(new != NULL);
     new->data = v;
     new->next = NULL;
-   if (Q->tail != NULL) {
+    if (Q->tail != NULL)
+    {
         Q->tail->next = new;
         Q->tail = new;
-   } else {
+    }
+    else
+    {
         Q->head = new;
         Q->tail = new;
     }
@@ -57,11 +64,13 @@ void QueueEnqueue(queue Q, int v) {
 }
 
 // remove int from front of queue
-int QueueDequeue(queue Q) {
+int QueueDequeue(queue Q)
+{
     assert(Q->length > 0);
     NodeT *p = Q->head;
     Q->head = Q->head->next;
-   if (Q->head == NULL) {
+    if (Q->head == NULL)
+    {
         Q->tail = NULL;
     }
     Q->length--;
@@ -70,19 +79,26 @@ int QueueDequeue(queue Q) {
     return d;
 }
 
-
 // By
-//  .----------------.  .----------------.  .----------------.  .-----------------.  .----------------.  .----------------. 
-// | .--------------. || .--------------. || .--------------. || .--------------. | | .--------------. || .--------------. |
-// | |  _________   | || | _____  _____ | || |      __      | || | ____  _____  | | | |  ____  ____  | || |     ____     | |
-// | | |  _   _  |  | || ||_   _||_   _|| || |     /  \     | || ||_   \|_   _| | | | | |_   ||   _| | || |   .'    `.   | |
-// | | |_/ | | \_|  | || |  | |    | |  | || |    / /\ \    | || |  |   \ | |   | | | |   | |__| |   | || |  /  .--.  \  | |
-// | |     | |      | || |  | '    ' |  | || |   / ____ \   | || |  | |\ \| |   | | | |   |  __  |   | || |  | |    | |  | |
-// | |    _| |_     | || |   \ `--' /   | || | _/ /    \ \_ | || | _| |_\   |_  | | | |  _| |  | |_  | || |  \  `--'  /  | |
-// | |   |_____|    | || |    `.__.'    | || ||____|  |____|| || ||_____|\____| | | | | |____||____| | || |   `.____.'   | |
-// | |              | || |              | || |              | || |              | | | |              | || |              | |
-// | '--------------' || '--------------' || '--------------' || '--------------' | | '--------------' || '--------------' |
-//  '----------------'  '----------------'  '----------------'  '----------------'   '----------------'  '----------------' 
+//  .----------------.  .----------------.  .----------------.
+//  .-----------------.  .----------------.  .----------------.
+// | .--------------. || .--------------. || .--------------. ||
+// .--------------. | | .--------------. || .--------------. | | |  _________ |
+// || | _____  _____ | || |      __      | || | ____  _____  | | | |  ____  ____
+// | || |     ____     | | | | |  _   _  |  | || ||_   _||_   _|| || |     /  \
+// | || ||_   \|_   _| | | | | |_   ||   _| | || |   .'    `.   | | | | |_/ | |
+// \_|  | || |  | |    | |  | || |    / /\ \    | || |  |   \ | |   | | | |   |
+// |__| |   | || |  /  .--.  \  | | | |     | |      | || |  | '    ' |  | || |
+// / ____ \   | || |  | |\ \| |   | | | |   |  __  |   | || |  | |    | |  | |
+// | |    _| |_     | || |   \ `--' /   | || | _/ /    \ \_ | || | _| |_\   |_
+// | | | |  _| |  | |_  | || |  \  `--'  /  | | | |   |_____|    | || | `.__.'
+// | || ||____|  |____|| || ||_____|\____| | | | | |____||____| | || | `.____.'
+// | | | |              | || |              | || |              | || | | | | |
+// | || |              | | | '--------------' || '--------------' ||
+// '--------------' || '--------------' | | '--------------' || '--------------'
+// |
+//  '----------------'  '----------------'  '----------------'
+//  '----------------'   '----------------'  '----------------'
 
 //  Email :    z5261243@unsw.edu.au
 //             hhoanhtuann@gmail.com

data_structures/graphs/queue.h

@@ -8,19 +8,26 @@ int   QueueIsEmpty(queue);      // check whether queue is empty
 void QueueEnqueue(queue, int); // insert an int at end of queue
 int QueueDequeue(queue);       // remove int from front of queue
 
-
 // By
-//  .----------------.  .----------------.  .----------------.  .-----------------.  .----------------.  .----------------. 
-// | .--------------. || .--------------. || .--------------. || .--------------. | | .--------------. || .--------------. |
-// | |  _________   | || | _____  _____ | || |      __      | || | ____  _____  | | | |  ____  ____  | || |     ____     | |
-// | | |  _   _  |  | || ||_   _||_   _|| || |     /  \     | || ||_   \|_   _| | | | | |_   ||   _| | || |   .'    `.   | |
-// | | |_/ | | \_|  | || |  | |    | |  | || |    / /\ \    | || |  |   \ | |   | | | |   | |__| |   | || |  /  .--.  \  | |
-// | |     | |      | || |  | '    ' |  | || |   / ____ \   | || |  | |\ \| |   | | | |   |  __  |   | || |  | |    | |  | |
-// | |    _| |_     | || |   \ `--' /   | || | _/ /    \ \_ | || | _| |_\   |_  | | | |  _| |  | |_  | || |  \  `--'  /  | |
-// | |   |_____|    | || |    `.__.'    | || ||____|  |____|| || ||_____|\____| | | | | |____||____| | || |   `.____.'   | |
-// | |              | || |              | || |              | || |              | | | |              | || |              | |
-// | '--------------' || '--------------' || '--------------' || '--------------' | | '--------------' || '--------------' |
-//  '----------------'  '----------------'  '----------------'  '----------------'   '----------------'  '----------------' 
+//  .----------------.  .----------------.  .----------------.
+//  .-----------------.  .----------------.  .----------------.
+// | .--------------. || .--------------. || .--------------. ||
+// .--------------. | | .--------------. || .--------------. | | |  _________ |
+// || | _____  _____ | || |      __      | || | ____  _____  | | | |  ____  ____
+// | || |     ____     | | | | |  _   _  |  | || ||_   _||_   _|| || |     /  \
+// | || ||_   \|_   _| | | | | |_   ||   _| | || |   .'    `.   | | | | |_/ | |
+// \_|  | || |  | |    | |  | || |    / /\ \    | || |  |   \ | |   | | | |   |
+// |__| |   | || |  /  .--.  \  | | | |     | |      | || |  | '    ' |  | || |
+// / ____ \   | || |  | |\ \| |   | | | |   |  __  |   | || |  | |    | |  | |
+// | |    _| |_     | || |   \ `--' /   | || | _/ /    \ \_ | || | _| |_\   |_
+// | | | |  _| |  | |_  | || |  \  `--'  /  | | | |   |_____|    | || | `.__.'
+// | || ||____|  |____|| || ||_____|\____| | | | | |____||____| | || | `.____.'
+// | | | |              | || |              | || |              | || | | | | |
+// | || |              | | | '--------------' || '--------------' ||
+// '--------------' || '--------------' | | '--------------' || '--------------'
+// |
+//  '----------------'  '----------------'  '----------------'
+//  '----------------'   '----------------'  '----------------'
 
 //  Email :    z5261243@unsw.edu.au
 //             hhoanhtuann@gmail.com

data_structures/graphs/strongly_connected_components.c

@@ -1,59 +1,61 @@
 #include <stdio.h>
 #include <stdlib.h>
-#define MAX_SIZE 40//Assume 40 nodes at max in graph
+#define MAX_SIZE 40 // Assume 40 nodes at max in graph
 #define INT_MIN 0
-//A vertex of the graph 
+// A vertex of the graph
 struct node
 {
     int vertex;
-    struct node* next;
+    struct node *next;
 };
-//Some declarations
-struct node* createNode(int v);
+// Some declarations
+struct node *createNode(int v);
 struct Graph
 {
     int numVertices;
-    int* visited;
-    struct node** adjLists; // we need int** to store a two dimensional array. Similary, we need struct node** to store an array of Linked lists
+    int *visited;
+    struct node *
+        *adjLists; // we need int** to store a two dimensional array. Similary,
+                   // we need struct node** to store an array of Linked lists
 };
-//Structure to create a stack, necessary for topological sorting
+// Structure to create a stack, necessary for topological sorting
 struct Stack
 {
     int arr[MAX_SIZE];
     int top;
 };
-struct Graph* createGraph(int);
-void addEdge(struct Graph*, int, int);
-void printGraph(struct Graph*);
-struct Graph* transpose(struct Graph*);
-void fillOrder(int,struct Graph*, struct Stack*);
-void scc(struct Graph*);
-void dfs(struct Graph*, int);
-struct Stack* createStack();
-void push(struct Stack*, int);
-int pop(struct Stack*);
+struct Graph *createGraph(int);
+void addEdge(struct Graph *, int, int);
+void printGraph(struct Graph *);
+struct Graph *transpose(struct Graph *);
+void fillOrder(int, struct Graph *, struct Stack *);
+void scc(struct Graph *);
+void dfs(struct Graph *, int);
+struct Stack *createStack();
+void push(struct Stack *, int);
+int pop(struct Stack *);
 
 int main()
 {
-	int vertices,edges,i,src,dst;
+    int vertices, edges, i, src, dst;
     printf("Enter the number of vertices\n");
-	scanf("%d",&vertices);
-	struct Graph* graph = createGraph(vertices);
+    scanf("%d", &vertices);
+    struct Graph *graph = createGraph(vertices);
     printf("Enter the number of edges\n");
-	scanf("%d",&edges);
-	for(i=0; i<edges; i++)
+    scanf("%d", &edges);
+    for (i = 0; i < edges; i++)
     {
-		printf("Edge %d \nEnter source: ",i+1);
-		scanf("%d",&src);
+        printf("Edge %d \nEnter source: ", i + 1);
+        scanf("%d", &src);
         printf("Enter destination: ");
-		scanf("%d",&dst);
+        scanf("%d", &dst);
         addEdge(graph, src, dst);
     }
     printf("The strongly connected conponents are:\n");
     scc(graph);
     printf("\n");
 
-	//Uncomment below part to get a ready-made example
+    // Uncomment below part to get a ready-made example
     /*struct Graph* graph2 = createGraph(4);
     addEdge(graph2, 0, 1);
     addEdge(graph2, 1, 2);
@@ -64,124 +66,131 @@ int main()
     printf("\n");*/
     return 0;
 }
-//Creates a topological sorting of the graph
-void fillOrder(int vertex, struct Graph* graph, struct Stack* stack)
+// Creates a topological sorting of the graph
+void fillOrder(int vertex, struct Graph *graph, struct Stack *stack)
 {
-	graph->visited[vertex]=1;
-	struct node* adjList = graph->adjLists[vertex];
-    struct node* temp = adjList;
-    //First add all dependents (that is, children) to stack
-    while(temp!=NULL) {
+    graph->visited[vertex] = 1;
+    struct node *adjList = graph->adjLists[vertex];
+    struct node *temp = adjList;
+    // First add all dependents (that is, children) to stack
+    while (temp != NULL)
+    {
         int connectedVertex = temp->vertex;
-        if(graph->visited[connectedVertex] == 0) {
+        if (graph->visited[connectedVertex] == 0)
+        {
             fillOrder(connectedVertex, graph, stack);
         }
-        temp=temp->next;
+        temp = temp->next;
     }
-    //and then add itself
-    push(stack,vertex);
+    // and then add itself
+    push(stack, vertex);
 }
-//Transpose the adjacency list
-struct Graph* transpose(struct Graph* g)
+// Transpose the adjacency list
+struct Graph *transpose(struct Graph *g)
 {
-	struct Graph* graph = createGraph(g->numVertices);//Number of vertices is same
-	int i=0;
-	for(i=0;i<g->numVertices;i++)
+    struct Graph *graph =
+        createGraph(g->numVertices); // Number of vertices is same
+    int i = 0;
+    for (i = 0; i < g->numVertices; i++)
     {
-		struct node* temp=g->adjLists[i];
-		while(temp!=NULL)
+        struct node *temp = g->adjLists[i];
+        while (temp != NULL)
         {
-			addEdge(graph,temp->vertex,i);//Reverse all edges
-			temp=temp->next;
+            addEdge(graph, temp->vertex, i); // Reverse all edges
+            temp = temp->next;
         }
     }
     return graph;
 }
-//Recursive dfs aproach
-void dfs(struct Graph* graph, int vertex) {
-    struct node* adjList = graph->adjLists[vertex];
-    struct node* temp = adjList;
+// Recursive dfs aproach
+void dfs(struct Graph *graph, int vertex)
+{
+    struct node *adjList = graph->adjLists[vertex];
+    struct node *temp = adjList;
 
-    //Add vertex to visited list and print it
+    // Add vertex to visited list and print it
     graph->visited[vertex] = 1;
     printf("%d ", vertex);
 
-    //Recursively call the dfs function on all unvisited neighbours
-    while(temp!=NULL) {
+    // Recursively call the dfs function on all unvisited neighbours
+    while (temp != NULL)
+    {
         int connectedVertex = temp->vertex;
-        if(graph->visited[connectedVertex] == 0) {
+        if (graph->visited[connectedVertex] == 0)
+        {
             dfs(graph, connectedVertex);
         }
         temp = temp->next;
     }
 }
 
-//Strongly connected components
-void scc(struct Graph* graph)
+// Strongly connected components
+void scc(struct Graph *graph)
 {
-	//Step I: Create a topological sort of the graph and store it in a stack
-	struct Stack* stack=createStack();
-	int i=0;
-	for(i=0;i<graph->numVertices;i++)
+    // Step I: Create a topological sort of the graph and store it in a stack
+    struct Stack *stack = createStack();
+    int i = 0;
+    for (i = 0; i < graph->numVertices; i++)
     {
-		//Execute topological sort on all elements
-		if(graph->visited[i]==0)
+        // Execute topological sort on all elements
+        if (graph->visited[i] == 0)
         {
-			fillOrder(i,graph,stack);
+            fillOrder(i, graph, stack);
         }
     }
-	//Step 2: Get the transpose graph
-	struct Graph* graphT=transpose(graph);
-	//Step 3: Perform a simple dfs by popping nodes from stack
-	while(stack->top!=-1)
+    // Step 2: Get the transpose graph
+    struct Graph *graphT = transpose(graph);
+    // Step 3: Perform a simple dfs by popping nodes from stack
+    while (stack->top != -1)
     {
-		int v=pop(stack);
-		if(graphT->visited[v]==0)
+        int v = pop(stack);
+        if (graphT->visited[v] == 0)
         {
-			dfs(graphT,v);
+            dfs(graphT, v);
             printf("\n");
         }
     }
 }
 
-//Allocate memory for a node
-struct node* createNode(int v)
+// Allocate memory for a node
+struct node *createNode(int v)
 {
-    struct node* newNode = malloc(sizeof(struct node));
+    struct node *newNode = malloc(sizeof(struct node));
     newNode->vertex = v;
     newNode->next = NULL;
     return newNode;
 }
-//Allocate memory for the entire graph structure
-struct Graph* createGraph(int vertices)
+// Allocate memory for the entire graph structure
+struct Graph *createGraph(int vertices)
 {
-    struct Graph* graph = malloc(sizeof(struct Graph));
+    struct Graph *graph = malloc(sizeof(struct Graph));
     graph->numVertices = vertices;
-    graph->adjLists = malloc(vertices * sizeof(struct node*));    
+    graph->adjLists = malloc(vertices * sizeof(struct node *));
     graph->visited = malloc(vertices * sizeof(int));
 
     int i;
-    for (i = 0; i < vertices; i++) {
+    for (i = 0; i < vertices; i++)
+    {
         graph->adjLists[i] = NULL;
         graph->visited[i] = 0;
     }
     return graph;
 }
-//Creates a unidirectional graph
-void addEdge(struct Graph* graph, int src, int dest)
+// Creates a unidirectional graph
+void addEdge(struct Graph *graph, int src, int dest)
 {
     // Add edge from src to dest
-    struct node* newNode = createNode(dest);
+    struct node *newNode = createNode(dest);
     newNode->next = graph->adjLists[src];
     graph->adjLists[src] = newNode;
 }
-//Utility function to see state of graph at a given time 
-void printGraph(struct Graph* graph)
+// Utility function to see state of graph at a given time
+void printGraph(struct Graph *graph)
 {
     int v;
     for (v = 0; v < graph->numVertices; v++)
     {
-        struct node* temp = graph->adjLists[v];
+        struct node *temp = graph->adjLists[v];
         printf("\n Adjacency list of vertex %d\n ", v);
         while (temp)
         {
@@ -191,22 +200,23 @@ void printGraph(struct Graph* graph)
         printf("\n");
     }
 }
-//Creates a stack
-struct Stack* createStack()
+// Creates a stack
+struct Stack *createStack()
 {
-	struct Stack* stack=malloc(sizeof(struct Stack));
-	stack->top=-1;
+    struct Stack *stack = malloc(sizeof(struct Stack));
+    stack->top = -1;
     return stack;
 }
-//Pushes element into stack
-void push(struct Stack* stack,int element)
+// Pushes element into stack
+void push(struct Stack *stack, int element)
 {
-	stack->arr[++stack->top]=element;//Increment then add, as we start from -1
+    stack->arr[++stack->top] =
+        element; // Increment then add, as we start from -1
 }
-//Removes element from stack, or returns INT_MIN if stack empty
-int pop(struct Stack* stack)
+// Removes element from stack, or returns INT_MIN if stack empty
+int pop(struct Stack *stack)
 {
-	if(stack->top==-1)
+    if (stack->top == -1)
         return INT_MIN;
     else
         return stack->arr[stack->top--];

data_structures/graphs/topologicalSort.c

@@ -1,57 +1,59 @@
 #include <stdio.h>
 #include <stdlib.h>
-#define MAX_SIZE 40//Assume 40 nodes at max in graph
+#define MAX_SIZE 40 // Assume 40 nodes at max in graph
 #define INT_MIN 0
-//A vertex of the graph 
+// A vertex of the graph
 struct node
 {
     int vertex;
-    struct node* next;
+    struct node *next;
 };
-//Some declarations
-struct node* createNode(int v);
+// Some declarations
+struct node *createNode(int v);
 struct Graph
 {
     int numVertices;
-    int* visited;
-    struct node** adjLists; // we need int** to store a two dimensional array. Similary, we need struct node** to store an array of Linked lists
+    int *visited;
+    struct node *
+        *adjLists; // we need int** to store a two dimensional array. Similary,
+                   // we need struct node** to store an array of Linked lists
 };
-//Structure to create a stack, necessary for topological sorting
+// Structure to create a stack, necessary for topological sorting
 struct Stack
 {
     int arr[MAX_SIZE];
     int top;
 };
-struct Graph* createGraph(int);
-void addEdge(struct Graph*, int, int);
-void printGraph(struct Graph*);
-void topologicalSortHelper(int,struct Graph*, struct Stack*);
-void topologicalSort(struct Graph*);
-struct Stack* createStack();
-void push(struct Stack*, int);
-int pop(struct Stack*);
+struct Graph *createGraph(int);
+void addEdge(struct Graph *, int, int);
+void printGraph(struct Graph *);
+void topologicalSortHelper(int, struct Graph *, struct Stack *);
+void topologicalSort(struct Graph *);
+struct Stack *createStack();
+void push(struct Stack *, int);
+int pop(struct Stack *);
 
 int main()
 {
-	int vertices,edges,i,src,dst;
+    int vertices, edges, i, src, dst;
     printf("Enter the number of vertices\n");
-	scanf("%d",&vertices);
-	struct Graph* graph = createGraph(vertices);
+    scanf("%d", &vertices);
+    struct Graph *graph = createGraph(vertices);
     printf("Enter the number of edges\n");
-	scanf("%d",&edges);
-	for(i=0; i<edges; i++)
+    scanf("%d", &edges);
+    for (i = 0; i < edges; i++)
     {
-		printf("Edge %d \nEnter source: ",i+1);
-		scanf("%d",&src);
+        printf("Edge %d \nEnter source: ", i + 1);
+        scanf("%d", &src);
         printf("Enter destination: ");
-		scanf("%d",&dst);
+        scanf("%d", &dst);
         addEdge(graph, src, dst);
     }
     printf("One topological sort order is:\n");
     topologicalSort(graph);
     printf("\n");
 
-	//Uncomment below part to get a ready-made example
+    // Uncomment below part to get a ready-made example
     /*struct Graph* graph2 = createGraph(4);
     addEdge(graph2, 0, 1);
     addEdge(graph2, 0, 2);
@@ -63,77 +65,80 @@ int main()
     return 0;
 }
 
-void topologicalSortHelper(int vertex, struct Graph* graph, struct Stack* stack)
+void topologicalSortHelper(int vertex, struct Graph *graph, struct Stack *stack)
 {
-	graph->visited[vertex]=1;
-	struct node* adjList = graph->adjLists[vertex];
-    struct node* temp = adjList;
-    //First add all dependents (that is, children) to stack
-    while(temp!=NULL) {
+    graph->visited[vertex] = 1;
+    struct node *adjList = graph->adjLists[vertex];
+    struct node *temp = adjList;
+    // First add all dependents (that is, children) to stack
+    while (temp != NULL)
+    {
         int connectedVertex = temp->vertex;
-        if(graph->visited[connectedVertex] == 0) {
+        if (graph->visited[connectedVertex] == 0)
+        {
             topologicalSortHelper(connectedVertex, graph, stack);
         }
-        temp=temp->next;
+        temp = temp->next;
     }
-    //and then add itself
-    push(stack,vertex);
+    // and then add itself
+    push(stack, vertex);
 }
 
-//Recursive topologial sort approach
-void topologicalSort(struct Graph* graph)
+// Recursive topologial sort approach
+void topologicalSort(struct Graph *graph)
 {
-	struct Stack* stack=createStack();
-	int i=0;
-	for(i=0;i<graph->numVertices;i++)
+    struct Stack *stack = createStack();
+    int i = 0;
+    for (i = 0; i < graph->numVertices; i++)
     {
-		//Execute topological sort on all elements
-		if(graph->visited[i]==0)
+        // Execute topological sort on all elements
+        if (graph->visited[i] == 0)
         {
-			topologicalSortHelper(i,graph,stack);
+            topologicalSortHelper(i, graph, stack);
         }
     }
-	while(stack->top!=-1)
-	printf("%d ",pop(stack));
+    while (stack->top != -1)
+        printf("%d ", pop(stack));
 }
-//Allocate memory for a node
-struct node* createNode(int v)
+// Allocate memory for a node
+struct node *createNode(int v)
 {
-    struct node* newNode = malloc(sizeof(struct node));
+    struct node *newNode = malloc(sizeof(struct node));
     newNode->vertex = v;
     newNode->next = NULL;
     return newNode;
 }
-//Allocate memory for the entire graph structure
-struct Graph* createGraph(int vertices)
+// Allocate memory for the entire graph structure
+struct Graph *createGraph(int vertices)
 {
-    struct Graph* graph = malloc(sizeof(struct Graph));
+    struct Graph *graph = malloc(sizeof(struct Graph));
     graph->numVertices = vertices;
-    graph->adjLists = malloc(vertices * sizeof(struct node*));    
+    graph->adjLists = malloc(vertices * sizeof(struct node *));
     graph->visited = malloc(vertices * sizeof(int));
 
     int i;
-    for (i = 0; i < vertices; i++) {
+    for (i = 0; i < vertices; i++)
+    {
         graph->adjLists[i] = NULL;
         graph->visited[i] = 0;
     }
     return graph;
 }
-//Creates a unidirectional graph
-void addEdge(struct Graph* graph, int src, int dest)
+// Creates a unidirectional graph
+void addEdge(struct Graph *graph, int src, int dest)
 {
     // Add edge from src to dest
-    struct node* newNode = createNode(dest);
+    struct node *newNode = createNode(dest);
     newNode->next = graph->adjLists[src];
     graph->adjLists[src] = newNode;
 }
-//Utility function to see state of graph at a given time 
-void printGraph(struct Graph* graph)
+// Utility function to see state of graph at a given time
+void printGraph(struct Graph *graph)
 {
     int v;
     for (v = 0; v < graph->numVertices; v++)
     {
-        struct node* temp = graph->adjLists[v];
+        struct node *temp = graph->adjLists[v];
         printf("\n Adjacency list of vertex %d\n ", v);
         while (temp)
         {
@@ -143,24 +148,24 @@ void printGraph(struct Graph* graph)
         printf("\n");
     }
 }
-//Creates a stack
-struct Stack* createStack()
+// Creates a stack
+struct Stack *createStack()
 {
-	struct Stack* stack=malloc(sizeof(struct Stack));
-	stack->top=-1;
+    struct Stack *stack = malloc(sizeof(struct Stack));
+    stack->top = -1;
     return stack;
 }
-//Pushes element into stack
-void push(struct Stack* stack,int element)
+// Pushes element into stack
+void push(struct Stack *stack, int element)
 {
-	stack->arr[++stack->top]=element;//Increment then add, as we start from -1
+    stack->arr[++stack->top] =
+        element; // Increment then add, as we start from -1
 }
-//Removes element from stack, or returns INT_MIN if stack empty
-int pop(struct Stack* stack)
+// Removes element from stack, or returns INT_MIN if stack empty
+int pop(struct Stack *stack)
 {
-	if(stack->top==-1)
+    if (stack->top == -1)
         return INT_MIN;
     else
         return stack->arr[stack->top--];
 }
-

data_structures/graphs/transitiveClosure.c

@@ -1,12 +1,14 @@
-#include <stdio.h>
 #include <stdbool.h>
+#include <stdio.h>
 
 #define NODES 4
 
-int digraph[NODES][NODES]={ {0,1,1,1}, {1,0,1,0}, {0,1,0,0}, {0,0,0,0} };
+int digraph[NODES][NODES] = {
+    {0, 1, 1, 1}, {1, 0, 1, 0}, {0, 1, 0, 0}, {0, 0, 0, 0}};
 int tc[NODES][NODES];
 
-void warshall() {
+void warshall()
+{
     int i, s, t;
     for (s = 0; s < NODES; s++)
         for (t = 0; t < NODES; t++)
@@ -19,11 +21,14 @@ void warshall() {
                     tc[s][t] = 1;
 }
 
-int main(void) {
+int main(void)
+{
     warshall();
     int i, j;
-   for (i = 0; i < NODES; i++) {
-      for (j = 0; j < NODES; j++) {
+    for (i = 0; i < NODES; i++)
+    {
+        for (j = 0; j < NODES; j++)
+        {
             printf("%d ", tc[i][j]);
         }
         putchar('\n');
@@ -32,17 +37,25 @@ int main(void) {
 }
 
 // By
-//  .----------------.  .----------------.  .----------------.  .-----------------.  .----------------.  .----------------. 
-// | .--------------. || .--------------. || .--------------. || .--------------. | | .--------------. || .--------------. |
-// | |  _________   | || | _____  _____ | || |      __      | || | ____  _____  | | | |  ____  ____  | || |     ____     | |
-// | | |  _   _  |  | || ||_   _||_   _|| || |     /  \     | || ||_   \|_   _| | | | | |_   ||   _| | || |   .'    `.   | |
-// | | |_/ | | \_|  | || |  | |    | |  | || |    / /\ \    | || |  |   \ | |   | | | |   | |__| |   | || |  /  .--.  \  | |
-// | |     | |      | || |  | '    ' |  | || |   / ____ \   | || |  | |\ \| |   | | | |   |  __  |   | || |  | |    | |  | |
-// | |    _| |_     | || |   \ `--' /   | || | _/ /    \ \_ | || | _| |_\   |_  | | | |  _| |  | |_  | || |  \  `--'  /  | |
-// | |   |_____|    | || |    `.__.'    | || ||____|  |____|| || ||_____|\____| | | | | |____||____| | || |   `.____.'   | |
-// | |              | || |              | || |              | || |              | | | |              | || |              | |
-// | '--------------' || '--------------' || '--------------' || '--------------' | | '--------------' || '--------------' |
-//  '----------------'  '----------------'  '----------------'  '----------------'   '----------------'  '----------------' 
+//  .----------------.  .----------------.  .----------------.
+//  .-----------------.  .----------------.  .----------------.
+// | .--------------. || .--------------. || .--------------. ||
+// .--------------. | | .--------------. || .--------------. | | |  _________ |
+// || | _____  _____ | || |      __      | || | ____  _____  | | | |  ____  ____
+// | || |     ____     | | | | |  _   _  |  | || ||_   _||_   _|| || |     /  \
+// | || ||_   \|_   _| | | | | |_   ||   _| | || |   .'    `.   | | | | |_/ | |
+// \_|  | || |  | |    | |  | || |    / /\ \    | || |  |   \ | |   | | | |   |
+// |__| |   | || |  /  .--.  \  | | | |     | |      | || |  | '    ' |  | || |
+// / ____ \   | || |  | |\ \| |   | | | |   |  __  |   | || |  | |    | |  | |
+// | |    _| |_     | || |   \ `--' /   | || | _/ /    \ \_ | || | _| |_\   |_
+// | | | |  _| |  | |_  | || |  \  `--'  /  | | | |   |_____|    | || | `.__.'
+// | || ||____|  |____|| || ||_____|\____| | | | | |____||____| | || | `.____.'
+// | | | |              | || |              | || |              | || | | | | |
+// | || |              | | | '--------------' || '--------------' ||
+// '--------------' || '--------------' | | '--------------' || '--------------'
+// |
+//  '----------------'  '----------------'  '----------------'
+//  '----------------'   '----------------'  '----------------'
 
 //  Email :    z5261243@unsw.edu.au
 //             hhoanhtuann@gmail.com

data_structures/hash_set/hash_set.c

@@ -21,8 +21,10 @@ unsigned add(hash_set_t *set, void *value)
 
 unsigned put(hash_set_t *set, long long hash, void *value)
 {
-    if (contains_hash(set, hash)) {
-        if (set->keys[retrieve_index_from_hash(hash, set->capacity)] == value) {
+    if (contains_hash(set, hash))
+    {
+        if (set->keys[retrieve_index_from_hash(hash, set->capacity)] == value)
+        {
             return 0;
         }
 
@@ -40,7 +42,10 @@ unsigned put(hash_set_t *set, long long hash, void *value)
 
 int contains(hash_set_t *set, void *value)
 {
-    return set->keys[retrieve_index_from_hash(hash(value), set->capacity)] == value ? 1 : 0;
+    return set->keys[retrieve_index_from_hash(hash(value), set->capacity)] ==
+                   value
+               ? 1
+               : 0;
 }
 
 int contains_hash(hash_set_t *set, long long hash)
@@ -48,11 +53,11 @@ int contains_hash(hash_set_t *set, long long hash)
     return set->keys[retrieve_index_from_hash(hash, set->capacity)] ? 1 : 0;
 }
 
-void delete(hash_set_t *set, void *value) {
+void delete (hash_set_t *set, void *value)
+{
     set->keys[retrieve_index_from_hash(hash(value), set->capacity)] = NULL;
 }
 
-
 // adler_32 hash
 long long hash(void *value)
 {
@@ -62,7 +67,8 @@ long long hash(void *value)
     int b = 0;
     const int MODADLER = 65521;
 
-    for (int i = 0; str[i] != '\0'; i++) {
+    for (int i = 0; str[i] != '\0'; i++)
+    {
         a = (a + str[i]) % MODADLER;
         b = (b + a) % MODADLER;
     }
@@ -79,14 +85,17 @@ void resize(hash_set_t *set)
 {
     void **keys_resized = calloc((set->capacity <<= 1), sizeof(void **));
 
-    for (int i = 0; i < set->length; i++) {
-        keys_resized[retrieve_index_from_hash(hash(set->values[i]), set->capacity)] = set->values[i];
+    for (int i = 0; i < set->length; i++)
+    {
+        keys_resized[retrieve_index_from_hash(hash(set->values[i]),
+                                              set->capacity)] = set->values[i];
     }
 
     free(set->keys);
 
     set->keys = keys_resized;
 
-    void **new_values = (void **)realloc(set->values, set->capacity * sizeof(void **));
+    void **new_values =
+        (void **)realloc(set->values, set->capacity * sizeof(void **));
     set->values = new_values;
 }

data_structures/hash_set/hash_set.h

@@ -3,7 +3,8 @@
 
 #define DEFAULT_HASH_SET_CAPACITY 1 << 10
 
-typedef struct {
+typedef struct
+{
     unsigned capacity;
     unsigned length;
     void **values;
@@ -20,11 +21,12 @@ extern int contains(hash_set_t *set, void *value);
 
 int contains_hash(hash_set_t *set, long long hash);
 
-extern void delete(hash_set_t *set, void *value);
+extern void delete (hash_set_t *set, void *value);
 
 extern long long hash(void *value);
 
-extern unsigned retrieve_index_from_hash(const long long hash, const unsigned capacity);
+extern unsigned retrieve_index_from_hash(const long long hash,
+                                         const unsigned capacity);
 
 extern void resize(hash_set_t *set);
 

data_structures/hash_set/main.c

@@ -34,7 +34,7 @@ int main()
 
     printf("contains %d ? %d\n", v7, contains(set, &v7));
 
-    delete(set, &v6);
+    delete (set, &v6);
 
     printf("contains %d ? %d\n", v6, contains(set, &v6));
 

data_structures/heap/max_heap.c

@@ -1,23 +1,29 @@
-#include<stdio.h>
-#include<stdlib.h>
+#include <stdio.h>
+#include <stdlib.h>
 
-typedef struct max_heap{
+typedef struct max_heap
+{
     int *p;
     int size;
     int count;
-}Heap;
+} Heap;
 
-Heap* create_heap(Heap* heap); /*Creates a max_heap structure and returns a pointer to the struct*/
-void down_heapify(Heap* heap, int index);/*Pushes an element downwards in the heap to find its correct position*/
-void up_heapify(Heap* heap, int index);/*Pushes an element upwards in the heap to find its correct position*/
-void push(Heap* heap, int x);/*Inserts an element in the heap*/
-void pop(Heap* heap);/*Removes the top element from the heap*/
-int top(Heap* heap);/*Returns the top element of the heap or returns INT_MIN if heap is empty*/
-int empty(Heap* heap);/*Checks if heap is empty*/
-int size(Heap* heap);/*Returns the size of heap*/
+Heap *create_heap(Heap *heap); /*Creates a max_heap structure and returns a
+                                  pointer to the struct*/
+void down_heapify(Heap *heap, int index); /*Pushes an element downwards in the
+                                             heap to find its correct position*/
+void up_heapify(Heap *heap, int index); /*Pushes an element upwards in the heap
+                                           to find its correct position*/
+void push(Heap *heap, int x);           /*Inserts an element in the heap*/
+void pop(Heap *heap); /*Removes the top element from the heap*/
+int top(Heap *heap); /*Returns the top element of the heap or returns INT_MIN if
+                        heap is empty*/
+int empty(Heap *heap); /*Checks if heap is empty*/
+int size(Heap *heap);  /*Returns the size of heap*/
 
-int main(){
-	Heap* head = create_heap(head);
+int main()
+{
+    Heap *head = create_heap(head);
     push(head, 10);
     printf("Pushing element : 10\n");
     push(head, 3);
@@ -41,82 +47,102 @@ int main(){
     printf("\n");
     return 0;
 }
-Heap* create_heap(Heap* heap){
+Heap *create_heap(Heap *heap)
+{
     heap = (Heap *)malloc(sizeof(Heap));
     heap->size = 1;
-	heap->p = (int *)malloc(heap->size*sizeof(int));
+    heap->p = (int *)malloc(heap->size * sizeof(int));
     heap->count = 0;
     return heap;
 }
 
-void down_heapify(Heap* heap, int index){
-	if(index>=heap->count)return;
-	int left = index*2+1;
-	int right = index*2+2;
+void down_heapify(Heap *heap, int index)
+{
+    if (index >= heap->count)
+        return;
+    int left = index * 2 + 1;
+    int right = index * 2 + 2;
     int leftflag = 0, rightflag = 0;
 
-	int maximum = *((heap->p)+index);
-	if(left<heap->count && maximum<*((heap->p)+left)){
-		maximum = *((heap->p)+left);
+    int maximum = *((heap->p) + index);
+    if (left < heap->count && maximum < *((heap->p) + left))
+    {
+        maximum = *((heap->p) + left);
         leftflag = 1;
     }
-	if(right<heap->count && maximum<*((heap->p)+right)){
-		maximum = *((heap->p)+right);
+    if (right < heap->count && maximum < *((heap->p) + right))
+    {
+        maximum = *((heap->p) + right);
         leftflag = 0;
         rightflag = 1;
     }
-	if(leftflag){
-		*((heap->p)+left) = *((heap->p)+index);
-	    *((heap->p)+index) = maximum;
+    if (leftflag)
+    {
+        *((heap->p) + left) = *((heap->p) + index);
+        *((heap->p) + index) = maximum;
         down_heapify(heap, left);
     }
-	if(rightflag){
-		*((heap->p)+right) = *((heap->p)+index);
-	    *((heap->p)+index) = maximum;
+    if (rightflag)
+    {
+        *((heap->p) + right) = *((heap->p) + index);
+        *((heap->p) + index) = maximum;
         down_heapify(heap, right);
     }
 }
-void up_heapify(Heap* heap, int index){
-	int parent = (index-1)/2;
-	if(parent<0)return;
-	if(*((heap->p)+index)>*((heap->p)+parent)){
-		int temp = *((heap->p)+index);
-		*((heap->p)+index) = *((heap->p)+parent);
-		*((heap->p)+parent) = temp;
+void up_heapify(Heap *heap, int index)
+{
+    int parent = (index - 1) / 2;
+    if (parent < 0)
+        return;
+    if (*((heap->p) + index) > *((heap->p) + parent))
+    {
+        int temp = *((heap->p) + index);
+        *((heap->p) + index) = *((heap->p) + parent);
+        *((heap->p) + parent) = temp;
         up_heapify(heap, parent);
     }
 }
 
-void push(Heap* heap, int x){
-	if(heap->count>=heap->size)return;
-	*((heap->p)+heap->count) = x;
+void push(Heap *heap, int x)
+{
+    if (heap->count >= heap->size)
+        return;
+    *((heap->p) + heap->count) = x;
     heap->count++;
-	if(4*heap->count >= 3*heap->size){
+    if (4 * heap->count >= 3 * heap->size)
+    {
         heap->size *= 2;
-		(heap->p) = (int *)realloc((heap->p), (heap->size)*sizeof(int));
+        (heap->p) = (int *)realloc((heap->p), (heap->size) * sizeof(int));
     }
     up_heapify(heap, heap->count - 1);
 }
-void pop(Heap* heap){
-	if(heap->count==0)return;
+void pop(Heap *heap)
+{
+    if (heap->count == 0)
+        return;
     heap->count--;
-	int temp = *((heap->p)+heap->count);
-	*((heap->p)+heap->count) = *(heap->p);
+    int temp = *((heap->p) + heap->count);
+    *((heap->p) + heap->count) = *(heap->p);
     *(heap->p) = temp;
     down_heapify(heap, 0);
-	if(4*heap->count<=heap->size){
+    if (4 * heap->count <= heap->size)
+    {
         heap->size /= 2;
-		(heap->p) = (int *)realloc((heap->p), (heap->size)*sizeof(int));
+        (heap->p) = (int *)realloc((heap->p), (heap->size) * sizeof(int));
     }
 }
-int top(Heap* heap){
-	if(heap->count!=0)return *(heap->p);
-	else return INT_MIN;
+int top(Heap *heap)
+{
+    if (heap->count != 0)
+        return *(heap->p);
+    else
+        return INT_MIN;
 }
-int empty(Heap* heap){
-	if(heap->count!=0)return 0;
-	else return 1;
-}
-int size(Heap* heap){
-	return heap->count;
+int empty(Heap *heap)
+{
+    if (heap->count != 0)
+        return 0;
+    else
+        return 1;
 }
+int size(Heap *heap) { return heap->count; }

data_structures/heap/min_heap.c

@@ -1,23 +1,29 @@
-#include<stdio.h>
-#include<stdlib.h>
+#include <stdio.h>
+#include <stdlib.h>
 
-typedef struct min_heap{
+typedef struct min_heap
+{
     int *p;
     int size;
     int count;
-}Heap;
+} Heap;
 
-Heap* create_heap(Heap* heap); /*Creates a min_heap structure and returns a pointer to the struct*/
-void down_heapify(Heap* heap, int index);/*Pushes an element downwards in the heap to find its correct position*/
-void up_heapify(Heap* heap, int index);/*Pushes an element upwards in the heap to find its correct position*/
-void push(Heap* heap, int x);/*Inserts an element in the heap*/
-void pop(Heap* heap);/*Removes the top element from the heap*/
-int top(Heap* heap);/*Returns the top element of the heap or returns INT_MIN if heap is empty*/
-int empty(Heap* heap);/*Checks if heap is empty*/
-int size(Heap* heap);/*Returns the size of heap*/
+Heap *create_heap(Heap *heap); /*Creates a min_heap structure and returns a
+                                  pointer to the struct*/
+void down_heapify(Heap *heap, int index); /*Pushes an element downwards in the
+                                             heap to find its correct position*/
+void up_heapify(Heap *heap, int index); /*Pushes an element upwards in the heap
+                                           to find its correct position*/
+void push(Heap *heap, int x);           /*Inserts an element in the heap*/
+void pop(Heap *heap); /*Removes the top element from the heap*/
+int top(Heap *heap); /*Returns the top element of the heap or returns INT_MIN if
+                        heap is empty*/
+int empty(Heap *heap); /*Checks if heap is empty*/
+int size(Heap *heap);  /*Returns the size of heap*/
 
-int main(){
-	Heap* head = create_heap(head);
+int main()
+{
+    Heap *head = create_heap(head);
     push(head, 10);
     printf("Pushing element : 10\n");
     push(head, 3);
@@ -41,82 +47,102 @@ int main(){
     printf("\n");
     return 0;
 }
-Heap* create_heap(Heap* heap){
+Heap *create_heap(Heap *heap)
+{
     heap = (Heap *)malloc(sizeof(Heap));
     heap->size = 1;
-	heap->p = (int *)malloc(heap->size*sizeof(int));
+    heap->p = (int *)malloc(heap->size * sizeof(int));
     heap->count = 0;
     return heap;
 }
 
-void down_heapify(Heap* heap, int index){
-	if(index>=heap->count)return;
-	int left = index*2+1;
-	int right = index*2+2;
+void down_heapify(Heap *heap, int index)
+{
+    if (index >= heap->count)
+        return;
+    int left = index * 2 + 1;
+    int right = index * 2 + 2;
     int leftflag = 0, rightflag = 0;
 
-	int minimum = *((heap->p)+index);
-	if(left<heap->count && minimum>*((heap->p)+left)){
-		minimum = *((heap->p)+left);
+    int minimum = *((heap->p) + index);
+    if (left < heap->count && minimum > *((heap->p) + left))
+    {
+        minimum = *((heap->p) + left);
         leftflag = 1;
     }
-	if(right<heap->count && minimum>*((heap->p)+right)){
-		minimum = *((heap->p)+right);
+    if (right < heap->count && minimum > *((heap->p) + right))
+    {
+        minimum = *((heap->p) + right);
         leftflag = 0;
         rightflag = 1;
     }
-	if(leftflag){
-		*((heap->p)+left) = *((heap->p)+index);
-	    *((heap->p)+index) = minimum;
+    if (leftflag)
+    {
+        *((heap->p) + left) = *((heap->p) + index);
+        *((heap->p) + index) = minimum;
         down_heapify(heap, left);
     }
-	if(rightflag){
-		*((heap->p)+right) = *((heap->p)+index);
-	    *((heap->p)+index) = minimum;
+    if (rightflag)
+    {
+        *((heap->p) + right) = *((heap->p) + index);
+        *((heap->p) + index) = minimum;
         down_heapify(heap, right);
     }
 }
-void up_heapify(Heap* heap, int index){
-	int parent = (index-1)/2;
-	if(parent<0)return;
-	if(*((heap->p)+index)<*((heap->p)+parent)){
-		int temp = *((heap->p)+index);
-		*((heap->p)+index) = *((heap->p)+parent);
-		*((heap->p)+parent) = temp;
+void up_heapify(Heap *heap, int index)
+{
+    int parent = (index - 1) / 2;
+    if (parent < 0)
+        return;
+    if (*((heap->p) + index) < *((heap->p) + parent))
+    {
+        int temp = *((heap->p) + index);
+        *((heap->p) + index) = *((heap->p) + parent);
+        *((heap->p) + parent) = temp;
         up_heapify(heap, parent);
     }
 }
 
-void push(Heap* heap, int x){
-	if(heap->count>=heap->size)return;
-	*((heap->p)+heap->count) = x;
+void push(Heap *heap, int x)
+{
+    if (heap->count >= heap->size)
+        return;
+    *((heap->p) + heap->count) = x;
     heap->count++;
-	if(4*heap->count >= 3*heap->size){
+    if (4 * heap->count >= 3 * heap->size)
+    {
         heap->size *= 2;
-		(heap->p) = (int *)realloc((heap->p), (heap->size)*sizeof(int));
+        (heap->p) = (int *)realloc((heap->p), (heap->size) * sizeof(int));
     }
     up_heapify(heap, heap->count - 1);
 }
-void pop(Heap* heap){
-	if(heap->count==0)return;
+void pop(Heap *heap)
+{
+    if (heap->count == 0)
+        return;
     heap->count--;
-	int temp = *((heap->p)+heap->count);
-	*((heap->p)+heap->count) = *(heap->p);
+    int temp = *((heap->p) + heap->count);
+    *((heap->p) + heap->count) = *(heap->p);
     *(heap->p) = temp;
     down_heapify(heap, 0);
-	if(4*heap->count<=heap->size){
+    if (4 * heap->count <= heap->size)
+    {
         heap->size /= 2;
-		(heap->p) = (int *)realloc((heap->p), (heap->size)*sizeof(int));
+        (heap->p) = (int *)realloc((heap->p), (heap->size) * sizeof(int));
     }
 }
-int top(Heap* heap){
-	if(heap->count!=0)return *(heap->p);
-	else return INT_MIN;
+int top(Heap *heap)
+{
+    if (heap->count != 0)
+        return *(heap->p);
+    else
+        return INT_MIN;
 }
-int empty(Heap* heap){
-	if(heap->count!=0)return 0;
-	else return 1;
-}
-int size(Heap* heap){
-	return heap->count;
+int empty(Heap *heap)
+{
+    if (heap->count != 0)
+        return 0;
+    else
+        return 1;
 }
+int size(Heap *heap) { return heap->count; }

data_structures/linked_list/ascendingpriorityqueue.c

@@ -1,183 +1,180 @@
-/* Ascending priority queue using Linked List - Program to implement Ascending priority queue using Linked List */
+/* Ascending priority queue using Linked List - Program to implement Ascending
+ * priority queue using Linked List */
 
-/*A priority queue is a special type of queue in which each element is associated with a priority and is served according 
-to its priority. If elements with the same priority occur, they are served according to their order in the queue.
+/*A priority queue is a special type of queue in which each element is
+associated with a priority and is served according to its priority. If elements
+with the same priority occur, they are served according to their order in the
+queue.
 
-Generally, the value of the element itself is considered for assigning the priority.
+Generally, the value of the element itself is considered for assigning the
+priority.
 
-For example: The element with the highest value is considered as the highest priority element. However, in other cases, 
-we can assume the element with the lowest value as the highest priority element. In other cases, 
-we can set priorities according to our needs.
+For example: The element with the highest value is considered as the highest
+priority element. However, in other cases, we can assume the element with the
+lowest value as the highest priority element. In other cases, we can set
+priorities according to our needs.
 
-In a queue, the first-in-first-out rule is implemented whereas, in a priority queue, the values are removed on the basis of priority. 
-The element with the highest priority is removed first.
+In a queue, the first-in-first-out rule is implemented whereas, in a priority
+queue, the values are removed on the basis of priority. The element with the
+highest priority is removed first.
 
 insert() - Would insert an element in a queue
 delete() -  Would delete the smallest element in the queue
 */
 
-
 #include <stdio.h>
 #include <stdlib.h>
-#define  NULL  ((void*)0)
+#define NULL ((void *)0)
 
 struct node
 {
-  int  data ;
-  struct  node  *next ;
-} ;
+    int data;
+    struct node *next;
+};
 
-struct  node  *front , *rear ;
+struct node *front, *rear;
 
-/* This function initializes the queue to empty by making both front and rear as NULL */
-void createqueue()
-{
-  front=rear=NULL ;
-}
+/* This function initializes the queue to empty by making both front and rear as
+ * NULL */
+void createqueue() { front = rear = NULL; }
 
 int empty()
 {
-  if(front==NULL)
-    return  1 ;
+    if (front == NULL)
+        return 1;
     else
-    return  0 ;
+        return 0;
 }
 
 void insert(int x)
 {
-  struct  node  *pnode ;
+    struct node *pnode;
 
-  pnode=(struct node*)malloc(sizeof(struct node)) ;
-  if(pnode==NULL)
+    pnode = (struct node *)malloc(sizeof(struct node));
+    if (pnode == NULL)
     {
-    printf("Memory overflow. Unable to insert.\n") ;
-    exit(1) ;
+        printf("Memory overflow. Unable to insert.\n");
+        exit(1);
     }
 
-  pnode->data=x ;  
-  pnode->next=NULL;   /* New node is always last node */
+    pnode->data = x;
+    pnode->next = NULL; /* New node is always last node */
 
-  if(empty())
-      front=rear=pnode ;
+    if (empty())
+        front = rear = pnode;
     else
     {
-      rear->next=pnode ;
-      rear=pnode ;
+        rear->next = pnode;
+        rear = pnode;
     }
 }
 
 int removes()
 {
-  int  min ;
-  struct  node  *follow , *follow1 , *p , *p1 ;
+    int min;
+    struct node *follow, *follow1, *p, *p1;
 
-  if(empty())
+    if (empty())
     {
-    printf("\nQueue Underflow. Unable to remove.") ;
-    exit(1) ;
+        printf("\nQueue Underflow. Unable to remove.");
+        exit(1);
     }
 
     /* finding the node with minimum value in the APQ.*/
-  p=p1=front ;
-  follow=follow1=NULL ;
-  min=front->data ;
-  while(p!=NULL)
+    p = p1 = front;
+    follow = follow1 = NULL;
+    min = front->data;
+    while (p != NULL)
     {
-    if(p->data<min)
+        if (p->data < min)
         {
-   min=p->data ;
-   follow1=follow ;
-   p1=p ;
+            min = p->data;
+            follow1 = follow;
+            p1 = p;
         }
-    follow=p ;
-    p=p->next ;
+        follow = p;
+        p = p->next;
     }
 
     /* Deleting the node with min value */
 
-  if(p1==front)  /* deleting first node.*/
+    if (p1 == front) /* deleting first node.*/
     {
-    front=front->next ;
-    if(front==NULL)  /* Deleting the only one node */
-      rear=NULL ;
+        front = front->next;
+        if (front == NULL) /* Deleting the only one node */
+            rear = NULL;
     }
-  else if(p1==rear)  /* Deleting last node */
+    else if (p1 == rear) /* Deleting last node */
     {
-      rear=follow1 ;
-      rear->next=NULL ;
+        rear = follow1;
+        rear->next = NULL;
     }
     else /* deleting any other node.*/
-      follow1->next=p1->next ;
+        follow1->next = p1->next;
 
-
-  free(p1) ;
-  return  min ;  /* DONT FORGET LAST 2 STATEMENTS.*/
+    free(p1);
+    return min; /* DONT FORGET LAST 2 STATEMENTS.*/
 }
 
 void show()
 {
-  struct  node  *p ;
+    struct node *p;
 
-  if(empty())
-    printf("Queue empty. No data to display \n") ;
+    if (empty())
+        printf("Queue empty. No data to display \n");
     else
     {
-    printf("Queue from front to rear is as shown: \n") ;
+        printf("Queue from front to rear is as shown: \n");
 
-    p=front ;
-    while(p!=NULL)
+        p = front;
+        while (p != NULL)
         {
-      printf("%d ",p->data) ;
-      p=p->next ;
+            printf("%d ", p->data);
+            p = p->next;
         }
 
-    printf("\n") ;
+        printf("\n");
     }
 }
 
-void  destroyqueue()
-{
-  front=rear=NULL ;
-}
+void destroyqueue() { front = rear = NULL; }
 
 int main()
 {
-  int  x , ch ;
-
-  createqueue() ;
+    int x, ch;
 
+    createqueue();
 
     do
     {
-    printf("\n\n  Menu: \n") ;
-    printf("1:Insert \n") ;
-    printf("2:Remove \n") ;
-    printf("3:exit \n") ;
-    printf("Enter your choice: ") ;
-    scanf("%d",&ch) ;
+        printf("\n\n  Menu: \n");
+        printf("1:Insert \n");
+        printf("2:Remove \n");
+        printf("3:exit \n");
+        printf("Enter your choice: ");
+        scanf("%d", &ch);
 
-    switch(ch)
+        switch (ch)
         {
         case 1:
-      printf("Enter element to be inserted: ") ;
-      scanf("%d",&x) ;
-      insert(x) ;
-      show() ;
-      break ;
+            printf("Enter element to be inserted: ");
+            scanf("%d", &x);
+            insert(x);
+            show();
+            break;
 
         case 2:
-      x=removes() ;
-      printf("Element removed is: %d\n",x) ;
-      show() ;
-      break ;
+            x = removes();
+            printf("Element removed is: %d\n", x);
+            show();
+            break;
 
         case 3:
-      break ;
+            break;
         }
-  }
-  while(ch!=3) ;
+    } while (ch != 3);
 
-  destroyqueue() ;
+    destroyqueue();
 
     return 0;
 }

data_structures/linked_list/merge_linked_lists.c

@@ -1,6 +1,7 @@
-#include<stdio.h>
-#include<stdlib.h>
-struct node{
+#include <stdio.h>
+#include <stdlib.h>
+struct node
+{
     int data;
     struct node *next;
 };
@@ -17,32 +18,39 @@ void merge()
 
     struct node *holder1 = NULL;
     struct node *holder2 = NULL;
-    	//Temporary pointer variables to store the address of next node of the two input linked list
+    // Temporary pointer variables to store the address of next node of the two
+    // input linked list
 
-    	while(temp1!=NULL && temp2!=NULL)	
+    while (temp1 != NULL && temp2 != NULL)
     {
-        		holder1 = temp1 -> next;
-        		//Storing the address of next node of first linked list
-        		temp1->next=temp2;
-        		//Making the first node of first linked list point to first node of second linked list
+        holder1 = temp1->next;
+        // Storing the address of next node of first linked list
+        temp1->next = temp2;
+        // Making the first node of first linked list point to first node of
+        // second linked list
 
-        		if(holder1!=NULL)			{
-                    //Making the first node of second linked list point to second node of first linked list
-                    holder2 = temp2 -> next;
-                    temp2 -> next = holder1;
+        if (holder1 != NULL)
+        {
+            // Making the first node of second linked list point to second node
+            // of first linked list
+            holder2 = temp2->next;
+            temp2->next = holder1;
         }
-        		temp1=holder1;
-        		temp2=holder2;	
-        		//Updating the address location of two pointer variables temp1 and temp2
+        temp1 = holder1;
+        temp2 = holder2;
+        // Updating the address location of two pointer variables temp1 and
+        // temp2
     }
 }
 
-void printlist(struct node *temp){
-    printf("%d",temp->data);
-    temp=temp->next;		
-    while(temp!=NULL){
-            printf("->%d",temp->data);
-            temp=temp->next;		
+void printlist(struct node *temp)
+{
+    printf("%d", temp->data);
+    temp = temp->next;
+    while (temp != NULL)
+    {
+        printf("->%d", temp->data);
+        temp = temp->next;
     }
     printf("\n");
 }
@@ -51,53 +59,53 @@ int main()
 {
     // Linked List 1: 1->3->5->7   :   Linked List 2: 2->4->6
     //  making lists
-    	struct node *one = (struct node*)malloc(sizeof(struct node));
-    	struct node *two = (struct node*)malloc(sizeof(struct node));
-    	struct node *three = (struct node*)malloc(sizeof(struct node));
-    	struct node *four = (struct node*)malloc(sizeof(struct node));
-    	struct node *five = (struct node*)malloc(sizeof(struct node));
-    	struct node *six = (struct node*)malloc(sizeof(struct node));
-    	struct node *seven = (struct node*)malloc(sizeof(struct node));
-    	//Seven nodes are created
+    struct node *one = (struct node *)malloc(sizeof(struct node));
+    struct node *two = (struct node *)malloc(sizeof(struct node));
+    struct node *three = (struct node *)malloc(sizeof(struct node));
+    struct node *four = (struct node *)malloc(sizeof(struct node));
+    struct node *five = (struct node *)malloc(sizeof(struct node));
+    struct node *six = (struct node *)malloc(sizeof(struct node));
+    struct node *seven = (struct node *)malloc(sizeof(struct node));
+    // Seven nodes are created
 
-    	head1=one;
-    	head2=two;
-    	//head1 points to first node of first linked list
-    	//head2 points to first node of second linked list
+    head1 = one;
+    head2 = two;
+    // head1 points to first node of first linked list
+    // head2 points to first node of second linked list
 
-    	one->data=1;
-    	one->next=three;
+    one->data = 1;
+    one->next = three;
 
-    	two->data=2;	
-    	two->next=four;
+    two->data = 2;
+    two->next = four;
 
-    	three->data=3;
-    	three->next=five;
+    three->data = 3;
+    three->next = five;
 
-    	four->data=4;
-    	four->next=six;
+    four->data = 4;
+    four->next = six;
 
-    	five->data=5;
-    	five->next=seven;
+    five->data = 5;
+    five->next = seven;
 
-    	six->data=6;
-    	six->next=NULL;
-    	//Last node of second input linked list
+    six->data = 6;
+    six->next = NULL;
+    // Last node of second input linked list
 
-    	seven->data=7;
-    	seven->next=NULL;
-    	//Last node of first input linked list
+    seven->data = 7;
+    seven->next = NULL;
+    // Last node of first input linked list
 
     printf("Linked List 1: ");
     printlist(head1);
     printf("\nLinked List 2: ");
     printlist(head2);
 
-        //Merging the two linked list into single linked list
+    // Merging the two linked list into single linked list
     merge();
 
     printf("\nMerged Linked List: ");
-        printlist(head1);   //list one has been modified
+    printlist(head1); // list one has been modified
 
     return 0;
 }

data_structures/linked_list/middle_element_in_list.c

@@ -1,11 +1,11 @@
-#include<stdio.h> 
-#include<stdlib.h> 
+#include <stdio.h>
+#include <stdlib.h>
 
 /* Link list node */
 struct Node
 {
     int data;
-	struct Node* next; 
+    struct Node *next;
 };
 
 /* Function to get the middle of the linked list*/
@@ -14,7 +14,7 @@ void printMiddle(struct Node *head)
     struct Node *slow_ptr = head;
     struct Node *fast_ptr = head;
 
-	if (head!=NULL) 
+    if (head != NULL)
     {
         while (fast_ptr != NULL && fast_ptr->next != NULL)
         {
@@ -25,11 +25,10 @@ void printMiddle(struct Node *head)
     }
 }
 
-void push(struct Node** head_ref, int new_data) 
+void push(struct Node **head_ref, int new_data)
 {
     /* allocate node */
-	struct Node* new_node = 
-		(struct Node*) malloc(sizeof(struct Node)); 
+    struct Node *new_node = (struct Node *)malloc(sizeof(struct Node));
 
     /* put in the data */
     new_node->data = new_data;
@@ -56,10 +55,10 @@ void printList(struct Node *ptr)
 int main()
 {
     /* Start with the empty list */
-	struct Node* head = NULL; 
+    struct Node *head = NULL;
     int i;
 
-	for (i=5; i>0; i--) 
+    for (i = 5; i > 0; i--)
     {
         push(&head, i);
         printList(head);

data_structures/linked_list/queue_linked_list.c

@@ -1,8 +1,6 @@
-/* Queue using Linked List - Program to create a queue ADT using linked list. ADT should support the following operations
-1)  Createqueue
-2)  Insert into the queue
-3)  Delete from the queue
-4)  destroyqueue
+/* Queue using Linked List - Program to create a queue ADT using linked list.
+ADT should support the following operations 1)  Createqueue 2)  Insert into the
+queue 3)  Delete from the queue 4)  destroyqueue
 */
 
 /* queue q declared globally */
@@ -13,137 +11,131 @@
 
 struct node
 {
-  int  data ;
-  struct  node  *next ;
-} ;
+    int data;
+    struct node *next;
+};
 
 struct queue
 {
- struct  node  *front , *rear ;
-} ;
+    struct node *front, *rear;
+};
 
-struct  queue  q ;
+struct queue q;
 
-/* This function initializes the queue to empty by making both front and rear as NULL */
-void createqueue()
-{
-  q.front=q.rear=NULL ;
-}
+/* This function initializes the queue to empty by making both front and rear as
+ * NULL */
+void createqueue() { q.front = q.rear = NULL; }
 
 int empty()
 {
-  if(q.front==NULL)
-    return  1 ;
+    if (q.front == NULL)
+        return 1;
     else
-    return  0 ;
+        return 0;
 }
 
 void insert(int x)
 {
-  struct  node  *pnode ;
+    struct node *pnode;
 
-  pnode=(struct node*)malloc(sizeof(struct node)) ;
-  if(pnode==NULL)
+    pnode = (struct node *)malloc(sizeof(struct node));
+    if (pnode == NULL)
     {
-    printf("Memory overflow. Unable to insert.\n") ;
-    exit(1) ;
+        printf("Memory overflow. Unable to insert.\n");
+        exit(1);
     }
 
-  pnode->data=x ;
-  pnode->next=NULL ;   /* New node is always last node */
+    pnode->data = x;
+    pnode->next = NULL; /* New node is always last node */
 
-  if(empty())
-      q.front=q.rear=pnode ;
+    if (empty())
+        q.front = q.rear = pnode;
     else
     {
-      (q.rear)->next=pnode ;
-      q.rear=pnode ;
+        (q.rear)->next = pnode;
+        q.rear = pnode;
     }
 }
 
 int removes()
 {
-  int  x ;
-  struct  node  *p ;
+    int x;
+    struct node *p;
 
-  if(empty())
+    if (empty())
     {
-    printf("Queue Underflow. Unable to remove.\n") ;
-    exit(1) ;
+        printf("Queue Underflow. Unable to remove.\n");
+        exit(1);
     }
 
-  p=q.front ;
-  x=(q.front)->data ;
-  q.front=(q.front)->next ;
-  if(q.front==NULL)       /* Queue contained only one node */
-       q.rear=NULL ;
-  free(p) ;
-  return  x ;
+    p = q.front;
+    x = (q.front)->data;
+    q.front = (q.front)->next;
+    if (q.front == NULL) /* Queue contained only one node */
+        q.rear = NULL;
+    free(p);
+    return x;
 }
 
 void show()
 {
-  struct  node  *p ;
+    struct node *p;
 
-  if(empty())
-    printf("Queue empty. No data to display \n") ;
+    if (empty())
+        printf("Queue empty. No data to display \n");
     else
     {
-    printf("Queue from front to rear is as shown: \n") ;
+        printf("Queue from front to rear is as shown: \n");
 
-    p=q.front ;
-    while(p!=NULL)
+        p = q.front;
+        while (p != NULL)
         {
-      printf("%d ",p->data) ;
-      p=p->next ;
+            printf("%d ", p->data);
+            p = p->next;
         }
 
-    printf("\n") ;
+        printf("\n");
     }
 }
 
-void  destroyqueue()
-{
-  q.front=q.rear=NULL ;
-}
+void destroyqueue() { q.front = q.rear = NULL; }
 
 int main()
 {
-  int  x , ch ;
+    int x, ch;
 
-  createqueue() ;
+    createqueue();
 
     do
     {
-    printf("\n\n  Menu: \n") ;
-    printf("1:Insert \n") ;
-    printf("2:Remove \n") ;
-    printf("3:exit \n") ;
-    printf("Enter your choice: ") ;
-    scanf("%d",&ch) ;
+        printf("\n\n  Menu: \n");
+        printf("1:Insert \n");
+        printf("2:Remove \n");
+        printf("3:exit \n");
+        printf("Enter your choice: ");
+        scanf("%d", &ch);
 
-    switch(ch)
+        switch (ch)
         {
         case 1:
-      printf("Enter element to be inserted: ") ;
-      scanf("%d",&x) ;
-      insert(x) ;
-      show() ;
-      break ;
+            printf("Enter element to be inserted: ");
+            scanf("%d", &x);
+            insert(x);
+            show();
+            break;
 
         case 2:
-      x=removes() ;
-      printf("Element removed is: %d\n",x) ;
-      show() ;
-      break ;
+            x = removes();
+            printf("Element removed is: %d\n", x);
+            show();
+            break;
 
         case 3:
-      break ;
+            break;
         }
-  }
-  while(ch!=3) ;
+    } while (ch != 3);
 
-  destroyqueue() ;
+    destroyqueue();
 
     return 0;
 }

data_structures/linked_list/singly_link_list_deletion.c

@@ -1,69 +1,71 @@
-/*Includes structure for a node which can be use to make new nodes of the Linked List.
-  It is assumed that the data in nodes will be an integer, though
-  function can be modified according to the data type, easily.
-  deleteNode deletes a node when passed with a key of the node.
+/*Includes structure for a node which can be use to make new nodes of the Linked
+  List. It is assumed that the data in nodes will be an integer, though function
+  can be modified according to the data type, easily. deleteNode deletes a node
+  when passed with a key of the node.
 */
-#include<stdio.h>
+#include <stdio.h>
 struct node
-{int info;
+{
+    int info;
     struct node *link;
 };
-struct node *start=NULL;
+struct node *start = NULL;
 ///////////////////////////////////////////////////////////
-struct node * createnode()//function to create node
+struct node *createnode() // function to create node
 {
     struct node *t;
-  t=(struct node*)malloc(sizeof(struct node));
-  return(t);
+    t = (struct node *)malloc(sizeof(struct node));
+    return (t);
 }
 ////////////////////////////////////////////////////////
-void insert()//function to insert at first location
+void insert() // function to insert at first location
 {
     struct node *p;
-  p=createnode();
+    p = createnode();
     printf("\nenter the number to insert");
-  scanf("%d",&p->info);
-  p->link=NULL;
-  if(start==NULL)
+    scanf("%d", &p->info);
+    p->link = NULL;
+    if (start == NULL)
     {
-      start=p;
+        start = p;
     }
     else
     {
-      p->link=start;
-      start=p;
+        p->link = start;
+        start = p;
     }
 }
 ///////////////////////////////////////////////////////////
-void deletion()//function to delete from first position
+void deletion() // function to delete from first position
 {
     struct node *t;
-    if(start==NULL)
+    if (start == NULL)
     {
         printf("\nlist is empty");
     }
     else
     {
         struct node *p;
-        p=start;
-        start=start->link;
+        p = start;
+        start = start->link;
         free(p);
     }
 }
 ///////////////////////////////////////////////////////
-void viewlist()//function to display values
+void viewlist() // function to display values
 {
     struct node *p;
-    if(start==NULL)
+    if (start == NULL)
     {
         printf("\nlist is empty");
     }
     else
-    {   p=start;
-        while(p!=NULL)
     {
-            printf("%d ",p->info);
-            p=p->link;
+        p = start;
+        while (p != NULL)
+        {
+            printf("%d ", p->info);
+            p = p->link;
         }
     }
 }
@@ -72,14 +74,14 @@ void viewlist()//function to display values
 int main()
 {
     int n;
-    while(1)
+    while (1)
     {
         printf("\n1.add value at first location");
         printf("\n2.delete value from first location");
         printf("\n3.view value");
         printf("\nenter your choice");
-        scanf("%d",&n);
-        switch(n)
+        scanf("%d", &n);
+        switch (n)
         {
         case 1:
             insert();
@@ -94,5 +96,5 @@ int main()
             printf("\ninvalid choice");
         }
     }
-  return(0);
+    return (0);
 }

data_structures/linked_list/stack_using_linked_lists.c

@@ -1,55 +1,52 @@
-#include<stdio.h>
-#include<stdlib.h>
+#include <stdio.h>
+#include <stdlib.h>
 struct node
 {
     int info;
     struct node *link;
 };
-struct node *top=NULL,*temp;
-void  push(struct node*);
-void pop(struct node*);
-void display(struct node*);
+struct node *top = NULL, *temp;
+void push(struct node *);
+void pop(struct node *);
+void display(struct node *);
 
 int main()
 {
- int x=0,item;  
+    int x = 0, item;
     printf("\t****stack using linked list****\n");
-	while(x!=4)
+    while (x != 4)
     {
         printf("enter your choice");
         printf("\n1.push\n2.pop\n3.display\n4.exit\n");
-		scanf("%d",&x);
-		switch(x)
+        scanf("%d", &x);
+        switch (x)
         {
         case 1:
             push(top);
             break;
-			case 2: pop(top);
+        case 2:
+            pop(top);
             break;
-			case 3: display(top);
+        case 3:
+            display(top);
             break;
-			case 4: return 0;
-			      
+        case 4:
+            return 0;
         }
     }
-	
 }
 
 void push(struct node *p)
 {
     int item;
     struct node *temp;
-	temp=(struct node *)malloc(sizeof(struct node));
+    temp = (struct node *)malloc(sizeof(struct node));
     printf("enter element to be inserted\n");
-			scanf("%d",&item);
-			temp->info=item;
-			
-
-    
-			temp->link=top;
-		top=temp;
-		
+    scanf("%d", &item);
+    temp->info = item;
 
+    temp->link = top;
+    top = temp;
 
     printf("inserted succesfully\n");
 }
@@ -58,35 +55,31 @@ void pop(struct node *p)
     int item;
     struct node *temp;
 
-		if(top==NULL)
+    if (top == NULL)
         printf("stack is empty\n");
-	  else{
-	  	item=top->info;
-	  	temp=top;
-	  	top=top->link;
+    else
+    {
+        item = top->info;
+        temp = top;
+        top = top->link;
         free(temp);
-	  	printf("Element popped is%d\n",item);
+        printf("Element popped is%d\n", item);
     }
-	
 }
 
-
 void display(struct node *p)
 {
 
-	if(top==NULL)
+    if (top == NULL)
         printf("stack is empty\n");
     else
-	{	printf("Elements in the stack are\n");
-		while(p!=NULL)
     {
-		printf("%d\n",p->info);
-		p=p->link;
+        printf("Elements in the stack are\n");
+        while (p != NULL)
+        {
+            printf("%d\n", p->info);
+            p = p->link;
         }
         // printf("%d\n",p->info);
-        
     }
-
 }
-
-

data_structures/list/list.c

@@ -1,22 +1,24 @@
+#include "list.h"
 #include <assert.h>
+#include <stdarg.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <stdarg.h>
-#include "list.h"
 
 #define L List_T
 
 /* Initial list */
-L List_init (void) {
+L List_init(void)
+{
     L list;
-    list = (L) malloc(sizeof(L));
+    list = (L)malloc(sizeof(L));
     list->next = NULL;
     return list;
 }
 
 /* Push an element into top of the list */
-L List_push(L list, void *val) {
+L List_push(L list, void *val)
+{
     L new_elem = (L)malloc(sizeof(L));
     new_elem->val = val;
     new_elem->next = list;
@@ -24,19 +26,22 @@ L List_push(L list, void *val) {
 }
 
 /* Length of list */
-int List_length(L list) {
+int List_length(L list)
+{
     int n;
-    for(n = 0; list; list=list->next)
+    for (n = 0; list; list = list->next)
         n++;
     return n;
 }
 
 /* Convert list to array */
-void **List_toArray(L list) {
+void **List_toArray(L list)
+{
     int i, n = List_length(list);
-    void **array = (void **)malloc((n+1) *sizeof(*array));
+    void **array = (void **)malloc((n + 1) * sizeof(*array));
 
-    for(i = 0; i < n; i++) {
+    for (i = 0; i < n; i++)
+    {
         array[i] = list->val;
         list = list->next;
     }
@@ -45,12 +50,14 @@ void **List_toArray(L list) {
 }
 
 /* Create and return a list */
-L List_list(L list, void *val, ...) {
+L List_list(L list, void *val, ...)
+{
     va_list ap;
     L *p = &list;
 
     va_start(ap, val);
-    for(; val; val = va_arg(ap, void *)) {
+    for (; val; val = va_arg(ap, void *))
+    {
         *p = malloc(sizeof(L));
         (*p)->val = val;
         p = &(*p)->next;
@@ -61,13 +68,14 @@ L List_list(L list, void *val, ...) {
 }
 
 /* Append 2 lists together */
-L List_append(L list, L tail) {
+L List_append(L list, L tail)
+{
     L *p = &list;
-    while((*p)->next) {
+    while ((*p)->next)
+    {
         p = &(*p)->next;
     }
 
     *p = tail;
     return list;
 }
-

data_structures/list/list.h

@@ -4,7 +4,8 @@
 #define L List_T
 typedef struct L *L;
 
-struct L {
+struct L
+{
     void *val;
     L next;
 };

data_structures/list/main.c

@@ -1,19 +1,21 @@
+#include "list.h"
+#include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <assert.h>
 #include <string.h>
-#include "list.h"
 
-void print_list(char **array) {
+void print_list(char **array)
+{
     int i;
-    for( i = 0; array[i]; i++)
+    for (i = 0; array[i]; i++)
         printf("%s", array[i]);
     printf("\n");
 }
 
-int main() {
+int main()
+{
     List_T list1, list2, list3;
-    char **str1 = (char **)malloc(100* sizeof(char *));
+    char **str1 = (char **)malloc(100 * sizeof(char *));
 
     list1 = List_init();
     list1 = List_push(list1, "Dang ");

data_structures/queue.c

@@ -1,25 +1,26 @@
 ////////////////////////////////////////////////////////////////////////////////
-//INCLUDES
+// INCLUDES
 #include <stdio.h>
 #include <stdlib.h>
 
 ////////////////////////////////////////////////////////////////////////////////
-//MACROS: CONSTANTS
+// MACROS: CONSTANTS
 
 ////////////////////////////////////////////////////////////////////////////////
-//DATA STRUCTURES
-struct node {
+// DATA STRUCTURES
+struct node
+{
     int data;
-    struct node* next;
-    struct node* pre;
-} *head, *tail, *tmp;
+    struct node *next;
+    struct node *pre;
+} * head, *tail, *tmp;
 
 ////////////////////////////////////////////////////////////////////////////////
-//GLOBAL VARIABLES
+// GLOBAL VARIABLES
 int count;
 
 ////////////////////////////////////////////////////////////////////////////////
-//FORWARD DECLARATIONS
+// FORWARD DECLARATIONS
 void create();
 void enque(int x);
 int deque();
@@ -28,19 +29,19 @@ int size();
 int isEmpty();
 
 ////////////////////////////////////////////////////////////////////////////////
-//MAIN ENTRY POINT
+// MAIN ENTRY POINT
 
-int main(int argc, char const *argv[]) {
+int main(int argc, char const *argv[])
+{
 
     create();
     enque(5);
 
-
     return 0;
 }
 
-
-void create() {
+void create()
+{
     head = NULL;
     tail = NULL;
 }
@@ -48,13 +49,17 @@ void create() {
 /**
  * Puts an item into the Queue.
  */
-void enque(int x) {
-    if(head == NULL) {
+void enque(int x)
+{
+    if (head == NULL)
+    {
         head = (struct node *)malloc(1 * sizeof(struct node));
         head->data = x;
         head->pre = NULL;
         tail = head;
-    } else {
+    }
+    else
+    {
         tmp = (struct node *)malloc(1 * sizeof(struct node));
         tmp->data = x;
         tmp->next = tail;
@@ -65,14 +70,18 @@ void enque(int x) {
 /**
  * Takes the next item from the Queue.
  */
-int deque() {
+int deque()
+{
     int returnData = 0;
-    if(head == NULL) {
+    if (head == NULL)
+    {
         printf("ERROR: Deque from empty queue.\n");
         exit(1);
-    } else {
+    }
+    else
+    {
         returnData = head->data;
-        if(head->pre == NULL)
+        if (head->pre == NULL)
             head = NULL;
         else
             head = head->pre;
@@ -84,6 +93,4 @@ int deque() {
 /**
  * Returns the size of the Queue.
  */
-int size() {
-    return count;
-}
+int size() { return count; }

data_structures/stack.c

@@ -4,27 +4,28 @@
  */
 
 ////////////////////////////////////////////////////////////////////////////////
-//INCLUDES
+// INCLUDES
 #include <stdio.h>
 #include <stdlib.h>
 
 ////////////////////////////////////////////////////////////////////////////////
-//MACROS: CONSTANTS
+// MACROS: CONSTANTS
 
 ////////////////////////////////////////////////////////////////////////////////
-//DATA STRUCTURES
-struct node {
+// DATA STRUCTURES
+struct node
+{
     int data;
-    struct node* next;
-    struct node* pre;
-} *head, *tmp;
+    struct node *next;
+    struct node *pre;
+} * head, *tmp;
 
 ////////////////////////////////////////////////////////////////////////////////
-//GLOBAL VARIABLES
+// GLOBAL VARIABLES
 int count = 0;
 
 ////////////////////////////////////////////////////////////////////////////////
-//FUNCTION PROTOTYPES
+// FUNCTION PROTOTYPES
 void create();
 void push(int x);
 int pop();
@@ -33,9 +34,10 @@ int size();
 int isEmpty();
 
 ////////////////////////////////////////////////////////////////////////////////
-//MAIN ENTRY POINT
+// MAIN ENTRY POINT
 
-int main(int argc, char const *argv[]) {
+int main(int argc, char const *argv[])
+{
 
     int x, y, z;
 
@@ -70,20 +72,22 @@ int main(int argc, char const *argv[]) {
 /**
  * Initialize the stack to NULL.
  */
-void create() {
-    head = NULL;
-}
+void create() { head = NULL; }
 
 /**
  * Push data onto the stack.
  */
-void push(int x) {
-    if(head == NULL) {
+void push(int x)
+{
+    if (head == NULL)
+    {
         head = (struct node *)malloc(1 * sizeof(struct node));
         head->next = NULL;
         head->pre = NULL;
         head->data = x;
-    } else {
+    }
+    else
+    {
         tmp = (struct node *)malloc(1 * sizeof(struct node));
         tmp->data = x;
         tmp->next = NULL;
@@ -97,19 +101,25 @@ void push(int x) {
 /**
  * Pop data from the stack
  */
-int pop() {
+int pop()
+{
     int returnData;
-    if(head == NULL) {
+    if (head == NULL)
+    {
         printf("ERROR: Pop from empty stack.\n");
         exit(1);
-    } else {
+    }
+    else
+    {
         returnData = head->data;
 
-        if(head->pre == NULL){
+        if (head->pre == NULL)
+        {
             free(head);
             head = NULL;
         }
-        else {
+        else
+        {
             head = head->pre;
             free(head->next);
         }
@@ -121,10 +131,12 @@ int pop() {
 /**
  * Returns the next value to be popped.
  */
-int peek() {
-    if(head != NULL)
+int peek()
+{
+    if (head != NULL)
         return head->data;
-    else {
+    else
+    {
         printf("ERROR: Peeking from empty stack.");
         exit(1);
     }
@@ -133,15 +145,14 @@ int peek() {
 /**
  * Returns the size of the stack.
  */
-int size() {
-    return count;
-}
+int size() { return count; }
 
 /**
  * Returns 1 if stack is empty, returns 0 if not empty.
  */
-int isEmpty() {
-    if(count == 0)
+int isEmpty()
+{
+    if (count == 0)
         return 1;
     return 0;
 }

data_structures/stack/main.c

@@ -1,4 +1,4 @@
-//program for stack using array
+// program for stack using array
 
 #include <stdio.h>
 
@@ -45,7 +45,7 @@ int main()
     return (0);
 }
 
-//function for pushing the element
+// function for pushing the element
 void push()
 {
     int n = 0;
@@ -55,7 +55,7 @@ void push()
     a[top] = n;
 }
 
-//function for poping the element out
+// function for poping the element out
 void pop()
 {
     if (top == -1)
@@ -71,7 +71,7 @@ void pop()
     }
 }
 
-//function for peeping the element from top of the stack
+// function for peeping the element from top of the stack
 void peek()
 {
     if (top >= 0)
@@ -80,7 +80,7 @@ void peek()
         printf("\nstack is empty");
 }
 
-//function to update the element of stack
+// function to update the element of stack
 void update()
 {
     int i, n;

data_structures/stack/parenthesis.c

@@ -1,7 +1,7 @@
+#include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <assert.h>
 
 #define SIZE 100
 
@@ -12,14 +12,15 @@ struct node
 };
 
 int c = 0;         // c used as counter to check if stack is empty or not
-struct node *head; //declaring head pointer globally assigned to NULL
+struct node *head; // declaring head pointer globally assigned to NULL
 
-void push(char x) //function for pushing
+void push(char x) // function for pushing
 {
     struct node *p = head, *temp;
     temp = (struct node *)malloc(sizeof(struct node));
     temp->data = x;
-    if (head == NULL) //will be execute only one time i.e, 1st time push is called
+    if (head ==
+        NULL) // will be execute only one time i.e, 1st time push is called
     {
         head = temp;
         p = head;
@@ -35,7 +36,7 @@ void push(char x) //function for pushing
     }
 }
 
-char pop(void) //function for pop
+char pop(void) // function for pop
 {
     char x;
     struct node *p = head;
@@ -50,14 +51,16 @@ int isBalanced(char *s)
 {
     int i = 0;
     char x;
-    while (s[i] != '\0') //loop for covering entire string of brackets
+    while (s[i] != '\0') // loop for covering entire string of brackets
     {
         // printf("\t s[i]=%c\n", s[i]); //DEBUG
-        if (s[i] == '{' || s[i] == '(' || s[i] == '[') //if opening bracket then push
+        if (s[i] == '{' || s[i] == '(' ||
+            s[i] == '[') // if opening bracket then push
             push(s[i]);
         else
         {
-            if (c <= 0) //i.e, stack is empty as only opening brackets are added to stack
+            if (c <= 0) // i.e, stack is empty as only opening brackets are
+                        // added to stack
                 return 0;
 
             x = pop();
@@ -71,7 +74,8 @@ int isBalanced(char *s)
         i++;
     }
 
-    //at end if stack is empy which means whole process has been performed correctly so return 1
+    // at end if stack is empy which means whole process has been performed
+    // correctly so return 1
     return (c == 0) ? 1 : 0;
 }
 

data_structures/stack/stack.c

@@ -6,9 +6,9 @@
     of data hiding.
 */
 
+#include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <assert.h>
 
 #include "stack.h"
 
@@ -114,18 +114,12 @@ void *pop()
 /*
     size: gets the number of elements of the stack.
 */
-int size()
-{
-    return counter;
-}
+int size() { return counter; }
 
 /*
     isEmpty(): returns 1 if stack is empty otherwise 0.
 */
-int isEmpty()
-{
-    return counter == 0;
-}
+int isEmpty() { return counter == 0; }
 
 /*
     top: returns the top element from the stack without removing it.

data_structures/stack/stack.h

@@ -5,7 +5,6 @@
     The stack is generic and self growing.
 */
 
-
 #ifndef __STACK__
 #define __STACK__
 
@@ -17,13 +16,13 @@ void initStack();
 /*
     push: pushs the argument onto the stack
 */
-void push(void * object);
+void push(void *object);
 
 /*
     pop: pops the top element of the stack from the stack.
     assumes: stack not empty.
 */
-void  * pop();
+void *pop();
 
 /*
     size: gets the number of elements of the stack.
@@ -38,6 +37,6 @@ int isEmpty();
 /*
     top: returns the top element from the stack without removing it.
 */
-void * top(); 
+void *top();
 
 #endif

data_structures/stack/stack_linked_list/main.c

@@ -1,15 +1,16 @@
+#include "stack.h"
+#include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <assert.h>
-#include "stack.h"
 
-int main() {
+int main()
+{
     Stack_T stk;
     stk = Stack_init();
-    Stack_push(stk, (int *) 1);
-    Stack_push(stk, (int *) 2);
-    Stack_push(stk, (int *) 3);
-    Stack_push(stk, (int *) 4);
+    Stack_push(stk, (int *)1);
+    Stack_push(stk, (int *)2);
+    Stack_push(stk, (int *)3);
+    Stack_push(stk, (int *)4);
     printf("Size: %d\n", Stack_size(stk));
     Stack_print(stk);
     Stack_pop(stk);

data_structures/stack/stack_linked_list/stack.c

@@ -1,48 +1,54 @@
+#include "stack.h"
 #include <assert.h>
 #include <stddef.h>
-#include <stdlib.h>
 #include <stdio.h>
-#include "stack.h"
+#include <stdlib.h>
 
 #define T Stack_T
 
-typedef struct elem {
+typedef struct elem
+{
     void *val;
     struct elem *next;
 } elem_t;
 
-struct T {
+struct T
+{
     int count;
     elem_t *head;
 };
 
 /* Initial stack */
-T Stack_init (void) {
+T Stack_init(void)
+{
     T stack;
-    stack = (T) malloc(sizeof(T));
+    stack = (T)malloc(sizeof(T));
     stack->count = 0;
     stack->head = NULL;
     return stack;
 }
 
 /* Check empty stack*/
-int Stack_empty(T stack) {
+int Stack_empty(T stack)
+{
     assert(stack);
     return stack->count == 0;
 }
 
 /* Return size of the stack */
-int Stack_size(T stack) {
+int Stack_size(T stack)
+{
     assert(stack);
     return stack->count;
 }
 
 /* Push an element into the stack */
-void Stack_push(T stack, void *val) {
+void Stack_push(T stack, void *val)
+{
     elem_t *t;
 
     assert(stack);
-    t = (elem_t *) malloc(sizeof(elem_t));
+    t = (elem_t *)malloc(sizeof(elem_t));
     t->val = val;
     t->next = stack->head;
     stack->head = t;
@@ -50,7 +56,8 @@ void Stack_push(T stack, void *val) {
 }
 
 /* Pop an element out of the stack */
-void *Stack_pop(T stack) {
+void *Stack_pop(T stack)
+{
     void *val;
     elem_t *t;
 
@@ -65,13 +72,15 @@ void *Stack_pop(T stack) {
 }
 
 /* Print all elements in the stack */
-void Stack_print(Stack_T stack) {
+void Stack_print(Stack_T stack)
+{
     assert(stack);
 
     int i, size = Stack_size(stack);
     elem_t *current_elem = stack->head;
     printf("Stack [Top --- Bottom]: ");
-    for(i = 0; i < size; ++i) {
+    for (i = 0; i < size; ++i)
+    {
         printf("%p ", (int *)current_elem->val);
         current_elem = current_elem->next;
     }

data_structures/stack/stack_linked_list/stack.h

@@ -4,12 +4,12 @@
 #define T Stack_T
 typedef struct T *T;
 
-extern T     Stack_init   (void);
-extern int   Stack_size   (T stack);
-extern int   Stack_empty  (T stack);
-extern void  Stack_push   (T stack, void *val);
-extern void *Stack_pop    (T stack);
-extern void  Stack_print  (T stack);
+extern T Stack_init(void);
+extern int Stack_size(T stack);
+extern int Stack_empty(T stack);
+extern void Stack_push(T stack, void *val);
+extern void *Stack_pop(T stack);
+extern void Stack_print(T stack);
 
 #undef T
 #endif

data_structures/trie/trie.c

@@ -3,8 +3,8 @@
 
 /*-----character - 97 used for get the character from the ASCII value-----*/
 
-#include <stdio.h>
 #include <stdbool.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -26,7 +26,8 @@ TrieNode *createTrieNode()
     node = malloc(sizeof(TrieNode));
     node->isEndOfWord = false;
     int i = 0;
-    while(i<ALPHABET_SIZE){
+    while (i < ALPHABET_SIZE)
+    {
         node->children[i] = NULL;
         i++;
     }
@@ -34,23 +35,23 @@ TrieNode *createTrieNode()
 }
 
 /*--Insert new word to Trie--*/
-void insert(TrieNode *root,char *word) 
+void insert(TrieNode *root, char *word)
 {
     /*----Addition of the word done by recurcively----*/
 
-	//Check wheather word character pointer is NULL  
-	if((strlen(word)-1) != 0)	
+    // Check wheather word character pointer is NULL
+    if ((strlen(word) - 1) != 0)
     {
         char character = *word;
-		if(root->children[character-97] == NULL)
+        if (root->children[character - 97] == NULL)
         {
             TrieNode *node = NULL;
             node = createTrieNode();
             node->character = character;
-			root->children[character-97] = node;
+            root->children[character - 97] = node;
         }
         word++;
-            insert(root->children[character-97],word);
+        insert(root->children[character - 97], word);
     }
     else
     {
@@ -60,15 +61,15 @@ void insert(TrieNode *root,char *word)
 }
 
 /*--Search a word in the Trie--*/
-TrieNode *search( TrieNode *root, char *word)
+TrieNode *search(TrieNode *root, char *word)
 {
     TrieNode *temp;
-	while(*word != '\0')
+    while (*word != '\0')
     {
         char character = *word;
-		if(root->children[character - 97] != NULL)
+        if (root->children[character - 97] != NULL)
         {
-			temp = root->children[character-97];
+            temp = root->children[character - 97];
             word++;
             root = temp;
         }
@@ -85,7 +86,7 @@ TrieNode *search( TrieNode *root, char *word)
 void printArray(char chars[], int len)
 {
     int i;
-	  for (i=0; i<len; i++) 
+    for (i = 0; i < len; i++)
     {
         printf("%c", chars[i]);
     }
@@ -93,9 +94,10 @@ void printArray(char chars[], int len)
 }
 
 /*---Return all the related words------*/
-void printPathsRecur(TrieNode* node, char prefix[], int filledLen) 
+void printPathsRecur(TrieNode *node, char prefix[], int filledLen)
 {
-	  if (node==NULL) return;
+    if (node == NULL)
+        return;
 
     prefix[filledLen] = node->character;
     filledLen++;
@@ -105,8 +107,8 @@ void printPathsRecur(TrieNode* node, char prefix[], int filledLen)
         printArray(prefix, filledLen);
     }
 
-	  int i ;
-	  for(i=0;i<ALPHABET_SIZE;i++)
+    int i;
+    for (i = 0; i < ALPHABET_SIZE; i++)
     {
         printPathsRecur(node->children[i], prefix, filledLen);
     }
@@ -116,13 +118,13 @@ void printPathsRecur(TrieNode* node, char prefix[], int filledLen)
 void traverse(char prefix[], TrieNode *root)
 {
     TrieNode *temp = NULL;
-    temp = search(root,prefix);
-    int j=0;
-    while(prefix[j]!='\0')
+    temp = search(root, prefix);
+    int j = 0;
+    while (prefix[j] != '\0')
     {
         j++;
     }
-	printPathsRecur(temp,prefix,j-1);
+    printPathsRecur(temp, prefix, j - 1);
 }
 
 /*------Demonstrate purposes uses text file called dictionary -------*/
@@ -139,9 +141,9 @@ char *receiveInput(char *s)
 
 int main()
 {
-	//Read the file dictionary
+    // Read the file dictionary
     int word_count = 0;
-    char* words[NUMBER_OF_WORDS];
+    char *words[NUMBER_OF_WORDS];
     FILE *fp = fopen("dictionary.txt", "r");
 
     if (fp == 0)
@@ -158,14 +160,13 @@ int main()
         words[word_count] = malloc(INPUT_WORD_SIZE);
     }
 
-
-    //Push the words in to Trie 
+    // Push the words in to Trie
     TrieNode *root = NULL;
     root = createTrieNode();
     int i;
-    for(i=0;i<NUMBER_OF_WORDS;i++)
+    for (i = 0; i < NUMBER_OF_WORDS; i++)
     {
-      insert(root,words[i]);
+        insert(root, words[i]);
     }
 
     while (1)
@@ -173,12 +174,14 @@ int main()
         printf("Enter keyword: ");
         char str[100];
         receiveInput(str);
-        printf("\n==========================================================\n");
+        printf(
+            "\n==========================================================\n");
         printf("\n********************* Possible Words ********************\n");
 
-       //Find the word through the Trie
-        traverse(str,root);
+        // Find the word through the Trie
+        traverse(str, root);
 
-        printf("\n==========================================================\n");
+        printf(
+            "\n==========================================================\n");
     }
 }

exercism/acronym/acronym.c

@@ -1,6 +1,6 @@
-#include <string.h>
-#include <stdio.h>
 #include <ctype.h>
+#include <stdio.h>
+#include <string.h>
 
 char *abbreviate(const char *phrase)
 {
@@ -43,7 +43,7 @@ char *abbreviate(const char *phrase)
     /* initalizes words-array with empty strings */
     for (i = 0; i < counter; i++)
     {
-        strcpy(words[i],"");
+        strcpy(words[i], "");
     }
 
     /* rewind string */

exercism/hello_world/hello_world.c

@@ -4,7 +4,7 @@
 
 const char *hello(void)
 {
-    char * ans = strdup("Hello, World!");
+    char *ans = strdup("Hello, World!");
     /* string is pointer of the first character */
     return ans;
 }

exercism/isogram/isogram.c

@@ -20,12 +20,12 @@ bool is_isogram(const char phrase[])
     /* contains the length of the given string */
     unsigned int len_phrase = strlen(phrase);
 
-    for (i = 0; i < len_phrase; i++ ) 
+    for (i = 0; i < len_phrase; i++)
     {
         current_char = phrase[i];
 
         /* makes sure the current character has no repetition */
-        for (j = i+1; j < len_phrase; j++)
+        for (j = i + 1; j < len_phrase; j++)
         {
             if (current_char == phrase[j])
             {
@@ -40,7 +40,7 @@ bool is_isogram(const char phrase[])
         }
     }
 
-    /* exit label */
-    end:
+/* exit label */
+end:
     return status;
 }

exercism/rna_transcription/rna_transcription.h

@@ -2,6 +2,6 @@
 #define __RNA_TRANSCRIPTION__H
 
 /* to_rna: compiles a DNA strand in its RNA complement */
-char * to_rna(const char s[]);
+char *to_rna(const char s[]);
 
 #endif

exercism/word_count/word_count.c

@@ -80,7 +80,7 @@ int word_count(const char *input_text, word_count_word_t *words)
 
         for (i = 0; i <= index_list; i++)
         {
-            if (strcmp(word_list[i],words->text) == 0)
+            if (strcmp(word_list[i], words->text) == 0)
             {
                 words->count++;
             }

exercism/word_count/word_count.h

@@ -5,7 +5,8 @@
 #define MAX_WORD_LENGTH 50 // no individual word can exceed this length
 
 // results structure
-typedef struct word_count_word {
+typedef struct word_count_word
+{
     char text[MAX_WORD_LENGTH];
     int count;
 } word_count_word_t;
@@ -13,8 +14,8 @@ typedef struct word_count_word {
 #define EXCESSIVE_LENGTH_WORD -1
 #define EXCESSIVE_NUMBER_OF_WORDS -2
 
-// word_count - routine to classify the unique words and their frequency in a test input string
-// inputs:
+// word_count - routine to classify the unique words and their frequency in a
+// test input string inputs:
 //    input_text =  a null-terminated string containing that is analyzed
 //
 // outputs:
@@ -22,6 +23,6 @@ typedef struct word_count_word {
 //    uniqueWords - number of words in the words structure
 //           returns a negative number if an error.
 //           words will contain the results up to that point.
-int word_count(const char *input_text, word_count_word_t * words);
+int word_count(const char *input_text, word_count_word_t *words);
 
 #endif

greedy_approach/djikstra.c

@@ -12,43 +12,48 @@ int dist[MAX];
 int q[MAX];
 int qp = 0;
 
-void enqueue (int v) {
-	q[qp++] = v;
-}
+void enqueue(int v) { q[qp++] = v; }
 
-int cf (void *a, void *b) {
+int cf(void *a, void *b)
+{
     int *x = (int *)a;
     int *y = (int *)b;
     return *y - *x;
 }
 
-int dequeue () {
+int dequeue()
+{
     qsort(q, qp, sizeof(int), cf);
     return q[--qp];
 }
 
-int queue_has_something () {
-	return (qp > 0);
-}
+int queue_has_something() { return (qp > 0); }
 
 int visited[MAX];
 int vp = 0;
 
-void dijkstra (int s) {
+void dijkstra(int s)
+{
     dist[s] = 0;
     int i;
-	for (i = 0; i < V; ++i) {
-		if (i != s) {
+    for (i = 0; i < V; ++i)
+    {
+        if (i != s)
+        {
             dist[i] = INF;
         }
         enqueue(i);
     }
-	while (queue_has_something()) {
+    while (queue_has_something())
+    {
         int u = dequeue();
         visited[vp++] = u;
-		for (i = 0; i < V; ++i) {
-			if (mat[u][i]) {
-				if (dist[i] > dist[u] + mat[u][i]) {
+        for (i = 0; i < V; ++i)
+        {
+            if (mat[u][i])
+            {
+                if (dist[i] > dist[u] + mat[u][i])
+                {
                     dist[i] = dist[u] + mat[u][i];
                 }
             }
@@ -56,14 +61,17 @@ void dijkstra (int s) {
     }
 }
 
-int main(int argc, char const *argv[]) {
+int main(int argc, char const *argv[])
+{
 
     printf("Enter the number of vertices: ");
     scanf(" %d", &V);
     printf("Enter the adj matrix: ");
     int i, j;
-	for (i = 0; i < V; ++i) {
-		for (j = 0; j < V; ++j) {
+    for (i = 0; i < V; ++i)
+    {
+        for (j = 0; j < V; ++j)
+        {
             scanf(" %d", &mat[i][j]);
         }
     }
@@ -71,7 +79,8 @@ int main(int argc, char const *argv[]) {
     dijkstra(0);
 
     printf("\nNode\tDist\n");
-	for (i = 0; i < V; ++i) {
+    for (i = 0; i < V; ++i)
+    {
         printf("%d\t%d\n", i, dist[i]);
     }
 

hash/hash.c

@@ -65,14 +65,16 @@ int adler_32(char s[])
 /* crc32 Hash-Algorithm*/
 #include <inttypes.h>
 
-uint32_t crc32(char* data){
+uint32_t crc32(char *data)
+{
     int i = 0;
     uint32_t crc = 0xffffffff;
-    while(data[i] != '\0'){
+    while (data[i] != '\0')
+    {
         uint8_t byte = data[i];
         crc = crc ^ byte;
-        for(int j = 8; j > 0; --j)
-            crc = (crc >> 1) ^ (0xEDB88320 & ( -(crc & 1)));
+        for (int j = 8; j > 0; --j)
+            crc = (crc >> 1) ^ (0xEDB88320 & (-(crc & 1)));
 
         i++;
     }

hash/hash.h

@@ -46,6 +46,4 @@ int adler_32(char[]);
 */
 int crc32(char[]);
 
-
-
 #endif

hash/test_program.c

@@ -3,8 +3,8 @@
     This file contains a simple test program for each hash-function.
 */
 
-#include <stdio.h>
 #include "hash.h"
+#include <stdio.h>
 
 int main(void)
 {

leetcode/src/1.c

@@ -1,10 +1,13 @@
-int* twoSum(int* nums, int numsSize, int target, int* returnSize){
+int *twoSum(int *nums, int numsSize, int target, int *returnSize)
+{
     int i, j;
     int *ret = calloc(2, sizeof(int));
-    for (i = 0; i < numsSize; i++) {
+    for (i = 0; i < numsSize; i++)
+    {
         int key = target - nums[i];
         for (j = i + 1; j < numsSize; j++)
-            if (nums[j] == key) {
+            if (nums[j] == key)
+            {
                 ret[0] = i;
                 ret[1] = j;
             }

leetcode/src/101.c

@@ -7,14 +7,17 @@
  * };
  */
 
-bool checkSymmetric(struct TreeNode *left, struct TreeNode *right) {
+bool checkSymmetric(struct TreeNode *left, struct TreeNode *right)
+{
     if (!left || !right)
         return left == right;
     if (left->val != right->val)
         return 0;
-    return checkSymmetric(left->left, right->right) && checkSymmetric(left->right, right->left);
+    return checkSymmetric(left->left, right->right) &&
+           checkSymmetric(left->right, right->left);
 }
 
-bool isSymmetric(struct TreeNode* root){
+bool isSymmetric(struct TreeNode *root)
+{
     return root == NULL || checkSymmetric(root->left, root->right);
 }

leetcode/src/104.c

@@ -7,16 +7,17 @@
  * };
  */
 
-int maxval(int a, int b) {
+int maxval(int a, int b)
+{
     if (a > b)
         return a;
     else
         return b;
 }
-int maxDepth(struct TreeNode* root){
+int maxDepth(struct TreeNode *root)
+{
     if (root == NULL)
         return 0;
     else
         return 1 + maxval(maxDepth(root->left), maxDepth(root->right));
 }
-

leetcode/src/108.c

@@ -7,10 +7,12 @@
  * };
  */
 
-struct TreeNode* convertBST(int *nums, int left, int right) {
+struct TreeNode *convertBST(int *nums, int left, int right)
+{
     if (left > right)
         return NULL;
-    else {
+    else
+    {
         int mid = (right + left) / 2;
         struct TreeNode *new_val = malloc(sizeof(struct TreeNode));
         new_val->val = nums[mid];
@@ -20,10 +22,10 @@ struct TreeNode* convertBST(int *nums, int left, int right) {
     }
 }
 
-struct TreeNode* sortedArrayToBST(int* nums, int numsSize){
-    if(numsSize == 0)
+struct TreeNode *sortedArrayToBST(int *nums, int numsSize)
+{
+    if (numsSize == 0)
         return NULL;
     else
-        return convertBST(nums, 0, numsSize -1);
+        return convertBST(nums, 0, numsSize - 1);
 }
-

leetcode/src/1089.c

@@ -1,14 +1,18 @@
-void duplicateZeros(int* arr, int arrSize){
+void duplicateZeros(int *arr, int arrSize)
+{
     int i, start = 0;
     int *tmp = malloc(arrSize * sizeof(int));
     /* Copy arr into tmp arr */
-    for(i = 0; i < arrSize; i++) {
+    for (i = 0; i < arrSize; i++)
+    {
         tmp[i] = arr[i];
     }
     i = 0;
-    for(start = 0; start < arrSize; start++) {
+    for (start = 0; start < arrSize; start++)
+    {
         arr[start] = tmp[i];
-        if(tmp[i] == 0) {
+        if (tmp[i] == 0)
+        {
             start++;
             if (start < arrSize)
                 arr[start] = 0;
@@ -16,5 +20,3 @@ void duplicateZeros(int* arr, int arrSize){
         i++;
     }
 }
-
-

leetcode/src/109.c

@@ -1,21 +1,23 @@
-struct TreeNode* buildBST(struct ListNode* head, struct ListNode* tail) {
-    if(head == tail)
+struct TreeNode *buildBST(struct ListNode *head, struct ListNode *tail)
+{
+    if (head == tail)
         return NULL;
-    struct ListNode* slow = head, *fast = head;
-    while(fast != tail && fast->next != tail) {
+    struct ListNode *slow = head, *fast = head;
+    while (fast != tail && fast->next != tail)
+    {
         fast = fast->next->next;
         slow = slow->next;
     }
-    struct TreeNode* node = malloc(sizeof(struct TreeNode));
+    struct TreeNode *node = malloc(sizeof(struct TreeNode));
     node->val = slow->val;
     node->left = buildBST(head, slow);
     node->right = buildBST(slow->next, tail);
     return node;
 }
-struct TreeNode* sortedListToBST(struct ListNode* head){
+struct TreeNode *sortedListToBST(struct ListNode *head)
+{
     if (!head)
         return NULL;
     else
         return buildBST(head, NULL);
 }
-

leetcode/src/11.c

@@ -1,30 +1,28 @@
-//Fucntion to calculate min of values a and b
-int min(int a, int b){
-    return ((a<b)?a:b);
-}
+// Fucntion to calculate min of values a and b
+int min(int a, int b) { return ((a < b) ? a : b); }
 
-//Two pointer approach to find maximum container area
-int maxArea(int* height, int heightSize){
+// Two pointer approach to find maximum container area
+int maxArea(int *height, int heightSize)
+{
 
-    //Start with maximum container width
+    // Start with maximum container width
     int start = 0;
-    int end = heightSize-1;
+    int end = heightSize - 1;
     int res = 0;
 
-    while(start<end){
-        //Calculate current area by taking minimum of two heights
-        int currArea = (end-start)*min(height[start],height[end]);
+    while (start < end)
+    {
+        // Calculate current area by taking minimum of two heights
+        int currArea = (end - start) * min(height[start], height[end]);
 
-        if(currArea>res)
+        if (currArea > res)
             res = currArea;
 
-        if(height[start]<height[end])
+        if (height[start] < height[end])
             start = start + 1;
         else
             end = end - 1;
-            
     }
 
     return res;
-    
 }

leetcode/src/110.c

@@ -1,19 +1,19 @@
-int max(int a, int b) {
-    return a >= b ? a : b;
-}
+int max(int a, int b) { return a >= b ? a : b; }
 
-int height(struct TreeNode* root) {
+int height(struct TreeNode *root)
+{
     if (root == NULL)
         return 0;
     else
         return 1 + max(height(root->left), height(root->right));
 }
 
-bool isBalanced(struct TreeNode* root){
+bool isBalanced(struct TreeNode *root)
+{
     if (root == NULL)
         return 1;
     int left = height(root->left);
     int right = height(root->right);
-    return abs(left - right) <= 1 && isBalanced(root->left) && isBalanced(root->right);
+    return abs(left - right) <= 1 && isBalanced(root->left) &&
+           isBalanced(root->right);
 }
-

leetcode/src/112.c

@@ -1,7 +1,9 @@
-bool hasPathSum(struct TreeNode* root, int sum) {
+bool hasPathSum(struct TreeNode *root, int sum)
+{
     if (root == NULL)
         return 0;
     if (!root->left && !root->right && sum - root->val == 0)
         return 1;
-    return hasPathSum(root->left, sum - root->val) || hasPathSum(root->right, sum - root->val);
+    return hasPathSum(root->left, sum - root->val) ||
+           hasPathSum(root->right, sum - root->val);
 }

leetcode/src/1184.c

@@ -1,12 +1,16 @@
-int distanceBetweenBusStops(int* distance, int distanceSize, int start, int destination){
+int distanceBetweenBusStops(int *distance, int distanceSize, int start,
+                            int destination)
+{
 
     int sum1 = 0, sum2 = 0;
-  if (start > destination) {
+    if (start > destination)
+    {
         int tmp = start;
         start = destination;
         destination = tmp;
     }
-  for (auto i = 0; i < distanceSize; ++i) {
+    for (auto i = 0; i < distanceSize; ++i)
+    {
         if (i >= start && i < destination)
             sum1 += distance[i];
         else

leetcode/src/1189.c

@@ -1,4 +1,5 @@
-int maxNumberOfBalloons(char * text){
+int maxNumberOfBalloons(char *text)
+{
     /*
         0 -> b,
         1 -> a,
@@ -9,16 +10,26 @@ int maxNumberOfBalloons(char * text){
     int count_letters[5] = {0};
     int i, min_counter_ballons;
 
-    for (char *ptr = text; *ptr; ptr++) {
-        if (*ptr == 'b') {
+    for (char *ptr = text; *ptr; ptr++)
+    {
+        if (*ptr == 'b')
+        {
             count_letters[0]++;
-        } else if(*ptr == 'a') {
+        }
+        else if (*ptr == 'a')
+        {
             count_letters[1]++;
-        } else if (*ptr == 'l') {
+        }
+        else if (*ptr == 'l')
+        {
             count_letters[2]++;
-        } else if(*ptr == 'o') {
+        }
+        else if (*ptr == 'o')
+        {
             count_letters[3]++;
-        } else if(*ptr == 'n') {
+        }
+        else if (*ptr == 'n')
+        {
             count_letters[4]++;
         }
     }
@@ -27,9 +38,11 @@ int maxNumberOfBalloons(char * text){
     count_letters[2] /= 2;
     count_letters[3] /= 2;
 
-    /* Max number of times which we can write ballon is equal to min value of letters on count_letter */
+    /* Max number of times which we can write ballon is equal to min value of
+     * letters on count_letter */
     min_counter_ballons = count_letters[0];
-    for (i = 1; i < 5; i++) {
+    for (i = 1; i < 5; i++)
+    {
         if (count_letters[i] < min_counter_ballons)
             min_counter_ballons = count_letters[i];
     }

leetcode/src/12.c

@@ -1,5 +1,7 @@
-char *getOne(char c){
-    switch (c) {
+char *getOne(char c)
+{
+    switch (c)
+    {
     case '9':
         return "IX";
 
@@ -35,8 +37,10 @@ char *getOne(char c){
     }
 }
 
-char *getTen(char c){
-    switch (c) {
+char *getTen(char c)
+{
+    switch (c)
+    {
     case '9':
         return "XC";
 
@@ -70,11 +74,12 @@ char *getTen(char c){
     default:
         return NULL;
     }
-
 }
 
-char *getHundred(char c){
-    switch (c) {
+char *getHundred(char c)
+{
+    switch (c)
+    {
     case '9':
         return "CM";
 
@@ -110,8 +115,10 @@ char *getHundred(char c){
     }
 }
 
-char *getThousand(char c){
-    switch (c) {
+char *getThousand(char c)
+{
+    switch (c)
+    {
     case '3':
         return "MMM";
 
@@ -126,30 +133,31 @@ char *getThousand(char c){
     }
 }
 
-
-
-
-char * intToRoman(int num){
+char *intToRoman(int num)
+{
     int length;
     char number[5];
-    char *s = malloc(16*sizeof(char));
+    char *s = malloc(16 * sizeof(char));
 
     sprintf(number, "%i", num);
 
     length = strlen(number);
 
-    switch (length){
+    switch (length)
+    {
     case 4:
-            sprintf(s,"%s%s%s%s", getThousand(number[0]), getHundred(number[1]), getTen(number[2]), getOne(number[3]));
+        sprintf(s, "%s%s%s%s", getThousand(number[0]), getHundred(number[1]),
+                getTen(number[2]), getOne(number[3]));
         break;
 
     case 3:
-            sprintf(s,"%s%s%s", getHundred(number[0]), getTen(number[1]), getOne(number[2]));
+        sprintf(s, "%s%s%s", getHundred(number[0]), getTen(number[1]),
+                getOne(number[2]));
 
         break;
 
     case 2:
-            sprintf(s,"%s%s", getTen(number[0]), getOne(number[1]));
+        sprintf(s, "%s%s", getTen(number[0]), getOne(number[1]));
 
         break;
 

leetcode/src/1207.c

@@ -1,14 +1,14 @@
 #define MAP_SIZE 2048
 
-int cmpvalue(const void *a, const void *b) {
-    return *(int *)b - *(int *)a;
-}
-bool uniqueOccurrences(int* arr, int arrSize){
+int cmpvalue(const void *a, const void *b) { return *(int *)b - *(int *)a; }
+bool uniqueOccurrences(int *arr, int arrSize)
+{
     int *map = calloc(MAP_SIZE, sizeof(int));
     int i;
-    for(i = 0; i < arrSize; i++) {
+    for (i = 0; i < arrSize; i++)
+    {
         if (arr[i] < 0)
-            map[arr[i] + MAP_SIZE/2] += 1;
+            map[arr[i] + MAP_SIZE / 2] += 1;
         else
             map[arr[i]] += 1;
     }
@@ -16,8 +16,9 @@ bool uniqueOccurrences(int* arr, int arrSize){
        Ex: 3 2 1 0 0 0 0 */
     qsort(map, MAP_SIZE, sizeof(int), cmpvalue);
     i = 0;
-    while(map[i]) {
-        if(map[i] == map[i+1])
+    while (map[i])
+    {
+        if (map[i] == map[i + 1])
             return 0;
         i++;
     }

leetcode/src/121.c

@@ -1,15 +1,15 @@
-int maxcmp(int a, int b) {
-	return (a >= b)? a : b;
-}
+int maxcmp(int a, int b) { return (a >= b) ? a : b; }
 
 /* max subarray problem by using Kadane's Algorithm
  */
-int maxProfit(int* prices, int pricesSize){
+int maxProfit(int *prices, int pricesSize)
+{
     /* maxCur: current maximum
      * maxSoFar: found maximum for subarray so far
      */
     int maxCur = 0, maxSoFar = 0;
-	for(int i = 1; i < pricesSize; i++) {
+    for (int i = 1; i < pricesSize; i++)
+    {
         maxCur = maxcmp(0, maxCur + prices[i] - prices[i - 1]);
         maxSoFar = maxcmp(maxSoFar, maxCur);
     }

leetcode/src/125.c

@@ -1,15 +1,21 @@
-bool isPalindrome(char * s){
+bool isPalindrome(char *s)
+{
     int start = 0, end = strlen(s) - 1;
-    while(start < end) {
-        if (!isalpha(s[start]) && !isalnum(s[start])) {
+    while (start < end)
+    {
+        if (!isalpha(s[start]) && !isalnum(s[start]))
+        {
             start++;
         }
-        else if (!isalpha(s[end]) && !isalnum(s[end])) {
+        else if (!isalpha(s[end]) && !isalnum(s[end]))
+        {
             end--;
-        } else {
+        }
+        else
+        {
             char c1 = tolower(s[start]);
             char c2 = tolower(s[end]);
-            if(c1 != c2)
+            if (c1 != c2)
                 return 0;
             start++;
             end--;

leetcode/src/13.c

@@ -1,10 +1,15 @@
-int romanToInt(char * s){
+int romanToInt(char *s)
+{
     int romanToInt = 0;
-    for (int i = 0; i < strlen(s); i++) {
-        switch(s[i]) {
+    for (int i = 0; i < strlen(s); i++)
+    {
+        switch (s[i])
+        {
         case 'I':
-                if (i+1 < strlen(s)) {
-                    if (s[i + 1] == 'V' || s[i + 1] == 'X') {
+            if (i + 1 < strlen(s))
+            {
+                if (s[i + 1] == 'V' || s[i + 1] == 'X')
+                {
                     romanToInt -= 1;
                     break;
                 }
@@ -15,8 +20,10 @@ int romanToInt(char * s){
             romanToInt += 5;
             break;
         case 'X':
-                if (i+1 < strlen(s)) {
-                    if (s[i + 1] == 'L' || s[i + 1] == 'C') {
+            if (i + 1 < strlen(s))
+            {
+                if (s[i + 1] == 'L' || s[i + 1] == 'C')
+                {
                     romanToInt -= 10;
                     break;
                 }
@@ -27,8 +34,10 @@ int romanToInt(char * s){
             romanToInt += 50;
             break;
         case 'C':
-                if (i+1 < strlen(s)) {
-                    if (s[i + 1] == 'D' || s[i + 1] == 'M') {
+            if (i + 1 < strlen(s))
+            {
+                if (s[i + 1] == 'D' || s[i + 1] == 'M')
+                {
                     romanToInt -= 100;
                     break;
                 }

leetcode/src/136.c

@@ -1,6 +1,7 @@
-int singleNumber(int* nums, int numsSize){
+int singleNumber(int *nums, int numsSize)
+{
     int i, result = 0;
-    for(i = 0; i < numsSize; i++)
+    for (i = 0; i < numsSize; i++)
         result = result ^ nums[i];
     return result;
 }

leetcode/src/141.c

@@ -5,12 +5,15 @@
  *     struct ListNode *next;
  * };
  */
-bool hasCycle(struct ListNode *head) {
-    struct ListNode *fast=head, *slow=head;
-    while( slow && fast && fast->next ){
-        fast=fast->next->next;
-        slow=slow->next;
-        if(fast==slow) return true;
+bool hasCycle(struct ListNode *head)
+{
+    struct ListNode *fast = head, *slow = head;
+    while (slow && fast && fast->next)
+    {
+        fast = fast->next->next;
+        slow = slow->next;
+        if (fast == slow)
+            return true;
     }
     return false;
 }

leetcode/src/142.c

@@ -1,16 +1,20 @@
-struct ListNode *detectCycle(struct ListNode *head) {
+struct ListNode *detectCycle(struct ListNode *head)
+{
     if (head == NULL || head->next == NULL)
         return NULL;
     struct ListNode *slow, *fast;
     slow = fast = head;
-    while(fast && fast->next) {
+    while (fast && fast->next)
+    {
         slow = slow->next;
         fast = fast->next->next;
-        if(slow == fast) {
+        if (slow == fast)
+        {
             struct ListNode *entry = head;
-            while(slow != entry) {
-                slow = slow -> next;
-                entry = entry -> next;
+            while (slow != entry)
+            {
+                slow = slow->next;
+                entry = entry->next;
             }
             return entry;
         }

leetcode/src/153.c

@@ -1,6 +1,8 @@
-int findMin(int* nums, int numsSize){
+int findMin(int *nums, int numsSize)
+{
     int low = 0, high = numsSize - 1;
-    while (low < high) {
+    while (low < high)
+    {
         int mid = low + (high - low) / 2;
         /* minimum is on left side */
         if (nums[mid] < nums[high])

leetcode/src/160.c

@@ -1,17 +1,19 @@
-struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
+struct ListNode *getIntersectionNode(struct ListNode *headA,
+                                     struct ListNode *headB)
+{
     struct ListNode *cur1 = headA, *cur2 = headB;
-    if(cur1 == NULL || cur2 == NULL)
+    if (cur1 == NULL || cur2 == NULL)
         return NULL;
-    while (cur1 && cur2 && cur1 != cur2) {
-        cur1 = cur1 -> next;
-        cur2 = cur2 -> next;
+    while (cur1 && cur2 && cur1 != cur2)
+    {
+        cur1 = cur1->next;
+        cur2 = cur2->next;
         if (cur1 == cur2)
             return cur1;
-        if(!cur1)
+        if (!cur1)
             cur1 = headB;
-        if(!cur2)
+        if (!cur2)
             cur2 = headA;
     }
     return cur1;
-
 }

leetcode/src/169.c

@@ -1,13 +1,17 @@
 /* Boyer-Moore Majority Vote Algorithm
  * http://www.cs.utexas.edu/~moore/best-ideas/mjrty/ */
-int majorityElement(int* nums, int numsSize){
+int majorityElement(int *nums, int numsSize)
+{
     int count = 1;
     int majorNum = nums[0];
-    for (int i = 1; i < numsSize; i++) {
-        if(count == 0) {
+    for (int i = 1; i < numsSize; i++)
+    {
+        if (count == 0)
+        {
             majorNum = nums[i];
             count++;
-        } else if (majorNum == nums[i])
+        }
+        else if (majorNum == nums[i])
             count++;
         else
             count--;

leetcode/src/173.c

@@ -9,37 +9,41 @@
 
 #include <limits.h>
 
-typedef struct {
+typedef struct
+{
     int *values;
     int CurrentIndex;
     int NumberOfNodes;
 } BSTIterator;
 
-void TraverseAndAssign(struct TreeNode *root, BSTIterator *obj) {
-    if(!root)
+void TraverseAndAssign(struct TreeNode *root, BSTIterator *obj)
+{
+    if (!root)
         return;
-    if(root->left) 
+    if (root->left)
         TraverseAndAssign(root->left, obj);
     obj->values[obj->CurrentIndex] = root->val;
     obj->CurrentIndex++;
-    if(root->right)
+    if (root->right)
         TraverseAndAssign(root->right, obj);
 }
 
-int TotalNodes(struct TreeNode *root) {
-    if(!root) 
+int TotalNodes(struct TreeNode *root)
+{
+    if (!root)
         return 0;
     int nodes_left = TotalNodes(root->left);
     int nodes_right = TotalNodes(root->right);
     return nodes_left + nodes_right + 1;
 }
 
-BSTIterator* bSTIteratorCreate(struct TreeNode* root) {
+BSTIterator *bSTIteratorCreate(struct TreeNode *root)
+{
     int n = TotalNodes(root);
-    int size = n+1;
+    int size = n + 1;
     printf("%d", size);
-    BSTIterator *obj = (BSTIterator*)malloc(sizeof(BSTIterator));
-    obj->values = (int*)calloc(size, sizeof(int));
+    BSTIterator *obj = (BSTIterator *)malloc(sizeof(BSTIterator));
+    obj->values = (int *)calloc(size, sizeof(int));
     obj->CurrentIndex = 0;
     obj->NumberOfNodes = n;
     obj->values[size - 1] = INT_MAX;
@@ -49,22 +53,26 @@ BSTIterator* bSTIteratorCreate(struct TreeNode* root) {
 }
 
 /** @return the next smallest number */
-int bSTIteratorNext(BSTIterator* obj) {
+int bSTIteratorNext(BSTIterator *obj)
+{
     int NextValue = obj->values[obj->CurrentIndex];
     obj->CurrentIndex++;
     return NextValue;
 }
 
 /** @return whether we have a next smallest number */
-bool bSTIteratorHasNext(BSTIterator* obj) {
-    if(!obj->NumberOfNodes) {
+bool bSTIteratorHasNext(BSTIterator *obj)
+{
+    if (!obj->NumberOfNodes)
+    {
         return false;
     }
     printf(" Here ");
     return (obj->values[obj->CurrentIndex] == INT_MAX) ? false : true;
 }
 
-void bSTIteratorFree(BSTIterator* obj) {
+void bSTIteratorFree(BSTIterator *obj)
+{
     free(obj->values);
     free(obj);
 }

leetcode/src/189.c

@@ -1,9 +1,12 @@
-void rotate(int* nums, int numsSize, int k){
-  for(int i = 1; i <= k; i++){
+void rotate(int *nums, int numsSize, int k)
+{
+    for (int i = 1; i <= k; i++)
+    {
         int j;
         int lastElement;
         lastElement = nums[numsSize - 1];
-    for(j = numsSize - 1; j > 0; j--){
+        for (j = numsSize - 1; j > 0; j--)
+        {
             nums[j] = nums[j - 1];
         }
         nums[0] = lastElement;