The document describes procedures and functions for implementing various data structures like stacks, queues, linked lists, and doubly linked lists. It includes operations for pushing/popping elements to/from stacks, inserting/deleting elements from queues and linked lists, and inserting/deleting nodes from doubly linked lists while maintaining pointers between nodes. The procedures/functions check for errors like overflow/underflow and update relevant pointers and fields during operations.

1. STACK
Procedure PUSH (S, TOP, X). This procedure inserts an element X to the top of a stack
which is represented by a vector S containing N elements with a pointer TOP denoting the top
element in the stack.
1. [Checkfor stackoverflow]
If TOP >= N
then Write (“STACK OVERLOW”)
Return
2. [Increment TOP]
TOP ← TOP + 1
3. [Insert element]
S [TOP] ← X
4. [Finished]
Return □
--------------------------------------------------------------------------------------------------------------------------
Function POP (S, TOP). This function removes the top element from a stack which is
represented by a vector S and returns this element. TOP is a pointer to the top element of the
stack.
1. [Checkfor underflowon stack]
If TOP = 0
then Write (“STACK UNDERFLOWON POP”) takeaction in response to underflow
Exit
2. [Decrement Pointer]
TOP ← TOP - 1
3. [Returnformer topelement on stack]
Return(S [TOP + 1]) □

2. Function PEEP (S, TOP, I). Given a vector S (consisting N elements) representing a
sequentially allocated stack, and a pointer TOP denoting the top element of the stack, this
function returns the value of the ith element from the top of the stack. The element is not deleted
by this function.
1. [Checkfor underflowon stack]
If TOP – I + 1 <=0
then Write (“STACK UNDERFLOWON PEEP”) take action in response to underflow
Exit
2. [Return ith element from top of stack]
Return(S [TOP – I + 1])
□
---------------------------------------------------------------------------------------------
Procedure CHANGE (S, TOP, X, I). As before, a vector S (consisting of N elements)
represents a sequentially allocated stack and a pointer TOP denotes the top element of the stack.
This procedure changes the value of the ith element from the top of the stack to the value
contained in X.
1. [Check the stackunderflow]
If TOP – I + 1 <=0
then Write (“STACK UNDERFLOWON CHANGE”)
Return
2. [Change ith element from top ofstack]
S [TOP – I + 1] ← X
3. [Finished]
Return □

3. SIMPLE QUEUE
Procedure QINSERT (Q,F, R, N, Y). Given F and R, pointers to the front and rear elements
of a queue, a queue Q consisting of N elements, and an element Y, this procedure inserts Y at the
rear of the queue. Prior to the first invocation of the procedure, F and R have been set to zero.
1. [Overflow?]
If R >= N
then Write (“OVERFLOW”)
Return
2. [Increment rear pointer]
R ← R + 1
3. [Insert element]
Q [R] ← Y
4. [Is front pointer properly set?]
If F=0
then F ←1
Return □
--------------------------------------------------------------------------------------------------------------------------
Function QDELETE (Q, F, R). Given F and R, the pointers to the front and rear elements of
a queue, respectively, and the queue Q to which they correspond, this function deletes and
returns the last element of the queue. Y is a temporary variable.
1. [Underflow?]
If F = 0
then Write (“UNDERFLOW”)
Return(0) (0 denotes an empty queue)
2. [Delete element]
Y ← Q [F]
3. [Queue empty? ]
If F = R
then F ← R ← 0
else F ← F + 1 (Increment Front pointer)
4. [Returnelement]
Return(Y) □

4. CIRCULAR QUEUE
Procedure CQINSERT (F, R, Q, N, Y). Given pointers to the front and rear elements of a
circular queue, F and R, a vector Q consisting of N elements, and an element Y, this procedure
inserts Y at the rear of the queue. Initially, F and R are set to zero.
1. [Reset rear pointer?]
If R = N
then R ← 1
else R ← R + 1
2. [Overflow?]
If F = R
then Write (“OVERFLOW”)
Return
3. [Insert element]
Q [R] ← Y
4. [Is front pointer properly set?]
If F = 0
then F ←1
Return □
--------------------------------------------------------------------------------------------------------------------------
Function CQDELETE ( F, R, Q, N). Given F and R, pointers to the front and rear elements of
a circular queue, respectively, and a vector Q consisting of N elements, this function deletes and
returns the last element of the queue. Y is a temporary variable.
1. [Underflow?]
If F = 0
then Write (“UNDERFLOW”)
Return(0)
2. [Delete element]
Y ← Q [F]
3. [Queue empty? ]
If F = R
then F ← R ← 0
Return(Y)
4. [Increment front pointer]
If F = N

5. then F ← 1
else F ← F + 1
Return (Y) □
LINKED LIST
Function INSERT (X, FIRST). Given X, a new element, and FIRST, a pointer to the first
element of a linked linear list whose typical node contains INFO and LINK fields, this function
inserts X. AVAIL is a pointer to the top element of the availability stack; NEW is a temporary
pointer variable. It is required that X precedes the node whose address is given by FIRST.
1. [Underflow?]
If AVAIL = NULL
then Write (“AVAILABILITYSTACK UNDERFLOW”)
Return(FIRST)
2. [Obtainaddress ofnext free node]
NEW ← AVAIL
3. [Remove free node from availability stack]
AVAIL ← LINK(AVAIL)
4. [Initialize fields of new node and its link to the list]
INFO(NEW) ← X
LINK(NEW) ← FIRST
5. [Returnaddress of new node]
Return(NEW) □

6. Function INSEND (X, FIRST). Given X, a new element, and FIRST, a pointer to the first
element of a linked linear list whose typical node contains INFO and LINK fields, this function
inserts X. AVAIL is a pointer to the top element of the availability stack; NEW and SAVE are
temporary pointer variables. It is required that X be inserted at the end of the list.
1. [Underflow?]
If AVAIL = NULL
then Write (“AVAILABILITYSTACK UNDERFLOW”)
Return(FIRST)
2. [Obtainaddress ofnext free node]
NEW ← AVAIL
3. [Remove free node from availability stack]
AVAIL ← LINK(AVAIL)
4. [Initialize fields of new node]
INFO(NEW) ← X
LINK(NEW) ← NULL
5. [Is the list empty?]
If FIRST= NULL
then Return(NEW)
6. [Initiate searchfor the last node]
SAVE ← FIRST
7. [Searchfor end of list]
Repeat while LINK(SAVE) ≠NULL
SAVE ← LINK(SAVE)
8. [Initialize fields of new node]
LINK(SAVE) ← NEW
9. [Returnaddress of new node]
Return(FIRST) □

7. Function INSORD (X, FIRST). Given a new term X, this function inserts it into a linked
linear list whose typical node contains INFO and LINK fields. AVAIL is a pointer to the top
element of the availability stack; NEW and SAVE are temporary pointer variables. It is required
that X be inserted so that it preserves the ordering of the terms in increasing order of
their INFO fields.
1. [Underflow?]
If AVAIL = NULL
then Write (“AVAILABILITYSTACK UNDERFLOW”)
Return(FIRST)
2. [Obtainaddress ofnext free node]
NEW ← AVAIL
3. [Remove free node from availability stack]
AVAIL ← LINK(AVAIL)
4. [Copy informationcontents into new node]
INFO(NEW) ← X
5. [Is the list empty?]
If FIRST= NULL
then LINK(NEW) ← NULL
Return(NEW)
6. [Does the new node precede all others in the list?]
If INFO(NEW) ≤INFO(FIRST)
then LINK(NEW) ← FIRST
Return(NEW)
7. [Initialize temporary pointer]
SAVE ← FIRST
8. [Searchfor predecessor ofnew node]
Repeat while LINK(SAVE) ≠NULL and INFO(LINK(SAVE)) ≤INFO(NEW)
SAVE ← LINK(SAVE)
9. [Set link fields of new node and its predecessor]
LINK(NEW) ← LINK(SAVE)
LINK(SAVE) ← NEW
10. [Returnfirst node pointer]
Return(FIRST) □

8. Procedure DELETE (X, FIRST).Given X and FIRST, pointer variables whose values denote
the address of a node in a linked list and the address of the first node in the linked list,
respectively, this procedure deletes the node whose address is given by X. TEMP is used to find
the desired node, and PRED keeps track of the predecessor of TEMP. Note that FIRST is changed
only when X is the first element of the list.
1. [Empty list?]
If FIRST = NULL
then Write (“UNDERFLOW”)
Return
2. [Initialize searchfor X]
TEMP ← FIRST
3. [Find X]
Repeat thru step  while TEMP ≠ X and LINK(TEMP) ≠NULL
4. [Update predecessor marker]
PRED← TEMP
5. [Move to next node]
TEMP ← LINK(TEMP)
6. [End of the list?]
If TEMP ≠ X
then Write (“NODE NOTFOUND”)
Return
7. [Delete X]
If X = FIRST (Is X the firstnode?)
then FIRST← LINK(FIRST)
else LINK(PRED) ← LINK(X)
8. [Returnnode to availability area]
LINK(X) ← AVAIL
AVAIL ← X
Return □

9. DOUBLY LINKED LINEAR LISTS
Procedure DOUBINS (L, R, M, X). Given a doubly linked linear list whose left-most and
right-most node addresses are given by the pointer variables L and R, respectively, it is required
to insert a node whose address is given by the pointer variable NEW. The left and right links of a
node are denoted by LPTR and RPTR, respectively. The information field of a node is denoted by
the variable INFO. The name of an element of the list is NODE. The insertion is to be performed
to the left of a specified node with its address given by the pointer variable M. The information
to be entered in the node is contained in X.
1. [Obtainnew no0de from availability stack]
NEW ⇐ NODE
2. [Copy informationfield]
INFO(NEW) ← X
3. [Insert into an empty list?]
If R = NULL
then LPTR(NEW) ← RPTR(NEW) ← NULL
L ← R ← NEW
Return
4. [Left most insertion?]
If M = L
then LPTR(NEW) ← NULL
RPTR(NEW) ← M
LPTR(M) ← NEW
L ← NEW
Return
5. [Insert inmiddle]
LPTR(NEW) ← LPTR(M)
RPTR(NEW) ← M
LPTR(M) ← NEW
RPTR (LPTR(NEW))← NEW
Return □

10. Procedure DOUBDEL (L, R, OLD). Given a doubly linked linear list with the addresses of
the left-most and right-most nodes given by the pointer variables L and R, respectively, it is
required to delete the node whose address is contained in the variable OLD. Nodes contain left
and right links with names LPTR and RPTR, respectively.
1. [Underflow?]
If R = NULL
then Write(“UNDERFLOW”)
Return
2. [Delete node]
If L = R
then L ← R ← NULL
else If OLD = L (Left-mostnodebeingdeleted)
then L ← RPTR(L)
LPTR(L) ← NULL
else If OLD = R (Right-mostnodebeingdeleted)
then R ← LPTR(R)
RPTR(R) ← NULL
else RPTR (LPTR(OLD)) ← RPTR (OLD)
LPTR (RPTR(OLD)) ← LPTR (OLD)
3. [Returndeletednode]
Restore(OLD)
Return □