Data Structures in C Practicals and Why Colleges with their IDE’s are Outdated. A Wiser Proof of Concept.

Data Structures in C and Why Colleges with their IDE’s are Outdated!

By Shritam Bhowmick
Web Application Penetration Tester
LinkedIn: https://www.linkedin.com/profile/view?id=281014248&trk=nav_responsive_tab_profile
Academia: https://independent.academia.edu/ShritamBhowmick
Facebook: https://www.facebook.com/coded32

The Introduction Preface

Hi, this is about all the practical lab C  for WBUT Winters (Semester 3rd of the University prescribed Syllabus) section data-structures questions solved at once place for a ready reference to the students who might seek help and also on an information as to why colleges now should be moving from the stone age. All the programs are complied under Tubro C++ compiler and would not be/should not be expected to be executed/processed to create an object under GNU C compiler or  any Windows variant compilers (such as Visual C compiler). Since the syllabus itself is too outdated and people had been talking about them in various forums; I came up with a compilation of the code as well as the questions which could help them understand the core with the ready service code to be executed only within from Turbo C++ compiler. This is C code and not C++ code. The source code for each of them had been practically tested on Windows 8.1 platform using DOSBOX as an emulator to run Turbo C.

The Recommendations

It’s recommended to move on with the syllabus and pay less attention there, if anyone really is serious on C and C++ programming. Python, Ruby, Delphi, Lua and Perl are the modern spectacular languages to choose from and Java is really not that friendly as you might think if you have to do a certain task. Java isn’t that flexible in terms that Java would really need long source code for a simple problem. See “Python to other languages – A comparison“. Get to know more at Stackoverflow. To refernce from the original source, here’s is the justification why someone would prefer to code in Python rather than any other older languages in a nutshell:

  1. Speed of development. I can crank out working code before the Java folks have stuff that will compile.
  2. Flexibility. I can refactor and rework a module in an afternoon. The Java folks have to redesign things on paper to be sure they can get some of the bigger refactorings to recompile. In Java, the changes aren’t as small and focused.I should probably blog about some of the nastier refactorings that would be a huge pain — even using the refactoring tools in Eclipse or NetBeans. The most recent example was a major change to the top-most superclass of a class hierarchy that would have invalidated a mountain of Java code. But the method was used in exactly two places, allowing a trivial change to the superclass and those two places. 100’s of unit tests passed, so I’m confident in the change without the compiler overhead.
  3. Simplicity. Python doesn’t need a sophisticated IDE and super-complex WS libraries. Python code can be written in Komodo Edit. A WS interface between your Java front-end and PostgresSQL can be knocked together in Werkzeug in a day. You can plug your transactions into this without much overhead.

The post primarily covered Python against Java, but there are instances why some one could just prefer Python over C which could be referenced from here in this post. This does not at all mean to compare C and Python on basis of what they have to deliver but rather compares them on an average on the end-users opinion perspective. There are other considerations as well into modern computing which is resolved below in the list.

Why Would Python be Slow but equivalently faster ever than C Deployments?

Python is a higher level language than C, which means it abstracts the details of the computer from you – memory management, pointers, etc, and allows you to write programs in a way which is closer to how humans think. It is true that C code usually runs 10 to 100 times faster than Python code if you measure only the execution time. However if you also include the development time Python often beats C. For many projects the development time is far more critical than the run time performance. Longer development time converts directly into extra costs, fewer features and slower time to market.

Why use C contrary to the switching to any other programming languages, a hope out of no-where!?

“If there ever were a quote that described programming with C, it would be this. To many programmers, this makes C scary and evil. It is the Devil, Satan, the trickster Loki come to destroy your productivity with his seductive talk of pointers and direct access to the machine. Then, once this computational Lucifer has you hooked, he destroys your world with the evil “segfault” and laughs as he reveals the trickery in your bargain with him.

But, C is not to blame for this state of affairs. No my friends, your computer and the Operating System controlling it are the real tricksters. They conspire to hide their true inner workings from you so that you can never really know what is going on. The C programming language’s only failing is giving you access to what is really there, and telling you the cold hard raw truth. C gives you the red pill. C pulls the curtain back to show you the wizard. C is truth. Why use C then if it’s so dangerous? Because C gives you power over the false reality of abstraction and liberates you from stupidity.”

The Coverage

Now since we are already hopped into C with Turbo C as a compiler. I’d go writing the source code of the practicals here and try to keep it updated as much as I could to my disposal. Instead this is the responsibility at your side to post back with comments on what else its to be added so this could help others in the process.

Notes

The source code has replaced all the instances of \n to n. Take care of that plus the include headers have not been defined to be kept away from copy/paste practices. This in my opinion will lead to a better coding practices and would lead to a great start with self-research.

The Question Set

The questions I have dug so far follows these:

  1. Doubly Linked List with insertion and deletion.
  2. Priority Queue with addition and deletion of elements.
  3. Dequeue or Double Ended Queue using Linked List.
  4. Dequeue or Double Ended Queue using Circular Array.
  5. Priority Queue Implementation using Arrays.
  6. Circular Queue using Linked List with Circular Queue Concept Notes.
  7. Circular Queue Implementation in C Data-Structures using Arrays.
  8. Stack for PUSH and POP operations in C both via recursive and regular methods.
  9. Linear Search Implementation in C using Arrays.
  10. Binary Search Implementation in C using Arrays.
  11. Insertion Sort Implementation in C using Arrays.
  12. Merge Sort Implementation in C using Arrays.
  13. Quick Sort Implementation in C using Arrays.
  14. Heap Sort Implementation in C using Arrays.

Source Code Solutions

1.) Doubly Linked List with Insertion, Deletion and Reverse Display

Here’s the source code (to avoid copy/paste gimmicks, I have stripped off all the includes. Feel free to add them at your own expense) for Doubly Linked List:

#include
#include
#include
struct node
{
struct node *previous;
int data;
struct node *next;
}*head, *last;

void insert_beginning(int value)
{
struct node *var,*temp;
var=(struct node *)malloc(sizeof(struct node));
var->data=value;
if(head==NULL)
{
head=var;
head->previous=NULL;
head->next=NULL;
last=head;
}
else
{
temp=var;
temp->previous=NULL;
temp->next=head;
head->previous=temp;
head=temp;
}
}

void insert_end(int value)
{
struct node *var,*temp;
var=(struct node *)malloc(sizeof(struct node));
var->data=value;
if(head==NULL)
{
head=var;
head->previous=NULL;
head->next=NULL;
last=head;
}
else
{
last=head;
while(last!=NULL)
{
temp=last;
last=last->next;
}
last=var;
temp->next=last;
last->previous=temp;
last->next=NULL;
}
}

int insert_after(int value, int loc)
{
struct node *temp,*var,*temp1;
var=(struct node *)malloc(sizeof(struct node));
var->data=value;
if(head==NULL)
{
head=var;
head->previous=NULL;
head->next=NULL;
}
else
{
temp=head;
while(temp!=NULL && temp->data!=loc)
{
temp=temp->next;
}
if(temp==NULL)
{
printf("n%d is not present in list ",loc);
}
else
{
temp1=temp->next;
temp->next=var;
var->previous=temp;
var->next=temp1;
temp1->previous=var;
}
}
last=head;
while(last->next!=NULL)
{
last=last->next;
}
}
int delete_from_end()
{
struct node *temp;
temp=last;
if(temp->previous==NULL)
{
free(temp);
head=NULL;
last=NULL;
return 0;
}
printf("nData deleted from list is %d n",last->data);
last=temp->previous;
last->next=NULL;
free(temp);
return 0;
}

int delete_from_middle(int value)
{
struct node *temp,*var,*t, *temp1;
temp=head;
while(temp!=NULL)
{
if(temp->data == value)
{
if(temp->previous==NULL)
{
free(temp);
head=NULL;
last=NULL;
return 0;
}
else
{
var->next=temp1;
temp1->previous=var;
free(temp);
return 0;
}
}
else
{
var=temp;
temp=temp->next;
temp1=temp->next;
}
}
printf("data deleted from list is %d",value);
}

void display()
{
struct node *temp;
temp=head;
if(temp==NULL)
{
printf("List is Empty");
}
while(temp!=NULL)
{
printf("-> %d ",temp->data);
temp=temp->next;
}
}

int main()
{
int value, i, loc;
head=NULL;
printf("Select the choice of operation on link list");
printf("n1.) insert at begningn2.) insert at atn3.) insert at middle");
printf("n4.) delete from endn5.) reverse the link listn6.) display listn7.)exit");
while(1)
{
printf("nnenter the choice of operation you want to do ");
scanf("%d",&i);
switch(i)
{
case 1:
{
printf("enter the value you want to insert in node ");
scanf("%d",&value);
insert_beginning(value);
display();
break;
}
case 2:
{
printf("enter the value you want to insert in node at last ");
scanf("%d",&value);
insert_end(value);
display();
break;
}
case 3:
{
printf("after which data you want to insert data ");
scanf("%d",&loc);
printf("enter the data you want to insert in list ");
scanf("%d",&value);
insert_after(value,loc);
display();
break;
}
case 4:
{
delete_from_end();
display();
break;
}
case 5:
{
printf("enter the value you want to delete");
scanf("%d",value);
delete_from_middle(value);
display();
break;
}
case 6 :
{
display();
break;
}
case 7 :
{
exit(0);
break;
}
}
}
printf("nn%d",last->data);
display();
getch();
}

2.) Priority Queue with Addition and Deletion of Elements

#include
#include
#define MAX 5

void insert_by_priority(int);
void delete_by_priority(int);
void create();
void check(int);
void display_pqueue();

int pri_que[MAX];
int front, rear;

void main()

{

int n, ch;
printf("n1 - Insert an element into queue");
printf("n2 - Delete an element from queue");
printf("n3 - Display queue elements");
printf("n4 - Exit");
create();

while (1)

{

printf("nEnter your choice : ");

scanf("%d", &ch);

switch (ch)

{

case 1:

printf("nEnter value to be inserted : ");

scanf("%d",&n);

insert_by_priority(n);

break;

case 2:

printf("nEnter value to delete : ");

scanf("%d",&n);

delete_by_priority(n);

break;

case 3:

display_pqueue();

break;

case 4:

exit(0);

default:

printf("nChoice is incorrect, Enter a correct choice");

}

}

}

/* Function to create an empty priority queue */

void create()

{

front = rear = -1;

}

/* Function to insert value into priority queue */

void insert_by_priority(int data)

{

if (rear >= MAX - 1)

{

printf("nQueue overflow no more elements can be inserted");

return;

}

if ((front == -1) && (rear == -1))

{

front++;

rear++;

pri_que[rear] = data;

return;

}

else

check(data);

rear++;

}

/* Function to check priority and place element */

void check(int data)

{

int i,j;

for (i = 0; i <= rear; i++) { if (data >= pri_que[i])

{

for (j = rear + 1; j > i; j--)

{

pri_que[j] = pri_que[j - 1];

}

pri_que[i] = data;

return;

}

}

pri_que[i] = data;

}

/* Function to delete an element from queue */

void delete_by_priority(int data)

{

int i;

if ((front==-1) && (rear==-1))

{

printf("nQueue is empty no elements to delete");

return;

}

for (i = 0; i <= rear; i++)

{

if (data == pri_que[i])

{

for (; i < rear; i++)

{

pri_que[i] = pri_que[i + 1];

}

pri_que[i] = -99;

rear--;

if (rear == -1)

front = -1;

return;

}

}

printf("n%d not found in queue to delete", data);

}

/* Function to display queue elements */

void display_pqueue()

{

if ((front == -1) && (rear == -1))

{

printf("nQueue is empty");

return;

}

for (; front <= rear; front++)

{

printf(" %d ", pri_que[front]);

}

front = 0;

}

3.) Dequeue or Double Ended Queue using Linked List

What is Dequeue?

The word dequeue is short form of double ended queue. In a dequeue , insertion as well as deletion can be carried out either at the rear end or the front end. The following diagram illustrates a version of the same concept:

Dequeue Represented Using a Circular Array

The source code is available below:

#define MAX 100
#include
#include

void insert(int);
int delStart();
int delEnd();
int queue[MAX];
int rear =0, front =0;
void display();
void insertEnd(int);
void insertStart(int);

int main()
{
char ch , a='y';
int choice, c, token;
printf("Enter your choice for which deque operation you want to perform operation n");
do
{
printf("n1.Input-restricted deque n");
printf("2.output-restricted deque n");
printf("nEnter your choice for the operation : ");
scanf("%d",&c);
switch(c)
{
case 1:
printf("nDo operation in Input-Restricted c dequen");
printf("1.Insert");
printf("n2.Delete from end");
printf("n3.Delete from begning");
printf("n4.show or display");
do
{
printf("nEnter your choice for the operation in c deque: ");
scanf("%d",&choice);
switch(choice)
{
case 1: insertEnd(token);
display();
break;
case 2: token=delEnd();
printf("nThe token deleted is %d",token);
display();
break;
case 3: token=delStart();
printf("nThe token deleted is %d",token);
display();
break;
case 4: display();
break;
default:printf("Wrong choice");
break;
}
printf("nDo you want to continue(y/n) to do operation in input-restricted c deque: ");
ch=getch();
}
while(ch=='y'||ch=='Y');
getch();
break;

case 2 :
printf("nDo operation in Output-Restricted c dequen");
printf("1.Insert at the End");
printf("n2.Insert at the begning");
printf("n3.Delete the element");
printf("n4.show or display");
do
{
printf("nEnter your choice for the operation: ");
scanf("%d",&choice);
switch(choice)
{
case 1: insertEnd(token);
display();
break;
case 2: insertStart(token);
display();
break;
case 3: token=delStart();
printf("nThe token deleted is %d",token);
display();
break;
case 4: display();
break;
default:printf("Wrong choice");
break;
}
printf("nDo you want to continue(y/n):");
ch=getch();
}
while(ch=='y'||ch=='Y');
getch();
break ;
}

printf("nDo you want to continue(y/n):");
ch=getch();
}
while(ch=='y'||ch=='Y');
getch();
}

void display()
{
int i;
printf("nThe queue elements are:");
for(i=rear;i<front;i++)
{
printf("%d  ",queue[i]);
}
}

void insertEnd(int token)
{
char a;
if(front==MAX/2)
{
printf("nQueue fullnyou cant enter more elements at the end of c queue");
return;
}
do
{
printf("nEnter the token to be inserted:");
scanf("%d",&token);
queue[front]=token;
front=front+1;
printf("do you want to continue insertion Y/N");
a=getch();
}
while(a=='y');
}

void insertStart(int token)
{
char a;
if(front==MAX/2)
{
printf("nQueue fullnyou cant enter more elements at the start of queue");
return;
}
do
{
printf("nEnter the token to be inserted:");
scanf("%d",&token);
rear=rear-1;
queue[rear]=token;
printf("do you want to continue insertion Y/N");
a=getch();
}
while(a=='y');
}
int delEnd()
{
int t;
if(front==rear)
{
printf("nQueue empty");
return 0;
}
front=front-1;
t=queue[front+1];
return t;
}
int delStart()
{
int t;
if(front==rear)
{
printf("nQueue empty");
return 0;
}
rear=rear+1;
t=queue[rear-1];
return t;
}

4.) Dequeue or Double Ended Queue using Circular Array

The available source code is different from the previous one which used linked list. This time the code uses the concept for circular array and implements a Dequeue or Double Ended Queue implementation around circular array. The source code is below as per the references.

#include
#include

#define MAX 30

typedef struct dequeue
{
int data[MAX];
int rear,front;
}dequeue;

void initialize(dequeue *p);
int empty(dequeue *p);
int full(dequeue *p);
void enqueueR(dequeue *p,int x);
void enqueueF(dequeue *p,int x);
int dequeueF(dequeue *p);
int dequeueR(dequeue *p);
void print(dequeue *p);

void main()
{
int i,x,op,n;
dequeue q;
initialize(&q);

do
{
printf("n1.Createn2.Insert(rear)n3.Insert(front)n4.Delete(rear)n5.Delete(front)");
printf("n6.Printn7.ExitnnEnter your choice:");
scanf("%d",&op);

switch(op)
{
case 1: printf("nEnter number of elements:");
scanf("%d",&n);
initialize(&q);
printf("nEnter the data:");

for(i=0;i<n;i++) { scanf("%d",&x); if(full(&q)) { printf("nQueue is full!!"); exit(0); } enqueueR(&q,x); } break; case 2: printf("nEnter element to be inserted:"); scanf("%d",&x); if(full(&q)) { printf("nQueue is full!!"); exit(0); } enqueueR(&q,x); break; case 3: printf("nEnter the element to be inserted:"); scanf("%d",&x); if(full(&q)) { printf("nQueue is full!!"); exit(0); } enqueueF(&q,x); break; case 4: if(empty(&q)) { printf("nQueue is empty!!"); exit(0); } x=dequeueR(&q); printf("nElement deleted is %dn",x); break; case 5: if(empty(&q)) { printf("nQueue is empty!!"); exit(0); } x=dequeueF(&q); printf("nElement deleted is %dn",x); break; case 6: print(&q); break; default: break; } }while(op!=7); } void initialize(dequeue *P) { P->rear=-1;
P->front=-1;
}

int empty(dequeue *P)
{
if(P->rear==-1)
return(1);
return(0);
}

int full(dequeue *P)
{
if((P->rear+1)%MAX==P->front)
return(1);
return(0);
}

void enqueueR(dequeue *P,int x)
{
if(empty(P))
{
P->rear=0;
P->front=0;
P->data[0]=x;
}
else
{
P->rear=(P->rear+1)%MAX;
P->data[P->rear]=x;
}
}

void enqueueF(dequeue *P,int x)
{
if(empty(P))
{
P->rear=0;
P->front=0;
P->data[0]=x;
}
else
{
P->front=(P->front-1+MAX)%MAX;
P->data[P->front]=x;
}
}

int dequeueF(dequeue *P)
{
int x;
x=P->data[P->front];
if(P->rear==P->front)   //delete the last element
initialize(P);
else
P->front=(P->front+1)%MAX;
return(x);
}

int dequeueR(dequeue *P)
{
int x;
x=P->data[P->rear];
if(P->rear==P->front)
initialize(P);
else
P->rear=(P->rear-1+MAX)%MAX;
return(x);
}

void print(dequeue *P)
{
if(empty(P))
{
printf("nQueue is empty!!");
exit(0);
}

int i;
i=P->front;
while(i!=P->rear)
{
printf("n%d",P->data[i]);
i=(i+1)%MAX;
}
printf("n%dn",P->data[P->rear]);
}

5.) Priority Queue using Array

I noticed I didn’t updated a priority queue implementation using arrays. This is the reason the source code is here for a ready reference to the readers of the blog. Here is the original version of the source code which is tested against the terms and conditions posted before which should be able to run via a Turbo C compiler. Any other compiler just won’t work because the syllabus itself is outdated, and people (and universities) must realize this fast.

#include
#include
#define size 5

int queue[5][2] = {0};
int top = -1;
int bottom;

void push(int value, int pr)

{

int i,j,k;

if(top < size-1) { if(queue[top][1] > pr)

{

for(i=0;i<top;i++) { if(queue[i][1] > pr)

{

break;

}

}

for(j=top;j>=i;j--)

{

queue[j+1][0] = queue[j][0];

queue[j+1][1] = queue[j][1];

}

top++;

queue[i][0] = value;

queue[i][1] = pr;

}

else

{

top++;

queue[top][0] = value;

queue[top][1] = pr;

}

}

else

{

printf("queue overflow n");

}

}

void pop()

{

int i;

if(queue[0][0] == 0)

{

printf("n The queue is empty  n");

}

else

{

printf("After , dequeue the following value is erased n  %d n", queue[0][0]);

for(i=0;i<top;i++) { queue[i][0] = queue[i+1][0]; queue[i][1] = queue[i+1][1]; } queue[top][0] = 0; queue[top][1] = 0; top--; } } void display() { int i,j; printf("ElementtPriority n"); for(i=size - 1;i>=0;i--)

{

for(j=0;j<2;j++)

{

printf(" %dt",queue[i][j]);

}

printf("n");

}

}

int main()

{

int i,j, ch=0 ,value = 0,pr=0;

while(1)

{

printf("n Please Enter the choice. n");

printf("1 for Enqueue n 2 for Dequeue n 3 for displayn  5 for exit: t n");

scanf("%d",&ch);

switch(ch)

{

case 1:

printf("n Please Enter the number to be inserted: t ");

scanf("%d", &value);

printf("n Please Enter the priority: t ");

scanf("%d", &pr);

push(value,pr);

break;

case 2:

pop();

break;

case 3:

display();

break;

case 5:

exit(0);

default:

printf("You entered wrong choice!");

}
}
}

6.) Circular Queue using Linked List in C Data-structures with Notes

In a standard queue data structure re-buffering problem occurs for each dequeue operation. To solve this problem by joining the front and rear ends of a queue to make the queue as a circular queue
Circular queue is a linear data structure. It follows FIFO principle.

  • In circular queue the last node is connected back to the first node to make a circle.
  • Circular linked list fallow the First In First Out principle
  • Elements are added at the rear end and the elements are deleted at front end of the queue
  • Both the front and the rear pointers points to the beginning of the array.
  • It is also called as “Ring buffer”.
  • Items can inserted and deleted from a queue in O(1) time.

Circular Queue can be created in three ways. They are:

  • · Using single linked list
  • · Using double linked list
  • · Using arrays

Follow is the source code for implementing a Circular Queue in C using Linked List:

#include
#include
#define max 5
int q[max];
int rear = -1, front = -1;
void insert();
void delet();
void display();

void main()
{
char ch;
int choice;
do
{
clrscr();
printf("n1 -> Insert");
printf("n2 -> Delete");
printf("n3 -> Display");
printf("n0 -> Exit");

printf("nnEnter Your Choice -> ");
scanf("%d", &choice);
switch (choice)
{
case 1:
insert();
break;
case 2:
delet();
break;
case 3:
display();
break;
case 0:
exit();
default:
printf("nnInvalid Choice");
}
printf("nnDo u Want to Continue -> ");
ch = getche();
} while (ch == 'y' || ch == 'Y');
}

void insert()
{
int data;
if ((rear == max - 1 && front == 0) || rear == front - 1)
{
printf("nSorry! Q is Full");
}
else
{
printf("nEnter data You want to insert ->");
scanf("%d", &data);
if (front == -1)
{
front++;
rear++;
}
else if (rear == max - 1)
{
rear = 0;
}
else
{
rear++;
}
q[rear] = data;
printf("nnData inserted successfully");
}
}
void delet()
{
if (front == -1)
{
printf("nnSorry! Q is Empty");
}
else
{
if (front == rear)
{
front = rear = -1;
}
else if (front == max - 1)
{
front = 0;
}
else
{
front++;
}
printf("nElement deleted Successfully");
}
}

void display()
{
int i;
if (front == -1)
{
printf("nnSorry! Q is Empty");
}
else
{
printf("nn:: Queue Elements are ::n");
if (front <= rear)
{
for (i = front; i <= rear; i++)
{
printf("n%d", q[i]);
}
}
else
{
for (i = front; i < max; i++)
{
printf("n%d", q[i]);
}
for (i = 0; i <= rear; i++)
{
printf("n%d", q[i]);
}
}
}
}

7.) Circular Queue Implementation in C using Arrays

Earlier in the post, we talked about implementation circular queue using Linked List. This section talks about the same implementation but using arrays. The source code below could be used for the purposes to demonstrate the concepts:

#include
#include
#include
#define MAXSIZE 5
int cq[MAXSIZE];
int front,rear;
void main()
{
void add(int,int);
void del(int);
int will=1,i,num;
front = -1;
rear = -1;
clrscr();
printf("nProgram for Circular Queue demonstration through array");
while(1)
{
printf("nnMAIN MENUn1.INSERTIONn2.DELETIONn3.EXIT");
printf("nnENTER YOUR CHOICE : ");
scanf("%d",&will);
switch(will)
{
case 1:
printf("nnENTER THE QUEUE ELEMENT : ");
scanf("%d",&num);
add(num,MAXSIZE);
break;
case 2:
del(MAXSIZE);
break;
case 3:
exit(0);
default: printf("nnInvalid Choice . ");
}

} //end of  outer while
}               //end of main
void add(int item,int MAX)
{
//rear++;
//rear= (rear%MAX);
if(front ==(rear+1)%MAX)
{
printf("nnCIRCULAR QUEUE IS OVERFLOW");
}
else
{
if(front==-1)
front=rear=0;
else
rear=(rear+1)%MAX;
cq[rear]=item;
printf("nnRear = %d    Front = %d ",rear,front);
}
}
void del(int MAX)
{
int a;
if(front == -1)
{
printf("nnCIRCULAR QUEUE IS UNDERFLOW");
}
else
{
a=cq[front];
if(front==rear)
front=rear=-1;
else
front = (front+1)%MAX;
printf("nnDELETED ELEMENT FROM QUEUE IS : %d ",a);
printf("nnRear = %d    Front = %d ",rear,front);

}
}

Here is a similar implementation of a queue using array. The source code could be referenced from the below:

#include
#include
#define N 6

int queue[N]={0};
int rear=0,front=0;

void insert(void);
void del(void);
void disp(void);
void cre(void);

void main()
{
int user=0;

clrscr();
while(user!=4)
{
clrscr();
printf("nnnttt THE SIZE OF QUEUE IS %d",N);
printf("nt 1.INSERT");
printf("nt 2.DELETE");
printf("nt 3.DISPLAY");
printf("nt 4.EXIT");
printf("nt 5.CREATE");
scanf("%d",&user);
switch(user)
{
case 1:
insert();
break;
case 2:
del();
break;
case 3:
disp();
break;
case 4:
printf("nt THANK U");
break;
case 5:
cre();
break;
}
getch();

}
getch();
}

void insert(void)
{
int t;
if(rear<N)
{
printf("nt ENTER A VALUE IN QUEUE");
scanf("%d",&t);
queue[rear]=t;
rear++;
}
else
{
printf("nt Q OVERFLOW!!!!!!!!!!!!!!!");
}
}
void del(void)
{
int i;
printf("nt %d gets deleted.........",queue[front]);
queue[front]=0;
front++;
}
void disp(void)
{
int i;
for(i=front;i<rear;i++)
{
printf("nt %d",queue[i]);
}
}
void cre(void)
{

int t;
printf("nt ENTER A VALUE IN QUEUE");
scanf("%d",&t);
front=0;
queue[front]=t;
rear=front+1;
}

8.) Stack Implementation to perform PUSH and POP Operations

After having gone through the Queue utilities in C and discussing queue with circular based and using Linked List, here is the source code to implement Stack for PUSH and POP operations in C.

#include
#define MAXSIZE 5

struct stack
{
int stk[MAXSIZE];
int top;
};
typedef struct stack STACK;
STACK s;

void push(void);
int  pop(void);
void display(void);

void main ()
{
int choice;
int option = 1;
s.top = -1;

printf ("STACK OPERATIONn");
while (option)
{
printf ("------------------------------------------n");
printf ("      1    -->    PUSH               n");
printf ("      2    -->    POP               n");
printf ("      3    -->    DISPLAY               n");
printf ("      4    -->    EXIT           n");
printf ("------------------------------------------n");

printf ("Enter your choicen");
scanf    ("%d", &choice);
switch (choice)
{
case 1:
push();
break;
case 2:
pop();
break;
case 3:
display();
break;
case 4:
return;
}
fflush (stdin);
printf ("Do you want to continue(Type 0 or 1)?n");
scanf    ("%d", &option);
}
}
/*  Function to add an element to the stack */
void push ()
{
int num;
if (s.top == (MAXSIZE - 1))
{
printf ("Stack is Fulln");
return;
}
else
{
printf ("Enter the element to be pushedn");
scanf ("%d", &num);
s.top = s.top + 1;
s.stk[s.top] = num;
}
return;
}
/*  Function to delete an element from the stack */
int pop ()
{
int num;
if (s.top == - 1)
{
printf ("Stack is Emptyn");
return (s.top);
}
else
{
num = s.stk[s.top];
printf ("poped element is = %dn", s.stk[s.top]);
s.top = s.top - 1;
}
return(num);
}
/*  Function to display the status of the stack */
void display ()
{
int i;
if (s.top == -1)
{
printf ("Stack is emptyn");
return;
}
else
{
printf ("n The status of the stack is n");
for (i = s.top; i >= 0; i--)
{
printf ("%dn", s.stk[i]);
}
}
printf ("n");
}

Here is yet another version of Stack implementation but using recursive method:

#include

#include

struct node

{

int a;

struct node *next;

};

void generate(struct node **);

void display(struct node *);

void stack_reverse(struct node **, struct node **);

void delete(struct node **);

int main()

{

struct node *head = NULL;

generate(&head);

printf("nThe sequence of contents in stackn");

display(head);

printf("nInversing the contents of the stackn");

if (head != NULL)

{

stack_reverse(&head, &(head->next));

}

printf("nThe contents in stack after reversaln");

display(head);

delete(&head);

return 0;

}

void stack_reverse(struct node **head, struct node **head_next)

{

struct node *temp;

if (*head_next != NULL)

{

temp = (*head_next)->next;

(*head_next)->next = (*head);

*head = *head_next;

*head_next = temp;

stack_reverse(head, head_next);

}

}

void display(struct node *head)

{

if (head != NULL)

{

printf("%d  ", head->a);

display(head->next);

}

}

void generate(struct node **head)

{

int num, i;

struct node *temp;

printf("Enter length of list: ");

scanf("%d", &num);

for (i = num; i > 0; i--)

{

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

temp->a = i;

if (*head == NULL)

{

*head = temp;

(*head)->next = NULL;

}

else

{

temp->next = *head;

*head = temp;

}

}

}

void delete(struct node **head)

{

struct node *temp;

while (*head != NULL)

{

temp = *head;

*head = (*head)->next;

free(temp);

}

}

9.) Linear Search Implementation in C

This is an abstract source code of Linear search utility in C. This could be used along in the Turbo C compiler. Others were specifically not tested and not recommended.

#include

int main()
{
int array[100], search, c, n;

printf("Enter the number of elements in arrayn");
scanf("%d",&n);

printf("Enter %d integer(s)n", n);

for (c = 0; c < n; c++)
scanf("%d", &array[c]);

printf("Enter the number to searchn");
scanf("%d", &search);

for (c = 0; c < n; c++)
{
if (array[c] == search)     /* if required element found */
{
printf("%d is present at location %d.n", search, c+1);
break;
}
}
if (c == n)
printf("%d is not present in array.n", search);

return 0;
}

10.) Binary Search using Arrays

The source code below is the implementation of binary search algorithm in C using arrays.

#include
int main(){

int a[10],i,n,m,c=0,l,u,mid;

printf("Enter the size of an array: ");
scanf("%d",&n);

printf("Enter the elements in ascending order: ");
for(i=0;i<n;i++){
scanf("%d",&a[i]);
}

printf("Enter the number to be search: ");
scanf("%d",&m);

l=0,u=n-1;
while(l<=u){
mid=(l+u)/2;
if(m==a[mid]){
c=1;
break;
}
else if(m<a[mid]){
u=mid-1;
}
else
l=mid+1;
}
if(c==0)
printf("The number is not found.");
else
printf("The number is found.");

return 0;
}

11.) Insertion Sort Implementation in C using Arrays.

This is insertion sort in C using Arrays. The source code is available below:

#include

int main()
{
int n, array[1000], c, d, t;

printf("Enter number of elementsn");
scanf("%d", &n);

printf("Enter %d integersn", n);

for (c = 0; c < n; c++) {
scanf("%d", &array[c]);
}

for (c = 1 ; c <= n - 1; c++) { d = c; while ( d > 0 && array[d] < array[d-1]) {
t          = array[d];
array[d]   = array[d-1];
array[d-1] = t;

d--;
}
}

printf("Sorted list in ascending order:n");

for (c = 0; c <= n - 1; c++) {
printf("%dn", array[c]);
}

return 0;
}

12.) Merge Sort in C using Arrays

Here is the source code for Merge sort in C using Arrays:

#include
#define MAX 50

void mergeSort(int arr[],int low,int mid,int high);
void partition(int arr[],int low,int high);

int main(){

int merge[MAX],i,n;

printf("Enter the total number of elements: ");
scanf("%d",&n);

printf("Enter the elements which to be sort: ");
for(i=0;i<n;i++){
scanf("%d",&merge[i]);
}

partition(merge,0,n-1);

printf("After merge sorting elements are: ");
for(i=0;i<n;i++){
printf("%d ",merge[i]);
}

return 0;
}

void partition(int arr[],int low,int high){

int mid;

if(low<high){
mid=(low+high)/2;
partition(arr,low,mid);
partition(arr,mid+1,high);
mergeSort(arr,low,mid,high);
}
}

void mergeSort(int arr[],int low,int mid,int high){

int i,m,k,l,temp[MAX];

l=low;
i=low;
m=mid+1;

while((l<=mid)&&(m<=high)){

if(arr[l]<=arr[m]){ temp[i]=arr[l]; l++; } else{ temp[i]=arr[m]; m++; } i++; } if(l>mid){
for(k=m;k<=high;k++){
temp[i]=arr[k];
i++;
}
}
else{
for(k=l;k<=mid;k++){
temp[i]=arr[k];
i++;
}
}

for(k=low;k<=high;k++){
arr[k]=temp[k];
}
}

13.) Quick Sort Implementation in C using Arrays

Below is the raw source code for Quick Sort implementation in C using Arrays:

#include

void quicksort(int [10],int,int);

int main(){
int x[20],size,i;

printf("Enter size of the array: ");
scanf("%d",&size);

printf("Enter %d elements: ",size);
for(i=0;i<size;i++)
scanf("%d",&x[i]);

quicksort(x,0,size-1);

printf("Sorted elements: ");
for(i=0;i<size;i++)
printf(" %d",x[i]);

return 0;
}

void quicksort(int x[10],int first,int last){
int pivot,j,temp,i;

if(first<last){
pivot=first;
i=first;
j=last;

while(i<j){
while(x[i]<=x[pivot]&&i<last) i++; while(x[j]>x[pivot])
j--;
if(i<j){
temp=x[i];
x[i]=x[j];
x[j]=temp;
}
}

temp=x[pivot];
x[pivot]=x[j];
x[j]=temp;
quicksort(x,first,j-1);
quicksort(x,j+1,last);

}
}

14.) Heap Sort Implementation in C using Arrays

Below is the source code for Heap Sort in C using Arrays:

#include
void main()

{

int heap[10], no, i, j, c, root, temp;

printf("n Enter no of elements :");

scanf("%d", &no);

printf("n Enter the nos : ");

for (i = 0; i < no; i++)

scanf("%d", &heap[i]);

for (i = 1; i < no; i++)

{

c = i;

do

{

root = (c - 1) / 2;

if (heap[root] < heap[c])   /* to create MAX heap array */

{

temp = heap[root];

heap[root] = heap[c];

heap[c] = temp;

}

c = root;

} while (c != 0);

}

printf("Heap array : ");

for (i = 0; i < no; i++) printf("%dt ", heap[i]); for (j = no - 1; j >= 0; j--)

{

temp = heap[0];

heap[0] = heap[j    /* swap max element with rightmost leaf element */

heap[j] = temp;

root = 0;

do

{

c = 2 * root + 1;    /* left node of root element */

if ((heap[c] < heap[c + 1]) && c < j-1)

c++;

if (heap[root]<heap[c] && c<j)    /* again rearrange to max heap array */

{

temp = heap[root];

heap[root] = heap[c];

heap[c] = temp;

}

root = c;

} while (c < j);

}

printf("n The sorted array is : ");

for (i = 0; i < no; i++)

printf("t %d", heap[i]);

printf("n Complexity : n Best case = Avg case = Worst case = O(n logn) n");

}

15.) Bubble Sort Implementation in C using Arrays

Below is the source code for bubble sort in C using Arrays:

#include

int main()
{
int array[100], n, c, d, swap;

printf("Enter number of elementsn");
scanf("%d", &n);

printf("Enter %d integersn", n);

for (c = 0; c < n; c++)
scanf("%d", &array[c]);

for (c = 0 ; c < ( n - 1 ); c++)
{
for (d = 0 ; d < n - c - 1; d++) { if (array[d] > array[d+1]) /* For decreasing order use < */
{
swap       = array[d];
array[d]   = array[d+1];
array[d+1] = swap;
}
}
}

printf("Sorted list in ascending order:n");

for ( c = 0 ; c < n ; c++ )
printf("%dn", array[c]);

return 0;
}

Advertisements

3 thoughts on “Data Structures in C Practicals and Why Colleges with their IDE’s are Outdated. A Wiser Proof of Concept.

  1. Pingback: C – Practical System Programming for Graphics in C. | Shritam Bhowmick

Looking for intellectual opinions. Feedbacks are welcome!

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s