STACK IMPLEMENTATION USING LINKED LIST


DYNAMIC IMPLEMENTATION OF STACK
      In computer science,  a stack is a last in, first out  (LIFO)  abstract data type and linear data structure.  A stack can have any  abstract data type  as an element, but is characterized by two fundamental operations,  called push and pop (or pull). The push operation adds a new item to the top of the stack,  or initializes the stack if it is empty.  If the stack is full and does not contain enough space to accept the given item,  the stack is then considered to be in an overflow state. The pop operation removes an item from the top of the stack.  A pop either reveals previously concealed items, or  esults in an empty stack, but if the stack is empty then it goes into underflow state (It means no items are present in stack to be removed).  A stack pointer is the register which holds the value of the stack.  The stack pointer always points to the top value of the stack.
A stack is a restricted data structure, because only a small number of operations are performed on it. The nature of the pop and push operations also means that stack elements have a natural order. Elements are removed from the stack in the reverse order to the order of their addition: therefore, the lower elements are those that have been on the stack the longest.
[Ref: wikipedia.org]

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



typedef struct ll
{
int digit ;
struct ll *next ;
}mynode ;
mynode *head,*new1,*prev ;

void addnode(mynode **hd,int data) ;
void deletenode(mynode **hd) ;
void traverse(mynode *hd) ;
void searchnode(mynode *hd,int data) ;

void main()
{
int data,choice ;
clrscr() ;
head = (mynode*)malloc(sizeof(mynode)) ;
head->next = NULL ;
while(1)
            {
                printf("\n1.ADD NODE") ;
                printf("\n2.DELETE NODE") ;
                printf("\n3.TRAVERSE LIST") ;
                printf("\n4.SEARCH NODE") ;
                printf("\n5.EXIT") ;
                printf("\nENTER CHOICE :  ") ;
                scanf("%d",&choice) ;

                switch(choice)
                            
                         {
                               case 1:        printf("\nEnter The Number : ") ;
                                                    scanf("%d",&data) ;
                                                    addnode(&head,data) ;
                                                    break ;
     
                               case 2:        deletenode(&head) ;
                                                    break ;

                               case 3:        traverse(head) ;
                                                    break ;

                               case 4:        printf("\nEnter Data To Be Searched : ") ;
                                                    scanf("%d",&data) ;
                                                   searchnode(head,data) ;
                                                    break ;

                               case 5:       printf("Thank's For Using Me !! Good Bye %c !!",1) ;
                                                   getch() ;

   exit(0) ;

                              default:        printf("\nInvalid Choice Re-Enter :  ") ;
                                                   break ;
                            }//switch
             } //while
}

void addnode(mynode **hd , int data)
{
     clrscr() ;
     new1 = (mynode*)malloc(sizeof(mynode)) ;
     new1->digit = data ;

     if((*hd)->next==NULL)
       {
           new1->next=*hd ;
           printf("\nFirst Node With Data %d Is Added",data) ;
           (*hd)=new1 ;
           return ;
       }//if

     new1->next = *hd ;
     printf("\nNode With Value %d Is Added ",data) ;
     (*hd) = new1 ;
}

void deletenode(mynode **hd)
{
     clrscr() ;
     prev = *hd ;
     
     if((*hd)->next == NULL)
        {
            printf("\nNothing Is In List Enter Some Data First") ;
            return ;
        }//if

    *hd = (*hd)->next ;
      printf("Node With Data %d Is Deleted",prev->digit) ;
     free(prev) ;
}

void traverse(mynode *hd)
{
     clrscr() ;
     
     if(hd->next==NULL)
        {
             printf("\nNothing Found Enter Some Data First ") ;
             return ;
        }//if

      printf("\nFollowing Data Are Found\n") ;
      while(hd->next != NULL)
           {
              printf("%d,",hd->digit) ;
              hd = hd->next ;
           }//while
}

void searchnode(mynode *hd,int data)
{
     clrscr() ;
     
     if((hd)->next==NULL)
       {
           printf("\nNothing Found List Is Empty") ;
           return ;
       }//if

     while((hd)->next!=NULL)
       {
          if((hd)->digit==data)
            {
               
               printf("\nData %d Is Found",data) ;
               return ;
            
             }//if

            hd=hd->next ;
       
       }//while

     printf("\nData %d Is Not Found ",data) ;
}
Location: Agra, Uttar Pradesh, India

Comments

Post a Comment

Popular posts from this blog

Program To Evaluate Square Root Of A Number

Program To Evaluate Square Root Of A Number :- #include<stdio.h> #include<conio.h> void main() { float a,q,b,i; clrscr(); printf("Enter Any Number : "); scanf("%f",&q); a=b=q/2; for(i=0;i<50;i++) { b=((a+(q/b))/2); a=b; } printf("The Square Root Of %f Is -> %f",q,b); getch(); }                              THIS EVALUATION  IS BASED ON BABYLONIAN METHOD Square roots by Divide-and-Average This method dating back to the Babylonians (1700 B.C.) is known as the Babylonian Algorithm. If A > 0 is a guess of the square root of the positive number Q, then a better approximation to √Q is given by B = (A + Q/A)/2. Now you use B as an approximation and compute C = (B + Q/B)/2, and so on to get as close as you want to the value of √Q. We have shown elsewhere why the Babylonian Algorithm works. Examp...
Read more

TIC-TAC-TOE THROUGH C

IMPLEMENTATION OF TIC-TAC-TOE THROUGH C :- From Wikipedia, the free encyclopedia. Tic-tac-toe, originally called noughts and crosses (and still known as this in Britain and Australia), Xs and Os (in Ireland) and X and 0 (in India) is a pencil-and-paper game for two players, X and O, who take turns marking the spaces in a 3×3 grid. The player who succeeds in placing three respective marks in a horizontal, vertical, or diagonal row wins the game. The following example game is won by the first player, X: Players soon discover that best play from both parties leads to a draw (often referred to as cat or cat's game). Hence, tic-tac-toe is most often played by young children. The friendliness of tic-tac-toe games makes them ideal as a pedagogical tool for teaching the concepts of good sportsmanship and the branch of artificial intelligence that deals with the searching of game trees. It is straightforward to write a computer program to play tic-tac-toe perfectly,...
Read more

LINKED LIST IMPLEMENTATION FOR GAME BATTLESHIP THROUGH C

LINKED LIST IMPLEMENTATION FOR GAME BATTLESHIP THROUGH C The game is played on four  grids , two for each player. The grids are typically square – usually 10×10 – and the individual squares in the grid are identified by letter and number. On one grid the player arranges ships and records the shots by the opponent. On the other grid the player records his/her own shots. Before play begins, each player secretly arranges their ships on their primary grid. Each ship occupies a number of consecutive squares on the grid, arranged either horizontally or vertically. The number of squares for each ship is determined by the type of the ship. The ships cannot overlap (i.e., only one ship can occupy any given square in the grid). The types and numbers of ships allowed are the same for each player. These may vary depending on the rules. REF:-  http://en.wikipedia.org/wiki/Battleship_(game) I have used Linked List For It's Implementation One Can Use Array too.....  _...
Read more