mirrors
/
TheAlgorithms-C
mirror of https://github.com/TheAlgorithms/C
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'auto_clang-format' of https://github.com/kvedala/C into auto_clang-format

This commit is contained in:
Krishna Vedala 2020-05-29 16:23:43 -04:00
parent 42f7ffc7ab 0779a2b70d
commit 2829b58c98
260 changed files with 7566 additions and 6554 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

88
client_server/UDP_Client.c
View File

@ -1,49 +1,49 @@
// 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>
// Client side implementation of UDP client-server model
#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
#define PORT 8080
#define MAXLINE 1024
// Driver code
int main() {
int sockfd;
char buffer[MAXLINE];
char *hello = "Hello from client";
struct sockaddr_in servaddr;
// Driver code
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 ) {
perror("socket creation failed");
exit(EXIT_FAILURE);
}
// Creating socket file descriptor
if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
{
perror("socket creation failed");
exit(EXIT_FAILURE);
}
memset(&servaddr, 0, sizeof(servaddr));
// Filling server information
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(PORT);
servaddr.sin_addr.s_addr = INADDR_ANY;
int n, len;
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);
buffer[n] = '\0';
printf("Server : %s\n", buffer);
memset(&servaddr, 0, sizeof(servaddr));
close(sockfd);
return 0;
}
// Filling server information
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(PORT);
servaddr.sin_addr.s_addr = INADDR_ANY;
int n, len;
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);
buffer[n] = '\0';
printf("Server : %s\n", buffer);
close(sockfd);
return 0;
}

105
client_server/UDP_Server.c
View File

@ -1,55 +1,54 @@
// 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>
// Server side implementation of UDP client-server model
#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
#define PORT 8080
#define MAXLINE 1024
// Driver code
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 ) {
perror("socket creation failed");
exit(EXIT_FAILURE);
}
memset(&servaddr, 0, sizeof(servaddr));
memset(&cliaddr, 0, sizeof(cliaddr));
// Filling server information
servaddr.sin_family = AF_INET; // IPv4
servaddr.sin_addr.s_addr = INADDR_ANY;
servaddr.sin_port = htons(PORT);
// Bind the socket with the server address
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);
buffer[n] = '\0';
printf("Client : %s\n", buffer);
sendto(sockfd, (const char *)hello, strlen(hello),
MSG_CONFIRM, (const struct sockaddr *) &cliaddr,
len);
printf("Hello message sent.\n");
return 0;
}
// Driver code
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)
{
perror("socket creation failed");
exit(EXIT_FAILURE);
}
memset(&servaddr, 0, sizeof(servaddr));
memset(&cliaddr, 0, sizeof(cliaddr));
// Filling server information
servaddr.sin_family = AF_INET; // IPv4
servaddr.sin_addr.s_addr = INADDR_ANY;
servaddr.sin_port = htons(PORT);
// Bind the socket with the server address
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);
buffer[n] = '\0';
printf("Client : %s\n", buffer);
sendto(sockfd, (const char *)hello, strlen(hello), MSG_CONFIRM,
(const struct sockaddr *)&cliaddr, len);
printf("Hello message sent.\n");
return 0;
}

12
client_server/client.c
View File

@ -1,11 +1,11 @@
// Write CPP code here
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
// Write CPP code here
#include <arpa/inet.h>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.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

186
client_server/server.c
View File

@ -1,95 +1,101 @@
#include <netdb.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <netdb.h>
#include <netinet/in.h>
#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#define MAX 80
#define PORT 8080
#define SA struct sockaddr
// Function designed for chat between client and server.
void func(int sockfd)
{
char buff[MAX];
int n;
// infinite loop for chat
for (;;) {
bzero(buff, MAX);
// read the message from client and copy it in buffer
read(sockfd, buff, sizeof(buff));
// print buffer which contains the client contents
printf("From client: %s\t To client : ", buff);
bzero(buff, MAX);
n = 0;
// copy server message in the buffer
while ((buff[n++] = getchar()) != '\n')
;
// and send that buffer to client
write(sockfd, buff, sizeof(buff));
// if msg contains "Exit" then server exit and chat ended.
if (strncmp("exit", buff, 4) == 0) {
printf("Server Exit...\n");
break;
}
}
}
// Driver function
int main()
{
int sockfd, connfd, len;
struct sockaddr_in servaddr, cli;
// socket create and verification
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd == -1) {
printf("socket creation failed...\n");
exit(0);
}
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#define MAX 80
#define PORT 8080
#define SA struct sockaddr
// Function designed for chat between client and server.
void func(int sockfd)
{
char buff[MAX];
int n;
// infinite loop for chat
for (;;)
{
bzero(buff, MAX);
// read the message from client and copy it in buffer
read(sockfd, buff, sizeof(buff));
// print buffer which contains the client contents
printf("From client: %s\t To client : ", buff);
bzero(buff, MAX);
n = 0;
// copy server message in the buffer
while ((buff[n++] = getchar()) != '\n')
;
// and send that buffer to client
write(sockfd, buff, sizeof(buff));
// if msg contains "Exit" then server exit and chat ended.
if (strncmp("exit", buff, 4) == 0)
{
printf("Server Exit...\n");
break;
}
}
}
// Driver function
int main()
{
int sockfd, connfd, len;
struct sockaddr_in servaddr, cli;
// socket create and verification
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd == -1)
{
printf("socket creation failed...\n");
exit(0);
}
else
printf("Socket successfully created..\n");
bzero(&servaddr, sizeof(servaddr));
// assign IP, PORT
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(PORT);
// Binding newly created socket to given IP and verification
if ((bind(sockfd, (SA*)&servaddr, sizeof(servaddr))) != 0) {
printf("socket bind failed...\n");
exit(0);
}
printf("Socket successfully created..\n");
bzero(&servaddr, sizeof(servaddr));
// assign IP, PORT
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(PORT);
// Binding newly created socket to given IP and verification
if ((bind(sockfd, (SA *)&servaddr, sizeof(servaddr))) != 0)
{
printf("socket bind failed...\n");
exit(0);
}
else
printf("Socket successfully binded..\n");
// Now server is ready to listen and verification
if ((listen(sockfd, 5)) != 0) {
printf("Listen failed...\n");
exit(0);
}
printf("Socket successfully binded..\n");
// Now server is ready to listen and verification
if ((listen(sockfd, 5)) != 0)
{
printf("Listen failed...\n");
exit(0);
}
else
printf("Server listening..\n");
len = sizeof(cli);
// Accept the data packet from client and verification
connfd = accept(sockfd, (SA*)&cli, &len);
if (connfd < 0) {
printf("server acccept failed...\n");
exit(0);
}
printf("Server listening..\n");
len = sizeof(cli);
// Accept the data packet from client and verification
connfd = accept(sockfd, (SA *)&cli, &len);
if (connfd < 0)
{
printf("server acccept failed...\n");
exit(0);
}
else
printf("server acccept the client...\n");
// Function for chatting between client and server
func(connfd);
// After chatting close the socket
close(sockfd);
}
printf("server acccept the client...\n");
// Function for chatting between client and server
func(connfd);
// After chatting close the socket
close(sockfd);
}

31
conversions/binary_to_decimal.c
View File

@ -1,25 +1,26 @@
/**
* Modified 07/12/2017, Kyler Smith
*
*
*/
#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);
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) {
remainder = number % 10;
number = number / 10;
decimal_number += remainder * temp;
temp = temp*2; //used as power of 2
}
// Iterate over the number until the end.
while (number > 0)
{
printf("%d\n", decimal_number);
remainder = number % 10;
number = number / 10;
decimal_number += remainder * temp;
temp = temp * 2; // used as power of 2
}
printf("%d\n", decimal_number);
}

6
conversions/binary_to_hexadecimal.c
View File

@ -1,12 +1,12 @@
/*
* C Program to Convert Binary to Hexadecimal
* C Program to Convert Binary to Hexadecimal
*/
#include <stdio.h>
int main()
{
long int binary, hexa = 0, i = 1, remainder;
printf("Enter the binary number: ");
scanf("%ld", &binary);
while (binary != 0)

24
conversions/binary_to_octal.c
View File

@ -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;

12
conversions/decimal_to_binary.c
View File

@ -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;
}

55
conversions/decimal_to_hexa.c
View File

@ -2,45 +2,50 @@
#include <stdio.h>
void decimal2Hexadecimal(long num);
int main(){
long decimalnum;
printf("Enter decimal number: ");
scanf("%ld", &decimalnum);
decimal2Hexadecimal(decimalnum);
int main()
{
return 0;
long decimalnum;
printf("Enter decimal number: ");
scanf("%ld", &decimalnum);
decimal2Hexadecimal(decimalnum);
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)
if (remainder < 10)
hexadecimalnum[j++] = 48 + remainder;
else
hexadecimalnum[j++] = 55 + remainder;
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");
printf("\n");
}

29
conversions/decimal_to_octal.c
View File

@ -1,35 +1,38 @@
/*****Decimal to octal conversion*******************/
#include <stdio.h>
void decimal2Octal(long decimalnum);
int main(){
int main()
{
long decimalnum;
printf("Enter the decimal number: ");
scanf("%ld", &decimalnum);
scanf("%ld", &decimalnum);
decimal2Octal(decimalnum);
return 0;
return 0;
}
/********function for convert decimal numbers to octal numbers************/
void decimal2Octal(long decimalnum){
long remainder, quotient;
/********function for convert decimal numbers to octal numbers************/
void decimal2Octal(long decimalnum)
{
long remainder, quotient;
int octalNumber[100], i = 1, j;
quotient = decimalnum;
while (quotient != 0){
octalNumber[i++] = quotient % 8;
while (quotient != 0)
{
octalNumber[i++] = quotient % 8;
quotient = quotient / 8;
}
}
for (j = i - 1; j > 0; j--)
printf("%d", octalNumber[j]);
printf("\n");
printf("\n");
}

42
conversions/decimal_to_octal_recursion.c
View File

@ -1,29 +1,29 @@
//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)
{
if ((decimal < 8) && (decimal > 0))
{
return decimal;
}
else if (decimal == 0)
{
return 0;
}
else
{
return ((decimal_to_octal(decimal / 8) * 10) + decimal % 8);
}
if ((decimal < 8) && (decimal > 0))
{
return decimal;
}
else if (decimal == 0)
{
return 0;
}
else
{
return ((decimal_to_octal(decimal / 8) * 10) + decimal % 8);
}
}
int main()
{
int octalNumber, decimalNumber;
printf("\nEnter your decimal number : ");
scanf("%d", &decimalNumber);
octalNumber = decimal_to_octal(decimalNumber);
printf("\nThe octal of %d is : %d", decimalNumber, octalNumber);
return 0;
int octalNumber, decimalNumber;
printf("\nEnter your decimal number : ");
scanf("%d", &decimalNumber);
octalNumber = decimal_to_octal(decimalNumber);
printf("\nThe octal of %d is : %d", decimalNumber, octalNumber);
return 0;
}

13
conversions/octal_to_decimal.c
View File

@ -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: ");

70
conversions/to_decimal.c
View File

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

349
data_structures/Array/CArray.c
View File

@ -13,243 +13,276 @@
*
*/
/*
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);
array->size = size;
int i;
for (i = 0; i < size; i++) {
array->array[i] = 0;
}
return array;
CArray *array = (CArray *)malloc(sizeof(CArray));
array->array = (int *)malloc(sizeof(int) * size);
array->size = size;
int i;
for (i = 0; i < size; i++)
{
array->array[i] = 0;
}
return array;
}
int insertValueCArray(CArray *array, int position, int value)
{
if (position >= 0 && position < array->size) {
if (array->array[position] == 0) {
array->array[position] = value;
return SUCCESS;
}
else return POSITION_INIT;
}
return INVALID_POSITION;
if (position >= 0 && position < array->size)
{
if (array->array[position] == 0)
{
array->array[position] = value;
return SUCCESS;
}
else
return POSITION_INIT;
}
return INVALID_POSITION;
}
int removeValueCArray(CArray *array, int position)
{
if (position >= 0 && position < array->size) {
if (array->array[position] != 0) {
array->array[position] = 0;
}
else return POSITION_EMPTY;
}
return INVALID_POSITION;
if (position >= 0 && position < array->size)
{
if (array->array[position] != 0)
{
array->array[position] = 0;
}
else
return POSITION_EMPTY;
}
return INVALID_POSITION;
}
int pushValueCArray(CArray *array, int value)
{
int i;
int ok = 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;
int i;
int ok = 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;
}
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;
}
return INVALID_POSITION;
else
return POSITION_NOT_INIT;
}
return INVALID_POSITION;
}
int eraseCArray(CArray *array)
{
int i;
for (i = 0; i < array->size; i++) {
array->array[i] = 0;
}
return 0;
int i;
for (i = 0; i < array->size; i++)
{
array->array[i] = 0;
}
return 0;
}
int switchValuesCArray(CArray *array, int position1, int position2)
{
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;
}
return INVALID_POSITION;
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;
}
return INVALID_POSITION;
}
int reverseCArray(CArray *array)
{
int i;
for (i = 0; i < array->size / 2; i++) {
swap(array, i, array->size - i - 1);
}
return SUCCESS;
int i;
for (i = 0; i < array->size / 2; i++)
{
swap(array, i, array->size - i - 1);
}
return SUCCESS;
}
int displayCArray(CArray *array)
{
int i;
printf("\nC ARRAY\n");
for (i = 0; i < array->size; i++) {
printf("%d ", array->array[i]);
}
printf("\n");
return 0;
int i;
printf("\nC ARRAY\n");
for (i = 0; i < array->size; i++)
{
printf("%d ", array->array[i]);
}
printf("\n");
return 0;
}
int blenderCArray(CArray *array)
{
srand(time(NULL) * array->size);
int i;
int total = array->size * 100;
for (i = 0; i < total; i++) {
swap(array, rand() % array->size, rand() % array->size);
}
return 0;
srand(time(NULL) * array->size);
int i;
int total = array->size * 100;
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++) {
array->array[i] = arr->array[i];
}
return array;
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++)
{
array->array[i] = arr->array[i];
}
return array;
}
void swap(CArray *array, int position1, int position2)
{
int temp = array->array[position1];
array->array[position1] = array->array[position2];
array->array[position2] = temp;
int temp = array->array[position1];
array->array[position1] = array->array[position2];
array->array[position2] = temp;
}
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]) {
swap(array, j, j + 1);
}
}
}
return 0;
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])
{
swap(array, j, j + 1);
}
}
}
return 0;
}
int selectionSortCArray(CArray *array)
{
int i, j, min;
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;
swap(array, min, i);
}
return 0;
int i, j, min;
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;
swap(array, min, i);
}
return 0;
}
int insertionSortCArray(CArray *array)
{
int i, j, num;
for (i = 1; i < array->size; i++) {
num = array->array[i];
j = i - 1;
while (j >= 0 && array->array[j] > num)
{
array->array[j + 1] = array->array[j];
j--;
}
array->array[j + 1] = num;
}
return 0;
int i, j, num;
for (i = 1; i < array->size; i++)
{
num = array->array[i];
j = i - 1;
while (j >= 0 && array->array[j] > num)
{
array->array[j + 1] = array->array[j];
j--;
}
array->array[j + 1] = num;
}
return 0;
}
int valueOcurranceCArray(CArray *array, int value)
{
int i, total = 0;
for (i = 0; i < array->size; i++) {
if (array->array[i] == value) total++;
}
return total;
int i, total = 0;
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) {
// Hopefully this won't overflow
resultArray->array[j] = i;
j++;
}
}
return resultArray;
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)
{
// Hopefully this won't overflow
resultArray->array[j] = i;
j++;
}
}
return resultArray;
}
int findMinCArray(CArray *array)
{
int i;
int min = array->array[0];
for (i = 1; i < array->size; i++) {
if (array->array[i] < min) {
min = array->array[i];
}
}
return min;
int i;
int min = array->array[0];
for (i = 1; i < array->size; i++)
{
if (array->array[i] < min)
{
min = array->array[i];
}
}
return min;
}
int findMaxCArray(CArray *array)
{
int i;
int max = array->array[0];
for (i = 1; i < array->size; i++) {
if (array->array[i] > max) {
max = array->array[i];
}
}
return max;
int i;
int max = array->array[0];
for (i = 1; i < array->size; i++)
{
if (array->array[i] > max)
{
max = array->array[i];
}
}
return max;
}

105
data_structures/Array/CArray.h
View File

@ -16,68 +16,69 @@
#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 {
int *array;
int size;
} CArray;
typedef struct CArray
{
int *array;
int size;
} CArray;
// +-------------------------------------+
// | Returns array |
// +-------------------------------------+
CArray * getCArray(int size);
CArray * getCopyCArray(CArray *array);
// +-------------------------------------+
// | Returns array |
// +-------------------------------------+
CArray *getCArray(int size);
CArray *getCopyCArray(CArray *array);
// +-------------------------------------+
// | Input / Output |
// +-------------------------------------+
int insertValueCArray(CArray *array, int position, int value);
int removeValueCArray(CArray *array, int position);
int pushValueCArray(CArray *array, int value);
int updateValueCArray(CArray *array, int position, int value);
// +-------------------------------------+
// | Input / Output |
// +-------------------------------------+
int insertValueCArray(CArray *array, int position, int value);
int removeValueCArray(CArray *array, int position);
int pushValueCArray(CArray *array, int value);
int updateValueCArray(CArray *array, int position, int value);
// +-------------------------------------+
// | Erase |
// +-------------------------------------+
int eraseCArray(CArray *array);
// +-------------------------------------+
// | Erase |
// +-------------------------------------+
int eraseCArray(CArray *array);
// +-------------------------------------+
// | Switching |
// +-------------------------------------+
int switchValuesCArray(CArray *array, int position1, int position2);
int reverseCArray(CArray *array);
// +-------------------------------------+
// | Switching |
// +-------------------------------------+
int switchValuesCArray(CArray *array, int position1, int position2);
int reverseCArray(CArray *array);
// +-------------------------------------+
// | Sorting |
// +-------------------------------------+
int bubbleSortCArray(CArray *array);
int selectionSortCArray(CArray *array);
int insertionSortCArray(CArray *array);
int blenderCArray(CArray *array);
// +-------------------------------------+
// | Sorting |
// +-------------------------------------+
int bubbleSortCArray(CArray *array);
int selectionSortCArray(CArray *array);
int insertionSortCArray(CArray *array);
int blenderCArray(CArray *array);
// +-------------------------------------+
// | Searching |
// +-------------------------------------+
int valueOcurranceCArray(CArray *array, int value);
CArray * valuePositionsCArray(CArray *array, int value);
int findMaxCArray(CArray *array);
int findMinCArray(CArray *array);
// +-------------------------------------+
// | Searching |
// +-------------------------------------+
int valueOcurranceCArray(CArray *array, int value);
CArray *valuePositionsCArray(CArray *array, int value);
int findMaxCArray(CArray *array);
int findMinCArray(CArray *array);
// +-------------------------------------+
// | Display |
// +-------------------------------------+
int displayCArray(CArray *array);
// +-------------------------------------+
// | Display |
// +-------------------------------------+
int displayCArray(CArray *array);
#ifdef __cplusplus
}

232
data_structures/Array/CArrayTests.c
View File

@ -13,140 +13,148 @@
*
*/
#include "CArray.h"
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "CArray.h"
int CArrayTests()
{
printf("\n");
printf(" +-------------------------------------+\n");
printf(" | |\n");
printf(" | C Array |\n");
printf(" | |\n");
printf(" +-------------------------------------+\n");
printf("\n");
printf("\n");
printf(" +-------------------------------------+\n");
printf(" | |\n");
printf(" | C Array |\n");
printf(" | |\n");
printf(" +-------------------------------------+\n");
printf("\n");
CArray *array = getCArray(10);
CArray *array = getCArray(10);
int i;
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
int i;
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++) {
removeValueCArray(array, i);
}
displayCArray(array);
for (i = 0; i < array->size; i++)
{
removeValueCArray(array, i);
}
printf("\nCode: %d", removeValueCArray(array, -1)); // 1
printf("\nCode: %d\n", insertValueCArray(array, -1, 1)); // 1
displayCArray(array);
// Erase
for (i = 0; i < array->size; i++) {
insertValueCArray(array, i, i + 1);
}
eraseCArray(array);
displayCArray(array); // Should give all 0s
printf("\nCode: %d", removeValueCArray(array, -1)); // 1
printf("\nCode: %d\n", insertValueCArray(array, -1, 1)); // 1
// Switching
CArray *arr = getCArray(13);
for (i = 0; i < arr->size; i++) {
insertValueCArray(arr, i, i + 1);
}
displayCArray(arr);
for (i = 0; i < arr->size / 2; i++) {
switchValuesCArray(arr, i, arr->size - i - 1);
}
// Erase
for (i = 0; i < array->size; i++)
{
insertValueCArray(array, i, i + 1);
}
eraseCArray(array);
displayCArray(array); // Should give all 0s
displayCArray(arr);
// Switching
CArray *arr = getCArray(13);
for (i = 0; i < arr->size; i++)
{
insertValueCArray(arr, i, i + 1);
}
displayCArray(arr);
for (i = 0; i < arr->size / 2; i++)
{
switchValuesCArray(arr, i, arr->size - i - 1);
}
// Or simply...
reverseCArray(arr);
displayCArray(arr);
displayCArray(arr);
// Sorting
srand(time(NULL));
CArray *barray = getCArray(20);
for (i = 0; i < barray->size; i++) {
insertValueCArray(barray, i, rand());
}
CArray *carray = getCopyCArray(barray);
CArray *darray = getCopyCArray(barray);
printf("\nNot sorted Array:");
displayCArray(barray);
// Or simply...
reverseCArray(arr);
printf("\nBubble Sort:");
clock_t begin1 = clock();
// Timing bubble sort
bubbleSortCArray(barray);
clock_t end1 = clock();
double time_spent1 = (double)(end1 - begin1) / CLOCKS_PER_SEC;
displayCArray(barray);
displayCArray(arr);
printf("\nSelection Sort:");
clock_t begin2 = clock();
// Timing selection sort
selectionSortCArray(carray);
clock_t end2 = clock();
double time_spent2 = (double)(end2 - begin2) / CLOCKS_PER_SEC;
displayCArray(carray);
// Sorting
srand(time(NULL));
CArray *barray = getCArray(20);
for (i = 0; i < barray->size; i++)
{
insertValueCArray(barray, i, rand());
}
CArray *carray = getCopyCArray(barray);
CArray *darray = getCopyCArray(barray);
printf("\nNot sorted Array:");
displayCArray(barray);
printf("\nInsertion Sort:");
clock_t begin3 = clock();
// Timing insertion sort
insertionSortCArray(darray);
clock_t end3 = clock();
double time_spent3 = (double)(end3 - begin3) / CLOCKS_PER_SEC;
displayCArray(carray);
printf("\nBubble Sort:");
clock_t begin1 = clock();
// Timing bubble sort
bubbleSortCArray(barray);
clock_t end1 = clock();
double time_spent1 = (double)(end1 - begin1) / CLOCKS_PER_SEC;
displayCArray(barray);
// Descending order
reverseCArray(barray);
// displayCArray(barray);
printf("\nSelection Sort:");
clock_t begin2 = clock();
// Timing selection sort
selectionSortCArray(carray);
clock_t end2 = clock();
double time_spent2 = (double)(end2 - begin2) / CLOCKS_PER_SEC;
displayCArray(carray);
// printf("\nBlender:");
// blenderCArray(barray);
// displayCArray(barray);
printf("\nInsertion Sort:");
clock_t begin3 = clock();
// Timing insertion sort
insertionSortCArray(darray);
clock_t end3 = clock();
double time_spent3 = (double)(end3 - begin3) / CLOCKS_PER_SEC;
displayCArray(carray);
printf("\nTotal time spent for bubble sort: %lf seconds", time_spent1);
printf("\nTotal time spent for selection sort: %lf seconds", time_spent2);
printf("\nTotal time spent for insertion sort: %lf seconds", time_spent3);
// Descending order
reverseCArray(barray);
// displayCArray(barray);
// Searching
CArray *aarray = getCArray(1000);
for (i = 0; i < aarray->size; i++) {
insertValueCArray(aarray, i, rand() % 100);
}
// printf("\nBlender:");
// blenderCArray(barray);
// displayCArray(barray);
int j = 24;
printf("\nOccurrences of the number %d in the array: %d", j,
valueOcurranceCArray(aarray, j));
printf("\nAnd its positions:\n");
CArray *positions = valuePositionsCArray(aarray, j);
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]]);
}
printf("\nThe list has a minimum value of %d and a maximum value of %d",
findMinCArray(aarray), findMaxCArray(aarray));
insertionSortCArray(aarray);
// displayCArray(aarray);
printf("\nTotal time spent for bubble sort: %lf seconds", time_spent1);
printf("\nTotal time spent for selection sort: %lf seconds", time_spent2);
printf("\nTotal time spent for insertion sort: %lf seconds", time_spent3);
free(arr);
free(array);
free(aarray);
free(barray);
free(carray);
free(darray);
printf("\n");
return 0;
// Searching
CArray *aarray = getCArray(1000);
for (i = 0; i < aarray->size; i++)
{
insertValueCArray(aarray, i, rand() % 100);
}
int j = 24;
printf("\nOccurrences of the number %d in the array: %d", j,
valueOcurranceCArray(aarray, j));
printf("\nAnd its positions:\n");
CArray *positions = valuePositionsCArray(aarray, j);
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]]);
}
printf("\nThe list has a minimum value of %d and a maximum value of %d",
findMinCArray(aarray), findMaxCArray(aarray));
insertionSortCArray(aarray);
// displayCArray(aarray);
free(arr);
free(array);
free(aarray);
free(barray);
free(carray);
free(darray);
printf("\n");
return 0;
}

571
data_structures/binary_trees/avl.c
View File

@ -3,429 +3,422 @@
struct AVLnode
{
int key;
struct AVLnode *left;
struct AVLnode *right;
int height;
int key;
struct AVLnode *left;
struct AVLnode *right;
int height;
};
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)
printf("!! Out of Space !!\n");
else
{
node->key = key;
node->left = NULL;
node->right = NULL;
node->height = 0;
}
if (node == NULL)
printf("!! Out of Space !!\n");
else
{
node->key = key;
node->left = NULL;
node->right = NULL;
node->height = 0;
}
return node;
return node;
}
int nodeHeight(avlNode *node)
{
if(node == NULL)
return -1;
else
return(node->height);
if (node == NULL)
return -1;
else
return (node->height);
}
int heightDiff(avlNode *node)
{
if(node == NULL)
return 0;
else
return(nodeHeight(node->left) - nodeHeight(node->right));
if (node == NULL)
return 0;
else
return (nodeHeight(node->left) - nodeHeight(node->right));
}
/* Returns the node with min key in the left subtree*/
avlNode *minNode(avlNode *node)
{
avlNode *temp = node;
avlNode *temp = node;
while(temp->left != NULL)
temp = temp->left;
while (temp->left != NULL)
temp = temp->left;
return temp;
return temp;
}
void printAVL(avlNode *node, int level)
{
int i;
if(node!=NULL)
{
printAVL(node->right, level+1);
printf("\n\n");
int i;
if (node != NULL)
{
printAVL(node->right, level + 1);
printf("\n\n");
for(i=0; i<level; i++)
printf("\t");
for (i = 0; i < level; i++)
printf("\t");
printf("%d", node->key);
printf("%d", node->key);
printAVL(node->left, level+1);
}
printAVL(node->left, level + 1);
}
}
avlNode *rightRotate(avlNode *z)
{
avlNode *y = z->left;
avlNode *T3 = y->right;
avlNode *y = z->left;
avlNode *T3 = y->right;
y->right = z;
z->left = T3;
y->right = z;
z->left = T3;
z->height = (max(nodeHeight(z->left), nodeHeight(z->right)) + 1);
y->height = (max(nodeHeight(y->left), nodeHeight(y->right)) + 1);
z->height = (max(nodeHeight(z->left), nodeHeight(z->right)) + 1);
y->height = (max(nodeHeight(y->left), nodeHeight(y->right)) + 1);
return y;
return y;
}
avlNode *leftRotate(avlNode *z)
{
avlNode *y = z->right;
avlNode *T3 = y->left;
avlNode *y = z->right;
avlNode *T3 = y->left;
y->left = z;
z->right = T3;
y->left = z;
z->right = T3;
z->height = (max(nodeHeight(z->left), nodeHeight(z->right)) + 1);
y->height = (max(nodeHeight(y->left), nodeHeight(y->right)) + 1);
z->height = (max(nodeHeight(z->left), nodeHeight(z->right)) + 1);
y->height = (max(nodeHeight(y->left), nodeHeight(y->right)) + 1);
return y;
return y;
}
avlNode *LeftRightRotate(avlNode *z)
{
z->left = leftRotate(z->left);
z->left = leftRotate(z->left);
return (rightRotate(z));
return (rightRotate(z));
}
avlNode *RightLeftRotate(avlNode *z)
{
z->right = rightRotate(z->right);
z->right = rightRotate(z->right);
return (leftRotate(z));
return (leftRotate(z));
}
avlNode *insert(avlNode *node, int key)
{
if(node == NULL)
return (newNode(key));
if (node == NULL)
return (newNode(key));
/*Binary Search Tree insertion*/
/*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);
/* 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);
/*Checking for the balance condition*/
int balance = heightDiff(node);
/*Left Left */
if (balance > 1 && key < (node->left->key))
return rightRotate(node);
/*Left Left */
if(balance>1 && key < (node->left->key))
return rightRotate(node);
/*Right Right */
if (balance < -1 && key > (node->right->key))
return leftRotate(node);
/*Right Right */
if(balance<-1 && key > (node->right->key))
return leftRotate(node);
/*Left Right */
if (balance > 1 && key > (node->left->key))
{
node = LeftRightRotate(node);
}
/*Left Right */
if (balance>1 && key > (node->left->key))
{
node = LeftRightRotate(node);
}
/*Right Left */
if (balance<-1 && key < (node->right->key))
{
node = RightLeftRotate(node);
}
return node;
/*Right Left */
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)
return node;
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*/
else
{
/*Single or No Child*/
if((node->left == NULL) || (node->right==NULL))
{
avlNode *temp = node->left ?
node->left :
node->right;
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))
{
avlNode *temp = node->left ? node->left : node->right;
/* No Child*/
if(temp == NULL)
{
temp = node;
node = NULL;
}
else /*Single Child : copy data to the parent*/
*node = *temp;
/* No Child*/
if (temp == NULL)
{
temp = node;
node = NULL;
}
else /*Single Child : copy data to the parent*/
*node = *temp;
free(temp);
}
else
{
/*Two Child*/
free(temp);
}
else
{
/*Two Child*/
/*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.*/
}
}
/*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.*/
}
}
/*single node in tree*/
if(node == NULL)
return node;
/*single node in tree*/
if (node == NULL)
return node;
/*Update height*/
node->height = (max(nodeHeight(node->left), nodeHeight(node->right)) + 1);
/*Update height*/
node->height = (max(nodeHeight(node->left), nodeHeight(node->right)) + 1);
int balance = heightDiff(node);
int balance = heightDiff(node);
/*Left Left */
if ((balance > 1) && (heightDiff(node->left) >= 0))
return rightRotate(node);
/*Left Left */
if((balance>1) && (heightDiff(node->left) >= 0))
return rightRotate(node);
/*Left Right */
if ((balance > 1) && (heightDiff(node->left) < 0))
{
node = LeftRightRotate(node);
}
/*Left Right */
if ((balance>1) && (heightDiff(node->left) < 0))
{
node = LeftRightRotate(node);
}
/*Right Right */
if ((balance < -1) && (heightDiff(node->right) >= 0))
return leftRotate(node);
/*Right Right */
if((balance<-1) && (heightDiff(node->right) >= 0))
return leftRotate(node);
/*Right Left */
if ((balance<-1) && (heightDiff(node->right) < 0))
{
node = RightLeftRotate(node);
}
return node;
/*Right Left */
if ((balance < -1) && (heightDiff(node->right) < 0))
{
node = RightLeftRotate(node);
}
return node;
}
avlNode *findNode(avlNode *node, int queryNum)
{
if(node!=NULL)
{
if(queryNum < node->key)
node = findNode(node->left, queryNum);
else if(queryNum > node->key)
node = findNode(node->right, queryNum);
}
if (node != NULL)
{
if (queryNum < node->key)
node = findNode(node->left, queryNum);
else if (queryNum > node->key)
node = findNode(node->right, queryNum);
}
return node;
return node;
}
void printPreOrder(avlNode *node)
{
if(node == NULL)
return;
if (node == NULL)
return;
printf(" %d ", (node->key));
printPreOrder(node->left);
printPreOrder(node->right);
printf(" %d ", (node->key));
printPreOrder(node->left);
printPreOrder(node->right);
}
void printInOrder(avlNode *node)
{
if(node == NULL)
return;
printInOrder(node->left);
printf(" %d ", (node->key));
printInOrder(node->right);
if (node == NULL)
return;
printInOrder(node->left);
printf(" %d ", (node->key));
printInOrder(node->right);
}
void printPostOrder(avlNode *node)
{
if(node == NULL)
return;
printPostOrder(node->left);
printPostOrder(node->right);
printf(" %d ", (node->key));
if (node == NULL)
return;
printPostOrder(node->left);
printPostOrder(node->right);
printf(" %d ", (node->key));
}
int main()
{
int choice;
int flag=1;
int insertNum;
int queryNum;
int choice;
int flag = 1;
int insertNum;
int queryNum;
avlNode *root = NULL;
avlNode *tempNode;
avlNode *root = NULL;
avlNode *tempNode;
while(flag == 1)
{
printf("\n\nEnter the Step to Run : \n");
while (flag == 1)
{
printf("\n\nEnter the Step to Run : \n");
printf("\t1: Insert a node into AVL tree\n");
printf("\t2: Delete a node in AVL tree\n");
printf("\t3: Search a node into AVL tree\n");
printf("\t4: printPreOrder (Ro L R) Tree\n");
printf("\t5: printInOrder (L Ro R) Tree\n");
printf("\t6: printPostOrder (L R Ro) Tree\n");
printf("\t7: printAVL Tree\n");
printf("\t1: Insert a node into AVL tree\n");
printf("\t2: Delete a node in AVL tree\n");
printf("\t3: Search a node into AVL tree\n");
printf("\t4: printPreOrder (Ro L R) Tree\n");
printf("\t5: printInOrder (L Ro R) Tree\n");
printf("\t6: printPostOrder (L R Ro) Tree\n");
printf("\t7: printAVL Tree\n");
printf("\t0: EXIT\n");
scanf("%d", &choice);
printf("\t0: EXIT\n");
scanf("%d", &choice);
switch(choice)
{
case 0:
{
flag=0;
printf("\n\t\tExiting, Thank You !!\n");
break;
}
switch (choice)
{
case 0:
{
flag = 0;
printf("\n\t\tExiting, Thank You !!\n");
break;
}
case 1:
{
case 1:
{
printf("\n\tEnter the Number to insert: ");
scanf("%d", &insertNum);
printf("\n\tEnter the Number to insert: ");
scanf("%d", &insertNum);
tempNode = findNode(root, insertNum);
tempNode = findNode(root, insertNum);
if(tempNode!=NULL)
printf("\n\t %d Already exists in the tree\n", insertNum);
else
{
printf("\n\tPrinting AVL Tree\n");
printAVL(root, 1);
printf("\n");
if (tempNode != NULL)
printf("\n\t %d Already exists in the tree\n", insertNum);
else
{
printf("\n\tPrinting AVL Tree\n");
printAVL(root, 1);
printf("\n");
root = insert(root, insertNum);
printf("\n\tPrinting AVL Tree\n");
printAVL(root, 1);
printf("\n");
}
root = insert(root, insertNum);
printf("\n\tPrinting AVL Tree\n");
printAVL(root, 1);
printf("\n");
}
break;
}
break;
}
case 2:
{
printf("\n\tEnter the Number to Delete: ");
scanf("%d", &queryNum);
case 2:
{
printf("\n\tEnter the Number to Delete: ");
scanf("%d", &queryNum);
tempNode = findNode(root, queryNum);
tempNode = findNode(root, queryNum);
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);
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);
printf("\n\tPrinting AVL Tree\n");
printAVL(root, 1);
printf("\n");
}
printf("\n\tPrinting AVL Tree\n");
printAVL(root, 1);
printf("\n");
}
break;
}
break;
}
case 3:
{
printf("\n\tEnter the Number to Search: ");
scanf("%d", &queryNum);
case 3:
{
printf("\n\tEnter the Number to Search: ");
scanf("%d", &queryNum);
tempNode = findNode(root, queryNum);
tempNode = findNode(root, queryNum);
if (tempNode == NULL)
printf("\n\t %d : Not Found\n", queryNum);
else
{
printf("\n\t %d : Found at height %d \n", queryNum,
tempNode->height);
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\tPrinting AVL Tree\n");
printAVL(root, 1);
printf("\n");
}
printf("\n\tPrinting AVL Tree\n");
printAVL(root, 1);
printf("\n");
}
break;
}
break;
}
case 4:
{
printf("\nPrinting Tree preOrder\n");
printPreOrder(root);
case 4:
{
printf("\nPrinting Tree preOrder\n");
printPreOrder(root);
break;
}
break;
}
case 5:
{
printf("\nPrinting Tree inOrder\n");
printInOrder(root);
case 5:
{
printf("\nPrinting Tree inOrder\n");
printInOrder(root);
break;
}
break;
}
case 6:
{
printf("\nPrinting Tree PostOrder\n");
printPostOrder(root);
case 6:
{
printf("\nPrinting Tree PostOrder\n");
printPostOrder(root);
break;
}
break;
}
case 7:
{
printf("\nPrinting AVL Tree\n");
printAVL(root, 1);
case 7:
{
printf("\nPrinting AVL Tree\n");
printAVL(root, 1);
break;
}
break;
}
default:
{
flag = 0;
printf("\n\t\tExiting, Thank You !!\n");
break;
}
}
}
default:
{
flag=0;
printf("\n\t\tExiting, Thank You !!\n");
break;
}
}
}
return 0;
return 0;
}

336
data_structures/binary_trees/binary_search_tree.c
View File

@ -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,198 +10,237 @@
*/
// 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;
// right child
struct node *right;
// data of the node
int data;
// 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;
tmp->left = NULL;
tmp->right = NULL;
// initializes the slug
tmp->data = data;
tmp->left = NULL;
tmp->right = NULL;
return tmp;
return tmp;
}
// Insertion procedure, which inserts the input key in a new node in the tree
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
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
else if (data < root->data)
root->left = insert(root->left, data);
// Returns the modified tree
return root;
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
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
else if (data < root->data)
root->left = insert(root->left, data);
// Returns the modified tree
return root;
}
// Utilitary procedure to find the greatest key in the left subtree
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;
else
root->right = getMax(root->right);
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;
else
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){
// 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);
// 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);
// If the input key matches the root's, check the following cases
// termination condition
else if (data == root->data){
// Case 1: the root has no leaves, remove the node
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;
root = root->right;
free(tmp);
return 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 {
// 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);
// 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);
// If the input key matches the root's, check the following cases
// termination condition
else if (data == root->data)
{
// Case 1: the root has no leaves, remove the node
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;
root = root->right;
free(tmp);
return 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
{
// 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)
root->data = tmp->data;
root->left = delete(root->left, tmp->data);
}
}
return root;
// 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);
}
}
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){
// If the root is null, the key's not present
if (root == NULL)
return 0;
// If the input key is greater than the root's, search in the right subtree
else if (data > root->data)
return find(root->right, data);
// If the input key is lower than the root's, search in the left subtree
else if (data < root->data)
return find(root->left, data);
// If the input and the root key match, return 1
else if (data == root->data)
return 1;
// 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;
// If the input key is greater than the root's, search in the right subtree
else if (data > root->data)
return find(root->right, data);
// If the input key is lower than the root's, search in the left subtree
else if (data < root->data)
return find(root->left, data);
// If the input and the root key match, return 1
else if (data == root->data)
return 1;
}
// Utilitary procedure to measure the height of the binary tree
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
int right_h = height(root->right);
int left_h = height(root->left);
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
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)
if (right_h > left_h)
return (right_h + 1);
else
return (left_h + 1);
}
// 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
return (left_h + 1);
}
}
// Utilitary procedure to free all nodes in a tree
void purge(node* root){
if (root != NULL){
if (root->left != NULL)
purge(root->left);
if (root->right != NULL)
purge(root->right);
free(root);
}
void purge(node *root)
{
if (root != NULL)
{
if (root->left != NULL)
purge(root->left);
if (root->right != NULL)
purge(root->right);
free(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){
inOrder(root->left);
printf("\t[ %d ]\t", root->data);
inOrder(root->right);
}
// 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;
int opt = -1;
int data = 0;
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);
break;
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);
}
else
printf("Tree is already empty!\n");
break;
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");
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");
break;
case 4: printf("Current height of the tree is: %d\n", height(root));
break;
case 4:
printf("Current height of the tree is: %d\n", height(root));
break;
case 5: inOrder(root);
break;
}
}
case 5:
inOrder(root);
break;
}
}
// deletes the tree from the heap.
purge(root);
purge(root);
}

4
data_structures/binary_trees/create_node.c
View File

@ -1,5 +1,5 @@
/* Includes structure for a node and a newNode() function which
can be used to create a new node in the tree.
can be used to create a new node in the tree.
It is assumed that the data in nodes will be an integer, though
function can be modified according to the data type, easily.
*/
@ -35,5 +35,5 @@ int main(void)
nameOfNode->leftNode and so on.
*/
return 0;
return 0;
}

10
data_structures/binary_trees/recursive_traversals.c
View File

@ -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)
@ -41,5 +41,5 @@ int main(void)
function with a pointer to the root node.
*/
return 0;
return 0;
}

556
data_structures/binary_trees/redBlackTree.c
View File

@ -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,18 +165,21 @@ 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;
parent->par = child;
// 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,19 +237,22 @@ 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;
parent->par = child;
// 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,26 +371,31 @@ void checkForCase2(Node* toDelete, int delete, int fromDirection, Node** root){
return;
}
// Get the sibling for further inspection
Node* sibling;
Node* parent = toDelete->par;
int locateChild = 0; // 0 if toDeleted is left of its parent else 1
if(parent->right == toDelete){
Node *sibling;
Node *parent = toDelete->par;
int locateChild = 0; // 0 if toDeleted is left of its parent else 1
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;
// Step 1: Left rotate sibling
@ -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,21 +447,24 @@ 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;
// Step 1: Right rotate sibling
@ -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){
if(val == buffRoot->val){
// Search for the element in the tree
while (1)
{
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,76 +720,85 @@ 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){
case 1:
printf("\n\nPlease Enter A Value to insert - ");
scanf("%d", &scanValue);
if(root == NULL){
root = newNode(scanValue, NULL);
root->color = 0;
}
else{
insertNode(scanValue, &root);
}
printf("\nSuccessfully Inserted %d in the tree\n\n", scanValue);
break;
case 2:
printf("\n\nPlease Enter A Value to Delete - ");
scanf("%d", &scanValue);
deleteNode(scanValue, &root);
printf("\nSuccessfully Inserted %d in the tree\n\n", scanValue);
break;
case 3:
printf("\nInorder Traversel - ");
printInorder(root);
printf("\n\n");
// checkBlack(root,0);
// printf("\n");
break;
default:
if(root != NULL){
printf("Root - %d\n", root->val);
}
while (choice)
{
switch (choice)
{
case 1:
printf("\n\nPlease Enter A Value to insert - ");
scanf("%d", &scanValue);
if (root == NULL)
{
root = newNode(scanValue, NULL);
root->color = 0;
}
else
{
insertNode(scanValue, &root);
}
printf("\nSuccessfully Inserted %d in the tree\n\n", scanValue);
break;
case 2:
printf("\n\nPlease Enter A Value to Delete - ");
scanf("%d", &scanValue);
deleteNode(scanValue, &root);
printf("\nSuccessfully Inserted %d in the tree\n\n", scanValue);
break;
case 3:
printf("\nInorder Traversel - ");
printInorder(root);
printf("\n\n");
// checkBlack(root,0);
// printf("\n");
break;
default:
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

47
data_structures/dictionary/dict.c
View File

@ -1,32 +1,30 @@
#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;
/* initializes the elemens of the array with NULL-pointer */
for (int i = 0; i < MAXELEMENTS; i++)
for (int i = 0; i < MAXELEMENTS; i++)
{
p_dic->elements[i] = NULL;
}
return p_dic;
}
else
else
{
printf("unable to create a dictionary\n");
return NULL;
}
}
/*
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);
@ -57,28 +55,26 @@ int add_item_label(Dictionary * dic,char label[],void * item)
{
dic->elements[index] = item;
return 0;
}
}
/* error case */
return -1;
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])
{
dic->elements[index] = item;
return 0;
}
}
/* error case */
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,20 +86,15 @@ 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)
{
return dict->elements[index];
}
printf("index out of bounds!\n");
return NULL;
}
void destroy(Dictionary * dict)
{
free(dict);
}
void destroy(Dictionary *dict) { free(dict); }

39
data_structures/dictionary/dict.h
View File

@ -1,6 +1,6 @@
/*
author: Christian Bender
public interface for the dictionary.
public interface for the dictionary.
The dictionary prepares space for 1000 elements.
*/
@ -14,13 +14,13 @@
special data type called 'Dictionary'
for generic use
*/
typedef struct Dict
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;
@ -28,41 +28,38 @@ typedef struct Dict
} Dictionary;
/*
create_dict: is a simple constructor for creating
a dictionary and setting up the
create_dict: is a simple constructor for creating
a dictionary and setting up the
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
/*
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)
/*
add_item_index: adds item (void*) to the dictionary at given index (int)
returns 0 if adding was sucessful otherwise -1
*/
int add_item_index(Dictionary *, int index, void *);
/*
get_element: returns the element at given label
*/
void *get_element_label(Dictionary *, char[]);
/*
get_element: returns the element at given label
get_element: returns the element at given index
*/
void * get_element_label(Dictionary *, char []);
void *get_element_index(Dictionary *, int);
/*
get_element: returns the element at given index
*/
void * get_element_index(Dictionary *, int );
/*
simple destrcutor function
*/
void destroy(Dictionary *);
#endif

24
data_structures/dictionary/test_program.c
View File

@ -10,32 +10,32 @@
int main(void)
{
Dictionary * testObj1;
Dictionary * testObj2;
Dictionary *testObj1;
Dictionary *testObj2;
int value = 28;
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
attention:
The void* pointer must be convert into an int* pointer.
attention:
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 */

15
data_structures/dynamic_array/dynamic_array.c
View File

@ -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];
}

3
data_structures/dynamic_array/dynamic_array.h
View File

@ -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;

6
data_structures/dynamic_array/main.c
View File

@ -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));
}

193
data_structures/graphs/BFS.c
View File

@ -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;
printf("Enter the number of vertices\n");
scanf("%d",&vertices);
struct Graph* graph = createGraph(vertices);
printf("Enter the number of edges\n");
scanf("%d",&edges);
for(i=0; i<edges; i++)
{
printf("Edge %d \nEnter source: ",i+1);
scanf("%d",&src);
printf("Enter destination: ");
scanf("%d",&dst);
addEdge(graph, src, dst);
}
printf("Enter source of bfs\n");
scanf("%d",&source);
bfs(graph, source);
//Uncomment below part to get a ready-made example
int vertices, edges, source, i, src, dst;
printf("Enter the number of vertices\n");
scanf("%d", &vertices);
struct Graph *graph = createGraph(vertices);
printf("Enter the number of edges\n");
scanf("%d", &edges);
for (i = 0; i < edges; i++)
{
printf("Edge %d \nEnter source: ", i + 1);
scanf("%d", &src);
printf("Enter destination: ");
scanf("%d", &dst);
addEdge(graph, src, dst);
}
printf("Enter source of bfs\n");
scanf("%d", &source);
bfs(graph, source);
// Uncomment below part to get a ready-made example
/*struct Graph* graph = createGraph(6);
addEdge(graph, 0, 1);
addEdge(graph, 0, 2);
@ -67,122 +68,128 @@ int main()
addEdge(graph, 2, 4);
addEdge(graph, 3, 4);
bfs(graph,0);*/
return 0;
}
void bfs(struct Graph* graph, int startVertex)
{
struct queue* q = createQueue();
//Add to visited list and put in queue
void bfs(struct Graph *graph, int startVertex)
{
struct queue *q = createQueue();
// 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);
//Iterate while queue not empty
while(!isEmpty(q)){
printf("%d ",pollQueue(q));
printf("Breadth first traversal from vertex %d is:\n", startVertex);
// 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);
}
temp = temp->next;
}
}
}
}
//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;
// Add edge from dest to src; comment it out for directed graph
newNode = createNode(src);
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
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]; }

228
data_structures/graphs/Bellman-Ford.c
View File

@ -1,130 +1,140 @@
#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{
int vertexNum;
int edgeNum;
struct Edge* edges;
// Structure for storing a graph
struct Graph
{
int vertexNum;
int edgeNum;
struct Edge *edges;
};
//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));
// 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));
}
//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;
// 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;
}
// 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;
}
//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;
}
return minInd;
return minInd;
}
//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]);
else
printf("%d\tINF",i);
}
// 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]);
else
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){
int V = graph->vertexNum;
int E = graph->edgeNum;
int dist[V];
// 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++)
dist[i] = INT_MAX;
dist[src] = 0;
// Initialize distances array as INF for all except source
// Intialize source as zero
for (int i = 0; i < V; i++)
dist[i] = INT_MAX;
dist[src] = 0;
//Calculate shortest path distance from source to all edges
//A path can contain maximum (|V|-1) edges
for(int i=0; i<=V-1; i++)
for(int j = 0; j<E; j++){
int u = graph->edges[j].src;
int v = graph->edges[j].dst;
int w = graph->edges[j].weight;
if(dist[u]!=INT_MAX && dist[u] + w < dist[v])
dist[v] = dist[u] + w;
}
//Iterate inner loop once more to check for negative cycle
for(int j = 0; j<E; j++){
int u = graph->edges[j].src;
int v = graph->edges[j].dst;
int w = graph->edges[j].weight;
if(dist[u]!=INT_MAX && dist[u] + w < dist[v]){
printf("Graph contains negative weight cycle. Hence, shortest distance not guaranteed.");
return;
}
}
// 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;
print(dist, V);
return;
if (dist[u] != INT_MAX && dist[u] + w < dist[v])
dist[v] = dist[u] + w;
}
// Iterate inner loop once more to check for negative cycle
for (int j = 0; j < E; j++)
{
int u = graph->edges[j].src;
int v = graph->edges[j].dst;
int w = graph->edges[j].weight;
if (dist[u] != INT_MAX && dist[u] + w < dist[v])
{
printf("Graph contains negative weight cycle. Hence, shortest "
"distance not guaranteed.");
return;
}
}
print(dist, V);
return;
}
// Driver Function
int main()
{
int V, E, gsrc;
int src, dst, weight;
struct Graph G;
printf("Enter number of vertices: ");
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);
printf("Enter destination: ");
scanf("%d", &dst);
printf("Enter weight: ");
scanf("%d", &weight);
addEdge(&G, src, dst, weight);
}
printf("\nEnter source:");
scanf("%d", &gsrc);
BellmanFord(&G, gsrc);
//Driver Function
int main(){
int V,E,gsrc;
int src,dst,weight;
struct Graph G;
printf("Enter number of vertices: ");
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);
printf("Enter destination: ");
scanf("%d",&dst);
printf("Enter weight: ");
scanf("%d",&weight);
addEdge(&G, src, dst, weight);
}
printf("\nEnter source:");
scanf("%d",&gsrc);
BellmanFord(&G,gsrc);
return 0;
return 0;
}

146
data_structures/graphs/DFS.c
View File

@ -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;
printf("Enter the number of vertices\n");
scanf("%d",&vertices);
struct Graph* graph = createGraph(vertices);
printf("Enter the number of edges\n");
scanf("%d",&edges);
for(i=0; i<edges; i++)
{
printf("Edge %d \nEnter source: ",i+1);
scanf("%d",&src);
printf("Enter destination: ");
scanf("%d",&dst);
addEdge(graph, src, dst);
}
printf("Enter source of DFS\n");
scanf("%d",&source);
printf("DFS from %d is:\n",source);
dfs(graph, source);
printf("\n");
//Uncomment below part to get a ready-made example
{
int vertices, edges, source, i, src, dst;
printf("Enter the number of vertices\n");
scanf("%d", &vertices);
struct Graph *graph = createGraph(vertices);
printf("Enter the number of edges\n");
scanf("%d", &edges);
for (i = 0; i < edges; i++)
{
printf("Edge %d \nEnter source: ", i + 1);
scanf("%d", &src);
printf("Enter destination: ");
scanf("%d", &dst);
addEdge(graph, src, dst);
}
printf("Enter source of DFS\n");
scanf("%d", &source);
printf("DFS from %d is:\n", source);
dfs(graph, source);
printf("\n");
// Uncomment below part to get a ready-made example
/*struct Graph* graph = createGraph(4);
addEdge(graph, 0, 1);
addEdge(graph, 0, 2);
@ -50,73 +52,77 @@ int main()
addEdge(graph, 2, 3);
printf("DFS from 0 is:\n");
dfs(graph,0);
printf("\n");*/
printf("\n");*/
return 0;
}
//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
graph->visited[vertex] = 1;
printf("%d ", vertex);
//Recursively call the dfs function on all unvisited neighbours
while(temp!=NULL) {
int connectedVertex = temp->vertex;
if(graph->visited[connectedVertex] == 0) {
dfs(graph, connectedVertex);
}
temp = temp->next;
}
}
//Allocate memory for a node
struct node* createNode(int v)
// Recursive dfs approach
void dfs(struct Graph *graph, int vertex)
{
struct node* newNode = malloc(sizeof(struct node));
struct node *adjList = graph->adjLists[vertex];
struct node *temp = adjList;
// 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)
{
int connectedVertex = temp->vertex;
if (graph->visited[connectedVertex] == 0)
{
dfs(graph, connectedVertex);
}
temp = temp->next;
}
}
// Allocate memory for a node
struct node *createNode(int v)
{
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;
// Add edge from dest to src
newNode = createNode(src);
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)
{

199
data_structures/graphs/Dijkstra.c
View File

@ -1,114 +1,121 @@
#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{
int vertexNum;
int** edges;
// Structure for storing a graph
struct Graph
{
int vertexNum;
int **edges;
};
//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[i][j] = INT_MAX;
G->edges[i][i] = 0;
}
// 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[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){
G->edges[src][dst] = 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)
{
minVal = mdist[i];
minInd = i;
}
//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;
}
return minInd;
return minInd;
}
//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]);
else
printf("%d\tINF",i);
}
// 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]);
else
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){
int V = graph->vertexNum;
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
// 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 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++)
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);
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])
mdist[v] = mdist[u] + graph->edges[u][v];
}
}
// Initialise mdist and vset. Set distance of source as zero
for (int i = 0; i < V; i++)
mdist[i] = INT_MAX, vset[i] = 0;
print(mdist, V);
return;
mdist[src] = 0;
// 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])
mdist[v] = mdist[u] + graph->edges[u][v];
}
}
print(mdist, V);
return;
}
// Driver Function
int main()
{
int V, E, gsrc;
int src, dst, weight;
struct Graph G;
printf("Enter number of vertices: ");
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);
printf("Enter destination: ");
scanf("%d", &dst);
printf("Enter weight: ");
scanf("%d", &weight);
addEdge(&G, src, dst, weight);
}
printf("\nEnter source:");
scanf("%d", &gsrc);
Dijkstra(&G, gsrc);
//Driver Function
int main(){
int V,E,gsrc;
int src,dst,weight;
struct Graph G;
printf("Enter number of vertices: ");
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);
printf("Enter destination: ");
scanf("%d",&dst);
printf("Enter weight: ");
scanf("%d",&weight);
addEdge(&G, src, dst, weight);
}
printf("\nEnter source:");
scanf("%d",&gsrc);
Dijkstra(&G,gsrc);
return 0;
return 0;
}

182
data_structures/graphs/Floyd-Warshall.c
View File

@ -1,104 +1,112 @@
#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{
int vertexNum;
int** edges;
// Structure for storing a graph
struct Graph
{
int vertexNum;
int **edges;
};
//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[i][j] = INT_MAX;
G->edges[i][i] = 0;
}
// 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[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){
G->edges[src][dst] = 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)
{
printf("\nThe Distance matrix for Floyd - Warshall\n");
for (int i = 0; i < V; i++)
{
for (int j = 0; j < V; j++)
{
//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++){
if(dist[i*V+j] != INT_MAX)
printf("%d\t",dist[i*V+j]);
else
printf("INF\t");
}
printf("\n");
}
if (dist[i * V + j] != INT_MAX)
printf("%d\t", dist[i * V + j]);
else
printf("INF\t");
}
printf("\n");
}
}
//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++)
dist[i][j] = graph->edges[i][j];
//Calculate distances
for(int k=0; k<V; k++)
//Choose an intermediate vertex
// 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];
for(int i=0; i<V; i++)
//Choose a source vertex for given intermediate
// Initialise distance array
for (int i = 0; i < V; i++)
for (int j = 0; j < V; j++)
dist[i][j] = graph->edges[i][j];
for(int j=0; j<V; j++)
//Choose a destination vertex for above source vertex
// Calculate distances
for (int k = 0; k < V; k++)
// Choose an intermediate vertex
if(dist[i][k] != INT_MAX && dist[k][j] != INT_MAX && dist[i][k] + dist[k][j] < dist[i][j])
//If the distance through intermediate vertex is less than direct edge then update value in distance array
dist[i][j] = dist[i][k] + dist[k][j];
for (int i = 0; i < V; i++)
// Choose a source vertex for given intermediate
//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);
}
for (int j = 0; j < V; j++)
// Choose a destination vertex for above source vertex
//Driver Function
int main(){
int V,E;
int src,dst,weight;
struct Graph G;
printf("Enter number of vertices: ");
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);
printf("Enter destination: ");
scanf("%d",&dst);
printf("Enter weight: ");
scanf("%d",&weight);
addEdge(&G, src, dst, weight);
}
FloydWarshall(&G);
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];
return 0;
// 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);
}
// Driver Function
int main()
{
int V, E;
int src, dst, weight;
struct Graph G;
printf("Enter number of vertices: ");
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);
printf("Enter destination: ");
scanf("%d", &dst);
printf("Enter weight: ");
scanf("%d", &weight);
addEdge(&G, src, dst, weight);
}
FloydWarshall(&G);
return 0;
}

152
data_structures/graphs/Graph.c
View File

@ -1,102 +1,118 @@
// Graph ADT
// Adjacency Matrix Representation
// Adjacency Matrix Representation
#include "Graph.h"
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct GraphRep {
int **edges; // adjacency matrix
int nV; // #vertices
int nE; // #edges
typedef struct GraphRep
{
int **edges; // adjacency matrix
int nV; // #vertices
int nE; // #edges
} GraphRep;
Graph newGraph(int V) {
assert(V >= 0);
int i;
Graph newGraph(int V)
{
assert(V >= 0);
int i;
Graph g = malloc(sizeof(GraphRep));
assert(g != NULL);
g->nV = V;
g->nE = 0;
Graph g = malloc(sizeof(GraphRep));
assert(g != NULL);
g->nV = V;
g->nE = 0;
// allocate memory for each row
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++) {
g->edges[i] = calloc(V, sizeof(int));
assert(g->edges[i] != NULL);
}
// allocate memory for each row
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++)
{
g->edges[i] = calloc(V, sizeof(int));
assert(g->edges[i] != NULL);
}
return g;
return g;
}
// 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));
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 insertEdge(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 not in graph
g->edges[e.v][e.w] = 1;
g->edges[e.w][e.v] = 1;
g->nE++;
}
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--;
}
}
void removeEdge(Graph g, Edge e) {
assert(g != NULL && validV(g,e.v) && validV(g,e.w));
bool adjacent(Graph g, Vertex v, Vertex w)
{
assert(g != NULL && validV(g, v) && validV(g, w));
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--;
}
return (g->edges[v][w] != 0);
}
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++)
if (g->edges[i][j])
printf("Edge %d - %d\n", i, 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) {
assert(g != NULL);
void freeGraph(Graph g)
{
assert(g != NULL);
int i;
for (i = 0; i < g->nV; i++)
free(g->edges[i]);
free(g->edges);
free(g);
int i;
for (i = 0; i < g->nV; i++)
free(g->edges[i]);
free(g->edges);
free(g);
}
// By
// .----------------. .----------------. .----------------. .-----------------. .----------------. .----------------.
// | .--------------. || .--------------. || .--------------. || .--------------. | | .--------------. || .--------------. |
// | | _________ | || | _____ _____ | || | __ | || | ____ _____ | | | | ____ ____ | || | ____ | |
// | | | _ _ | | || ||_ _||_ _|| || | / \ | || ||_ \|_ _| | | | | |_ || _| | || | .' `. | |
// | | |_/ | | \_| | || | | | | | | || | / /\ \ | || | | \ | | | | | | | |__| | | || | / .--. \ | |
// | | | | | || | | ' ' | | || | / ____ \ | || | | |\ \| | | | | | | __ | | || | | | | | | |
// | | _| |_ | || | \ `--' / | || | _/ / \ \_ | || | _| |_\ |_ | | | | _| | | |_ | || | \ `--' / | |
// | | |_____| | || | `.__.' | || ||____| |____|| || ||_____|\____| | | | | |____||____| | || | `.____.' | |
// | | | || | | || | | || | | | | | | || | | |
// | '--------------' || '--------------' || '--------------' || '--------------' | | '--------------' || '--------------' |
// '----------------' '----------------' '----------------' '----------------' '----------------' '----------------'
// By
// .----------------. .----------------. .----------------.
// .-----------------. .----------------. .----------------.
// | .--------------. || .--------------. || .--------------. ||
// .--------------. | | .--------------. || .--------------. | | | _________ |
// || | _____ _____ | || | __ | || | ____ _____ | | | | ____ ____
// | || | ____ | | | | | _ _ | | || ||_ _||_ _|| || | / \
// | || ||_ \|_ _| | | | | |_ || _| | || | .' `. | | | | |_/ | |
// \_| | || | | | | | | || | / /\ \ | || | | \ | | | | | | |
// |__| | | || | / .--. \ | | | | | | | || | | ' ' | | || |
// / ____ \ | || | | |\ \| | | | | | | __ | | || | | | | | | |
// | | _| |_ | || | \ `--' / | || | _/ / \ \_ | || | _| |_\ |_
// | | | | _| | | |_ | || | \ `--' / | | | | |_____| | || | `.__.'
// | || ||____| |____|| || ||_____|\____| | | | | |____||____| | || | `.____.'
// | | | | | || | | || | | || | | | | |
// | || | | | | '--------------' || '--------------' ||
// '--------------' || '--------------' | | '--------------' || '--------------'
// |
// '----------------' '----------------' '----------------'
// '----------------' '----------------' '----------------'
// Email : z5261243@unsw.edu.au
// hhoanhtuann@gmail.com

52
data_structures/graphs/Graph.h
View File

@ -1,4 +1,4 @@
// Graph ADT interface ... COMP2521
// Graph ADT interface ... COMP2521
#include <stdbool.h>
typedef struct GraphRep *Graph;
@ -7,31 +7,39 @@ typedef struct GraphRep *Graph;
typedef int Vertex;
// edges are pairs of vertices (end-points)
typedef struct Edge {
Vertex v;
Vertex w;
typedef struct Edge
{
Vertex v;
Vertex w;
} Edge;
Graph newGraph(int);
void insertEdge(Graph, Edge);
void removeEdge(Graph, Edge);
bool adjacent(Graph, Vertex, Vertex);
void showGraph(Graph);
void freeGraph(Graph);
void insertEdge(Graph, Edge);
void removeEdge(Graph, Edge);
bool adjacent(Graph, Vertex, Vertex);
void showGraph(Graph);
void freeGraph(Graph);
// By
// .----------------. .----------------. .----------------.
// .-----------------. .----------------. .----------------.
// | .--------------. || .--------------. || .--------------. ||
// .--------------. | | .--------------. || .--------------. | | | _________ |
// || | _____ _____ | || | __ | || | ____ _____ | | | | ____ ____
// | || | ____ | | | | | _ _ | | || ||_ _||_ _|| || | / \
// | || ||_ \|_ _| | | | | |_ || _| | || | .' `. | | | | |_/ | |
// \_| | || | | | | | | || | / /\ \ | || | | \ | | | | | | |
// |__| | | || | / .--. \ | | | | | | | || | | ' ' | | || |
// / ____ \ | || | | |\ \| | | | | | | __ | | || | | | | | | |
// | | _| |_ | || | \ `--' / | || | _/ / \ \_ | || | _| |_\ |_
// | | | | _| | | |_ | || | \ `--' / | | | | |_____| | || | `.__.'
// | || ||____| |____|| || ||_____|\____| | | | | |____||____| | || | `.____.'
// | | | | | || | | || | | || | | | | |
// | || | | | | '--------------' || '--------------' ||
// '--------------' || '--------------' | | '--------------' || '--------------'
// |
// '----------------' '----------------' '----------------'
// '----------------' '----------------' '----------------'
// By
// .----------------. .----------------. .----------------. .-----------------. .----------------. .----------------.
// | .--------------. || .--------------. || .--------------. || .--------------. | | .--------------. || .--------------. |
// | | _________ | || | _____ _____ | || | __ | || | ____ _____ | | | | ____ ____ | || | ____ | |
// | | | _ _ | | || ||_ _||_ _|| || | / \ | || ||_ \|_ _| | | | | |_ || _| | || | .' `. | |
// | | |_/ | | \_| | || | | | | | | || | / /\ \ | || | | \ | | | | | | | |__| | | || | / .--. \ | |
// | | | | | || | | ' ' | | || | / ____ \ | || | | |\ \| | | | | | | __ | | || | | | | | | |
// | | _| |_ | || | \ `--' / | || | _/ / \ \_ | || | _| |_\ |_ | | | | _| | | |_ | || | \ `--' / | |
// | | |_____| | || | `.__.' | || ||____| |____|| || ||_____|\____| | | | | |____||____| | || | `.____.' | |
// | | | || | | || | | || | | | | | | || | | |
// | '--------------' || '--------------' || '--------------' || '--------------' | | '--------------' || '--------------' |
// '----------------' '----------------' '----------------' '----------------' '----------------' '----------------'
// Email : z5261243@unsw.edu.au
// hhoanhtuann@gmail.com

178
data_structures/graphs/bfsQueue.c
View File

@ -1,81 +1,125 @@
#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
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) {
Vertex v;
for (v = 0; v < nV; v++)
visited[v] = -1;
bool findPathBFS(Graph g, int nV, Vertex src, Vertex dest)
{
Vertex v;
for (v = 0; v < nV; v++)
visited[v] = -1;
visited[src] = src;
queue Q = newQueue();
QueueEnqueue(Q, src);
while (!QueueIsEmpty(Q)) {
v = QueueDequeue(Q);
Vertex w;
for (w = 0; w < nV; w++)
if (adjacent(g, v, w) && visited[w] == -1) {
visited[w] = v;
if (w == dest)
return true;
else
QueueEnqueue(Q, w);
}
}
return false;
visited[src] = src;
queue Q = newQueue();
QueueEnqueue(Q, src);
while (!QueueIsEmpty(Q))
{
v = QueueDequeue(Q);
Vertex w;
for (w = 0; w < nV; w++)
if (adjacent(g, v, w) && visited[w] == -1)
{
visited[w] = v;
if (w == dest)
return true;
else
QueueEnqueue(Q, w);
}
}
return false;
}
int main(void) {
int V = 10;
Graph g = newGraph(V);
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);
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);
int src = 0, dest = 6;
if (findPathBFS(g, V, src, dest)) {
Vertex v = dest;
while (v != src) {
printf("%d - ", v);
v = visited[v];
}
printf("%d\n", src);
}
return 0;
int src = 0, dest = 6;
if (findPathBFS(g, V, src, dest))
{
Vertex v = dest;
while (v != src)
{
printf("%d - ", v);
v = visited[v];
}
printf("%d\n", src);
}
return 0;
}
// By
// .----------------. .----------------. .----------------. .-----------------. .----------------. .----------------.
// | .--------------. || .--------------. || .--------------. || .--------------. | | .--------------. || .--------------. |
// | | _________ | || | _____ _____ | || | __ | || | ____ _____ | | | | ____ ____ | || | ____ | |
// | | | _ _ | | || ||_ _||_ _|| || | / \ | || ||_ \|_ _| | | | | |_ || _| | || | .' `. | |
// | | |_/ | | \_| | || | | | | | | || | / /\ \ | || | | \ | | | | | | | |__| | | || | / .--. \ | |
// | | | | | || | | ' ' | | || | / ____ \ | || | | |\ \| | | | | | | __ | | || | | | | | | |
// | | _| |_ | || | \ `--' / | || | _/ / \ \_ | || | _| |_\ |_ | | | | _| | | |_ | || | \ `--' / | |
// | | |_____| | || | `.__.' | || ||____| |____|| || ||_____|\____| | | | | |____||____| | || | `.____.' | |
// | | | || | | || | | || | | | | | | || | | |
// | '--------------' || '--------------' || '--------------' || '--------------' | | '--------------' || '--------------' |
// '----------------' '----------------' '----------------' '----------------' '----------------' '----------------'
// By
// .----------------. .----------------. .----------------.
// .-----------------. .----------------. .----------------.
// | .--------------. || .--------------. || .--------------. ||
// .--------------. | | .--------------. || .--------------. | | | _________ |
// || | _____ _____ | || | __ | || | ____ _____ | | | | ____ ____
// | || | ____ | | | | | _ _ | | || ||_ _||_ _|| || | / \
// | || ||_ \|_ _| | | | | |_ || _| | || | .' `. | | | | |_/ | |
// \_| | || | | | | | | || | / /\ \ | || | | \ | | | | | | |
// |__| | | || | / .--. \ | | | | | | | || | | ' ' | | || |
// / ____ \ | || | | |\ \| | | | | | | __ | | || | | | | | | |
// | | _| |_ | || | \ `--' / | || | _/ / \ \_ | || | _| |_\ |_
// | | | | _| | | |_ | || | \ `--' / | | | | |_____| | || | `.__.'
// | || ||____| |____|| || ||_____|\____| | | | | |____||____| | || | `.____.'
// | | | | | || | | || | | || | | | | |
// | || | | | | '--------------' || '--------------' ||
// '--------------' || '--------------' | | '--------------' || '--------------'
// |
// '----------------' '----------------' '----------------'
// '----------------' '----------------' '----------------'
// Email : z5261243@unsw.edu.au
// hhoanhtuann@gmail.com

146
data_structures/graphs/dfsRecursive.c
View File

@ -1,74 +1,104 @@
#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
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) {
Vertex w;
for (w = 0; w < nV; w++)
if (adjacent(g, v, w) && visited[w] == -1) {
visited[w] = v;
if (w == dest)
return true;
else if (dfsPathCheck(g, nV, w, dest))
return true;
}
return false;
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)
{
visited[w] = v;
if (w == dest)
return true;
else if (dfsPathCheck(g, nV, w, dest))
return true;
}
return false;
}
bool findPathDFS(Graph g, int nV, Vertex src, Vertex dest) {
Vertex v;
for (v = 0; v < nV; v++)
visited[v] = -1;
visited[src] = src;
return dfsPathCheck(g, nV, src, dest);
bool findPathDFS(Graph g, int nV, Vertex src, Vertex dest)
{
Vertex v;
for (v = 0; v < nV; v++)
visited[v] = -1;
visited[src] = src;
return dfsPathCheck(g, nV, src, dest);
}
int main(void) {
int V = 6;
Graph g = newGraph(V);
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);
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);
int src = 0, dest = 5;
if (findPathDFS(g, V, src, dest)) {
Vertex v = dest;
while (v != src) {
printf("%d - ", v);
v = visited[v];
}
printf("%d\n", src);
}
return 0;
int src = 0, dest = 5;
if (findPathDFS(g, V, src, dest))
{
Vertex v = dest;
while (v != src)
{
printf("%d - ", v);
v = visited[v];
}
printf("%d\n", src);
}
return 0;
}
// By
// .----------------. .----------------. .----------------.
// .-----------------. .----------------. .----------------.
// | .--------------. || .--------------. || .--------------. ||
// .--------------. | | .--------------. || .--------------. | | | _________ |
// || | _____ _____ | || | __ | || | ____ _____ | | | | ____ ____
// | || | ____ | | | | | _ _ | | || ||_ _||_ _|| || | / \
// | || ||_ \|_ _| | | | | |_ || _| | || | .' `. | | | | |_/ | |
// \_| | || | | | | | | || | / /\ \ | || | | \ | | | | | | |
// |__| | | || | / .--. \ | | | | | | | || | | ' ' | | || |
// / ____ \ | || | | |\ \| | | | | | | __ | | || | | | | | | |
// | | _| |_ | || | \ `--' / | || | _/ / \ \_ | || | _| |_\ |_
// | | | | _| | | |_ | || | \ `--' / | | | | |_____| | || | `.__.'
// | || ||____| |____|| || ||_____|\____| | | | | |____||____| | || | `.____.'
// | | | | | || | | || | | || | | | | |
// | || | | | | '--------------' || '--------------' ||
// '--------------' || '--------------' | | '--------------' || '--------------'
// |
// '----------------' '----------------' '----------------'
// '----------------' '----------------' '----------------'
// By
// .----------------. .----------------. .----------------. .-----------------. .----------------. .----------------.
// | .--------------. || .--------------. || .--------------. || .--------------. | | .--------------. || .--------------. |
// | | _________ | || | _____ _____ | || | __ | || | ____ _____ | | | | ____ ____ | || | ____ | |
// | | | _ _ | | || ||_ _||_ _|| || | / \ | || ||_ \|_ _| | | | | |_ || _| | || | .' `. | |
// | | |_/ | | \_| | || | | | | | | || | / /\ \ | || | | \ | | | | | | | |__| | | || | / .--. \ | |
// | | | | | || | | ' ' | | || | / ____ \ | || | | |\ \| | | | | | | __ | | || | | | | | | |
// | | _| |_ | || | \ `--' / | || | _/ / \ \_ | || | _| |_\ |_ | | | | _| | | |_ | || | \ `--' / | |
// | | |_____| | || | `.__.' | || ||____| |____|| || ||_____|\____| | | | | |____||____| | || | `.____.' | |
// | | | || | | || | | || | | | | | | || | | |
// | '--------------' || '--------------' || '--------------' || '--------------' | | '--------------' || '--------------' |
// '----------------' '----------------' '----------------' '----------------' '----------------' '----------------'
// Email : z5261243@unsw.edu.au
// hhoanhtuann@gmail.com

143
data_structures/graphs/euler.c
View File

@ -1,82 +1,95 @@
#include <stdio.h>
#include <stdbool.h>
#include "Graph.h"
#include <stdbool.h>
#include <stdio.h>
// Return the number of vertices that v is
// Return the number of vertices that v is
// connected to
int degree(Graph g, int nV, Vertex v) {
int deg = 0;
Vertex w;
for (w = 0; w < nV; w++)
if (adjacent(g, v, w))
deg++;
return deg;
int degree(Graph g, int nV, Vertex v)
{
int deg = 0;
Vertex w;
for (w = 0; w < nV; w++)
if (adjacent(g, v, w))
deg++;
return deg;
}
// If start from vertex v, decide if the
// 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) {
if (degree(g, nV, v) % 2 == 0 || degree(g, nV, w) % 2 == 0)
return false;
} else if (degree(g, nV, v) % 2 != 0) {
return false;
}
Vertex x;
for (x = 0; x < nV; x++)
if (x != v && x != w && degree(g, nV, x) % 2 != 0)
return false;
return true;
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)
{
return false;
}
Vertex x;
for (x = 0; x < nV; x++)
if (x != v && x != w && degree(g, nV, x) % 2 != 0)
return false;
return true;
}
int main(void) {
Edge e;
int n;
int main(void)
{
Edge e;
int n;
printf("Enter the number of vertices: ");
scanf("%d", &n);
Graph g = newGraph(n);
printf("Enter the number of vertices: ");
scanf("%d", &n);
Graph g = newGraph(n);
Vertex src, dest;
printf("Enter source node: ");
scanf("%d", &src);
printf("Enter destination node: ");
scanf("%d", &dest);
printf("Enter an edge (from): ");
while (scanf("%d", &e.v) == 1) {
printf("Enter an edge (to): ");
scanf("%d", &e.w);
insertEdge(g, e);
printf("Enter an edge (from): ");
}
printf("Finished.\n");
Vertex src, dest;
printf("Enter source node: ");
scanf("%d", &src);
printf("Enter destination node: ");
scanf("%d", &dest);
printf("The graph has ");
if (hasEulerPath(g, n, src, dest))
printf("an");
else
printf("no");
printf(" Euler path from %d to %d.\n", src, dest);
printf("Enter an edge (from): ");
while (scanf("%d", &e.v) == 1)
{
printf("Enter an edge (to): ");
scanf("%d", &e.w);
insertEdge(g, e);
printf("Enter an edge (from): ");
}
printf("Finished.\n");
freeGraph(g);
return 0;
printf("The graph has ");
if (hasEulerPath(g, n, src, dest))
printf("an");
else
printf("no");
printf(" Euler path from %d to %d.\n", src, dest);
freeGraph(g);
return 0;
}
// By
// .----------------. .----------------. .----------------.
// .-----------------. .----------------. .----------------.
// | .--------------. || .--------------. || .--------------. ||
// .--------------. | | .--------------. || .--------------. | | | _________ |
// || | _____ _____ | || | __ | || | ____ _____ | | | | ____ ____
// | || | ____ | | | | | _ _ | | || ||_ _||_ _|| || | / \
// | || ||_ \|_ _| | | | | |_ || _| | || | .' `. | | | | |_/ | |
// \_| | || | | | | | | || | / /\ \ | || | | \ | | | | | | |
// |__| | | || | / .--. \ | | | | | | | || | | ' ' | | || |
// / ____ \ | || | | |\ \| | | | | | | __ | | || | | | | | | |
// | | _| |_ | || | \ `--' / | || | _/ / \ \_ | || | _| |_\ |_
// | | | | _| | | |_ | || | \ `--' / | | | | |_____| | || | `.__.'
// | || ||____| |____|| || ||_____|\____| | | | | |____||____| | || | `.____.'
// | | | | | || | | || | | || | | | | |
// | || | | | | '--------------' || '--------------' ||
// '--------------' || '--------------' | | '--------------' || '--------------'
// |
// '----------------' '----------------' '----------------'
// '----------------' '----------------' '----------------'
// By
// .----------------. .----------------. .----------------. .-----------------. .----------------. .----------------.
// | .--------------. || .--------------. || .--------------. || .--------------. | | .--------------. || .--------------. |
// | | _________ | || | _____ _____ | || | __ | || | ____ _____ | | | | ____ ____ | || | ____ | |
// | | | _ _ | | || ||_ _||_ _|| || | / \ | || ||_ \|_ _| | | | | |_ || _| | || | .' `. | |
// | | |_/ | | \_| | || | | | | | | || | / /\ \ | || | | \ | | | | | | | |__| | | || | / .--. \ | |
// | | | | | || | | ' ' | | || | / ____ \ | || | | |\ \| | | | | | | __ | | || | | | | | | |
// | | _| |_ | || | \ `--' / | || | _/ / \ \_ | || | _| |_\ |_ | | | | _| | | |_ | || | \ `--' / | |
// | | |_____| | || | `.__.' | || ||____| |____|| || ||_____|\____| | | | | |____||____| | || | `.____.' | |
// | | | || | | || | | || | | | | | | || | | |
// | '--------------' || '--------------' || '--------------' || '--------------' | | '--------------' || '--------------' |
// '----------------' '----------------' '----------------' '----------------' '----------------' '----------------'
// Email : z5261243@unsw.edu.au
// hhoanhtuann@gmail.com

151
data_structures/graphs/hamiltonian.c
View File

@ -1,87 +1,104 @@
#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) {
return (d == 0);
} 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)) {
return true;
}
}
}
}
visited[v] = false;
return false;
Vertex w;
if (v == dest)
{
return (d == 0);
}
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))
{
return true;
}
}
}
}
visited[v] = false;
return false;
}
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);
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);
}
int main(void) {
Edge e;
int n;
int main(void)
{
Edge e;
int n;
printf("Enter the number of vertices: ");
scanf("%d", &n);
Graph g = newGraph(n);
printf("Enter the number of vertices: ");
scanf("%d", &n);
Graph g = newGraph(n);
Vertex src, dest;
printf("Enter source node: ");
scanf("%d", &src);
printf("Enter destination node: ");
scanf("%d", &dest);
printf("Enter an edge (from): ");
while (scanf("%d", &e.v) == 1) {
printf("Enter an edge (to): ");
scanf("%d", &e.w);
insertEdge(g, e);
printf("Enter an edge (from): ");
}
printf("Finished.\n");
Vertex src, dest;
printf("Enter source node: ");
scanf("%d", &src);
printf("Enter destination node: ");
scanf("%d", &dest);
printf("The graph has ");
if (hasHamiltonianPath(g, n, src, dest))
printf("a");
else
printf("no");
printf(" Hamiltonian path from %d to %d.\n", src, dest);
printf("Enter an edge (from): ");
while (scanf("%d", &e.v) == 1)
{
printf("Enter an edge (to): ");
scanf("%d", &e.w);
insertEdge(g, e);
printf("Enter an edge (from): ");
}
printf("Finished.\n");
freeGraph(g);
return 0;
printf("The graph has ");
if (hasHamiltonianPath(g, n, src, dest))
printf("a");
else
printf("no");
printf(" Hamiltonian path from %d to %d.\n", src, dest);
freeGraph(g);
return 0;
}
// By
// .----------------. .----------------. .----------------.
// .-----------------. .----------------. .----------------.
// | .--------------. || .--------------. || .--------------. ||
// .--------------. | | .--------------. || .--------------. | | | _________ |
// || | _____ _____ | || | __ | || | ____ _____ | | | | ____ ____
// | || | ____ | | | | | _ _ | | || ||_ _||_ _|| || | / \
// | || ||_ \|_ _| | | | | |_ || _| | || | .' `. | | | | |_/ | |
// \_| | || | | | | | | || | / /\ \ | || | | \ | | | | | | |
// |__| | | || | / .--. \ | | | | | | | || | | ' ' | | || |
// / ____ \ | || | | |\ \| | | | | | | __ | | || | | | | | | |
// | | _| |_ | || | \ `--' / | || | _/ / \ \_ | || | _| |_\ |_
// | | | | _| | | |_ | || | \ `--' / | | | | |_____| | || | `.__.'
// | || ||____| |____|| || ||_____|\____| | | | | |____||____| | || | `.____.'
// | | | | | || | | || | | || | | | | |
// | || | | | | '--------------' || '--------------' ||
// '--------------' || '--------------' | | '--------------' || '--------------'
// |
// '----------------' '----------------' '----------------'
// '----------------' '----------------' '----------------'
// By
// .----------------. .----------------. .----------------. .-----------------. .----------------. .----------------.
// | .--------------. || .--------------. || .--------------. || .--------------. | | .--------------. || .--------------. |
// | | _________ | || | _____ _____ | || | __ | || | ____ _____ | | | | ____ ____ | || | ____ | |
// | | | _ _ | | || ||_ _||_ _|| || | / \ | || ||_ \|_ _| | | | | |_ || _| | || | .' `. | |
// | | |_/ | | \_| | || | | | | | | || | / /\ \ | || | | \ | | | | | | | |__| | | || | / .--. \ | |
// | | | | | || | | ' ' | | || | / ____ \ | || | | |\ \| | | | | | | __ | | || | | | | | | |
// | | _| |_ | || | \ `--' / | || | _/ / \ \_ | || | _| |_\ |_ | | | | _| | | |_ | || | \ `--' / | |
// | | |_____| | || | `.__.' | || ||____| |____|| || ||_____|\____| | | | | |____||____| | || | `.____.' | |
// | | | || | | || | | || | | | | | | || | | |
// | '--------------' || '--------------' || '--------------' || '--------------' | | '--------------' || '--------------' |
// '----------------' '----------------' '----------------' '----------------' '----------------' '----------------'
// Email : z5261243@unsw.edu.au
// hhoanhtuann@gmail.com

318
data_structures/graphs/kruskal.c
View File

@ -1,189 +1,187 @@
// C program for Kruskal's algorithm to find Minimum Spanning Tree
// of a given connected, undirected and weighted graph
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// C program for Kruskal's algorithm to find Minimum Spanning Tree
// of a given connected, undirected and weighted graph
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// a structure to represent a weighted edge in graph
struct Edge
{
int src, dest, weight;
};
// a structure to represent a weighted edge in graph
struct Edge
{
int src, dest, weight;
};
// a structure to represent a connected, undirected
// and weighted graph
struct Graph
{
// V-> Number of vertices, E-> Number of edges
int V, E;
// a structure to represent a connected, undirected
// and weighted graph
struct Graph
{
// V-> Number of vertices, E-> Number of edges
int V, E;
// graph is represented as an array of edges.
// 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;
};
// graph is represented as an array of edges.
// 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;
};
// Creates a graph with V vertices and E edges
struct Graph* createGraph(int V, int E)
{
struct Graph* graph = new Graph();
graph->V = V;
graph->E = E;
// Creates a graph with V vertices and E edges
struct Graph *createGraph(int V, int E)
{
struct Graph *graph = new Graph();
graph->V = V;
graph->E = E;
graph->edge = new Edge[E];
graph->edge = new Edge[E];
return graph;
}
return graph;
}
// A structure to represent a subset for union-find
struct subset
{
int parent;
int rank;
};
// A structure to represent a subset for union-find
struct subset
{
int parent;
int rank;
};
// A utility function to find set of an element i
// (uses path compression technique)
int find(struct subset subsets[], int i)
{
// find root and make root as parent of i
// (path compression)
if (subsets[i].parent != i)
subsets[i].parent = find(subsets, subsets[i].parent);
// A utility function to find set of an element i
// (uses path compression technique)
int find(struct subset subsets[], int i)
{
// find root and make root as parent of i
// (path compression)
if (subsets[i].parent != i)
subsets[i].parent = find(subsets, subsets[i].parent);
return subsets[i].parent;
}
return subsets[i].parent;
}
// A function that does union of two sets of x and y
// (uses union by rank)
void Union(struct subset subsets[], int x, int y)
{
int xroot = find(subsets, x);
int yroot = find(subsets, y);
// A function that does union of two sets of x and y
// (uses union by rank)
void Union(struct subset subsets[], int x, int y)
{
int xroot = find(subsets, x);
int yroot = find(subsets, y);
// Attach smaller rank tree under root of high
// rank tree (Union by Rank)
if (subsets[xroot].rank < subsets[yroot].rank)
subsets[xroot].parent = yroot;
else if (subsets[xroot].rank > subsets[yroot].rank)
subsets[yroot].parent = xroot;
// Attach smaller rank tree under root of high
// rank tree (Union by Rank)
if (subsets[xroot].rank < subsets[yroot].rank)
subsets[xroot].parent = yroot;
else if (subsets[xroot].rank > subsets[yroot].rank)
subsets[yroot].parent = xroot;
// If ranks are same, then make one as root and
// increment its rank by one
else
{
subsets[yroot].parent = xroot;
subsets[xroot].rank++;
}
}
// If ranks are same, then make one as root and
// increment its rank by one
else
{
subsets[yroot].parent = xroot;
subsets[xroot].rank++;
}
}
// Compare two edges according to their weights.
// Used in qsort() for sorting an array of edges
int myComp(const void* a, const void* b)
{
struct Edge* a1 = (struct Edge*)a;
struct Edge* b1 = (struct Edge*)b;
return a1->weight > b1->weight;
}
// Compare two edges according to their weights.
// Used in qsort() for sorting an array of edges
int myComp(const void *a, const void *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)
{
int V = graph->V;
struct Edge result[V]; // Tnis will store the resultant MST
int e = 0; // An index variable, used for result[]
int i = 0; // An index variable, used for sorted edges
// The main function to construct MST using Kruskal's algorithm
void KruskalMST(struct Graph *graph)
{
int V = graph->V;
struct Edge result[V]; // Tnis will store the resultant MST
int e = 0; // An index variable, used for result[]
int i = 0; // An index variable, used for sorted edges
// Step 1: Sort all the edges in non-decreasing
// order of their weight. If we are not allowed to
// change the given graph, we can create a copy of
// array of edges
qsort(graph->edge, graph->E, sizeof(graph->edge[0]), myComp);
// Step 1: Sort all the edges in non-decreasing
// order of their weight. If we are not allowed to
// change the given graph, we can create a copy of
// array of edges
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) );
// Allocate memory for creating V ssubsets
struct subset *subsets = (struct subset *)malloc(V * sizeof(struct subset));
// Create V subsets with single elements
for (int v = 0; v < V; ++v)
{
subsets[v].parent = v;
subsets[v].rank = 0;
}
// Create V subsets with single elements
for (int v = 0; v < V; ++v)
{
subsets[v].parent = v;
subsets[v].rank = 0;
}
// Number of edges to be taken is equal to V-1
while (e < V - 1 && i < graph->E)
{
// Step 2: Pick the smallest edge. And increment
// the index for next iteration
struct Edge next_edge = graph->edge[i++];
// Number of edges to be taken is equal to V-1
while (e < V - 1 && i < graph->E)
{
// Step 2: Pick the smallest edge. And increment
// the index for next iteration
struct Edge next_edge = graph->edge[i++];
int x = find(subsets, next_edge.src);
int y = find(subsets, next_edge.dest);
int x = find(subsets, next_edge.src);
int y = find(subsets, next_edge.dest);
// If including this edge does't cause cycle,
// include it in result and increment the index
// of result for next edge
if (x != y)
{
result[e++] = next_edge;
Union(subsets, x, y);
}
// Else discard the next_edge
}
// If including this edge does't cause cycle,
// include it in result and increment the index
// of result for next edge
if (x != y)
{
result[e++] = next_edge;
Union(subsets, x, y);
}
// Else discard the next_edge
}
// print the contents of result[] to display the
// built MST
printf("Following are the edges in the constructed MST\n");
for (i = 0; i < e; ++i)
printf("%d -- %d == %d\n", result[i].src, result[i].dest,
result[i].weight);
return;
}
// print the contents of result[] to display the
// built MST
printf("Following are the edges in the constructed MST\n");
for (i = 0; i < e; ++i)
printf("%d -- %d == %d\n", result[i].src, result[i].dest,
result[i].weight);
return;
}
// Driver program to test above functions
int main()
{
/* Let us create following weighted graph
10
0--------1
| \ |
6| 5\ |15
| \ |
2--------3
4 */
int V = 4; // Number of vertices in graph
int E = 5; // Number of edges in graph
struct Graph* graph = createGraph(V, E);
// Driver program to test above functions
int main()
{
/* Let us create following weighted graph
10
0--------1
| \ |
6| 5\ |15
| \ |
2--------3
4 */
int V = 4; // Number of vertices in graph
int E = 5; // Number of edges in graph
struct Graph *graph = createGraph(V, E);
// add edge 0-1
graph->edge[0].src = 0;
graph->edge[0].dest = 1;
graph->edge[0].weight = 10;
// add edge 0-1
graph->edge[0].src = 0;
graph->edge[0].dest = 1;
graph->edge[0].weight = 10;
// add edge 0-2
graph->edge[1].src = 0;
graph->edge[1].dest = 2;
graph->edge[1].weight = 6;
// add edge 0-2
graph->edge[1].src = 0;
graph->edge[1].dest = 2;
graph->edge[1].weight = 6;
// add edge 0-3
graph->edge[2].src = 0;
graph->edge[2].dest = 3;
graph->edge[2].weight = 5;
// add edge 0-3
graph->edge[2].src = 0;
graph->edge[2].dest = 3;
graph->edge[2].weight = 5;
// add edge 1-3
graph->edge[3].src = 1;
graph->edge[3].dest = 3;
graph->edge[3].weight = 15;
// add edge 1-3
graph->edge[3].src = 1;
graph->edge[3].dest = 3;
graph->edge[3].weight = 15;
// add edge 2-3
graph->edge[4].src = 2;
graph->edge[4].dest = 3;
graph->edge[4].weight = 4;
// add edge 2-3
graph->edge[4].src = 2;
graph->edge[4].dest = 3;
graph->edge[4].weight = 4;
KruskalMST(graph);
KruskalMST(graph);
return 0;
}
return 0;
}

144
data_structures/graphs/queue.c
View File

@ -1,88 +1,104 @@
// Queue ADT implementation ... COMP2521
// Queue ADT implementation ... COMP2521
#include <stdlib.h>
#include <assert.h>
#include "queue.h"
#include <assert.h>
#include <stdlib.h>
typedef struct node {
int data;
struct node *next;
typedef struct node
{
int data;
struct node *next;
} NodeT;
typedef struct QueueRep {
int length;
NodeT *head;
NodeT *tail;
typedef struct QueueRep
{
int length;
NodeT *head;
NodeT *tail;
} QueueRep;
// set up empty queue
queue newQueue() {
queue Q = malloc(sizeof(QueueRep));
Q->length = 0;
Q->head = NULL;
Q->tail = NULL;
return Q;
queue newQueue()
{
queue Q = malloc(sizeof(QueueRep));
Q->length = 0;
Q->head = NULL;
Q->tail = NULL;
return Q;
}
// remove unwanted queue
void dropQueue(queue Q) {
NodeT *curr = Q->head;
while (curr != NULL) {
NodeT *temp = curr->next;
free(curr);
curr = temp;
}
free(Q);
void dropQueue(queue Q)
{
NodeT *curr = Q->head;
while (curr != NULL)
{
NodeT *temp = curr->next;
free(curr);
curr = temp;
}
free(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) {
NodeT *new = malloc(sizeof(NodeT));
assert(new != NULL);
new->data = v;
new->next = NULL;
if (Q->tail != NULL) {
Q->tail->next = new;
Q->tail = new;
} else {
Q->head = new;
Q->tail = new;
}
Q->length++;
void QueueEnqueue(queue Q, int v)
{
NodeT *new = malloc(sizeof(NodeT));
assert(new != NULL);
new->data = v;
new->next = NULL;
if (Q->tail != NULL)
{
Q->tail->next = new;
Q->tail = new;
}
else
{
Q->head = new;
Q->tail = new;
}
Q->length++;
}
// remove int from front of queue
int QueueDequeue(queue Q) {
assert(Q->length > 0);
NodeT *p = Q->head;
Q->head = Q->head->next;
if (Q->head == NULL) {
Q->tail = NULL;
}
Q->length--;
int d = p->data;
free(p);
return d;
int QueueDequeue(queue Q)
{
assert(Q->length > 0);
NodeT *p = Q->head;
Q->head = Q->head->next;
if (Q->head == NULL)
{
Q->tail = NULL;
}
Q->length--;
int d = p->data;
free(p);
return d;
}
// By
// .----------------. .----------------. .----------------.
// .-----------------. .----------------. .----------------.
// | .--------------. || .--------------. || .--------------. ||
// .--------------. | | .--------------. || .--------------. | | | _________ |
// || | _____ _____ | || | __ | || | ____ _____ | | | | ____ ____
// | || | ____ | | | | | _ _ | | || ||_ _||_ _|| || | / \
// | || ||_ \|_ _| | | | | |_ || _| | || | .' `. | | | | |_/ | |
// \_| | || | | | | | | || | / /\ \ | || | | \ | | | | | | |
// |__| | | || | / .--. \ | | | | | | | || | | ' ' | | || |
// / ____ \ | || | | |\ \| | | | | | | __ | | || | | | | | | |
// | | _| |_ | || | \ `--' / | || | _/ / \ \_ | || | _| |_\ |_
// | | | | _| | | |_ | || | \ `--' / | | | | |_____| | || | `.__.'
// | || ||____| |____|| || ||_____|\____| | | | | |____||____| | || | `.____.'
// | | | | | || | | || | | || | | | | |
// | || | | | | '--------------' || '--------------' ||
// '--------------' || '--------------' | | '--------------' || '--------------'
// |
// '----------------' '----------------' '----------------'
// '----------------' '----------------' '----------------'
// By
// .----------------. .----------------. .----------------. .-----------------. .----------------. .----------------.
// | .--------------. || .--------------. || .--------------. || .--------------. | | .--------------. || .--------------. |
// | | _________ | || | _____ _____ | || | __ | || | ____ _____ | | | | ____ ____ | || | ____ | |
// | | | _ _ | | || ||_ _||_ _|| || | / \ | || ||_ \|_ _| | | | | |_ || _| | || | .' `. | |
// | | |_/ | | \_| | || | | | | | | || | / /\ \ | || | | \ | | | | | | | |__| | | || | / .--. \ | |
// | | | | | || | | ' ' | | || | / ____ \ | || | | |\ \| | | | | | | __ | | || | | | | | | |
// | | _| |_ | || | \ `--' / | || | _/ / \ \_ | || | _| |_\ |_ | | | | _| | | |_ | || | \ `--' / | |
// | | |_____| | || | `.__.' | || ||____| |____|| || ||_____|\____| | | | | |____||____| | || | `.____.' | |
// | | | || | | || | | || | | | | | | || | | |
// | '--------------' || '--------------' || '--------------' || '--------------' | | '--------------' || '--------------' |
// '----------------' '----------------' '----------------' '----------------' '----------------' '----------------'
// Email : z5261243@unsw.edu.au
// hhoanhtuann@gmail.com

45
data_structures/graphs/queue.h
View File

@ -1,26 +1,33 @@
// Queue ADT header file ... COMP2521
// Queue ADT header file ... COMP2521
typedef struct QueueRep *queue;
queue newQueue(); // set up empty queue
void dropQueue(queue); // remove unwanted queue
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
queue newQueue(); // set up empty queue
void dropQueue(queue); // remove unwanted queue
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
// .----------------. .----------------. .----------------.
// .-----------------. .----------------. .----------------.
// | .--------------. || .--------------. || .--------------. ||
// .--------------. | | .--------------. || .--------------. | | | _________ |
// || | _____ _____ | || | __ | || | ____ _____ | | | | ____ ____
// | || | ____ | | | | | _ _ | | || ||_ _||_ _|| || | / \
// | || ||_ \|_ _| | | | | |_ || _| | || | .' `. | | | | |_/ | |
// \_| | || | | | | | | || | / /\ \ | || | | \ | | | | | | |
// |__| | | || | / .--. \ | | | | | | | || | | ' ' | | || |
// / ____ \ | || | | |\ \| | | | | | | __ | | || | | | | | | |
// | | _| |_ | || | \ `--' / | || | _/ / \ \_ | || | _| |_\ |_
// | | | | _| | | |_ | || | \ `--' / | | | | |_____| | || | `.__.'
// | || ||____| |____|| || ||_____|\____| | | | | |____||____| | || | `.____.'
// | | | | | || | | || | | || | | | | |
// | || | | | | '--------------' || '--------------' ||
// '--------------' || '--------------' | | '--------------' || '--------------'
// |
// '----------------' '----------------' '----------------'
// '----------------' '----------------' '----------------'
// By
// .----------------. .----------------. .----------------. .-----------------. .----------------. .----------------.
// | .--------------. || .--------------. || .--------------. || .--------------. | | .--------------. || .--------------. |
// | | _________ | || | _____ _____ | || | __ | || | ____ _____ | | | | ____ ____ | || | ____ | |
// | | | _ _ | | || ||_ _||_ _|| || | / \ | || ||_ \|_ _| | | | | |_ || _| | || | .' `. | |
// | | |_/ | | \_| | || | | | | | | || | / /\ \ | || | | \ | | | | | | | |__| | | || | / .--. \ | |
// | | | | | || | | ' ' | | || | / ____ \ | || | | |\ \| | | | | | | __ | | || | | | | | | |
// | | _| |_ | || | \ `--' / | || | _/ / \ \_ | || | _| |_\ |_ | | | | _| | | |_ | || | \ `--' / | |
// | | |_____| | || | `.__.' | || ||____| |____|| || ||_____|\____| | | | | |____||____| | || | `.____.' | |
// | | | || | | || | | || | | | | | | || | | |
// | '--------------' || '--------------' || '--------------' || '--------------' | | '--------------' || '--------------' |
// '----------------' '----------------' '----------------' '----------------' '----------------' '----------------'
// Email : z5261243@unsw.edu.au
// hhoanhtuann@gmail.com

292
data_structures/graphs/strongly_connected_components.c
View File

@ -1,59 +1,61 @@
#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 40//Assume 40 nodes at max in graph
#define INT_MIN 0
//A vertex of the graph
#define MAX_SIZE 40 // Assume 40 nodes at max in graph
#define INT_MIN 0
// 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;
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;
printf("Enter the number of vertices\n");
scanf("%d",&vertices);
struct Graph* graph = createGraph(vertices);
printf("Enter the number of edges\n");
scanf("%d",&edges);
for(i=0; i<edges; i++)
{
printf("Edge %d \nEnter source: ",i+1);
scanf("%d",&src);
printf("Enter destination: ");
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
{
int vertices, edges, i, src, dst;
printf("Enter the number of vertices\n");
scanf("%d", &vertices);
struct Graph *graph = createGraph(vertices);
printf("Enter the number of edges\n");
scanf("%d", &edges);
for (i = 0; i < edges; i++)
{
printf("Edge %d \nEnter source: ", i + 1);
scanf("%d", &src);
printf("Enter destination: ");
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
/*struct Graph* graph2 = createGraph(4);
addEdge(graph2, 0, 1);
addEdge(graph2, 1, 2);
@ -61,127 +63,134 @@ int main()
addEdge(graph2, 2, 3);
printf("The strongly connected components are:\n");
scc(graph2);
printf("\n");*/
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) {
int connectedVertex = temp->vertex;
if(graph->visited[connectedVertex] == 0) {
fillOrder(connectedVertex, graph, stack);
}
temp=temp->next;
}
//and then add itself
push(stack,vertex);
}
//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 node* temp=g->adjLists[i];
while(temp!=NULL)
{
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;
//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) {
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) {
dfs(graph, connectedVertex);
if (graph->visited[connectedVertex] == 0)
{
fillOrder(connectedVertex, graph, stack);
}
temp = temp->next;
}
}
// and then add itself
push(stack, vertex);
}
// 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 node *temp = g->adjLists[i];
while (temp != NULL)
{
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;
// 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)
{
int connectedVertex = temp->vertex;
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++)
{
//Execute topological sort on all elements
if(graph->visited[i]==0)
{
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)
{
int v=pop(stack);
if(graphT->visited[v]==0)
{
dfs(graphT,v);
printf("\n");
}
}
// 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)
{
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)
{
int v = pop(stack);
if (graphT->visited[v] == 0)
{
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,23 +200,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)
return INT_MIN;
else
return stack->arr[stack->top--];
if (stack->top == -1)
return INT_MIN;
else
return stack->arr[stack->top--];
}

195
data_structures/graphs/topologicalSort.c
View File

@ -1,57 +1,59 @@
#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 40//Assume 40 nodes at max in graph
#define INT_MIN 0
//A vertex of the graph
#define MAX_SIZE 40 // Assume 40 nodes at max in graph
#define INT_MIN 0
// 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;
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;
printf("Enter the number of vertices\n");
scanf("%d",&vertices);
struct Graph* graph = createGraph(vertices);
printf("Enter the number of edges\n");
scanf("%d",&edges);
for(i=0; i<edges; i++)
{
printf("Edge %d \nEnter source: ",i+1);
scanf("%d",&src);
printf("Enter destination: ");
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
{
int vertices, edges, i, src, dst;
printf("Enter the number of vertices\n");
scanf("%d", &vertices);
struct Graph *graph = createGraph(vertices);
printf("Enter the number of edges\n");
scanf("%d", &edges);
for (i = 0; i < edges; i++)
{
printf("Edge %d \nEnter source: ", i + 1);
scanf("%d", &src);
printf("Enter destination: ");
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
/*struct Graph* graph2 = createGraph(4);
addEdge(graph2, 0, 1);
addEdge(graph2, 0, 2);
@ -59,81 +61,84 @@ int main()
addEdge(graph2, 2, 3);
printf("One topological sort is:\n");
topologicalSort(graph2);
printf("\n");*/
printf("\n");*/
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) {
topologicalSortHelper(connectedVertex, graph, stack);
}
temp=temp->next;
if (graph->visited[connectedVertex] == 0)
{
topologicalSortHelper(connectedVertex, graph, stack);
}
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++)
{
//Execute topological sort on all elements
if(graph->visited[i]==0)
{
topologicalSortHelper(i,graph,stack);
}
}
while(stack->top!=-1)
printf("%d ",pop(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)
{
topologicalSortHelper(i, graph, 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)
return INT_MIN;
else
return stack->arr[stack->top--];
if (stack->top == -1)
return INT_MIN;
else
return stack->arr[stack->top--];
}

83
data_structures/graphs/transitiveClosure.c
View File

@ -1,48 +1,61 @@
#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() {
int i, s, t;
for (s = 0; s < NODES; s++)
for (t = 0; t < NODES; t++)
tc[s][t] = digraph[s][t];
void warshall()
{
int i, s, t;
for (s = 0; s < NODES; s++)
for (t = 0; t < NODES; t++)
tc[s][t] = digraph[s][t];
for (i = 0; i < NODES; i++)
for (s = 0; s < NODES; s++)
for (t = 0; t < NODES; t++)
if (tc[s][i] && tc[i][t])
tc[s][t] = 1;
for (i = 0; i < NODES; i++)
for (s = 0; s < NODES; s++)
for (t = 0; t < NODES; t++)
if (tc[s][i] && tc[i][t])
tc[s][t] = 1;
}
int main(void) {
warshall();
int i, j;
for (i = 0; i < NODES; i++) {
for (j = 0; j < NODES; j++) {
printf("%d ", tc[i][j]);
}
putchar('\n');
}
return 0;
int main(void)
{
warshall();
int i, j;
for (i = 0; i < NODES; i++)
{
for (j = 0; j < NODES; j++)
{
printf("%d ", tc[i][j]);
}
putchar('\n');
}
return 0;
}
// By
// .----------------. .----------------. .----------------. .-----------------. .----------------. .----------------.
// | .--------------. || .--------------. || .--------------. || .--------------. | | .--------------. || .--------------. |
// | | _________ | || | _____ _____ | || | __ | || | ____ _____ | | | | ____ ____ | || | ____ | |
// | | | _ _ | | || ||_ _||_ _|| || | / \ | || ||_ \|_ _| | | | | |_ || _| | || | .' `. | |
// | | |_/ | | \_| | || | | | | | | || | / /\ \ | || | | \ | | | | | | | |__| | | || | / .--. \ | |
// | | | | | || | | ' ' | | || | / ____ \ | || | | |\ \| | | | | | | __ | | || | | | | | | |
// | | _| |_ | || | \ `--' / | || | _/ / \ \_ | || | _| |_\ |_ | | | | _| | | |_ | || | \ `--' / | |
// | | |_____| | || | `.__.' | || ||____| |____|| || ||_____|\____| | | | | |____||____| | || | `.____.' | |
// | | | || | | || | | || | | | | | | || | | |
// | '--------------' || '--------------' || '--------------' || '--------------' | | '--------------' || '--------------' |
// '----------------' '----------------' '----------------' '----------------' '----------------' '----------------'
// By
// .----------------. .----------------. .----------------.
// .-----------------. .----------------. .----------------.
// | .--------------. || .--------------. || .--------------. ||
// .--------------. | | .--------------. || .--------------. | | | _________ |
// || | _____ _____ | || | __ | || | ____ _____ | | | | ____ ____
// | || | ____ | | | | | _ _ | | || ||_ _||_ _|| || | / \
// | || ||_ \|_ _| | | | | |_ || _| | || | .' `. | | | | |_/ | |
// \_| | || | | | | | | || | / /\ \ | || | | \ | | | | | | |
// |__| | | || | / .--. \ | | | | | | | || | | ' ' | | || |
// / ____ \ | || | | |\ \| | | | | | | __ | | || | | | | | | |
// | | _| |_ | || | \ `--' / | || | _/ / \ \_ | || | _| |_\ |_
// | | | | _| | | |_ | || | \ `--' / | | | | |_____| | || | `.__.'
// | || ||____| |____|| || ||_____|\____| | | | | |____||____| | || | `.____.'
// | | | | | || | | || | | || | | | | |
// | || | | | | '--------------' || '--------------' ||
// '--------------' || '--------------' | | '--------------' || '--------------'
// |
// '----------------' '----------------' '----------------'
// '----------------' '----------------' '----------------'
// Email : z5261243@unsw.edu.au
// hhoanhtuann@gmail.com

27
data_structures/hash_set/hash_set.c
View File

@ -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;
}

8
data_structures/hash_set/hash_set.h
View File

@ -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);

2
data_structures/hash_set/main.c
View File

@ -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));

244
data_structures/heap/max_heap.c
View File

@ -1,122 +1,148 @@
#include<stdio.h>
#include<stdlib.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct max_heap{
int *p;
int size;
int count;
}Heap;
typedef struct max_heap
{
int *p;
int size;
int count;
} 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);
push(head, 10);
printf("Pushing element : 10\n");
push(head, 3);
printf("Pushing element : 3\n");
push(head, 2);
printf("Pushing element : 2\n");
push(head, 8);
printf("Pushing element : 8\n");
printf("Top element = %d \n", top(head));
push(head, 1);
printf("Pushing element : 1\n");
push(head, 7);
printf("Pushing element : 7\n");
printf("Top element = %d \n", top(head));
pop(head);
printf("Popping an element.\n");
printf("Top element = %d \n", top(head));
pop(head);
printf("Popping an element.\n");
printf("Top element = %d \n", top(head));
printf("\n");
return 0;
int main()
{
Heap *head = create_heap(head);
push(head, 10);
printf("Pushing element : 10\n");
push(head, 3);
printf("Pushing element : 3\n");
push(head, 2);
printf("Pushing element : 2\n");
push(head, 8);
printf("Pushing element : 8\n");
printf("Top element = %d \n", top(head));
push(head, 1);
printf("Pushing element : 1\n");
push(head, 7);
printf("Pushing element : 7\n");
printf("Top element = %d \n", top(head));
pop(head);
printf("Popping an element.\n");
printf("Top element = %d \n", top(head));
pop(head);
printf("Popping an element.\n");
printf("Top element = %d \n", top(head));
printf("\n");
return 0;
}
Heap* create_heap(Heap* heap){
heap = (Heap *)malloc(sizeof(Heap));
heap->size = 1;
heap->p = (int *)malloc(heap->size*sizeof(int));
heap->count = 0;
return heap;
Heap *create_heap(Heap *heap)
{
heap = (Heap *)malloc(sizeof(Heap));
heap->size = 1;
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;
int leftflag = 0, rightflag = 0;
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);
leftflag = 0;
rightflag = 1;
}
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;
down_heapify(heap, right);
}
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);
leftflag = 1;
}
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;
down_heapify(heap, left);
}
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;
up_heapify(heap, parent);
}
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;
heap->count++;
if(4*heap->count >= 3*heap->size){
heap->size *= 2;
(heap->p) = (int *)realloc((heap->p), (heap->size)*sizeof(int));
}
up_heapify(heap, heap->count - 1);
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)
{
heap->size *= 2;
(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;
heap->count--;
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){
heap->size /= 2;
(heap->p) = (int *)realloc((heap->p), (heap->size)*sizeof(int));
}
void pop(Heap *heap)
{
if (heap->count == 0)
return;
heap->count--;
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)
{
heap->size /= 2;
(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; }

244
data_structures/heap/min_heap.c
View File

@ -1,122 +1,148 @@
#include<stdio.h>
#include<stdlib.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct min_heap{
int *p;
int size;
int count;
}Heap;
typedef struct min_heap
{
int *p;
int size;
int count;
} 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);
push(head, 10);
printf("Pushing element : 10\n");
push(head, 3);
printf("Pushing element : 3\n");
push(head, 2);
printf("Pushing element : 2\n");
push(head, 8);
printf("Pushing element : 8\n");
printf("Top element = %d \n", top(head));
push(head, 1);
printf("Pushing element : 1\n");
push(head, 7);
printf("Pushing element : 7\n");
printf("Top element = %d \n", top(head));
pop(head);
printf("Popping an element.\n");
printf("Top element = %d \n", top(head));
pop(head);
printf("Popping an element.\n");
printf("Top element = %d \n", top(head));
printf("\n");
return 0;
int main()
{
Heap *head = create_heap(head);
push(head, 10);
printf("Pushing element : 10\n");
push(head, 3);
printf("Pushing element : 3\n");
push(head, 2);
printf("Pushing element : 2\n");
push(head, 8);
printf("Pushing element : 8\n");
printf("Top element = %d \n", top(head));
push(head, 1);
printf("Pushing element : 1\n");
push(head, 7);
printf("Pushing element : 7\n");
printf("Top element = %d \n", top(head));
pop(head);
printf("Popping an element.\n");
printf("Top element = %d \n", top(head));
pop(head);
printf("Popping an element.\n");
printf("Top element = %d \n", top(head));
printf("\n");
return 0;
}
Heap* create_heap(Heap* heap){
heap = (Heap *)malloc(sizeof(Heap));
heap->size = 1;
heap->p = (int *)malloc(heap->size*sizeof(int));
heap->count = 0;
return heap;
Heap *create_heap(Heap *heap)
{
heap = (Heap *)malloc(sizeof(Heap));
heap->size = 1;
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;
int leftflag = 0, rightflag = 0;
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);
leftflag = 0;
rightflag = 1;
}
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;
down_heapify(heap, right);
}
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);
leftflag = 1;
}
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;
down_heapify(heap, left);
}
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;
up_heapify(heap, parent);
}
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;
heap->count++;
if(4*heap->count >= 3*heap->size){
heap->size *= 2;
(heap->p) = (int *)realloc((heap->p), (heap->size)*sizeof(int));
}
up_heapify(heap, heap->count - 1);
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)
{
heap->size *= 2;
(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;
heap->count--;
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){
heap->size /= 2;
(heap->p) = (int *)realloc((heap->p), (heap->size)*sizeof(int));
}
void pop(Heap *heap)
{
if (heap->count == 0)
return;
heap->count--;
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)
{
heap->size /= 2;
(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; }

311
data_structures/linked_list/ascendingpriorityqueue.c
View File

@ -1,185 +1,182 @@
/* 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
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)
#include <stdio.h>
#include <stdlib.h>
#define NULL ((void*)0)
struct node
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()
/* This function initializes the queue to empty by making both front and rear as
* NULL */
void createqueue() { front = rear = NULL; }
int empty()
{
front=rear=NULL ;
if (front == NULL)
return 1;
else
return 0;
}
int empty()
void insert(int x)
{
if(front==NULL)
return 1 ;
else
return 0 ;
}
struct node *pnode;
void insert(int x)
{
struct node *pnode ;
pnode=(struct node*)malloc(sizeof(struct node)) ;
if(pnode==NULL)
{
printf("Memory overflow. Unable to insert.\n") ;
exit(1) ;
}
pnode->data=x ;
pnode->next=NULL; /* New node is always last node */
if(empty())
front=rear=pnode ;
else
{
rear->next=pnode ;
rear=pnode ;
}
}
int removes()
{
int min ;
struct node *follow , *follow1 , *p , *p1 ;
if(empty())
{
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)
{
if(p->data<min)
pnode = (struct node *)malloc(sizeof(struct node));
if (pnode == NULL)
{
min=p->data ;
follow1=follow ;
p1=p ;
}
follow=p ;
p=p->next ;
}
/* Deleting the node with min value */
if(p1==front) /* deleting first node.*/
{
front=front->next ;
if(front==NULL) /* Deleting the only one node */
rear=NULL ;
}
else if(p1==rear) /* Deleting last node */
{
rear=follow1 ;
rear->next=NULL ;
}
else /* deleting any other node.*/
follow1->next=p1->next ;
free(p1) ;
return min ; /* DONT FORGET LAST 2 STATEMENTS.*/
}
void show()
{
struct node *p ;
if(empty())
printf("Queue empty. No data to display \n") ;
else
{
printf("Queue from front to rear is as shown: \n") ;
p=front ;
while(p!=NULL)
{
printf("%d ",p->data) ;
p=p->next ;
printf("Memory overflow. Unable to insert.\n");
exit(1);
}
printf("\n") ;
}
}
pnode->data = x;
pnode->next = NULL; /* New node is always last node */
void destroyqueue()
{
front=rear=NULL ;
}
int main()
{
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) ;
switch(ch)
if (empty())
front = rear = pnode;
else
{
case 1:
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 ;
case 3:
break ;
rear->next = pnode;
rear = pnode;
}
}
while(ch!=3) ;
}
destroyqueue() ;
int removes()
{
int min;
struct node *follow, *follow1, *p, *p1;
return 0;
if (empty())
{
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)
{
if (p->data < min)
{
min = p->data;
follow1 = follow;
p1 = p;
}
follow = p;
p = p->next;
}
/* Deleting the node with min value */
if (p1 == front) /* deleting first node.*/
{
front = front->next;
if (front == NULL) /* Deleting the only one node */
rear = NULL;
}
else if (p1 == rear) /* Deleting last node */
{
rear = follow1;
rear->next = NULL;
}
else /* deleting any other node.*/
follow1->next = p1->next;
free(p1);
return min; /* DONT FORGET LAST 2 STATEMENTS.*/
}
void show()
{
struct node *p;
if (empty())
printf("Queue empty. No data to display \n");
else
{
printf("Queue from front to rear is as shown: \n");
p = front;
while (p != NULL)
{
printf("%d ", p->data);
p = p->next;
}
printf("\n");
}
}
void destroyqueue() { front = rear = NULL; }
int main()
{
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);
switch (ch)
{
case 1:
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;
case 3:
break;
}
} while (ch != 3);
destroyqueue();
return 0;
}
/* Output of the Program*/

144
data_structures/linked_list/merge_linked_lists.c
View File

@ -1,8 +1,9 @@
#include<stdio.h>
#include<stdlib.h>
struct node{
int data;
struct node *next;
#include <stdio.h>
#include <stdlib.h>
struct node
{
int data;
struct node *next;
};
struct node *head1 = NULL;
@ -12,37 +13,44 @@ struct node *head2 = NULL;
void merge()
{
struct node *temp1 = head1;
struct node *temp2 = head2;
struct node *temp1 = head1;
struct node *temp2 = head2;
struct node *holder1 = NULL;
struct node *holder2 = NULL;
//Temporary pointer variables to store the address of next node of the two input linked list
struct node *holder1 = NULL;
struct node *holder2 = NULL;
// Temporary pointer variables to store the address of next node of the two
// input linked list
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
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
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
}
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
}
}
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);
printf("Linked List 1: ");
printlist(head1);
printf("\nLinked List 2: ");
printlist(head2);
//Merging the two linked list into single linked list
merge();
// Merging the two linked list into single linked list
merge();
printf("\nMerged Linked List: ");
printlist(head1); //list one has been modified
printf("\nMerged Linked List: ");
printlist(head1); // list one has been modified
return 0;
return 0;
}

111
data_structures/linked_list/middle_element_in_list.c
View File

@ -1,70 +1,69 @@
#include<stdio.h>
#include<stdlib.h>
#include <stdio.h>
#include <stdlib.h>
/* Link list node */
struct Node
{
int data;
struct Node* next;
};
struct Node
{
int data;
struct Node *next;
};
/* Function to get the middle of the linked list*/
void printMiddle(struct Node *head)
{
struct Node *slow_ptr = head;
struct Node *fast_ptr = head;
void printMiddle(struct Node *head)
{
struct Node *slow_ptr = head;
struct Node *fast_ptr = head;
if (head!=NULL)
{
while (fast_ptr != NULL && fast_ptr->next != NULL)
{
fast_ptr = fast_ptr->next->next;
slow_ptr = slow_ptr->next;
}
printf("The middle element is [%d]\n\n", slow_ptr->data);
}
}
if (head != NULL)
{
while (fast_ptr != NULL && fast_ptr->next != NULL)
{
fast_ptr = fast_ptr->next->next;
slow_ptr = slow_ptr->next;
}
printf("The middle element is [%d]\n\n", slow_ptr->data);
}
}
void push(struct Node** head_ref, int new_data)
{
/* allocate node */
struct Node* new_node =
(struct Node*) malloc(sizeof(struct Node));
void push(struct Node **head_ref, int new_data)
{
/* allocate node */
struct Node *new_node = (struct Node *)malloc(sizeof(struct Node));
/* put in the data */
new_node->data = new_data;
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
/* move the head to point to the new node */
(*head_ref) = new_node;
}
// A utility function to print a given linked list
void printList(struct Node *ptr)
{
while (ptr != NULL)
{
printf("%d->", ptr->data);
ptr = ptr->next;
}
printf("NULL\n");
}
// A utility function to print a given linked list
void printList(struct Node *ptr)
{
while (ptr != NULL)
{
printf("%d->", ptr->data);
ptr = ptr->next;
}
printf("NULL\n");
}
/* Drier program to test above function*/
int main()
{
/* Start with the empty list */
struct Node* head = NULL;
int i;
int main()
{
/* Start with the empty list */
struct Node *head = NULL;
int i;
for (i=5; i>0; i--)
{
push(&head, i);
printList(head);
printMiddle(head);
}
for (i = 5; i > 0; i--)
{
push(&head, i);
printList(head);
printMiddle(head);
}
return 0;
}
return 0;
}

220
data_structures/linked_list/queue_linked_list.c
View File

@ -1,149 +1,141 @@
/* 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 */
#include <stdio.h>
#include <stdlib.h>
#define NULL 0
#define NULL 0
struct node
struct node
{
int data ;
struct node *next ;
} ;
int data;
struct node *next;
};
struct queue
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()
/* This function initializes the queue to empty by making both front and rear as
* NULL */
void createqueue() { q.front = q.rear = NULL; }
int empty()
{
q.front=q.rear=NULL ;
if (q.front == NULL)
return 1;
else
return 0;
}
int empty()
void insert(int x)
{
if(q.front==NULL)
return 1 ;
else
return 0 ;
}
struct node *pnode;
void insert(int x)
{
struct node *pnode ;
pnode=(struct node*)malloc(sizeof(struct node)) ;
if(pnode==NULL)
{
printf("Memory overflow. Unable to insert.\n") ;
exit(1) ;
}
pnode->data=x ;
pnode->next=NULL ; /* New node is always last node */
if(empty())
q.front=q.rear=pnode ;
else
{
(q.rear)->next=pnode ;
q.rear=pnode ;
}
}
int removes()
{
int x ;
struct node *p ;
if(empty())
{
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 ;
}
void show()
{
struct node *p ;
if(empty())
printf("Queue empty. No data to display \n") ;
else
{
printf("Queue from front to rear is as shown: \n") ;
p=q.front ;
while(p!=NULL)
pnode = (struct node *)malloc(sizeof(struct node));
if (pnode == NULL)
{
printf("%d ",p->data) ;
p=p->next ;
printf("Memory overflow. Unable to insert.\n");
exit(1);
}
printf("\n") ;
}
pnode->data = x;
pnode->next = NULL; /* New node is always last node */
if (empty())
q.front = q.rear = pnode;
else
{
(q.rear)->next = pnode;
q.rear = pnode;
}
}
void destroyqueue()
int removes()
{
q.front=q.rear=NULL ;
int x;
struct node *p;
if (empty())
{
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;
}
void show()
{
struct node *p;
if (empty())
printf("Queue empty. No data to display \n");
else
{
printf("Queue from front to rear is as shown: \n");
p = q.front;
while (p != NULL)
{
printf("%d ", p->data);
p = p->next;
}
printf("\n");
}
}
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) ;
switch(ch)
do
{
case 1:
printf("Enter element to be inserted: ") ;
scanf("%d",&x) ;
insert(x) ;
show() ;
break ;
printf("\n\n Menu: \n");
printf("1:Insert \n");
printf("2:Remove \n");
printf("3:exit \n");
printf("Enter your choice: ");
scanf("%d", &ch);
case 2:
x=removes() ;
printf("Element removed is: %d\n",x) ;
show() ;
break ;
switch (ch)
{
case 1:
printf("Enter element to be inserted: ");
scanf("%d", &x);
insert(x);
show();
break;
case 3:
break ;
}
}
while(ch!=3) ;
case 2:
x = removes();
printf("Element removed is: %d\n", x);
show();
break;
destroyqueue() ;
case 3:
break;
}
} while (ch != 3);
return 0;
destroyqueue();
return 0;
}

96
data_structures/linked_list/singly_link_list_deletion.c
View File

@ -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;
struct node *link;
{
int info;
struct node *link;
};
struct node *start=NULL;
struct node *start = NULL;
///////////////////////////////////////////////////////////
struct node * createnode()//function to create node
{
struct node *t;
t=(struct node*)malloc(sizeof(struct node));
return(t);
}
////////////////////////////////////////////////////////
void insert()//function to insert at first location
{
struct node *p;
p=createnode();
printf("\nenter the number to insert");
scanf("%d",&p->info);
p->link=NULL;
if(start==NULL)
{
start=p;
}
else
{
p->link=start;
start=p;
}
}
///////////////////////////////////////////////////////////
void deletion()//function to delete from first position
struct node *createnode() // function to create node
{
struct node *t;
if(start==NULL)
t = (struct node *)malloc(sizeof(struct node));
return (t);
}
////////////////////////////////////////////////////////
void insert() // function to insert at first location
{
struct node *p;
p = createnode();
printf("\nenter the number to insert");
scanf("%d", &p->info);
p->link = NULL;
if (start == NULL)
{
start = p;
}
else
{
p->link = start;
start = p;
}
}
///////////////////////////////////////////////////////////
void deletion() // function to delete from first position
{
struct node *t;
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)
{
p = start;
while (p != NULL)
{
printf("%d ",p->info);
p=p->link;
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);
}

137
data_structures/linked_list/stack_using_linked_lists.c
View File

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

38
data_structures/list/list.c
View File

@ -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;
}

17
data_structures/list/list.h
View File

@ -4,20 +4,21 @@
#define L List_T
typedef struct L *L;
struct L {
struct L
{
void *val;
L next;
};
extern L List_init(void);
extern L List_push(L list, void *val);
extern int List_length(L list);
extern L List_init(void);
extern L List_push(L list, void *val);
extern int List_length(L list);
extern void **List_toArray(L list);
extern L List_append(L list, L tail);
extern L List_list(L list, void *val, ...);
extern L List_append(L list, L tail);
extern L List_list(L list, void *val, ...);
/* TODO */
extern L List_copy(L list);
extern int List_pop(L *list);
extern L List_copy(L list);
extern int List_pop(L *list);
#undef L
#endif

14
data_structures/list/main.c
View File

@ -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 ");

59
data_structures/queue.c
View File

@ -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;
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,25 +70,27 @@ 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;
head->next = NULL;
}
return returnData;
return returnData;
}
/**
* Returns the size of the Queue.
*/
int size() {
return count;
}
int size() { return count; }

75
data_structures/stack.c
View File

@ -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;
@ -52,7 +54,7 @@ int main(int argc, char const *argv[]) {
y = pop();
// 3, 2. Count: 1. Empty: 0;
printf("%d, %d.\t\tCount: %d.\tEmpty: %d.\n", x, y, size(), isEmpty());
pop(); // Empty the stack.
pop(); // Empty the stack.
push(5);
push(6);
@ -64,26 +66,28 @@ int main(int argc, char const *argv[]) {
// 1, 6, 7, 8. Count: 2. Empty: 0.
printf("%d, %d, %d.\tCount: %d.\tEmpty: %d.\n", x, y, z, size(), isEmpty());
return 0;
return 0;
}
/**
* 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;
}

10
data_structures/stack/main.c
View File

@ -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;

22
data_structures/stack/parenthesis.c
View File

@ -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;
}

32
data_structures/stack/stack.c
View File

@ -6,15 +6,15 @@
of data hiding.
*/
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "stack.h"
/*
/*
actual stack data structure
This pointer will pointing at the actual field (of void * pointers)
This pointer will pointing at the actual field (of void * pointers)
that represents the stack.
*/
void **array;
@ -25,8 +25,8 @@ int max = 10;
/* counter variable for counting the elements of the stack. */
int counter = 0;
/*
offset address
/*
offset address
points at the top element of the stack.
*/
int offset = -1;
@ -42,7 +42,7 @@ void initStack()
grow: increases the stack by 10 elements.
This utility function isn't part of the public interface
*/
void grow()
void grow()
{
max += 10; /* increases the capacity */
@ -56,7 +56,7 @@ void grow()
}
/*free the memory */
free(array);
array = tmp;
array = tmp;
}
/* push: pushs the argument onto the stack */
@ -70,9 +70,9 @@ void push(void *object)
offset++; /* increases the element-pointer */
/*
moves pointer by the offset address
pushs the object onto stack
/*
moves pointer by the offset address
pushs the object onto stack
*/
*(array + offset) = object;
@ -82,7 +82,7 @@ void push(void *object)
else /* stack is full */
{
grow(); /* lets grow stack */
grow(); /* lets grow stack */
push(object); /* recursive call */
}
}
@ -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.

11
data_structures/stack/stack.h
View File

@ -2,10 +2,9 @@
author: Christian Bender
This header represents the public stack-interface.
The stack is generic and self growing.
The stack is generic and self growing.
*/
#ifndef __STACK__
#define __STACK__
@ -15,15 +14,15 @@
void initStack();
/*
push: pushs the argument onto the stack
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

15
data_structures/stack/stack_linked_list/main.c
View File

@ -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);

35
data_structures/stack/stack_linked_list/stack.c
View File

@ -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;
}

12
data_structures/stack/stack_linked_list/stack.h
View File

@ -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

183
data_structures/trie/trie.c
View File

@ -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>
@ -16,113 +16,115 @@ typedef struct TrieNode
struct TrieNode *children[ALPHABET_SIZE];
char character;
bool isEndOfWord;
} TrieNode;
/*--Create new node--*/
TrieNode *createTrieNode()
{
TrieNode *node;
TrieNode *createTrieNode()
{
TrieNode *node;
node = malloc(sizeof(TrieNode));
node->isEndOfWord = false;
node->isEndOfWord = false;
int i = 0;
while(i<ALPHABET_SIZE){
while (i < ALPHABET_SIZE)
{
node->children[i] = NULL;
i++;
}
return node;
return node;
}
/*--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)
{
char character = *word;
if(root->children[character-97] == NULL)
{
TrieNode *node = NULL;
node = createTrieNode();
node->character = character;
root->children[character-97] = node;
}
word++;
insert(root->children[character-97],word);
}
else
{
root->isEndOfWord = true;
}
return;
/*----Addition of the word done by recurcively----*/
// Check wheather word character pointer is NULL
if ((strlen(word) - 1) != 0)
{
char character = *word;
if (root->children[character - 97] == NULL)
{
TrieNode *node = NULL;
node = createTrieNode();
node->character = character;
root->children[character - 97] = node;
}
word++;
insert(root->children[character - 97], word);
}
else
{
root->isEndOfWord = true;
}
return;
}
/*--Search a word in the Trie--*/
TrieNode *search( TrieNode *root, char *word)
TrieNode *search(TrieNode *root, char *word)
{
TrieNode *temp;
while(*word != '\0')
{
char character = *word;
if(root->children[character - 97] != NULL)
{
temp = root->children[character-97];
word++;
root = temp;
}
else
{
printf("No possible words!!\n");
return NULL;
}
}
return root;
TrieNode *temp;
while (*word != '\0')
{
char character = *word;
if (root->children[character - 97] != NULL)
{
temp = root->children[character - 97];
word++;
root = temp;
}
else
{
printf("No possible words!!\n");
return NULL;
}
}
return root;
}
/*---Print a word in the array--*/
void printArray(char chars[], int len)
void printArray(char chars[], int len)
{
int i;
for (i=0; i<len; i++)
{
printf("%c", chars[i]);
}
printf("\n");
int i;
for (i = 0; i < len; i++)
{
printf("%c", chars[i]);
}
printf("\n");
}
/*---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++;
prefix[filledLen] = node->character;
filledLen++;
if (node->isEndOfWord)
{
printArray(prefix, filledLen);
}
if (node->isEndOfWord)
{
printArray(prefix, filledLen);
}
int i ;
for(i=0;i<ALPHABET_SIZE;i++)
{
printPathsRecur(node->children[i], prefix, filledLen);
}
int i;
for (i = 0; i < ALPHABET_SIZE; i++)
{
printPathsRecur(node->children[i], prefix, filledLen);
}
}
/*--Travel through the Trie and return words from it--*/
void traverse(char prefix[], TrieNode *root)
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 -------*/
@ -137,48 +139,49 @@ char *receiveInput(char *s)
return s;
}
int main()
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)
{
fprintf(stderr, "Error while opening dictionary file");
exit(1);
}
words[word_count] = malloc(INPUT_WORD_SIZE);
while (fgets(words[word_count], INPUT_WORD_SIZE, fp))
while (fgets(words[word_count], INPUT_WORD_SIZE, fp))
{
word_count++;
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)
while (1)
{
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);
printf("\n==========================================================\n");
// Find the word through the Trie
traverse(str, root);
printf(
"\n==========================================================\n");
}
}

10
exercism/acronym/acronym.c
View File

@ -1,6 +1,6 @@
#include <string.h>
#include <stdio.h>
#include <ctype.h>
#include <stdio.h>
#include <string.h>
char *abbreviate(const char *phrase)
{
@ -19,8 +19,8 @@ char *abbreviate(const char *phrase)
/* for -loop variable */
int i = 0;
/*
counts the empty-characters.
/*
counts the empty-characters.
for determine the number of words
*/
while (p_str && (i < 80))
@ -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 */

4
exercism/hello_world/hello_world.c
View File

@ -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;
return ans;
}

14
exercism/isogram/isogram.c
View File

@ -4,7 +4,7 @@
/*
is_isogram: returns true if the given string a isogram, otherwise false.
*/
bool is_isogram(const char phrase[])
bool is_isogram(const char phrase[])
{
/* use 'unsigned' because of the function strlen(...) */
@ -20,18 +20,18 @@ 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])
{
status = false;
/*
/*
because the given string is none isogram.
that means we can exit the nested for-loop.
*/
@ -40,7 +40,7 @@ bool is_isogram(const char phrase[])
}
}
/* exit label */
end:
return status;
/* exit label */
end:
return status;
}

2
exercism/rna_transcription/rna_transcription.h
View File

@ -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

4
exercism/word_count/word_count.c
View File

@ -2,7 +2,7 @@
#include <string.h>
/*
word_count: returns the full number of words in the input_text,
word_count: returns the full number of words in the input_text,
otherwise an error code: (see below)
error codes: EXCESSIVE_LENGTH_WORD -1
@ -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++;
}

19
exercism/word_count/word_count.h
View File

@ -1,20 +1,21 @@
#ifndef WORD_COUNT_H
#define WORD_COUNT_H
#define MAX_WORDS 20 // at most MAX_WORDS can be found in the test input string
#define MAX_WORD_LENGTH 50 // no individual word can exceed this length
#define MAX_WORDS 20 // at most MAX_WORDS can be found in the test input string
#define MAX_WORD_LENGTH 50 // no individual word can exceed this length
// results structure
typedef struct word_count_word {
char text[MAX_WORD_LENGTH];
int count;
typedef struct word_count_word
{
char text[MAX_WORD_LENGTH];
int count;
} word_count_word_t;
#define EXCESSIVE_LENGTH_WORD -1
#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

113
greedy_approach/djikstra.c
View File

@ -12,68 +12,77 @@ 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 *x = (int *)a;
int *y = (int *)b;
return *y - *x;
}
int cf (void *a, void *b) {
int *x = (int *)a;
int *y = (int *)b;
return *y - *x;
int dequeue()
{
qsort(q, qp, sizeof(int), cf);
return q[--qp];
}
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) {
dist[s] = 0;
int i;
for (i = 0; i < V; ++i) {
if (i != s) {
dist[i] = INF;
}
enqueue(i);
}
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]) {
dist[i] = dist[u] + mat[u][i];
}
}
}
}
void dijkstra(int s)
{
dist[s] = 0;
int i;
for (i = 0; i < V; ++i)
{
if (i != s)
{
dist[i] = INF;
}
enqueue(i);
}
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])
{
dist[i] = dist[u] + mat[u][i];
}
}
}
}
}
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) {
scanf(" %d", &mat[i][j]);
}
}
dijkstra(0);
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)
{
scanf(" %d", &mat[i][j]);
}
}
printf("\nNode\tDist\n");
for (i = 0; i < V; ++i) {
printf("%d\t%d\n", i, dist[i]);
}
return 0;
dijkstra(0);
printf("\nNode\tDist\n");
for (i = 0; i < V; ++i)
{
printf("%d\t%d\n", i, dist[i]);
}
return 0;
}

10
hash/hash.c
View File

@ -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++;
}

2
hash/hash.h
View File

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

4
hash/test_program.c
View File

@ -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)
{
@ -13,7 +13,7 @@ int main(void)
/* actual tests */
printf("sdbm: %s --> %llX\n", s, sdbm(s));
printf("djb2: %s --> %llX\n", s, djb2(s));
printf("xor8: %s --> %X\n", s, xor8(s)); /* 8 bit */
printf("xor8: %s --> %X\n", s, xor8(s)); /* 8 bit */
printf("adler_32: %s --> %X\n", s, adler_32(s)); /* 32 bit */
return 0;

9
leetcode/src/1.c
View File

@ -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;
}

9
leetcode/src/101.c
View File

@ -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);
}

7
leetcode/src/104.c
View File

@ -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));
}

14
leetcode/src/108.c
View File

@ -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);
}

14
leetcode/src/1089.c
View File

@ -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++;
}
}

16
leetcode/src/109.c
View File

@ -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);
}

32
leetcode/src/11.c
View File

@ -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]);
if(currArea>res)
while (start < end)
{
// Calculate current area by taking minimum of two heights
int currArea = (end - start) * min(height[start], height[end]);
if (currArea > res)
res = currArea;
if(height[start]<height[end])
if (height[start] < height[end])
start = start + 1;
else
end = end - 1;
}
return res;
}

14
leetcode/src/110.c
View File

@ -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);
}

6
leetcode/src/112.c
View File

@ -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);
}

32
leetcode/src/1184.c
View File

@ -1,16 +1,20 @@
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) {
int tmp = start;
start = destination;
destination = tmp;
}
for (auto i = 0; i < distanceSize; ++i) {
if (i >= start && i < destination)
sum1 += distance[i];
else
sum2 += distance[i];
}
return sum1 < sum2 ? sum1 : sum2;
int sum1 = 0, sum2 = 0;
if (start > destination)
{
int tmp = start;
start = destination;
destination = tmp;
}
for (auto i = 0; i < distanceSize; ++i)
{
if (i >= start && i < destination)
sum1 += distance[i];
else
sum2 += distance[i];
}
return sum1 < sum2 ? sum1 : sum2;
}

43
leetcode/src/1189.c
View File

@ -1,6 +1,7 @@
int maxNumberOfBalloons(char * text){
/*
0 -> b,
int maxNumberOfBalloons(char *text)
{
/*
0 -> b,
1 -> a,
2 -> l,
3 -> o,
@ -8,31 +9,43 @@ 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]++;
}
}
/* Divide by 2 the repeted letters */
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];
}
return min_counter_ballons;
}

246
leetcode/src/12.c
View File

@ -1,164 +1,172 @@
char *getOne(char c){
switch (c) {
case '9':
return "IX";
char *getOne(char c)
{
switch (c)
{
case '9':
return "IX";
case '8':
return "VIII";
case '8':
return "VIII";
case '7':
return "VII";
case '7':
return "VII";
case '6':
return "VI";
case '6':
return "VI";
case '5':
return "V";
case '5':
return "V";
case '4':
return "IV";
case '4':
return "IV";
case '3':
return "III";
case '3':
return "III";
case '2':
return "II";
case '2':
return "II";
case '1':
return "I";
case '1':
return "I";
case '0':
return "";
case '0':
return "";
default:
return NULL;
default:
return NULL;
}
}
char *getTen(char c){
switch (c) {
case '9':
return "XC";
char *getTen(char c)
{
switch (c)
{
case '9':
return "XC";
case '8':
return "LXXX";
case '8':
return "LXXX";
case '7':
return "LXX";
case '7':
return "LXX";
case '6':
return "LX";
case '6':
return "LX";
case '5':
return "L";
case '5':
return "L";
case '4':
return "XL";
case '4':
return "XL";
case '3':
return "XXX";
case '3':
return "XXX";
case '2':
return "XX";
case '2':
return "XX";
case '1':
return "X";
case '1':
return "X";
case '0':
return "";
case '0':
return "";
default:
return NULL;
}
}
char *getHundred(char c){
switch (c) {
case '9':
return "CM";
case '8':
return "DCCC";
case '7':
return "DCC";
case '6':
return "DC";
case '5':
return "D";
case '4':
return "CD";
case '3':
return "CCC";
case '2':
return "CC";
case '1':
return "C";
case '0':
return "";
default:
return NULL;
default:
return NULL;
}
}
char *getThousand(char c){
switch (c) {
case '3':
return "MMM";
char *getHundred(char c)
{
switch (c)
{
case '9':
return "CM";
case '2':
return "MM";
case '8':
return "DCCC";
case '1':
return "M";
default:
return NULL;
case '7':
return "DCC";
case '6':
return "DC";
case '5':
return "D";
case '4':
return "CD";
case '3':
return "CCC";
case '2':
return "CC";
case '1':
return "C";
case '0':
return "";
default:
return NULL;
}
}
char *getThousand(char c)
{
switch (c)
{
case '3':
return "MMM";
case '2':
return "MM";
case '1':
return "M";
char * intToRoman(int num){
default:
return NULL;
}
}
char *intToRoman(int num)
{
int length;
char number[5];
char *s = malloc(16*sizeof(char));
sprintf(number, "%i", num);
char *s = malloc(16 * sizeof(char));
sprintf(number, "%i", num);
length = strlen(number);
switch (length){
case 4:
sprintf(s,"%s%s%s%s", getThousand(number[0]), getHundred(number[1]), getTen(number[2]), getOne(number[3]));
break;
switch (length)
{
case 4:
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]));
break;
case 3:
sprintf(s, "%s%s%s", getHundred(number[0]), getTen(number[1]),
getOne(number[2]));
case 2:
sprintf(s,"%s%s", getTen(number[0]), getOne(number[1]));
break;
break;
case 1:
s = getOne(number[0]);
break;
case 2:
sprintf(s, "%s%s", getTen(number[0]), getOne(number[1]));
default:
break;
break;
case 1:
s = getOne(number[0]);
break;
default:
break;
}
return s;
}

17
leetcode/src/1207.c
View File

@ -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++;
}

26
leetcode/src/121.c
View File

@ -1,17 +1,17 @@
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){
/* maxCur: current maximum
* maxSoFar: found maximum for subarray so far
*/
int maxCur = 0, maxSoFar = 0;
for(int i = 1; i < pricesSize; i++) {
maxCur = maxcmp(0, maxCur + prices[i] - prices[i - 1]);
maxSoFar = maxcmp(maxSoFar, maxCur);
}
return maxSoFar;
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++)
{
maxCur = maxcmp(0, maxCur + prices[i] - prices[i - 1]);
maxSoFar = maxcmp(maxSoFar, maxCur);
}
return maxSoFar;
}

18
leetcode/src/125.c
View File

@ -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--;

91
leetcode/src/13.c
View File

@ -1,48 +1,57 @@
int romanToInt(char * s){
int romanToInt(char *s)
{
int romanToInt = 0;
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') {
romanToInt -= 1;
break;
}
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')
{
romanToInt -= 1;
break;
}
romanToInt += 1;
break;
case 'V':
romanToInt += 5;
break;
case 'X':
if (i+1 < strlen(s)) {
if (s[i + 1] == 'L' || s[i + 1] == 'C') {
romanToInt -= 10;
break;
}
}
romanToInt += 1;
break;
case 'V':
romanToInt += 5;
break;
case 'X':
if (i + 1 < strlen(s))
{
if (s[i + 1] == 'L' || s[i + 1] == 'C')
{
romanToInt -= 10;
break;
}
romanToInt += 10;
break;
case 'L':
romanToInt += 50;
break;
case 'C':
if (i+1 < strlen(s)) {
if (s[i + 1] == 'D' || s[i + 1] == 'M') {
romanToInt -= 100;
break;
}
}
romanToInt += 10;
break;
case 'L':
romanToInt += 50;
break;
case 'C':
if (i + 1 < strlen(s))
{
if (s[i + 1] == 'D' || s[i + 1] == 'M')
{
romanToInt -= 100;
break;
}
romanToInt += 100;
break;
case 'D':
romanToInt += 500;
break;
case 'M':
romanToInt += 1000;
break;
default:
break;
}
romanToInt += 100;
break;
case 'D':
romanToInt += 500;
break;
case 'M':
romanToInt += 1000;
break;
default:
break;
}
}
return romanToInt;

5
leetcode/src/136.c
View File

@ -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;
}

15
leetcode/src/141.c
View File

@ -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;
}

16
leetcode/src/142.c
View File

@ -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;
}

8
leetcode/src/153.c
View File

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

18
leetcode/src/160.c
View File

@ -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;
}

12
leetcode/src/169.c
View File

@ -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--;

Some files were not shown because too many files have changed in this diff Show More