#1.

Complete Program for Singly Linked List

// This program is summation of all the sub function we have covered from 1-12

/*****************************************************************************

@Mukesh Mann dated 27-01-2020.

*******************************************************************************/
#include <stdio.h>
/* Lets create structure of the node*/
struct node
{
int data;
struct node *link;
}*head; // Creating a global head pointer of struct type
/* lets declare a function to create nodes*/
void createnode(int n);
void inseratbegning();
void inseratend();
void traverselist();
void inseratanyindex();
void deletnodefrombegning();
void deletelastnode();
void deleteatanyindex();
void movelastnodetofront();
struct node * Reverseiterative(struct node *);
void ReverseusingRecursion(struct node *,struct node *);

//void struct node *ReverseusingRecurssion(struct node);

/* lets call main function */

int main()
{
int n;
printf("Enter number of node\n\n");
scanf("%d", &n);
createnode(n);
printf("Inserting a new node with value 40 at the begning of list\n\n");
inseratbegning();
printf("Inserting a new node with value 70 at the end of list\n\n");
inseratend();
printf("\nTraversing the created list\n");
traverselist();
printf("Inserting a new node with value 90 after node 2 in the linked list\n\n");
inseratanyindex();
printf("After inserting current list is as under\n\n ");
traverselist();
 printf("Deleteing firt node from list\n");
deletnodefrombegning();
printf("After deleteing current list values are\n\n ");
traverselist();
printf("----------------------------------Delete node from last--------------------\n");
deletelastnode();
printf("After deleteing last node the current list values are\n\n ");
traverselist();
printf("----------------------------------Delete node WITH VALUE =3 IN THE LIST-------
-------------\n");
deleteatanyindex();
printf("After deleteing node WITH VALUE =3; the current list values are\n\n
");
traverselist();
printf("Move last node to front of node\n\n ");
movelastnodetofront();
printf("----------------------AfterMoving last node to front the list is --------------\n\n
");
traverselist();
printf("----------------------An Iterative verison to reverse data in linked list ----------
----\n\n ");
//*Reverseiterative function will return a pointer and takes a pointer
head= (*Reverseiterative)(head);
traverselist();

printf("----------------------A Recursive verison to reverse data in linked list ----------

----\n\n ");
//*Reverseiterative function will return a pointer and takes a pointer
ReverseusingRecursion(NULL,head);
traverselist();
return 0;
}
void createnode(int n)
{

int data ;
struct node *temp;
/* lets create first node using malloc */
head=(struct node*)malloc(sizeof(struct node));

if(head == NULL)
{
printf("Memory not allocated ");
return;

}
 printf("Enter first node data ");
scanf("%d", &data);
temp=head;
head-> data = data;
head->link=NULL;

for(int i=2; i<=n; i++)

{

struct node *NewNode=(struct node *)malloc(sizeof(struct node));

if(NewNode== NULL)
{
printf("Memory not allocated ");
break;
}
printf("Enter node data ");
scanf("%d", &data);
NewNode->data=data;
NewNode->link=NULL;
temp->link=NewNode; // linking current node with NewNode
temp = temp->link; // Moving temp node to NewNode location
}
printf("List created successfuly!\n");

/*****
traverselist function
*****/
void traverselist()
{
struct node *temp=head;
int i=1;
while(temp)
{
printf("Printing %d Element of Linked List %d\n",i,temp->data);
i++;
temp= temp->link;
}
}
/*****
inseratbegning function
*****/
void inseratbegning()
{
 printf("\nLets insert a node at the begninig\n");
struct node *mynode;
mynode=(struct node *)malloc(sizeof(struct node));

mynode->link=head;
mynode->data=40;
head=mynode;
printf("New Node Inserted Successfuly at the begning!\n");
}

/*****
inseratEnd function
*****/
void inseratend()
{
printf("\nLets insert a node at the End\n");
struct node *mynode;
struct node *temp=head;
mynode=(struct node *)malloc(sizeof(struct node));

while(temp->link!=NULL)
{

temp=temp->link;

}
temp->link=mynode;
mynode->link=NULL;
mynode->data=70;
printf("New Node Inserted Successfuly at the End!\n");
}

/*****
inseratanyindex function
*****/
void inseratanyindex()
{
printf("\nLets insert a node at the End\n");
struct node *mynode;
struct node *temp=head;
mynode=(struct node *)malloc(sizeof(struct node));

while(temp->data!=2)
{
temp=temp->link;
 }
mynode->link=temp->link;
temp->link=mynode;
mynode->data=90;
printf("New Node Inserted Successfuly at the after node 2!\n");
}
/*****
deletnodefrombegning()
*****/
deletnodefrombegning()
{
struct node *temp=head;
if(head== NULL)
{
printf("THERE IS NO NODE TO DELETE\n");
}
if(head->link==NULL) // there is only one node
{
free(head);
head=NULL;
}
head=head->link;
free(temp);
}

/*****
deletelastnode()
*****/
deletelastnode()
{
struct node *temp=head;
while(temp->link->link!=NULL)
{
temp=temp->link;
}
temp->link->link=NULL;
free(temp->link);
temp->link=NULL;
}
/*****
deleteatanyindex()
*****/
deleteatanyindex()
{
struct node *temp=head;
while(temp->link->data!=3)
 {
temp=temp->link;
}
struct node *temp1=temp->link;
temp->link=temp1->link->link;
free(temp1);
temp1= NULL;
}
/*****
Moving Last node to the front of linked list
movelastnodetofront()
*****/
// Lets have two pointer (p,q) one will be one step ahead of other;
// the moment one pointer (p) reaches last node ; point its link to head,
// and put null into q ;
movelastnodetofront()
{

struct node *p,*q;

p=head;
while(p->link != NULL)
{

q=p;
p=p->link;
}
q->link= NULL;
p->link=head;
head=p;
}
/*****
Reverseing content of linked list using Iterative version
Reverseiterative() is a function pointer which returns a pointer to a structure
and it takes head as its initial pointer as parameter
*****/
struct node *Reverseiterative(struct node *curr)
{

struct node *prev= NULL;

struct node *nextnode= NULL;
while(curr)
{
nextnode =curr->link;
curr->link= prev;
prev=curr;
curr=nextnode;
 }
head=prev;
printf("value of current node is%d",head);
return prev;
}

/*****
Reverseing content of linked list using Recursion
ReverseusingRecursion() is a function which returns a pointer to a structure
and it takes NULL in prev node and head in curr.
*****/
void ReverseusingRecursion(struct node *prev, struct node *curr)
{
if(curr)
{
ReverseusingRecursion(curr,curr->link);
curr->link=prev;
}
else
head=prev;
}

#2. Reverse the elements of linked list using Recursive Version

/*****
Reversing content of linked list using Recursion
ReverseusingRecursion() is a function which returns a pointer to a structure
and it takes NULL in prev node and head in curr.
*****/

void ReverseusingRecursion(struct node *,struct node *); // Global Declaration

of function

ReverseusingRecursion(NULL,head); // Calling ReverseusingRecursion()

function from main()

void ReverseusingRecursion(struct node *prev, struct node *curr)

{
if(curr)
{
ReverseusingRecursion(curr,curr->link);
curr->link=prev;
}
else
 head=prev;
}

#3. Doubly Linked List :1- Creating a Structure node for

doubly Linked List
#include <stdio.h>
/* Lets create structure of the node*/
struct node
{
int data;
struct node *prev;
struct node *next;
}*head; // Creating a global head pointer of struct type

#4.Doubly Linked List :2- Create and traverse in doubly

Linked List
/*****************************************************************************
Doubly linked list creation !
@Mukesh Mann dated 10-02-2020.
*******************************************************************************/
#include <stdio.h>
/* Lets create structure of the node*/
struct node
{
int data;
struct node *prev;
struct node *next;
}*head; // Creating a global head pointer of struct type
/* lets declare a function to create nodes*/
void createnode();
void traverselist();
int main()
{
int n;
printf("Enter number of node\n\n");
scanf("%d", &n);
createnode(n);
printf("\nTraversing the created list\n");
traverselist();
}
void createnode(int n)
{
struct node *temp;
int x ;
//struct node *temp;
/* lets create first node using malloc */
head=(struct node*)malloc(sizeof(struct node));

if(head == NULL)
{
printf("Memory not allocated ");
return;

}
printf("Enter first node data ");
scanf("%d", &x);
temp=head;
temp->prev=NULL;
temp->next=NULL;
temp->data = x;
int k;
for(int i=2; i<=n; i++)
{

struct node *NewNode=(struct node *)malloc(sizeof(struct node));

if(NewNode== NULL)
{
printf("Memory not allocated ");
break;
}
printf("Enter node data ");
scanf("%d", &k);
NewNode->data=k;
NewNode->next=NULL;
NewNode->prev=temp;
temp->next=NewNode;
//head->next->prev=head;
temp=temp->next;

//printf("Printing Element of Linked List %d\n",head->data);

}
printf("List created successfuly!\n");

/*****
traverselist function
*****/
void traverselist()
{
struct node *temp;
temp=head;
// printf("Value in temp is %d and temp points to %d", temp,temp->data);
int i=1;
while(temp!=NULL)
{
printf("Printing %d Element of Linked List - %d\n",i,temp->data);
i++;
temp=temp->next;
}
return;
}

Data Structure- 1. Stacks Introduction

As you know that a program is supposed to take some input and is expected to give some
output ! The input and the output to a program is given in some format, that format is what we
called as data structure!
You can think if we give a unsorted array to a sorting program than the time taken to sort the
elements is more as compared to a sorted input array ! this means that the format of input data
plays an important role as far as far as performance of an algorithm is considered. !
In this respect the first and traditional way of giving the data was using - STACK.

A stack is a data structure ( i.e., a type of input format) which follows LIFO property, that is the
last element is popped out first from the top of the stack.
The main application of stacks are in

1. Recursion :- Remember how recursive calls for a function is made by creating a stack
activation record

2. Text Editors- use stacks for Redo & undo Operations.

3. Brower's use stacks for remembering which page is visited and then going back( i,e, POP )

In this article we will study how stack push and pop operation.
Data Structure- 2. Stacks Push and POP Operation
As you know that in stack we always perform push and pop f an element from
the top of the stack , here is the code to do the same

/******************************************************************************
Push and Pop Operation in Stack !
@Mukesh Mann dated 16-02-2020
*******************************************************************************/
#include <stdio.h>
int top=-1; // Delaring a Top variable initially pointing to -1
int stack [10]; // a stack array of 10 elements

int main()
{

// Push operation in stack array

for (int i=0; i<=10; i++)
{
top=top+1;
stack[top]=i;
}

// Printing content of stack array

for (int i=1; i<=10; i++)
{
printf(" The element in the stack are %d\n",stack[i]);
}

// pop operation in stack array

for (int i=1; i<=10; i++)

{
printf(" poping %d element %d\n",i, stack[top]);
top=top-1;
}

printf(" After perfroming pop operation the content of stack is

%d\n",stack[top]);

return 0;
}
Data Structure- 3. Stacks Push and POP Operation using
Linked List

As you know
that in a stack the push and pop operation always done from the top, so if you imagine each
index of stack a linked list than the push operation is nothing more than inserting a node at the
front of list and pop operation is nothing but deletion a node from the front of list ( i.e., TOP)

here is the code for you ! Note that we have used power of recursion here to push the
elements in the stack !
/******************************************************************************
Stacks Push and POP Operation using Linked List
@Mukesh Mann dated 16-02-2020
*******************************************************************************/

#include <stdio.h>
/* Lets create structure of the node*/
struct node
{
int data;
struct node *link;

}*head= NULL; // Creating a global head pointer of struct type

createnode(int n, int item)

{
if(n){
int data ;
struct node *temp;
/* lets create first node using malloc */
temp=(struct node*)malloc(sizeof(struct node));

if(temp == NULL)
{
printf("Memory not allocated ");
return;

temp-> data = item;

temp->link=head;
head= temp;
// now suppose second element is 1 more than previous
createnode(n-1,item+1);
return head;
 }

int main()
{
int n, item;
printf("Enter number of elemens to be pushed in stack\n\n");
scanf("%d", &n);
printf("Enter the item \n\n");
scanf("%d", &item);
struct node *temp1=createnode(n,item); / holding returned value of head
which is a pointer
for(int i=0;i<n;i++)
{
head= temp1;
printf("Top %d in the stack is %d\n", i, temp1->data);
temp1= temp1->link;
}
return 0;
}

// The deletion of an element from the stack using concept of linked list is left as an
exercise for you

Data Structure- 4. Queue Concept

Like Stack data Structure ! Queue is also another type of Data Structure which follows the concept of
FIFO ! Thas is the element which comes first will be deleted first!

Concept to code !- We maintain two variables called front and Rear, The Front will always point to the
first element in the queue and the Rear will element will always point to the current element that is just
inserted into the queue.
If you will follow this than lets suppose we are given the following list of element

<5,6,7,8> then in queue it will look like, Initially

Thus whenever you wish to insert ( Enqueue) an element then simply increment
the rear and put the item there ! when you wish to delete ( Dequeue ) the item the
you simply increment the front and take out the item from there!

Thus here is the Code to push and pop an element from the queue !
/******************************************************************************
Queue Concept using an Array !
@Mukesh Mann dated 16-02-2020
*******************************************************************************/
/*
* C Program to Implement a Queue using an Array
*/
#include <stdio.h>

#define MAX 50

void insert();
void delete();
void display();
int queue_array[MAX];
int rear = - 1;
int front = - 1;
main()
{
int choice;
while (1)
 {
printf("1.Insert element to queue \n");
printf("2.Delete element from queue \n");
printf("3.Display all elements of queue \n");
printf("4.Quit \n");
printf("Enter your choice : ");
scanf("%d", &choice);
switch (choice)
{
case 1:
insert();
break;
case 2:
delete();
break;
case 3:
display();
break;
case 4:
exit(1);
default:
printf("Wrong choice \n");
} /* End of switch */
} /* End of while */
} /* End of main() */

void insert()
{
int add_item;
if (rear == MAX - 1)
printf("Queue Overflow \n");
else
{
if (front == - 1)
/*If queue is initially empty */
front = 0;
printf("Inset the element in queue : ");
scanf("%d", &add_item);
rear = rear + 1;
queue_array[rear] = add_item;
}
} /* End of insert() */

void delete()
{
if (front == - 1 || front > rear)
 {
printf("Queue Underflow \n");
return ;
}
else
{
printf("Element deleted from queue is : %d\n", queue_array[front]);
front = front + 1;
}
} /* End of delete() */

void display()
{
int i;
if (front == - 1)
printf("Queue is empty \n");
else
{
printf("Queue is : \n");
for (i = front; i <= rear; i++)
printf("%d ", queue_array[i]);
printf("\n");
}
} /* End of display() */

Data Structure- 5 Queue Concept using Circular Array

// In this article we will Learn concept of circular array to

implement the queue concept because as we can see the in linear array there is
a no way to store new item even if there is a space after deleting an element !
with circular array w will use MAX-1 index of array and initially we will put front
and rear to index zero position !

1. when we need to insert a data we just increment the rear and insert
the data !
2. When we need to delete the data we just increase the front and print
the data!
Only important point is that when during insertion if rear== front then it means the queue is
full now and we will put rear one position back , if rear =0 then one position back is MAX-1; and
if rear != 0 then one position back is rear-1;

In order to move rear and front we will use mod operator!

/******************************************************************************
Queue Concept using Circular Array !
@Mukesh Mann dated 16-02-2020
*******************************************************************************/
#define MAX 4
enqueue(int);
//void delete();
void display();
int queue_array[MAX];
int rear = 0;
int front = 0;
enqueue(int item)
{
//int item;
rear=(rear+1)%MAX;
if (front==rear)
{
printf("Queue Overflow \n");
if(rear==0)
{
rear=MAX-1;
}
else {
rear=rear-1;}
return;
}
else
{
queue_array[rear]= item;
printf("iTEM INSERTED is %d\n",queue_array[rear]);
return;
}
} /* End of Enqueue() */

deqeue()
{
if(front==rear)
{
printf("Queue is empty on");
return -1;
}
else
{
front=(front+1)%MAX;
int item= queue_array[front];
printf("Deleted Item is %d\n",item);
return item;
}

} /* End of deqeue() */

main()
{
// Here we try to insert 3 item using a loop
// initially front and rear are point to zero and we will utilize only max-1 index of
circular array
for (int i = front; i <= MAX-1; i++){
enqueue(i);
}

for (int i = front; i <= MAX-1; i++){

deqeue();
}

#1.Trees basics
Tree
In this unit Let me briefly tell you that why we are studying this ADT

As you know that Searching an element using in a linked list takes ~0(n) time. How?

Lets assume that you wish to search an element named "A" in a given linked list ( Obviously LL
is a non linear data Structure) which contains elements A,B,D,E . What will be the worst case (
This is when The Element is placed at the last in the linked list) so how much time it will take to
search this A now, Obviously you have to traverse each element and then you will be able to
find A ., How many elements are there in the list ? 4 here , so if elements are n then how much
time you will take in worst case = ~0(n). Fine!

Now if we can reduce this time to some Log time Don't you think it is more wonderful ?

How, Lets use the concept of one more non linear ADT called Trees. A tree is a non
linear structure in which each node is connected with some other node (forming parent child
relationship) to form a hierarchical structure. the point is to reduce the searching time !

But even before that lets try to understand different types of trees with their terminologies !

1. We have discussed linear data structures, such as, Arrays, Strings, Stacks, and
Queues.
2. Now, we will learn about a Non-Linear Data Structure called TREE.
3. A tree is a structure which is mainly used to store data that is hierarchical in
nature. First, we will understand general trees and then Binary Trees.
4. These binary trees are used to form binary search trees and heaps. They are
widely used to manipulate Arithmetic Expressions, Construct Symbol Tables, and for
Syntax Analysis.
Now Hope you understood The definition ! Please keep in mind that some
books follow slightly different convention while defining the types of trees

Now lets try to explore why the complexity turns out to be log(n) in
searching for an element.
But ! wait what if the tree is skewed !
So, What will be the advantage of using trees if its complexity turns out to be ~0(n); Yes you are
right their is no advantage if the tree is skewed but if it is complete or almost complete than
you can take log(n) time advantage over ~o(n). Ok!

Hope You are now clear about different terminologies used in Trees ! and the reason we are
using this ADT

But wait I know that you reduced the time by using Trees but it is on the cost of inserting and
deletion ! in Trees both operation involves traversing a node and then deletion/insertion. So in
wort case A node is present at last and thus you need to traverse all the nodes in order to reach
that node.
If visiting a node takes C amount then to visit n nodes will take ~=Cx o(n) =O()n

Conclusion - Trees reduces searching (log (n) , in linked list = O(n)) nut insertion and deletion
time increases that is = O(n) which is O(1) in case of lionked list.

2#Trees Traversal
In this Unit we will Learn about Trees ADT and how to Implement them

Why to use Tree ADT. Theoretical understanding regarding its time has already been
seen why we are using trees! Remember the time complexity in searching log (n) over
the cost of insertion and deletion (o(n) ) . Have you observed in your computer how files
are organised in a tree structure
Fine !

Observe some other interesting applications of Trees!

Now let’s start this journey by finding different possibilities with which we can make trees

See there are two scenarios - 1) if you are given some nodes without label and 2) with
labels

can you draw number of binary trees possible in each case?

A binary tree is one which is having degree of at most 2 , thus node with degree 0,1,2 are
binary
3_Tree Traversals Lab

/******************************************************************************
Trees Concepts ! Inoder Traversal
@Mukesh Mann dated 23-03-2020
*******************************************************************************/
/******************************************************************************
*******************************************************************************/
#include <stdio.h>

typedef struct node

int data;

struct node *left;

struct node *right;

}Node;

// Lets try to creat a root node first

int * create()

int x;

Node *newnode=(Node*)malloc(sizeof(Node));

printf("Enter the data for the nodes(-1 for no data)");

scanf("%d", &x);

if(x==-1)

//printf("You have not entered any data");

return NULL;

newnode->data=x;

printf("Enter the left child data rooted at %d \n",newnode->data);

newnode->left=create();

printf("Enter the right child data rooted at %d\n",newnode->data);

newnode->right=create();

return newnode;

void traverse(Node *t)

if(!t==NULL)

{
 printf("Left child data is %d ",t->data);

//printf("Left child data is %d",t->left->data);

//printf("right child data is %d",t->left->data);

traverse(t->left);

t=t->right;

if(!t==NULL)

printf("Right child data is %d\n",t->data);

//printf("Left child data is %d",t->left->data);

//printf("right child data is %d",t->left->data);

traverse(t->right);

//t=root;

void Inorder(Node *t)

//printf("In order traversal is" );

if(t)
 {

Inorder(t->left);

printf(" %d",t->data);

Inorder(t->right);

int main()

Node *root=create();

Node *t=root;

printf("Root child is %d\n ",t->data);

traverse(t);

Inorder(t);

printf(" is the order traversal \n\n" );

return 0;