STACK
------------------------------------------------------------
PUSH(S,TOP,X)
STEP-1 [cheak for overflow]
if TOP≥N
then write('overflow')
take action in respnce to underflow
exit.
STEP-2 [Increament TOP pointer]
TOP<--TOP+1.
STEP-3 [Insert element]
S[TOP]<--X.
STEP-4 [Finished]
finish.
=========================================================================================================
POP(S,TOP)
STEP-1 [cheak for underflow]
if TOP=0,
then write('STACK UNDERFLOW ON TOP')
take action in respnce to underflow
exit.
STEP-2 [Decreament TOP pointer]
TOP<--TOP-1.
STEP-3 [Remove element]
return (S[TOP+1]).
=========================================================================================================
PEEP(S,TOP,I)
STEP-1 [cheak for underflow]
if TOP-I+1≤0
then write('STACK UNDERFLOW ON PEEP'),
take action in respnce to underflow
exit.
STEP-2 [return Ith element from TOP of STACK]
return(S[TOP-I+1]).
=========================================================================================================
CHANGE(S,TOP,X,I)
STEP-1 [Cheak for underflow]
if TOP-I+1≤0
then write ('STACK UNDERFLOW ON CHANGE'),
STEP-2 [CHANGE Ih element from TOP of the STACK]
S[TOP-I+1]<--X.
STEP-3 [finished]
return.
========================================================================================
STEP-1 [cheak for overflow]
if TOP≥N
then write('overflow')
take action in respnce to underflow
exit.
STEP-2 [Increament TOP pointer]
TOP<--TOP+1.
STEP-3 [Insert element]
S[TOP]<--X.
STEP-4 [Finished]
finish.
=========================================================================================================
POP(S,TOP)
STEP-1 [cheak for underflow]
if TOP=0,
then write('STACK UNDERFLOW ON TOP')
take action in respnce to underflow
exit.
STEP-2 [Decreament TOP pointer]
TOP<--TOP-1.
STEP-3 [Remove element]
return (S[TOP+1]).
=========================================================================================================
PEEP(S,TOP,I)
STEP-1 [cheak for underflow]
if TOP-I+1≤0
then write('STACK UNDERFLOW ON PEEP'),
take action in respnce to underflow
exit.
STEP-2 [return Ith element from TOP of STACK]
return(S[TOP-I+1]).
=========================================================================================================
CHANGE(S,TOP,X,I)
STEP-1 [Cheak for underflow]
if TOP-I+1≤0
then write ('STACK UNDERFLOW ON CHANGE'),
STEP-2 [CHANGE Ih element from TOP of the STACK]
S[TOP-I+1]<--X.
STEP-3 [finished]
return.
========================================================================================
RECOGNIZE
------------------------------------------------------------------------------
STEP-1 [Initialize STACK by placing a letter 'C' on the TOP]
TOP<--1
S[TOP]<--'C'
STEP-2 [Get and STACK Symbols Until 'C' or blank is encountered]
NEXT<--NEXTCHAR(STRING)
repeat while NEXT≠'C'
if NEXT=' '
then write 'INVALID STRING'
exit
else
CALL PUSH(S,TOP,NEXT)
NEXT<--NEXTCHAR(STRING)
STEP-3 [Scan characters following 'C': compare them to characters On STACK]
repeat while S[TOP]≠'C':
NEXT<--NEXTCHAT(STRING)
X<--POP(S,TOP)
if NEXT≠X
then write 'INVALID STRING'
exit
NEXT<--NEXTCHAR(STRING)
STEP-4 [NEXT symbol must be a blank]
if NEXT = ''
then write'VALID STRING'
else
write 'INVALID STRING'
STEP-5 [finished]
exit.
========================================================================================
INSERT
------------------------------------------------------------
------------------------------------------------------------
INSERT(X,FIRST)
STEP-1 [Cheak Availability]
if AVAIL=NULL
then write('NO SPACE AVAILABLE')
exit.
STEP-2 [Set New Address]
NEW<--AVAIL.
STEP-3 [Change AVAIL to next NODE]
AVAIL<--LINK(AVAIL).
STEP-4 [Set DATA&LINK Part]
DATA(NEW)<--X
LINK(NEW)<--FIRST.
STEP-5 [Return Address]
return NEW.
========================================================================================
INSENO(X,FIRST)
STEP-1 [Cheak Availability]
if AVAIL=NULL
then write('NO SPACE AVAILABLE')
exit.
STEP-2 [Set New Address]
NEW<--AVAIL.
STEP-3 [Change AVAIL to next NODE]
AVAIL<--LINK(AVAIL).
STEP-4 [Set DATA&LINK Part]
DATA(NEW)<--X
LINK(NEW)<--NULL.
STEP-5 [Set Pointer to Search]
SAVE<--FIRST
STEP-6 [Find Last NODE]
Repeat While LINK(SAVE)≠ NULL then
SAVE<--LINK(SAVE)
STEP-7 [Insert NODE]
LINK(SAVE)<--NEW
STEP-8 [Finished]
Repeat FIRST.
=========================================================================================================
INSPOS(X,FIRST,N)
STEP-1 [Cheak Availability]
if AVAIL=NULL
then write('NO SPACE AVAILABLE')
exit.
STEP-2 [Set New Address]
NEW<--AVAIL.
STEP-3 [Change AVAIL to NEXT NODE]
AVAIL<--LINK(AVAIL).
STEP-4 [Set DATAK Part]
DATA(NEW)<--X
STEP-5 [Set Pointer to search]
SAVE<--FIRST
STEP-6 [Find Last Node]
repeat while DATA(SAVE)≠N then
SAVE<--LINK(SAVE)
STEP-7 [Insert node]
LINK(NEW)<--LINK(SAVE)
LINK(SAVE)<--NEW
STEP-8 [Return Address]
return FIRST
=========================================================================================================
INSORD(X,FIRST)
STEP-1 [Cheak Availability]
if AVAIL=NULL
then write('NO SPACE AVAILABLE')
exit.
STEP-2 [Set New Address]
NEW<--AVAIL.
STEP-3 [Change AVAIL to NEXT NODE]
AVAIL<--LINK(AVAIL).
STEP-4 [Set DATA&LINK Part]
INFO(NEW)<--X
STEP-5 [Is List Empty]
if FIRST=NULL then
LINK(NEW)<--NULL
return(NEW)
STEP-6 [Does This will be FIRST NODE]
if INFO(NEW)≤INFO(FIRST)
LINK(NEW)<--FIRST
return(NEW)
STEP-7 [search element]
SAVE<--FIRST
STEP-8 [Stetement search]
Repeat while
LINK(SAVE)≠NULL
INFO(LINK(SAVE))≤X
SAVE<--LINK(SAVE)
STEP-9 [Set the LINK]
LINK(NEW)<--LINK(SAVE)
LINK(SAVE)<--NEW.
========================================================================================
STEP-1 [Cheak Availability]
if AVAIL=NULL
then write('NO SPACE AVAILABLE')
exit.
STEP-2 [Set New Address]
NEW<--AVAIL.
STEP-3 [Change AVAIL to next NODE]
AVAIL<--LINK(AVAIL).
STEP-4 [Set DATA&LINK Part]
DATA(NEW)<--X
LINK(NEW)<--FIRST.
STEP-5 [Return Address]
return NEW.
========================================================================================
INSENO(X,FIRST)
STEP-1 [Cheak Availability]
if AVAIL=NULL
then write('NO SPACE AVAILABLE')
exit.
STEP-2 [Set New Address]
NEW<--AVAIL.
STEP-3 [Change AVAIL to next NODE]
AVAIL<--LINK(AVAIL).
STEP-4 [Set DATA&LINK Part]
DATA(NEW)<--X
LINK(NEW)<--NULL.
STEP-5 [Set Pointer to Search]
SAVE<--FIRST
STEP-6 [Find Last NODE]
Repeat While LINK(SAVE)≠ NULL then
SAVE<--LINK(SAVE)
STEP-7 [Insert NODE]
LINK(SAVE)<--NEW
STEP-8 [Finished]
Repeat FIRST.
=========================================================================================================
INSPOS(X,FIRST,N)
STEP-1 [Cheak Availability]
if AVAIL=NULL
then write('NO SPACE AVAILABLE')
exit.
STEP-2 [Set New Address]
NEW<--AVAIL.
STEP-3 [Change AVAIL to NEXT NODE]
AVAIL<--LINK(AVAIL).
STEP-4 [Set DATAK Part]
DATA(NEW)<--X
STEP-5 [Set Pointer to search]
SAVE<--FIRST
STEP-6 [Find Last Node]
repeat while DATA(SAVE)≠N then
SAVE<--LINK(SAVE)
STEP-7 [Insert node]
LINK(NEW)<--LINK(SAVE)
LINK(SAVE)<--NEW
STEP-8 [Return Address]
return FIRST
=========================================================================================================
INSORD(X,FIRST)
STEP-1 [Cheak Availability]
if AVAIL=NULL
then write('NO SPACE AVAILABLE')
exit.
STEP-2 [Set New Address]
NEW<--AVAIL.
STEP-3 [Change AVAIL to NEXT NODE]
AVAIL<--LINK(AVAIL).
STEP-4 [Set DATA&LINK Part]
INFO(NEW)<--X
STEP-5 [Is List Empty]
if FIRST=NULL then
LINK(NEW)<--NULL
return(NEW)
STEP-6 [Does This will be FIRST NODE]
if INFO(NEW)≤INFO(FIRST)
LINK(NEW)<--FIRST
return(NEW)
STEP-7 [search element]
SAVE<--FIRST
STEP-8 [Stetement search]
Repeat while
LINK(SAVE)≠NULL
INFO(LINK(SAVE))≤X
SAVE<--LINK(SAVE)
STEP-9 [Set the LINK]
LINK(NEW)<--LINK(SAVE)
LINK(SAVE)<--NEW.
========================================================================================
DELETE(X,FIRST)
STEP-1 [Cheak For Node]
if FIRST=NULL
then write('UNDERFLOW')
exit.
STEP-2 [Initilize Search]
TEMP<--FIRST
STEP-3 [Find X]
repeat thru step 5 while TEMP≠X and
LINK(TEMP)≠NULL
STEP-4 [Update Predeccessor Marker]
PRED<--TEMP
STEP-5 [Move To NEXT node]
TEMP<--LINK(TEMP)
STEP-6 [Cheak Last Node]
if TEMP≠X then
write 'NOT NODE AVAILABLE'
return
STEP-7 [DELETE X ]
if FIRST=X
FIRST<--LINK(FIRST)
else
LINK(PRED)<--LINK(X)
STEP-8 [Return Node]
LINK(X)<--AVAIL
AVAIL<--X
return
==============================================================================
COPY(FIRST)
STEP-1 [Empty List?]
if FIRST=NULL
then return (NULL)
STEP-2 [COPY FIRST NODE]
if AVAIL=NULL
then write 'UNDERFLOW'
return(0)
else
NEW<--AVAIL
AVAIL<--LINK(AVAIL)
FIELD(NEW)<--INFO(FIRST)
BEGIN<--NEW
STEP-3 [Initilize Traversal]
SAVE<--FIRST
STEP-4 [Move To Next Node If Not At End Of List]
repeat through step (6) while
LINK(SAVE)≠NULL
STEP-5 [Update Predecessor and SAVE Pointers]
PRED<--NEW
SAVE<--LINK(SAVE)
STEP-6 [Copy Node]
if AVAIL=NULL then
write 'UNDERFLOW'
return(0)
else
NEW<--AVAIL
AVAIL<--LINK(AVAIL)
FIELD(NEW)<--INFO(SAVE)
PTR(PRED)<--NEW
STEP-7 [Set Link of LAST Node and return]
PTR(NEW)<--NULL
return(BEGIN)
==============================================================================
if FIRST=NULL
then return (NULL)
STEP-2 [COPY FIRST NODE]
if AVAIL=NULL
then write 'UNDERFLOW'
return(0)
else
NEW<--AVAIL
AVAIL<--LINK(AVAIL)
FIELD(NEW)<--INFO(FIRST)
BEGIN<--NEW
STEP-3 [Initilize Traversal]
SAVE<--FIRST
STEP-4 [Move To Next Node If Not At End Of List]
repeat through step (6) while
LINK(SAVE)≠NULL
STEP-5 [Update Predecessor and SAVE Pointers]
PRED<--NEW
SAVE<--LINK(SAVE)
STEP-6 [Copy Node]
if AVAIL=NULL then
write 'UNDERFLOW'
return(0)
else
NEW<--AVAIL
AVAIL<--LINK(AVAIL)
FIELD(NEW)<--INFO(SAVE)
PTR(PRED)<--NEW
STEP-7 [Set Link of LAST Node and return]
PTR(NEW)<--NULL
return(BEGIN)
==============================================================================
Doubly linked list
DOUBINS(L,R,M,X)
STEP-1 [Obtain NEW NODE from Availability STACK]
NEW<--NODE
STEP-2 [COPY Information Field]
INFO(NEW)<--X
STEP-3 [Insertion INTO an Empty List?]
if R=NULL
then LPTR(NEW)<--RPTR(NEW)<--NULL
L<--R<--NEW
return
STEP-4 [Left-Most Insertion?]
if M=L
then LPTR(NEW)<--NULL
RPTR(NEW)<--M
LPTR(M)<--NEW
L<--NEW
return
STEP-5 [Insert in Middle]
LPTR(NEW)<--LPTR(M)
RPTR(NEW)<--M
LPTR(M)<--NEW
RPTR(LPTR(NEW))<--NEW
return
==============================================================================
NEW<--NODE
STEP-2 [COPY Information Field]
INFO(NEW)<--X
STEP-3 [Insertion INTO an Empty List?]
if R=NULL
then LPTR(NEW)<--RPTR(NEW)<--NULL
L<--R<--NEW
return
STEP-4 [Left-Most Insertion?]
if M=L
then LPTR(NEW)<--NULL
RPTR(NEW)<--M
LPTR(M)<--NEW
L<--NEW
return
STEP-5 [Insert in Middle]
LPTR(NEW)<--LPTR(M)
RPTR(NEW)<--M
LPTR(M)<--NEW
RPTR(LPTR(NEW))<--NEW
return
==============================================================================
DOUBDEL(L,R,OLD)
STEP-1 [UNDERFLOW?]
if R=NULL
then write'UNDERFLOW'
return
STEP-2 [DELETE node]
if L=R
then L<-R<-NULL
else if OLD=L
then L<- RPTR(L)
LPTR(L)<-NULL
else if OLD=R
then R<-LPTR(R)
RPTR(R)<-NULL
else
RPTR(LPTR(OLD))<-RPTR(OLD)
LPTR(RPTR(OLD))<-LPTR(OLD)
STEP-3 [return deleted node]
restore (OLD)
return
==============================================================================
if R=NULL
then write'UNDERFLOW'
return
STEP-2 [DELETE node]
if L=R
then L<-R<-NULL
else if OLD=L
then L<- RPTR(L)
LPTR(L)<-NULL
else if OLD=R
then R<-LPTR(R)
RPTR(R)<-NULL
else
RPTR(LPTR(OLD))<-RPTR(OLD)
LPTR(RPTR(OLD))<-LPTR(OLD)
STEP-3 [return deleted node]
restore (OLD)
return
==============================================================================
CIRCULAR LINKED LIST
STEP-1 [cheak for UNDERFLOW]
if AVAIL=NULL
then write'UNDERFLOW'
return (FIRST)
STEP-2 [obtain address of NEXT node]
NEW<-AVAIL
STEP-3 [Remove node from FREE LIST]
AVAIL<-LINK(AVAIL)
STEP-4 [Initilize DATA part]
INFO(NEW)<-X
STEP-5 [LIST empty]
if FIRST = NULL
then LINK(NEW)<-NEW
return(NEW)
STEP-6 [Initilize Search]
T1<-T2<-FIRST
STEP-7 [Search]
repeat while LINK(T2)≠T1
T2<-LINK)(T2)
STEP-8 [Set LINK of NEW node]
LINK(T2)<-NEW
LINK(NEW)<-FIRST
STEP-9 [Return]
return FIRST