DSA WITH C

/*
Name – KUSHAGRA JOSHI
Roll no. - 40
Section - G

QUESTION-1: Write a C Program to store N elements to an array and then send all positive elements of the
array to the end without altering the original sequence.
*/

SOURCE CODE:
#include <stdio.h>
int negative = 0 , positive = 0 ;
void func(int arr[] , int n){
int left[negative] ;
int right[positive] ;
int j = 0 , k = 0;
for(int i = 0 ; i < n ;i++){
if(arr[i] < 0){
left[j++] = arr[i] ;
}else{
right[k++] = arr[i] ;
}
}
j=0;
int i = 0 ;
while(j < negative){
arr[i++] = left[j++];
}
k=0;
while(k < positive){
arr[i++] = right[k++] ;
}
}
int main(){
int n ;
scanf("%d" , &n) ;
int arr[n] ;
for(int i = 0 ; i < n ;i++)
{ scanf("%d",
&arr[i] ) ; if(arr[i] >=
0){
positive += 1;
}else{
negative += 1 ;
}
}
func(arr , n) ;
for(int i = 0 ; i < n ; i++)
{ printf("%d " ,
arr[i]) ;
}

1
 DSA WITH C
return 0;
}

2
 DSA WITH C

OUTPUT:

Enter the number of elements :

6
Enter the elements :
89 5 -91 62 -20 55
The resulting array is:
-91 -20 89 5 62 55

3
 DSA WITH C
/*
Name – KUSHAGRA JOSHI
Roll no. - 40
Section - G

QUESTION-2: Write a C program to create two linked lists positive and negative from an Original linked
list, so that positive linked list contains all positive elements and negative linked list contains negative ele-
ments. Positive and negative linked lists should use the node of existing original linked list.
*/

SOURCE CODE:
#include <stdio.h>
#include <stdlib.h>
typedef struct Node{
int data ;
struct Node *next ;
}Node;
Node *insertatend(Node *head, int val){
Node *node = (Node *)malloc(sizeof(Node)) ;
node -> data = val ;
node -> next = NULL ;
if(head == NULL){
head = node ;
}
else{
Node *current = head ;
while(current -> next != NULL){
current = current -> next ;
}
current -> next = node ;
}
return head;
}
void display(Node *head){
if(head == NULL){
printf("Empty\n");
return ;
}
Node *current = head ;
while(current != NULL){
printf("%d " , current -> data) ;
current = current -> next;
}
printf("\n") ;
return ;
}
void solve(){
Node *head = NULL ;
int t ;
printf("Enter -1 to break :\n") ;
while(scanf("%d" ,&t)){
4
 DSA WITH C
if(t == -1){
break ;
}
head = insertatend(head , t) ;
}
printf("The linked list is : ") ;
display(head) ;
Node *negative = malloc(sizeof(Node));
negative -> data = - 1;
Node *neg = negative;
Node *positive = malloc(sizeof(Node));
Node *pos = positive ;
positive -> data = -1 ;
Node *current = head ;
while(current != NULL){
if(current -> data >= 0){
positive -> next = current ;
positive = current ;
}
else{
negative -> next = current ;
negative = current ;
}
current = current -> next ;
}
positive -> next = NULL ;
negative -> next = NULL ;
if(neg -> next != NULL){
neg = neg -> next ;
}
else{
neg = NULL ;
}
if(pos -> next != NULL){
pos = pos -> next ;
}
else{
pos= NULL ;
}
printf("Negative : ") ;
display(neg) ;
printf("Positive : ") ;
display(pos) ;
return ;
}
int main(){
solve() ;
}

5
 DSA WITH C

OUTPUT:

Enter -1 to break :
35 -18 95 -97 47 89 -4 98 0 -1
The linked list is : 35 -18 95 -97 47 89 -4 98 0
Negative : -18 -97 -4
Positive : 35 95 47 89 98 0

6
 DSA WITH C
/*
Name – KUSHAGRA JOSHI
Roll no. - 40
Section - G

QUESTION-3: Write a C program to create a linked list P, then write a ‘C’ function named split to create
two linked lists Q & R from P So that Q contains all elements in odd positions of P and R contains the
re- maining elements. Finally print both linked lists i.e Q and R.
*/

SOURCE CODE:
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
typedef struct Node{
int data ;
struct Node *next ;
}Node;
Node *insertatend(Node *head , int val){
Node *node = (Node *)malloc(sizeof(Node)) ;
node -> data = val ;
node -> next = NULL ;
if(head == NULL){
head = node ;
}
else{
Node *current = head ;
while(current -> next != NULL){
current = current -> next ;
}
current -> next = node ;
}
return head ;
}
void display(Node *head)
{ Node *current = head ;
while(current != NULL){
printf("%d " , current ->data) ;
current = current -> next ;
}
printf("\n") ;
return ;
}
void split(Node *P){
if(P == NULL || P -> next == NULL){
display(P) ;
return ;
}
Node *q =
(Node*)malloc(sizeof(Node)) ; Node *r =
(Node*)malloc(sizeof(Node)) ; Node *Q
7
 DSA WITH C
=q;

8
 DSA WITH C
Node *R = r ;
Node *current = P
; while(true){
q -> next = current ;
q = q -> next ;
if(current -> next != NULL){
r -> next = current -> next ;
r = r -> next ;
}
else{
break ;
}
if(current -> next -> next == NULL){
break ;
}
else{
current = current -> next -> next ;
}
}
q -> next = NULL ;
r -> next = NULL ;
printf("The elements at odd position are : \n") ;
display(Q -> next) ;
printf("The elements at even position are : \n") ;
display(R -> next) ;
return ;
}
void solve(){
Node *head = NULL ;
int t ;
printf("Enter -1 to break : \n") ;
while(scanf("%d" , &t)){
if(t == -1){
break ;
}
head = insertatend(head , t) ;
}
split(head) ;
}
int main()
{ solve()
;}

9
 DSA WITH C

OUTPUT:
Enter -1 to break :
46 98 -23 98 54 36 -23 -1
The elements at odd position are :
46 -23 54 -23
The elements at even position are :
98 98 36

1
 DSA WITH C
/*
Name – KUSHAGRA JOSHI
Roll no. - 40
Section - G

QUESTION-4: Write a program to add of two polynomials of degree n, using linked list. For example:
p1=an x n +an-1x n-1 + an-2x n-2 +..........a0 x 0
P2=bn x n +bn-1x n-1 + bn-2x n-2 +..........b0 x 0
p1 = first polynomial p2 = second polynomial. Find out p3= p1+p2
*/

SOURCE CODE:
#include <stdio.h>
#include <stdlib.h>
typedef struct Node{
int cons ;
int deg ;
struct Node *next ;
}Node ;
Node *insert(Node *head , int x , int y){
Node *node = (Node *)malloc(sizeof(Node)) ;
node -> cons = x ;
node -> deg = y ;
node -> next = NULL ;
if(head == NULL){
head = node ;
}
else{
Node *current = head ;
while(current -> next){
current = current -> next ;
}
current -> next = node ;
}
return head ;
}
void display(Node *head){
if(head == NULL){
return ;
}
Node *current = head ;
while(current -> next){
printf("%dx^%d + " , current -> cons , current -> deg) ;
current = current -> next ;
}
printf("%d \n" , current -> cons) ; return ;
}
Node *add(Node *head1 , Node *head2 , int n , int t){
Node *ptr = head1 ;
Node *current = head2 ;
Node *res = (Node *)malloc(sizeof(Node)) ;
1
 DSA WITH C
Node *dn = res;
res -> next = NULL ;
int d = n - t ;
if(t > n){
ptr = head2 ;
current = head1 ;
d=t-n;
}
while(d--){
res -> next = ptr ;
res = res -> next ;
ptr = ptr -> next ;
}
while(current != NULL && ptr != NULL){
current -> cons = (current -> cons + ptr -> cons) ;
res -> next = current ;
res = res -> next ;
current = current -> next ;
ptr = ptr -> next ;
}
res -> next = NULL ;
return dn -> next ;
}
int main(){
Node *head= NULL ;
Node *head2 = NULL ;
printf("Enter the highest degree of first polynomial : ") ;
int n ;
scanf("%d" , &n) ;
printf("Enter the coefficients in decreasing order of power : \n") ;
for(int i = n ; i >= 0 ; i--){
int a ;
scanf("%d" , &a) ;
head = insert(head , a, i) ;
}
printf("Enter the highest degree of second polynomial : ") ;
int t ;
scanf("%d" , &t) ;
printf("Enter the coefficients in decreasing order of power : \n") ;
for(int i = t ; i >= 0 ; i--){
int x ;
scanf("%d" , &x) ;
head2 = insert(head2 , x , i) ;
}
printf("First : ") ;
display(head) ;
printf("Second : ") ;
display(head2) ;
printf("Result : ") ;
Node *res = add(head , head2 , n , t) ;
display(res) ;
}

1
 DSA WITH C

OUTPUT:

Enter the highest degree of first polynomial : 3

Enter the coefficients in decreasing order of power : 9 5 8 4
Enter the highest degree of second polynomial : 2
Enter the coefficients in decreasing order of power : 7 6 3
First : 9x^3 + 5x^2 + 8x^1 + 4
Second : 7x^2 + 6x^1 + 3
Result : 9x^3 + 12x^2 + 14x^1 + 7

/*
1
 DSA WITH C
Name – KUSHAGRA JOSHI
Roll no. - 40
Section - G

QUESTION-5: Write a C program to implement time sharing environment (using circular linked list) for N
processes, where CPU allocates time slots of 10ns for given N processes, then print which
process will be completed in how much time.
*/

SOURCE CODE:
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define cputime 10
typedef struct Node{
int data , idx ;
struct Node *next;
} Node;

Node *insert(Node *head , int i){

Node *node = (Node *)malloc(sizeof(Node));
int val;
printf("Enter time for process %d: \n", i);
scanf("%d", &val);
node -> data = val;
node -> idx = i;
if (head == NULL){
head = node;
}else{
Node *current = head;
while (current -> next != head){
current = current -> next;
}
current -> next = node;
}
node -> next = head;
return head;
}

void timetaken(Node *head){

int total = 0;
Node *prev ;
while (true){
if(head -> data >= cputime){
head -> data -= cputime;
total += cputime;
1
 DSA WITH C
}
else{
total += head -> data;
head -> data = 0;
}
if (head -> data == 0){
printf("Process %d completed after: %d\n", head -> idx , total) ;
if(head -> next == head){
break ;
}
else{
Node *temp = head;
prev -> next = head -> next ;
head = head -> next ;
free(temp) ;
}
}
else{
prev = head ;
head = head -> next ;
}
}
printf("Total time taken: %d\n",total) ;
}

int main(){
int n ;
printf("Enter No. of Process: ") ;
scanf("%d", &n);
Node *head = NULL;
for (int i = 1; i <= n; i++){
head = insert(head, i);
}
timetaken(head);
}

1
 DSA WITH C
OUTPUT:

Enter No. of Process: 3

Enter time for process 1:
30
Enter time for process 2:
50
Enter time for process 3:
60
Process 1 completed after: 70
Process 2 completed after: 120
Process 3 completed after: 140
Total time taken: 140

1
 DSA WITH C
/*
Name – KUSHAGRA JOSHI
Roll no. - 40
Section - G

QUESTION-6: Write a C program to create a double linked list by inserting nodes in such a way that the
resultant linked list remains in ascending order. (do not use any sorting technique).
*/

SOURCE CODE:
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
typedef struct Node{
int data ;
struct Node *next ;
struct Node *prev ;
}Node;
Node *head = NULL ;
Node *tail = NULL ;
Node *insert(Node *head , int val){
Node *current = head ;
Node *node = (Node *)malloc(sizeof(Node))
; node -> data = val ;
node -> next = NULL;
node -> prev = NULL;
if(head == NULL){
head = tail = node ;
return head ;
}
if(val <= head -> data){
node -> next = head ;
head -> prev = node ;
head = node ;
return head ;
}
if(val >= tail -> data){
tail -> next = node ;
node -> prev = tail ;
tail = node ;
return head ;
}
else{
while(true){
if(val <= current -> data){
Node *prev_node = current -> prev ;
1
 DSA WITH C
prev_node -> next = node ;
node -> next = current ;
node -> prev = prev_node ;
current -> prev = node ;
break ;
}
else{
current = current -> next ;
}
}
}
return head ;
}
void display(Node *head)
{ Node *current = head ;
while(current != NULL){
printf("%d " , current -> data) ;
current = current -> next ;
}
printf("\n") ;
return ;
}

void solve(){
int t ;
printf("Enter -1 to break") ;
while(scanf("%d" , &t)){
if(t == -1){
break ;
}
head = insert(head , t) ;
}
printf("The linked list is : \n") ;
display(head) ;
}
int main(){
solve() ;
}

1
 DSA WITH C

OUTPUT:

Enter -1 to break
87 -54 2 98 99 43 -1
The linked list is :
-54 2 43 87 98 99

1
 DSA WITH C
/*
Name – KUSHAGRA JOSHI
Roll no. - 40
Section - G

QUESTION-7: Write a C program to create a binary search tree and perform following operations:
1) Search a particular key.
2) Delete a node from the tree.
3) Find total number of leaf nodes
4) Find height of a binary search tree
5) Count total numbers of nodes from right hand side of root node */

SOURCE CODE:
#include <stdio.h>
#include <stdlib.h>
typedef struct Node{
int data ;
struct Node *left ;
struct Node *right ;
}Node ;
void insert(Node **rootnode , int val){
if(*rootnode == NULL){
Node *node = (Node *)malloc(sizeof(Node)) ;
node -> data = val ;
node -> left = NULL ;
node -> right = NULL ;
*rootnode = node ;
return ;
}
else{
if(((*rootnode)) -> data > val)
{ insert((&(*rootnode) ->
left) ,val) ;
}
else{
insert((&(*rootnode) -> right) , val) ;
}
}
}
void preordertraversal(Node *rootnode){
if(rootnode == NULL){
return ;
}
printf("%d " , rootnode -> data) ;
preordertraversal(rootnode -> left) ;
preordertraversal(rootnode -> right) ; return ;
}
void search(Node *rootnode , int val){
if(rootnode == NULL){
printf("The value is not found") ; return ;
}
if(rootnode -> data == val){
printf("The value is found") ; return ;
}

2
 DSA WITH C
if(rootnode -> data > val){

2
 DSA WITH C
search(rootnode -> left , val) ;
}
else{
search(rootnode -> right , val) ;
}
}

Node *minvalue(Node **rootnode){

Node *current = *rootnode ;
while(current != NULL && current -> left != NULL){
current = current -> left ;
}
return current ;
}
void delete(Node **rootnode , int val){
if(*rootnode == NULL){
return ;
}
if(((*rootnode) -> data) > val)
{ delete((&(*rootnode) -> left) ,
val) ;
}
else if(((*rootnode) -> data) < val)
{ delete((& (*rootnode) -> right) ,
val) ;
}
else{
if((*rootnode) -> left == NULL && (*rootnode) -> right == NULL){
*rootnode = NULL ; return ;
}
else if((*rootnode) -> left == NULL){
Node *temp = (*rootnode) -> right ;
(*rootnode) -> data = temp -> data;
(*rootnode) -> right = NULL ;
}
else if((*rootnode) -> right == NULL){
Node *temp = ((*rootnode) -> left) ;
(*rootnode) -> data = temp -> data ;
(*rootnode) -> left = NULL ;
}
else{
Node *nodetobedeleted = minvalue((&(*rootnode) -> right)) ;
(*rootnode) -> data = nodetobedeleted -> data ;
delete((&(*rootnode) -> right) , nodetobedeleted -> data) ;
}
}
}
int totalleafnodes(Node *rootnode){
if(rootnode -> left == NULL && rootnode -> right == NULL){
return 1;
}
int a = 0 , b = 0 ;
if(rootnode -> left != NULL){
a = totalleafnodes(rootnode -> left) ;
}
if(rootnode -> right != NULL){
b = totalleafnodes(rootnode -> right) ;
2
 DSA WITH C
}
return a + b ;
}

2
 DSA WITH C
int max(int a , int b){
if(a > b){
return a ;
}else{
return b ;
}
}
int height(Node *rootnode){
if(rootnode -> right == NULL && rootnode -> left == NULL){
return 0 ;
}
int a = 0 , b =0 ;
if(rootnode -> right != NULL){
a = height(rootnode -> right) ;
}
if(rootnode -> left != NULL){
b = height(rootnode -> left) ;
}
return max(a , b) + 1;
}
int totalrightnodes(Node *rootnode){
if(rootnode == NULL){
return 0 ;
}
if(rootnode -> right != NULL){
return 1 + totalrightnodes(rootnode -> right) ;
} else{
return 0 ;
}
}
int main(){
Node *rootnode = NULL ;
int t ;
while(scanf("%d" , &t)){
if(t == -1){
break ;
}
insert(&rootnode , t) ;
}
printf("Preordertraversal : ") ;
preordertraversal(rootnode) ;
printf("The total number of leaf nodes are %d: \n" , totalleafnodes(rootnode)) ;
printf("The height of the bst is : %d \n" , height(rootnode));
printf("The total number of nodes to the right of the rootnode are : %d\n" , totalrightnodes(rootnode));
printf("Enter the node to be found : \n") ;
int nodetobefound ;
scanf("%d" ,&nodetobefound) ;
search(rootnode , nodetobefound) ;
printf("\n") ;
printf("Enter the node to be deleted : ") ;
int val ;
scanf("%d" , &val) ;
delete(&rootnode , val) ;
preordertraversal(rootnode) ;
return 0 ;
}

2
 DSA WITH C

OUTPUT:
Enter -1 to break
67 54 87 12 98 34 76 89 -1
Preordertraversal : 67 54 12 34 87 76 98 89
The total number of leaf nodes are: 3
The height of the bst is : 3
The total number of nodes to the right of the rootnode are : 2
Enter the node to be found :
98
The value is found
Enter the node to be deleted : 12
67 54 34 87 76 98 89

2
 DSA WITH C
/*
Name – KUSHAGRA JOSHI
Roll no. - 40
Section - G

QUESTION-8: Write a C program to sort an unsorted sequence of strings given by user in an array, using
Merge sort technique.
*/

SOURCE CODE:
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define mxN 100
void merge(char *arr[] , int l , int mid , int h){
int i = l , j = mid + 1 ;
int k = 0 ;
char **v = malloc(sizeof(char *) * (h - l + 1)) ;
while(i <= mid && j <= h){
if(strcmp(arr[i] , arr[j]) < 0)
{ v[k++] = arr[i++] ;
}
else{
v[k++] = arr[j++] ;
}
}
while(i <= mid){ v[k+
+] = arr[i++] ;
}
while(j <= h){ v[k+
+] = arr[j++] ;
}
k=0;
for(int i = l ; i <= h ; i++){
arr[i] = v[k++] ;
}
return ;
}
void mergesort(char *arr[] , int l , int h){
if(l >= h){
return ;
}
int mid = (l + h) / 2 ;
mergesort(arr , l , mid) ;
mergesort(arr , mid + 1 , h) ;
merge(arr , l , mid , h) ;
2
 DSA WITH C
}
int main(){
printf("Enter the number of strings : ") ;
int n ;
scanf("%d " , &n) ;
char** arr = malloc(sizeof(char *)* n);
printf("Enter the strings : \n") ;
for(int i = 0 ; i < n ; i++){

arr[i] = malloc(sizeof(char) * mxN);

scanf("%s",arr[i]);
}
mergesort(arr , 0 , n - 1) ;
printf("The strings in increasing order are : \n") ;
for(int i = 0 ; i < n ; i++){
printf("%s " , arr[i]) ;
}
return 0;

2
 DSA WITH C

OUTPUT:

Enter the number of strings : 6

Enter the strings :

Nobody is coming to save you

The strings in increasing order are :

Nobody coming is save to you

2
 DSA WITH C
/*
Name – KUSHAGRA JOSHI
Roll no. - 40
Section - G

QUESTION-9: Write a C program to implement linked representation of a graph in memory using array of
pointers.
*/

SOURCE CODE:
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
int visited[1000] = {0} ;
typedef struct Node{
int data ;
struct Node *next ;
}Node ;
typedef struct adjlist{
Node *head ;
}adjlist ;
typedef struct Graph{
int v ;
struct adjlist *arr ;
}Graph ;
Graph *create(int v){
Graph *gr = (Graph *)malloc(sizeof(Graph)) ;
gr -> v = v ;
gr -> arr = (adjlist *)malloc((v + 1) * sizeof(adjlist)) ;
for(int i = 1 ; i <= v ; i++){
gr -> arr[i].head = NULL ;
}
return gr ;
}
Node *newNode(int val){
Node *node = (Node *)malloc(sizeof(Node)) ;
node -> data = val ;
node -> next = NULL ;
return node ;
}
void addedge(Graph *gr , int u , int v){
Node *node = newNode(v) ;
if(gr -> arr[u].head == NULL){
gr -> arr[u].head = node ;
}
else{
node -> next = gr -> arr[u].head ;
gr -> arr[u].head = node ;
}
Node *newnode = newNode(u) ;
if(gr -> arr[v].head == NULL){

2
 DSA WITH C
gr -> arr[v].head = newnode ;
}
else{
newnode -> next = gr -> arr[v].head ;
gr -> arr[v].head = newnode ;
}
}
void display(Graph *gr){
for(int i = 1 ; i <= gr -> v ; i++){
printf("%d---->" , i) ;
Node *current = gr -> arr[i].head ;
while(current != NULL){
printf("%d " , current -> data) ;
current = current -> next ;
}
printf("\n") ;
}
return
;
}
void solve(){
int n , m ;
printf("Enter the number of vertices and the number of edges\n") ;
scanf("%d %d" , &n , &m) ;
Graph *gr = create(n) ;
printf("Enter the source and destination of each edge : ") ;
for(int i = 0; i < m ; i++){
int x , y ;
scanf("%d %d", &x , &y) ;
addedge(gr , x , y) ;
}
printf("The linked list representation of graph is : \n") ;
display(gr) ;
return ;
}
int main(){
solve() ;
}

3
 DSA WITH C

OUTPUT:

Enter the number of vertices and the number of edges

55
Enter the source and destination of each edge :
12
23
13
24
34
The linked list representation of graph is :
1---->3 2
2 ---->4 3 1
3 ---->4 1 2
4 ---->3 2
5 ---->

3
 DSA WITH C
/*
Name – KUSHAGRA JOSHI
Roll no. - 40
Section - G

QUESTION-10: Write a C program to implement DFS.

*/

SOURCE CODE:
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
int visited[1000] = {0} ;
typedef struct Node{
int data ;
struct Node *next ;
}Node ;
typedef struct adjlist{
Node *head ;
}adjlist ;
typedef struct Graph{
int v ;
struct adjlist *arr ;
}Graph ;
Graph *create(int v){
Graph *gr = (Graph *)malloc(sizeof(Graph)) ;
gr -> v = v + 1 ;
gr -> arr = (adjlist *)malloc((v + 1) * sizeof(adjlist)) ;
for(int i = 1 ; i <= v ; i++){
gr -> arr[i].head = NULL ;
}
return gr ;
}
Node *newNode(int val){
Node *node = (Node *)malloc(sizeof(Node)) ;
node -> data = val ;
node -> next = NULL ;
return node ;
}
void addedge(Graph *gr , int u , int v){
Node *node = newNode(v) ;
if(gr -> arr[u].head == NULL){
gr -> arr[u].head = node ;
}
else{
node -> next = gr -> arr[u].head ;
gr -> arr[u].head = node ;
}
Node *newnode = newNode(u) ;
if(gr -> arr[v].head == NULL){
gr -> arr[v].head = newnode ;

3
 DSA WITH C
}
else{
newnode -> next = gr -> arr[v].head ;
gr -> arr[v].head = newnode ;
}
}

void dfs(Graph *gr , int current){

printf("%d " , current) ;
visited[current] = 1 ;
Node *newcurrent = gr -> arr[current].head ;
while(newcurrent != NULL){
if(!visited[newcurrent -> data])
{ dfs(gr, newcurrent ->
data) ;
}
newcurrent = newcurrent -> next ;
}
}
void solve(){
int n , m ;
printf("Enter the number of vertices and the number of edges\n") ;
scanf("%d %d" , &n , &m) ;
Graph *gr = create(n) ;
printf("Enter the source and destination of each edge : \n") ;
for(int i = 0; i < m ; i++){
int x , y ;
scanf("%d %d", &x , &y) ;
addedge(gr , x , y) ;
}
printf("DFS Traversal : ") ;
for(int i = 1 ; i <= n; i++){
if(!visited[i]){
dfs(gr , i) ;
}
}
return ;
}
int main(){
solve() ;
}

3
 DSA WITH C

OUTPUT:
Enter the number of vertices and the number of edges
44
Enter the source and destination of each edge :
13
12
23
24
DFS Traversal : 1 2 4 3

3
 DSA WITH C
/*
Name – KUSHAGRA JOSHI
Roll no. - 40
Section - G

QUESTION-11: Write a C program to implement Kruskal’s algorithm.

*/

SOURCE CODE:
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
typedef struct Edge{
int w , x , y ;
} Edge ;
typedef struct Graph{
int V , E ;
Edge *edgelist ;
}Graph ;
Graph *create(int n , int m){
Graph *gr = (Graph *)malloc(sizeof(Graph)) ;
gr -> V = n ;
gr -> E = m ;
gr -> edgelist = (Edge *)malloc(sizeof(Edge) * (m + 1)) ;
return gr ;
}
int *parent ;
int *rank ;
void init(int n){
parent = (int *)malloc(sizeof(int) * (n + 1)) ;
rank = (int *)malloc(sizeof(int) * (n + 1)) ;
for(int i = 1 ; i <= n ; i++){
parent[i] = -1 ;
rank[i] = 1 ;
}
return ;
}
int findset(int x){
if(parent[x] == -1){
return x ;
}
return parent[x] = findset(parent[x]) ;
}
void unite(int x , int y){
int s1 = findset(x) ;
int s2 = findset(y) ;

if(s1 != s2){
if(rank[s1] < rank[s2])
{ parent[s1] = s2 ;
rank[s2] += rank[s1] ;

3
 DSA WITH C
}
else{
parent[s2] = s1 ;
rank[s1] += rank[s2] ;
}
}
return ;
}
int comp(const void *a , const void *b){
Edge *x = (Edge *)a ;
Edge *y = (Edge *)b ;
return x -> w > y -> w ;
}
int kruskal(Graph *gr){
int answer = 0 ;
for(int i = 0 ; i < gr -> E ; i++){
int s1 = findset(gr -> edgelist[i].x) ;
int s2 = findset(gr -> edgelist[i].y) ;
if(s1 != s2){
unite(s1 , s2) ;
answer += gr -> edgelist[i].w ;
}
}
return answer ;
}
void solve(){
int n , m ;
printf("Enter the number of vertices and edges\n") ;
scanf("%d %d" , &n , &m) ;
Graph *gr = create(n , m) ;
init(n) ;
printf("Enter the source , destination and the weight of the edge \n") ;
for(int i = 0 ; i < m ; i++){
int x , y , w ;
scanf("%d %d %d" , &x , &y , &w) ;
gr -> edgelist[i].x = x ;
gr -> edgelist[i].y = y ;
gr -> edgelist[i].w = w ;
}
qsort(gr -> edgelist , gr -> E , sizeof(gr -> edgelist[0]) , comp) ;
printf("The cost of minimum spanning tree is : %d \n" , kruskal(gr)) ;
}
int main(){
solve() ;
}

3
 DSA WITH

OUTPUT:

Enter the number of vertices and edges

45
Enter the source, destination and the weight of the edge
1 2 10
2 3 15
135
422
4 3 40
The cost of minimum spanning tree is : 17