Basic operation performed in graph

/*Basic operation performed in graph*/

#include <stdio.h>
#include <stdlib.h>

// A structure to represent an adjacency list node
struct AdjListNode
{
    int dest;
    struct AdjListNode* next;
};

// A structure to represent an adjacency list
struct AdjList
{
    struct AdjListNode *head;
};

// A structure to represent a graph. A graph
// is an array of adjacency lists.
// Size of array will be V (number of vertices
// in graph)
struct Graph
{
    int V;
    struct AdjList* array;
};

// A utility function to create a new adjacency list node
struct AdjListNode* newAdjListNode(int dest)
{
    struct AdjListNode* newNode =
     (struct AdjListNode*) malloc(sizeof(struct AdjListNode));
    newNode->dest = dest;
    newNode->next = NULL;
    return newNode;
}

// A utility function that creates a graph of V vertices
struct Graph* createGraph(int V)
{
    struct Graph* graph =
        (struct Graph*) malloc(sizeof(struct Graph));
    graph->V = V;

    // Create an array of adjacency lists.  Size of
    // array will be V
    graph->array =
      (struct AdjList*) malloc(V * sizeof(struct AdjList));

    // Initialize each adjacency list as empty by
    // making head as NULL
    int i;
    for (i = 0; i < V; ++i)
        graph->array[i].head = NULL;

    return graph;
}

// Adds an edge to an undirected graph
void addEdge(struct Graph* graph, int src, int dest)
{

    // Add an edge from src to dest.  A new node is  
        // added to the adjacency list of src.  The node
    // is added at the begining
    struct AdjListNode* newNode = newAdjListNode(dest);
    newNode->next = graph->array[src].head;
    graph->array[src].head = newNode;

    // Since graph is undirected, add an edge from
    // dest to src also
    newNode = newAdjListNode(src);
    newNode->next = graph->array[dest].head;
    graph->array[dest].head = newNode;
}

// A utility function to print the adjacency list
// representation of graph
void printGraph(struct Graph* graph)
{
    int v;
    for (v = 0; v < graph->V; ++v)
    {
        struct AdjListNode* pCrawl = graph->array[v].head;
        printf("\n Adjacency list of vertex %d\n head ", v);
        while (pCrawl)
        {
            printf("-> %d", pCrawl->dest);
            pCrawl = pCrawl->next;
        }
        printf("\n");
    }
}

// Driver program to test above functions
int main()
{
    // create the graph given in above fugure
    int V = 5;
    struct Graph* graph = createGraph(V);
    addEdge(graph, 0, 1);
    addEdge(graph, 0, 4);
    addEdge(graph, 1, 2);
    addEdge(graph, 1, 3);
    addEdge(graph, 1, 4);
    addEdge(graph, 2, 3);
    addEdge(graph, 3, 4);

    // print the adjacency list representation of the above graph
    printGraph(graph);

    return 0;
}

----------------------------------------------------------
OUTPUT:-
   

sk.

Depth First Search (DFS) Program in C

/*Depth First Search (DFS) Program in C */

#include<stdio.h>
void DFS(int);
int G[10][10],visited[10],n;    //n is no of vertices and graph is sorted in array G[10][10]
void main()
{
    int i,j;
    printf("Enter number of vertices:");
scanf("%d",&n);
    //read the adjecency matrix
printf("\nEnter adjecency matrix of the graph:");
for(i=0;i<n;i++)
       for(j=0;j<n;j++)
scanf("%d",&G[i][j]);
    //visited is initialized to zero
   for(i=0;i<n;i++)
        visited[i]=0;
    DFS(0);
}
void DFS(int i)
{
    int j;
printf("\n%d",i);
    visited[i]=1;

for(j=0;j<n;j++)
       if(!visited[j]&&G[i][j]==1)
            DFS(j);

}

----------------------------------------------------------
OUTPUT:-

sk.

C programming code for binary search

/*C programming code for binary search*/

#include <stdio.h>

 

int main()

{

   int c, first, last, middle, n, search, array[100];

 

   printf("Enter number of elements\n");

   scanf("%d",&n);

 

   printf("Enter %d integers\n", n);

 

   for (c = 0; c < n; c++)

      scanf("%d",&array[c]);

 

   printf("Enter value to find\n");

   scanf("%d", &search);

 

   first = 0;

   last = n - 1;

   middle = (first+last)/2;

 

   while (first <= last) {

      if (array[middle] < search)

         first = middle + 1;    

      else if (array[middle] == search) {

         printf("%d found at location    %d.\n", search, middle+1);

         break;

      }

      else

         last = middle - 1;

 

      middle = (first + last)/2;

   }

   if (first > last)

      printf("Not found! %d isn't present in the list.\n", search);

 

   return 0;  

}

----------------------------------------------------------

OUTPUT:-

sk.

Binary search tree

/*Binary search tree*/    


#include<stdio.h>
#include<stdlib.h> 
struct node
{
    int data;
    struct node* left;
    struct node* right;
};
struct node* createNode(value){
    struct node* newNode = malloc(sizeof(struct node));
    newNode->data = value;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
} 
struct node* insert(struct node* root, int data)
{
    if (root == NULL) return createNode(data);
    if (data < root->data)
        root->left  = insert(root->left, data);
    else if (data > root->data)
        root->right = insert(root->right, data); 
    return root;

}
void inorder(struct node* root){
    if(root == NULL) return;
    inorder(root->left);
    printf("%d ->", root->data);
    inorder(root->right);
}
int main(){
    struct node *root = NULL;
    root = insert(root, 8);
    insert(root, 3);
    insert(root, 1);
    insert(root, 6);
    insert(root, 7);
    insert(root, 10);
    insert(root, 14);
    insert(root, 4);
    inorder(root);
}

----------------------------------------------------------
OUTPUT:-

sk.

Insertion sort algorithm implementation in C

/*Insertion sort algorithm implementation in C*/

/* Insertion sort ascending order */

 

#include <stdio.h>

 

int main()

{

  int n, array[1000], c, d, t;

 

  printf("Enter number of elements\n");

  scanf("%d", &n);

 

  printf("Enter %d integers\n", 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-1] > array[d]) {

      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("%d\n", array[c]);

  }

 

  return 0;

}

----------------------------------------------------------

OUTPUT:-

sk.

Merge Sort Program in C

/*Merge Sort Program in C*/

#include <stdio.h>
#define max 10
int a[11] = { 10, 14, 19, 26, 27, 31, 33, 35, 42, 44, 0 };
int b[10];
void merging(int low, int mid, int high) {
   int l1, l2, i;
   for(l1 = low, l2 = mid + 1, i = low; l1 <= mid && l2 <= high; i++) {
      if(a[l1] <= a[l2])
         b[i] = a[l1++];
      else
         b[i] = a[l2++];
   }
   while(l1 <= mid)   
      b[i++] = a[l1++];
   while(l2 <= high) 
      b[i++] = a[l2++];
   for(i = low; i <= high; i++)
      a[i] = b[i];
}
void sort(int low, int high) {
   int mid;
 
   if(low < high) {
      mid = (low + high) / 2;
      sort(low, mid);
      sort(mid+1, high);
      merging(low, mid, high);
   } else {
      return;
   } 
}

int main()
{
     int i;
   printf("List before sorting\n");
   for(i = 0; i <= max; i++)
      printf("%d ", a[i]);
   sort(0, max);
   printf("\nList after sorting\n");
   for(i = 0; i <= max; i++)
      printf("%d ", a[i]);
}

----------------------------------------------------------
OUTPUT:-

sk.

Selection sort algorithm implementation in C

/*Selection sort algorithm implementation in C*/

#include <stdio.h>

 

int main()

{

  int array[100], n, c, d, position, swap;

 

  printf("Enter number of elements\n");

  scanf("%d", &n);

 

  printf("Enter %d integers\n", n);

 

  for (c = 0; c < n; c++)

    scanf("%d", &array[c]);

 

  for (c = 0; c < (n - 1); c++)

  {

    position = c;

   

    for (d = c + 1; d < n; d++)

    {

      if (array[position] > array[d])

        position = d;

    }

    if (position != c)

    {

      swap = array[c];

      array[c] = array[position];

      array[position] = swap;

    }

  }

 

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

 

  for (c = 0; c < n; c++)

    printf("%d\n", array[c]);

 

  return 0;

}

----------------------------------------------------------

OUTPUT:-

sk.

Program in C to implement all the operations of doubly linked list

/*Program in C to implement all the operations of doubly linked list*/

#include<stdio.h>  

#include<stdlib.h>  

struct node  

{  

    struct node *prev;  

    struct node *next;  

    int data;  

};  

struct node *head;  

void insertion_beginning();  

void insertion_last();  

void insertion_specified();  

void deletion_beginning();  

void deletion_last();  

void deletion_specified();  

void display();  

void search();  

void main ()  

{  

int choice =0;  

    while(choice != 9)  

    {  

        printf("\n*********Main Menu*********\n");  

        printf("\nChoose one option from the following list ...\n");  

        printf("\n===============================================\n");  

        printf("\n1.Insert in begining\n2.Insert at last\n3.Insert at any random location\n4.Delete from Beginning\n  

        5.Delete from last\n6.Delete the node after the given data\n7.Search\n8.Show\n9.Exit\n");  

        printf("\nEnter your choice?\n");  

        scanf("\n%d",&choice);  

        switch(choice)  

        {  

            case 1:  

            insertion_beginning();  

            break;  

            case 2:  

                    insertion_last();  

            break;  

            case 3:  

            insertion_specified();  

            break;  

            case 4:  

            deletion_beginning();  

            break;  

            case 5:  

            deletion_last();  

            break;  

            case 6:  

            deletion_specified();  

            break;  

            case 7:  

            search();  

            break;  

            case 8:  

            display();  

            break;  

            case 9:  

            exit(0);  

            break;  

            default:  

            printf("Please enter valid choice..");  

        }  

    }  

}  

void insertion_beginning()  

{  

   struct node *ptr;   

   int item;  

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

   if(ptr == NULL)  

   {  

       printf("\nOVERFLOW");  

   }  

   else  

   {  

    printf("\nEnter Item value");  

    scanf("%d",&item);  

      

   if(head==NULL)  

   {  

       ptr->next = NULL;  

       ptr->prev=NULL;  

       ptr->data=item;  

       head=ptr;  

   }  

   else   

    {  

       ptr->data=item;  

       ptr->prev=NULL;  

       ptr->next = head;  

       head->prev=ptr;  

       head=ptr;  

   }  

   printf("\nNode inserted\n");  

}  

     

}  

void insertion_last()  

{  

   struct node *ptr,*temp;  

   int item;  

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

   if(ptr == NULL)  

   {  

       printf("\nOVERFLOW");  

   }  

   else  

   {  

       printf("\nEnter value");  

       scanf("%d",&item);  

        ptr->data=item;  

       if(head == NULL)  

       {  

           ptr->next = NULL;  

           ptr->prev = NULL;  

           head = ptr;  

       }  

       else  

       {  

          temp = head;  

          while(temp->next!=NULL)  

          {  

              temp = temp->next;  

          }  

          temp->next = ptr;  

          ptr ->prev=temp;  

          ptr->next = NULL;  

          }  

             

       }  

     printf("\nnode inserted\n");  

    }  

void insertion_specified()  

{  

   struct node *ptr,*temp;  

   int item,loc,i;  

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

   if(ptr == NULL)  

   {  

       printf("\n OVERFLOW");  

   }  

   else  

   {  

       temp=head;  

       printf("Enter the location");  

       scanf("%d",&loc);  

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

       {  

           temp = temp->next;  

           if(temp == NULL)  

           {  

               printf("\n There are less than %d elements", loc);  

               return;  

           }  

       }  

       printf("Enter value");  

       scanf("%d",&item);  

       ptr->data = item;  

       ptr->next = temp->next;  

       ptr -> prev = temp;  

       temp->next = ptr;  

       temp->next->prev=ptr;  

       printf("\nnode inserted\n");  

   }  

}  

void deletion_beginning()  

{  

    struct node *ptr;  

    if(head == NULL)  

    {  

        printf("\n UNDERFLOW");  

    }  

    else if(head->next == NULL)  

    {  

       head = NULL;   

        free(head);  

        printf("\nnode deleted\n");  

    }  

    else  

    {  

        ptr = head;  

        head = head -> next;  

        head -> prev = NULL;  

        free(ptr);  

        printf("\nnode deleted\n");  

    }  

  

}  

void deletion_last()  

{  

    struct node *ptr;  

    if(head == NULL)  

    {  

        printf("\n UNDERFLOW");  

    }  

    else if(head->next == NULL)  

    {  

        head = NULL;   

        free(head);   

        printf("\nnode deleted\n");  

    }  

    else   

    {  

        ptr = head;   

        if(ptr->next != NULL)  

        {  

            ptr = ptr -> next;   

        }  

        ptr -> prev -> next = NULL;   

        free(ptr);  

        printf("\nnode deleted\n");  

    }  

}  

void deletion_specified()  

{  

    struct node *ptr, *temp;  

    int val;  

    printf("\n Enter the data after which the node is to be deleted : ");  

    scanf("%d", &val);  

    ptr = head;  

    while(ptr -> data != val)  

    ptr = ptr -> next;  

    if(ptr -> next == NULL)  

    {  

        printf("\nCan't delete\n");  

    }  

    else if(ptr -> next -> next == NULL)  

    {  

        ptr ->next = NULL;  

    }  

    else  

    {   

        temp = ptr -> next;  

        ptr -> next = temp -> next;  

        temp -> next -> prev = ptr;  

        free(temp);  

        printf("\nnode deleted\n");  

    }     

}  

void display()  

{  

    struct node *ptr;  

    printf("\n printing values...\n");  

    ptr = head;  

    while(ptr != NULL)  

    {  

        printf("%d\n",ptr->data);  

        ptr=ptr->next;  

    }  

}   

void search()  

{  

    struct node *ptr;  

    int item,i=0,flag;  

    ptr = head;   

    if(ptr == NULL)  

    {  

        printf("\nEmpty List\n");  

    }  

    else  

    {   

        printf("\nEnter item which you want to search?\n");   

   scanf("%d",&item);  

        while (ptr!=NULL)  

        {  

            if(ptr->data == item)  

            {  

                printf("\nitem found at location %d ",i+1);  

                flag=0;  

                break;  

            }   

            else  

            {  

                flag=1;  

            }  

            i++;  

            ptr = ptr -> next;  

        }  

        if(flag==1)  

        {  

            printf("\nItem not found\n");  

        }  

    }     

          

}  

----------------------------------------------------------

OUTPUT:-

sk.

Program to delete node of Linked List

/*Program to delete node of Linked List*/

/**
 * C program to delete first node from Singly Linked List
 */

#include <stdio.h>
#include <stdlib.h>


/* Structure of a node */
struct node {
    int data;          // Data
    struct node *next; // Address
}*head;


void createList(int n);
void deleteFirstNode();
void displayList();



int main()
{
    int n, choice;

    /*
     * Create a singly linked list of n nodes
     */
    printf("Enter the total number of nodes: ");
    scanf("%d", &n);

    createList(n);
    printf("\nData in the list \n");
    displayList();

    printf("\nPress 1 to delete first node: ");
    scanf("%d", &choice);

    /* Delete first node from list */
    if(choice == 1)
        deleteFirstNode();

    printf("\nData in the list \n");
    displayList();

    return 0;
}


/*
 * Create a list of n nodes
 */
void createList(int n)
{
    struct node *newNode, *temp;
    int data, i;

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

    /*
     * If unable to allocate memory for head node
     */
    if(head == NULL)
    {
      printf("Unable to allocate memory.");
    }
    else
    {
        /*
         * In data of node from the user
         */
        printf("Enter the data of node 1: ");
        scanf("%d", &data);

        head->data = data; // Link the data field with data
        head->next = NULL; // Link the address field to NULL

        temp = head;

        /*
         * Create n nodes and adds to linked list
         */
        for(i=2; i<=n; i++)
        {
            newNode = (struct node *)malloc(sizeof(struct node));

            /* If memory is not allocated for newNode */
            if(newNode == NULL)
            {
                printf("Unable to allocate memory.");
                break;
            }
            else
            {
                printf("Enter the data of node %d: ", i);
                scanf("%d", &data);
               newNode->data = data; // Link the data field of newNode with data
                newNode->next = NULL; // Link the address field of newNode with NULL

                temp->next = newNode; // Link previous node i.e. temp to the newNode
                temp = temp->next;
            }
        }

        printf("SINGLY LINKED LIST CREATED SUCCESSFULLY\n");
    }
}


/*
 * Deletes the first node of the linked list
 */
void deleteFirstNode()
{
    struct node *toDelete;

    if(head == NULL)
    {
        printf("List is already empty.");
    }
    else
    {
        toDelete = head;
        head = head->next;

        printf("\nData deleted = %d\n", toDelete->data);

        /* Clears the memory occupied by first node*/
        free(toDelete);
       printf("SUCCESSFULLY DELETED FIRST NODE FROM LIST\n");
    }
}


/*
 * Displays the entire list
 */
void displayList()
{
    struct node *temp;

    /*
     * If the list is empty i.e. head = NULL
     */
    if(head == NULL)
    {
        printf("List is empty.");
    }
    else
    {
        temp = head;
        while(temp != NULL)
        {
            printf("Data = %d\n", temp->data); // Print data of current node
            temp = temp->next;                 // Move to next node
        }
    }
}

----------------------------------------------------------OUTPUT:-

sk.

Program to insert node at the beginning of singly linked list

/*Program to insert node at the beginning of singly linked list*/

/**
 * C program to insert a new node at the beginning of a Singly Linked List
 */

#include <stdio.h>
#include <stdlib.h>


/* Structure of a node */
struct node {
    int data;          // Data
    struct node *next; // Address
}*head;


void createList(int n);
void insertNodeAtBeginning(int data);
void displayList();


int main()
{
    int n, data;

    /*
     * Create a singly linked list of n nodes
     */
    printf("Enter the total number of nodes: ");
    scanf("%d", &n);

    createList(n);
    printf("\nData in the list \n");
    displayList();

    /*
     * Insert data at the beginning of the singly linked list
     */
    printf("\nEnter data to insert at beginning of the list: ");
    scanf("%d", &data);
    insertNodeAtBeginning(data);

    printf("\nData in the list \n");
    displayList();

    return 0;
}


/*
 * Create a list of n nodes
 */
void createList(int n)
{
    struct node *newNode, *temp;
    int data, i;

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

    /*
     * If unable to allocate memory for head node
     */
    if(head == NULL)
    {
      printf("Unable to allocate memory.");
    }
    else
    {
        /*
         * Input data of node from the user
         */
        printf("Enter the data of node 1: ");
        scanf("%d", &data);

        head->data = data; // Link data field with data
        head->next = NULL; // Link address field to NULL

        temp = head;

        /*
         * Create n nodes and adds to linked list
         */
        for(i=2; i<=n; i++)
        {
            newNode = (struct node *)malloc(sizeof(struct node));

            /* If memory is not allocated for newNode */
            if(newNode == NULL)
            {
                printf("Unable to allocate memory.");
                break;
            }
            else
            {
                printf("Enter the data of node %d: ", i);
                scanf("%d", &data);
      newNode->data = data; // Link data field of newNode with data
                newNode->next = NULL; // Link address field of newNode with NULL

                temp->next = newNode; // Link previous node i.e. temp to the newNode
             
                temp = temp->next;
            }
        }

        printf("SINGLY LINKED LIST CREATED SUCCESSFULLY\n");
    }
}


/*
 * Create a new node and inserts at the beginning of the linked list.
 */
void insertNodeAtBeginning(int data)
{
    struct node *newNode;

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

    if(newNode == NULL)
    {
        printf("Unable to allocate memory.");
    }
    else
    {
        newNode->data = data; // Link data part
        newNode->next = head; // Link address part

 head = newNode;          // Make newNode as first node

printf("DATA INSERTED SUCCESSFULLY\n");
    }
}


/*
 * Display entire list
 */
void displayList()
{
    struct node *temp;

    /*
     * If the list is empty i.e. head = NULL
     */
    if(head == NULL)
    {
        printf("List is empty.");
    }
    else
    {
        temp = head;
        while(temp != NULL)
        {
            printf("Data = %d\n", temp->data); // Print data of current node
            temp = temp->next;                 // Move to next node
        }
    }
}

----------------------------------------------------------
OUTPUT:-

sk.

search in unsorted linked list in c

/*search in unsorted linked list in c*/

/*
 * C Program to Search for an Element in the Linked List without 
 * using Recursion
 */

#include <stdio.h>
#include <stdlib.h>

struct node
{
    int a;
    struct node *next;
};

void generate(struct node **, int);
void search(struct node *, int);
void delete(struct node **);

int main()
{
    struct node *head = NULL;
    int key, num;

    printf("Enter the number of nodes: ");
    scanf("%d", &num);
    printf("\nDisplaying the list\n");
    generate(&head, num);
    printf("\nEnter key to search: ");
    scanf("%d", &key);
    search(head, key);

    delete(&head);
return 0;
}

void generate(struct node **head, int num)
{
    int i;
    struct node *temp;

    for (i = 0; i < num; i++)
    {
        temp = (struct node *)malloc(sizeof(struct node));
        temp->a = rand() % num;
        if (*head == NULL)
        {
            *head = temp;
            temp->next = NULL;
        }
        else
        {
            temp->next = *head;
            *head = temp;
        }
        printf("%d  ", temp->a);
    }
}

void search(struct node *head, int key)
{
    while (head != NULL)
    {
        if (head->a == key)
        {
            printf("key found\n");
           return;
        }
        head = head->next;
    }
    printf("Key not found\n");
}

void delete(struct node **head)
{
    struct node *temp;

    while (*head != NULL)
    {
        temp = *head;
        *head = (*head)->next;
        free(temp);
    }
}

----------------------------------------------------------
OUTPUT:-

sk.

Circular Queue

/*Circular Queue*/

#include <stdio.h>

#define MAX 5

/*Declaration of circular queue.*/

typedef struct

{

    int front   ;

    int rear    ;

    int count   ;

    int ele[MAX]    ;

}CirQueue;

/*Initailization of circular queue.*/

void initCirQueue(CirQueue * q)

{

    q->front =  0;

    q->rear  = -1;

    q->count =  0;

}

/*Check Queue is full or not*/

int isFull(CirQueue * q)

{

    int full=0;

     

    if(q->count == MAX)

        full = 1;   

    return full;

}

/*Check Queue is empty or not*/

int isEmpty(CirQueue * q)

{

    int empty=0;

     

    if(q->count == 0)

        empty = 1;  

    return empty;

}

/*To insert item into circular queue.*/

void insertCirQueue(CirQueue * q, int item)

{

    if( isFull(q) )

    {

        printf("\nQueue Overflow");

        return;

    }

     

    q->rear = (q->rear+1)%MAX;

    q->ele[q->rear] = item;

     

    q->count++;

  

    printf("\nInserted item : %d",item);

/*To delete item from queue.*/

int deleteCirQueue(CirQueue * q, int *item)

{

    if( isEmpty(q) )

    {

        printf("\nQueue Underflow");

        return -1;

    }

    *item    = q->ele[q->front];

    q->front = (q->front+1)%MAX;

     

    q->count--;

    return 0;

}

int main()

{

    int item=0;

    CirQueue q;

    initCirQueue(&q);

    insertCirQueue(&q, 10); 

    insertCirQueue(&q, 20);

    insertCirQueue(&q, 30);

    insertCirQueue(&q, 40);

    insertCirQueue(&q, 50);

    insertCirQueue(&q, 60);

    if ( deleteCirQueue( &q, &item ) == 0 )

        printf("\nDeleted item is : %d",item);

     

    if ( deleteCirQueue( &q, &item ) == 0 )

        printf("\nDeleted item is : %d",item);

     

    if ( deleteCirQueue( &q, &item ) == 0 )

        printf("\nDeleted item is : %d",item);

     

    if ( deleteCirQueue( &q, &item ) == 0 )

        printf("\nDeleted item is : %d",item);

     

    if ( deleteCirQueue( &q, &item ) == 0 )

        printf("\nDeleted item is : %d",item);

    insertCirQueue(&q, 60);

     

    if ( deleteCirQueue( &q, &item ) == 0 )

        printf("\nDeleted item is : %d",item);

    if ( deleteCirQueue( &q, &item ) == 0 )

printf("\nDeleted item is : %d",item);

    printf("\n");

    return 0;   

}

----------------------------------------------------------

OUTPUT:-

sk.

Quick Sort Using Array

/*Quick Sort Using Array*/

#include<stdio.h>

void quicksort(int number[25],int first,int last){

   int i, j, pivot, temp;

   if(first<last){

      pivot=first;

      i=first;

      j=last;

      while(i<j){

         while(number[i]<=number[pivot]&&i<last)

            i++;

         while(number[j]>number[pivot])

            j--;

         if(i<j){

            temp=number[i];

            number[i]=number[j];

            number[j]=temp;

         }

      }

      temp=number[pivot];

      number[pivot]=number[j];

      number[j]=temp;

      quicksort(number,first,j-1);

      quicksort(number,j+1,last);

   }

}

int main(){

   int i, count, number[25];

printf("How many elements are u going to enter?: ");

   scanf("%d",&count);

  printf("Enter %d elements: ", count);

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

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

    quicksort(number,0,count-1);

   printf("Order of Sorted elements: ");

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

      printf(" %d",number[i]);

  return 0;

}

----------------------------------------------------------

OUTPUT:-

sk.

Convert infix expression into postfix

/*Convert infix expression into postfix*/

#include<stdio.h>

#include<string.h>

char stack[50];

int top=-1;

void post(char infix[]);

void push(char);

char pop();

void main()

{

    char infix[25];

    printf("\nENTER THE INFIX EXPRESSION = ");

    gets(infix);

    post(infix);

    getch();

}

void push(char symb)

{

    if(top>=49)

    {

          printf("\nSTACK OVERFLOW");

         getch();

         return;

    }

    else

    {

          top=top+1;

         stack[top]=symb;

    }

}

char pop()

{

     char item;

     if(top==-1)

     {

            printf("\nSTACK IS EMPTY");

            getch();

            return(0);

      }

      else

     {

            item=stack[top];

            top--;

     }

     return(item);

}

int preced(char ch)

{

      if(ch==47)

      {

             return(5);

      }

      else if(ch==42)

      {

            return(4);

      }

      else if(ch==43)

      {

             return(3);

      }

      else

      return(2);

}

void post(char infix[])

{

      int l;

      int index=0,pos=0;

      char symbol,temp;

      char postfix[40];

      l=strlen(infix);

      push('#');

      while(index<l)

      {

             symbol=infix[index];

             switch(symbol)

             {

                    case '(': push(symbol);

                    break;

                    case ')': temp=pop();

                    while(temp!='(')

                    {

                            postfix[pos]=temp;

                            pos++;

                            temp=pop();

                    }

                    break;

                    case '+':

                    case '-':

                    case '*':

                    case '/':

                    case '^':

                    while(preced(stack[top])>=preced(symbol))

                    {

                            temp=pop();

                            postfix[pos]=temp;

                            pos++;

                    }

                    push(symbol);

                    break;

          default: postfix[pos++]=symbol;

                    break;

            }

            index++;

      }

      while(top>0)

      {

               temp=pop();

               postfix[pos++]=temp;

      }

       postfix[pos++]='\0';

       puts(postfix);

       return;

}

----------------------------------------------------------
OUTPUT:-

sk.

C program to implement a queue using linked list

/*C program to implement a queue using linked list*/

#include<stdio.h>

void enq();

void deq();

void display();

main()

 {

 int n;

 printf("\tMENU\n1.ENQUEUE\n2.DEQUEUE\n3.DISPLAY\n4.EXIT\n");

 do

  {

  printf("\nEnter your choice\n");

  scanf("%d",&n);

  switch(n)

   {

   case 1:

   enq();

   break;

   case 2:

   deq();

   break;

   case 3:

   display();

   break;

   case 4:

   break;

   default:

   printf("Invalid choice\n");

   break;

   }

  }

 while(n!=4);

 }

typedef struct node

 {

 int data;

 struct node *link;

 }n;

n *front=NULL;

n *rear=NULL;

void enq()

 {

 int item;

 n *temp;

 printf("Enter the item\n");

 scanf("%d",&item);

 temp=(n*)malloc(sizeof(n));

 temp->data=item;

 temp->link=NULL;

 if(rear==NULL)

  {

  front=temp;

  rear=temp;

  }

 else

  {

  rear->link=temp;

  rear=temp;

  }

 }

void deq()

 {

 int item;

 if(front==NULL)

 printf("Queue is empty\n");

 else

  {

  item=front->data;

  printf("The element deleted = %d\n",item);

  }

 if(front==rear)

  {

  front=NULL;

  rear=NULL;

  }

 else

 front=front->link;

 }

void display()

 {

 n *ptr;

 if(front==NULL)

 printf("Queue is empty\n");

 else

  {

  ptr=front;

  printf("The elements of the queue are :");

  while(ptr!=NULL)

   {

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

   ptr=ptr->link;

   }

  }

 }

----------------------------------------------------------

OUTPUT:-

 

sk.

C Program to implement Queue

/*C Program to implement Queue*/

include<conio.h>
#include<stdio.h>
#define max 5
int queue[max],front=0,rear=0;
int menu();
void enqueue();
void dequeue();
void display();
void main()
{
int ch;
clrscr();
printf("\nProgrammingUnit.com - Free Source Codes\n");
printf("\nQueues using Arrays\n");
do
{
    ch=menu();
    switch(ch)
    {
    case 1: enqueue();
    break;
    case 2: dequeue();
    break;
    case 3: display();
    break;
    case 4: exit();
    break;
    default:printf("\n Please enter a valid choice!!");
    }
}while(1);
}

int menu()
    {
    int ch;
    printf("\n1.ENQUEUE \n2.DEQUEUE \n3.DISPLAY \n4.EXIT");
    printf("\nEnter your Choice:");
    scanf("%d",&ch);
    return ch;
    }

void enqueue()
{
    int element;
    if(rear==max)
    {
        printf("\nOverflow!!");
    }
    else
    {
        printf("\nEnter Element:");
        scanf("%d",&element);
        queue[rear++]=element;
        printf("\n %d Enqueued at %d",element,rear);
    }

}

void dequeue()
{
    if(rear==front)
    {
        printf("\nUnderflow!!");
    }
    else
    {
        front++;
        printf("\nElement is Dequeued from %d",front);
    }
}
void display()
{
    int i;
    if(front==rear)
    {
        printf("\nQueue is Empty!!!");
    }
    else
    {
        printf(" \n");
        for(i=front;i<max;i++)
        {
            printf(" | %d ",queue[i]);
        }
            printf("|");
    }
}

----------------------------------------------------------
OUTPUT:-

sk.

sk.

Implement stack using Linked List - C Program

/*Implement stack using Linked List - C Program*/

#include<stdio.h>
#include<malloc.h>
typedef struct node
{
    char s_name[20],s_address[50];
    int s_marks;
    struct node *next;
}s;
s *push(s*);
s *pop(s *);
void display(s *);
int main()
{
    s *top=NULL;
    int ch,x,c=0;
    printf("Enter 1 for push\n");
    printf("Enter 2 for pop\n");
    printf("Enter 3 for display\n");
    do
    {
         printf("Enter your choice: ");
         scanf("%d",&ch);
         switch(ch)
         {
             case 1:
             top=push(top);
             break;
             case 2:
             top=pop(top);
             break;
             case 3:
             display(top);
             break;
         }
         printf("do you want to continuoe press 1: ");
         scanf("%d",&c);
     }while(c==1);
}
s *push(s *top)
{
    s *p;
    p=(s *)malloc(sizeof(s));
    if(p==NULL)
    {
        printf("no memory allocated");
    }
    else
    {
        printf("\nEnter the student name: ");
        scanf("%s",&p->s_name);

        printf("Enter student address: ");
        scanf("%s",&p->s_address);
        printf("Enter the marks of students: ");
        scanf("%d",&p->s_marks);
        p->next=top;
        top=p;
    }
    return(top);
}
s *pop(s *top)
{
   s *p;
   if(top==NULL)
   {
       printf("nothing to pop");
   }
   else
   {
       printf("\nThe student name is: %s",top->s_name);
       printf("\nThe student address is: %s",top->s_address);
       printf("\nThe marks of the student is: %d",top->s_marks);
       top=top->next;
   }
   return(top);
}
void display(s *top)
{
    if(top==NULL)
    {
        printf("nothing to display");
    }
    else
    {
        while(top!=NULL)
        {
             printf("\nThe student name is: %s",top->s_name);
             printf("\nThe student address is: %s",top->s_address);
             printf("\nThe marks of the student is: %d",top->s_marks);
             top=top->next;
         }
     }
}

----------------------------------------------------------
OUTPUT:-

sk.

C program to implement stack data structure

/*C program to implement stack data structure*/

#include<stdio.h>

int stack[100],choice,n,top,x,i;

void push(void);

void pop(void);

void display(void);

int main()

{

    //clrscr();

    top=-1;

    printf("\n Enter the size of STACK[MAX=100]:");

    scanf("%d",&n);

    printf("\n\t STACK OPERATIONS USING ARRAY");

    printf("\n\t--------------------------------");

    printf("\n\t 1.PUSH\n\t 2.POP\n\t 3.DISPLAY\n\t 4.EXIT");

    do

    {

        printf("\n Enter the Choice:");

        scanf("%d",&choice);

        switch(choice)

        {

            case 1:

            {

                push();

                break;

            }

            case 2:

            {

                pop();

                break;

            }

            case 3:

            {

                display();

                break;

            }

            case 4:

            {

                printf("\n\t EXIT POINT ");

                break;

            }

            default:

            {

                printf ("\n\t Please Enter a Valid Choice(1/2/3/4)");

            }

                 

        }

    }

    while(choice!=4);

    return 0;

}

void push()

{

    if(top>=n-1)

    {

        printf("\n\tSTACK is over flow");

         

    }

    else

    {

        printf(" Enter a value to be pushed:");

        scanf("%d",&x);

        top++;

        stack[top]=x;

    }

}

void pop()

{

    if(top<=-1)

    {

        printf("\n\t Stack is under flow");

    }

    else

    {

        printf("\n\t The popped elements is %d",stack[top]);

        top--;

    }

}

void display()

{

    if(top>=0)

    {

        printf("\n The elements in STACK \n");

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

            printf("\n%d",stack[i]);

        printf("\n Press Next Choice");

    }

    else

    {

        printf("\n The STACK is empty");

    }

    

}

----------------------------------------------------------

OUTPUT:-

       "FOR OUTPUT GO NEXT PAGE"   

C program for bubble sort

/*C program for bubble sort*/

#include <stdio.h>

int main()

{

  int array[100], n, c, d, swap;

  printf("Enter number of elements\n");

  scanf("%d", &n);

  printf("Enter %d integers\n", 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("%d\n", array[c]);

  return 0;

}

----------------------------------------------------------

OUTPUT:-

sk.

C program for binary search

/*C program for binary search*/

#include <stdio.h>

int main()

{

   int c, first, last, middle, n, search, array[100];

   printf("Enter number of elements\n");

   scanf("%d",&n);

   printf("Enter %d integers\n", n);

   for (c = 0; c < n; c++)

      scanf("%d",&array[c]);

   printf("Enter value to find\n");

   scanf("%d", &search);

   first = 0;

   last = n - 1;

   middle = (first+last)/2;

   while (first <= last) {

      if (array[middle] < search)

         first = middle + 1;    

      else if (array[middle] == search) {

         printf("%d found at location %d.\n", search, middle+1);

         break;

      }

      else

         last = middle - 1;

      middle = (first + last)/2;

   }

   if (first > last)

      printf("Not found! %d isn't present in the list.\n", search);

   return 0;  

}

----------------------------------------------------------

OUTPUT:-

sk.