List,Stacks and Queues.pptx

Lists, Stacks, and Queues
1 Abstract Data Types (ADT)
2 The List ADT
3 The Stack ADT
4 The Queue ADT

Our goals: we will learn
 The concept of Abstract
Data Types (ADTS)
 How to efficiently
perform operations on
lists
 The Stack ADT and its
use in implementing
recursion
 The Queue ADT and its
use in operating systems
and algorithm design

Abstract Data Types (ADT)
Data type
 a set of objects + a set of operations
Example
 integer
• set of whole numbers {…, -2, -1, 0, 1, 2, 3,…}
• operations: +, -, x, /

Abstract Data Types (ADT)…
Abstract Data Type
 a set of objects and
 the set of operations that can be performed on the
objects
Example
 the List ADT
• A set of the elements that can be integers
• Operations: PrintList , MakeEmpty , Insert, Delete,
FindKth

Abstract Data Types (ADT)…
Why do we call it abstract?
 In an ADT’s definition, it is not mentioned how to
implement the set of operations
 ADTs are not directly usable
 They have to be implemented
 A given ADT may have more than one
implementation

The List ADT
Objects
 A general list is of the form A1, A2,…, AN
• where the size of the list is N
• and a list of size 0 is called an empty list
• Ai+1 follows Ai for i < N and
• Ai-1 precedesAi for i >1
• We don’t define the predecessor of A1 or the
successor of AN
• The position of element Ai is i

The List ADT…
Operations
 PrintList: prints the list
 MakeEmpty: create an empty list
 Find: returns the position of an object in a list
• list: 34,12, 52, 16, 12
• Find(52)  3
 Insert: insert an object to the list
• Insert(X,3)  34, 12, 52, X, 16, 12
 Delete: delete an element from the list
• Delete(52)  34, 12, X, 16, 12
 FindKth: retrieve the element at a certain position

The List ADT…
 The List ADT can be implemented using an array or a
linked list
Simple array implementation
 Elements are stored in contiguously
 an estimate of the maximum size of the list is
required and this usually requires a high
overestimate, which wastes considerable space
4 -1
1
-2
6
2
-1
-2
5
-3
A1
AN

The List ADT…
Running time of the operations
 The running time for PrintList and Find ?
• O(N)
 The running time for FindKth ?
• O(1)
 The running time for Insert ?
• O(N)
 The running time for Delete ?
• O(N)
are slow operations,
because we have to
move other elements
Can we somehow avoid the linear cost of insertion
and deletion?

The List ADT…
Linked Lists
 consists of a series of structures, which are not
necessarily adjacent in memory
 Each structure or node contains the element and a
pointer (called Next ) to a structure containing its
successor
A1
AN
NULL
4 -3 -1
……..
A node in the list
Pointer is a variable that
contains the address where
some other data are stored
Conceptual view

The List ADT…
Running time of the operations
 PrintList (L)
 Find(L, key)
 FindKth (L,i) takes O(i)
A1 800 A2 712 A5 0
A3 992 A4 692
1000 800 712 992 692
Actual view
O(N)
O(N)
O(N)

The List ADT…
Insertion into a Linked List
 requires obtaining a new cell from the system and
then executing two pointer maneuvers
 Running time O(1)
A1 A3
NULL
4 -3 -1
5
A3
A4
A2

The List ADT…
Deletion from a Linked List
 Requires one pointer change
 Running time O(1)
NULL
A1 A
4
4 -3 -1
5
A3
delete
A2

The List ADT…
Array versus Linked Lists
 Linked lists are more complex to code and manage
than arrays, but they have some distinct advantages
 Dynamic
• a linked list unlike an array easily grows and
shrinks in size when necessary
 Easy and fast insertions and deletions

The List ADT…
Programming Details
NULL
header
(An empty list)
NULL
A1 A3
A2
header
•A header or “dummy” node placed at position 0 is used
in common practice to keep track of an empty list, for
eventual deletion or even to use again
•It also allows us to add a node at the beginning of a list
and to delete the first node in a list

The List ADT… #ifndef _List_H
#define _List_H
struct Node;
typedef struct Node* PtrToNode;
typedef PtrToNode List;
typedef PtrToNode Position;
List MakeEmpty( List L );
int IsEmpty( List L );
int IsLast( Position P, List L );
Position Find( ElementType X, List L );
void Delete( ElementType X, List L );
Position FindPrevious( ElementType X, List L );
void Insert( ElementType X, List L, Position P );
void DeleteList( List L );
Position Header( List L );
Position First( List L );
Position Advance( Position P );
ElementType Retrieve( Position P );
#endif /* _List_H */
struct Node
{
ElementType Element;
Position Next;
};
Programming Details…

The List ADT…
/* Return true if L is empty */
int
IsEmpty( List L )
{
return L->Next == NULL;
}
Running time?

The List ADT…
/* Return true if P is the last position in list L */
int
IsLast( Position P, List L )
{
return P->Next == NULL;
}
This implementation does
not use the parameter list L
Running time?

The List ADT…
/* Return Position of X in L; NULL if not found */
Position
Find( ElementType X, List L )
{
Position P;
/* 1*/ P = L->Next;
/* 2*/ while( P != NULL && P->Element != X )
/* 3*/ P = P->Next;
/* 4*/ return P;
}
Running time?

3-23
The List ADT…
/* If X is not found, then Next field of returned value is NULL */
/* Assumes a header */
Position
FindPrevious( ElementType X, List L )
{
Position P;
/* 1*/ P = L;
/* 2*/ while( P->Next != NULL && P->Next->Element != X )
/* 3*/ P = P->Next;
/* 4*/ return P;
}
Running time?

Lists, Stacks, and Queues 3-24
The List ADT…
 A consequence of the
free(P) command is
that the address that
P is pointing to is
unchanged, but the
data that reside at
that address are now
undefined
/* Assume use of a header node */
/* Cell pointed to by P->Next is wiped out */
/* Assume that the position is legal */
void
Delete( ElementType X, List L )
{
Position P, TmpCell;
P = FindPrevious( X, L );
if( !IsLast( P, L ) )
{
/* X is found; delete it */
TmpCell = P->Next;
/* Bypass deleted cell */
P->Next = TmpCell->Next;
free( TmpCell );
}
}
Running time?

The List ADT…
/* Insert (after legal position P) */
/* Header implementation assumed */
void
Insert( ElementType X, List L, Position P )
{
Position TmpCell;
/* 1*/ TmpCell = malloc( sizeof( struct Node ) );
/* 2*/ if( TmpCell == NULL )
/* 3*/ FatalError( "Out of space!!!" );
/* 4*/ TmpCell->Element = X;
/* 5*/ TmpCell->Next = P->Next;
/* 6*/ P->Next = TmpCell;
}
Running time?

The List ADT…
Common errors
 The most common error
you will encounter is that
your program will crash
with message, such as
“memory access
violation” , or
“segmentation violation”
 pointer variable
contains a bogus address
 pointer is not properly
initialized
 e.g. line1 is omitted
/* Incorrect DeleteList algorithm */
void
DeleteList( List L )
{
Position P;
/* 1*/ P = L->Next;
/* Header assumed */
/* 2*/ L->Next = NULL;
/* 3*/ while( P != NULL )
{
/* 4*/ free( P );
/* 5*/ P = P->Next;
}
}
incorrect?

The List ADT…
 The second common error
is that we think that
declaring a pointer to a
structure creates the
structure
 Use malloc to create a
structure
 It takes as an argument
the number of bytes to be
allocated and returns a
pointer to the allocated
memory
/* Correct DeleteList algorithm */
void
DeleteList( List L )
{
Position P, Tmp;
/* 1*/ P = L->Next;
/* Header assumed */
/* 2*/ L->Next = NULL;
/* 3*/ while( P != NULL )
{
/* 4*/ Tmp = P->Next;
/* 5*/ free( P );
/* 6*/ P = Tmp;
}
}

The List ADT…
Problems with Linked Lists or Singly Linked Lists
 finding the successor of an item easy what
about the predecessor ?
 we can’t traverse singly linked lists backwards
 So, circular linked lists and doubly linked lists
were invented
NULL
A1 A3
A2
header

The List ADT…
Doubly Linked Lists
 Each node points to not only its successor but
also to its predecessor
 more space is required (for an extra pointer)
 cost of insertions and deletions doubles because
now more pointers to fix
 Simplifies deletion
NULL
A3 A4
A2
A1
NULL

The List ADT…
Circularly Linked Lists
previous element next
A2 A4
A3
A1
A double circularly linked list

The List ADT…
Examples
 The Polynomial ADT
 Lets define an ADT for single-variable polynomials
(with nonnegative exponents)
 Example:
 Operations: addition, subtraction, multiplication
i
N
i
i x
A
f(x) 


0
9
4
5
7 2
3
4
5



 x
x
x
x
1 -7 5 -4 0 9

The List ADT…
Implementation
 If most of the
coefficients of the
polynomial are
nonzero, we can use
a simple array to
store them
typedef struct
{
int CoeffArray[ MaxDegree + 1 ];
int HighPower;
} *Polynomial;
void
ZeroPolynomial( Polynomial Poly )
{
int i;
for( i = 0; i <= MaxDegree; i++ )
Poly->CoeffArray[ i ] = 0;
Poly->HighPower = 0;
}

The List ADT…
Implementation
 Ignore the time to
initialize the output
polynomials to
zero, then running
time is proportional
to the product of
the degree of the
two input
polynomials
void
MultPolynomial( const Polynomial Poly1,
const Polynomial Poly2, Polynomial PolyProd )
{
int i, j;
ZeroPolynomial( PolyProd );
PolyProd->HighPower = Poly1->HighPower +
Poly2->HighPower;
if( PolyProd->HighPower > MaxDegree )
Error( "Exceeded array size" );
else
for( i = 0; i <= Poly1->HighPower; i++ )
for( j = 0; j <= Poly2->HighPower; j++ )
PolyProd->CoeffArray[ i + j ] +=
Poly1->CoeffArray[ i ] *
Poly2->CoeffArray[ j ];
}

The List ADT…
 Singly Linked lists would definitely be a good alternative
to arrays for sparse polynomials
5
11
2
3
)
(
1
5
10
)
(
1492
1990
2
14
1000
1







x
x
x
x
P
x
x
x
P
10 1000 5 14 1 0
P1 NULL
3 1990 1492
-2 11 1 5 0
P2 NULL
Each node has the coefficient, the
exponent, and the pointer to next

The List ADT…
Multi-lists
 Registration Problem
 A university with 40,000 students and 2,500
courses needs to be able to generate two types of
reports
• Lists the registration of each class
• Lists, by student, the classes that each student
is registered for
 Array-based Implementation
• 2D array of 100 million entries
C1
C2
C3
C4
.
.
.
.
S1 S2……………………………..

The List ADT…
Multi-lists…
 Linked List implementation
C1
C2
CN
S1 SM

The List ADT…
Cursor implementation of Linked Lists
 Languages , such as FORTRAN and BASIC, do not
support pointers
 Two important features of pointer implementation
– Data are stored in a node which also contains
pointer to the next node
– Using malloc, we obtain a new node from the
memory and using free we can release it
 In absence of pointers how would we implement
Linked Lists
 Have to simulate the above two features

2 The List ADT
3 The Stack ADT
4 The Queue ADT

The Stack ADT
Example
 pile of plates
1
2
bottom
top
1
2
3
bottom
top
1
bottom
top
running time?

The Stack ADT…
 A stack is a list with the restriction that insertions
and deletions take place at the same end of the list
according to the last-in-first-out (LIFO) principle
 This end is called top
 The other end is called bottom
Where do we use a stack?
 Function calls
 Multitasking OS

The Stack ADT…
Operations
 Push
• insert an element onto the top of the stack
• an input operation
 Pop
• remove the most recently inserted element
from the stack
• an output operation
 Top
• examines the most recently inserted element
• an output operation

The Stack ADT…
empty stack
top A
top
push an element
top
push another
A
B
top
pop
A

The Stack ADT…
Common errors
 A Pop or Top on an empty stack is generally
considered an error in the stack ADT
 Running out of space when performing a Push is
an implementation error and not an ADT error
Stack Implementations
 Since stack is a list, therefore any list
implementation could be used to implement a
stack
• Singly Linked lists
• Arrays

The Stack ADT…
Linked List Implementation of Stacks
 Push is performed by inserting at
the front of the list
 Pop is performed by deleting the
element at the front of list
 Top operation returns the value
of the element at the front
NULL
Top of Stack

The Stack ADT…
Programming details
 Implementing the
stack with a header
#ifndef _Stack_h
#define _Stack_h
struct Node;
typedef struct Node *PtrToNode;
typedef PtrToNode Stack;
int IsEmpty( Stack S );
Stack CreateStack( void );
void DisposeStack( Stack S );
void MakeEmpty( Stack S );
void Push( ElementType X, Stack S );
ElementType Top( Stack S );
void Pop( Stack S );
#endif /* _Stack_h */
struct Node
{
ElementType Element;
PtrToNode Next;
};

The Stack ADT…
Programming details…
int
IsEmpty( Stack S )
{
return S->Next == NULL;
}
Running time?

The Stack ADT…
Stack
CreateStack( void )
{
Stack S;
S = malloc( sizeof( struct Node ) );
if( S == NULL )
FatalError( "Out of space!!!" );
S->Next = NULL;
MakeEmpty( S );
return S;
}
Running time?

The Stack ADT…
void
MakeEmpty( Stack S )
{
if( S == NULL )
Error( "Must use CreateStack first" );
else
while( !IsEmpty( S ) )
Pop( S );
}
Running time?

The Stack ADT…
void
Push( ElementType X, Stack S )
{
PtrToNode TmpCell;
TmpCell = malloc( sizeof( struct Node ) );
if( TmpCell == NULL )
FatalError( "Out of space!!!" );
else
{
TmpCell->Element = X;
TmpCell->Next = S->Next;
S->Next = TmpCell;
}
}
Running time?

The Stack ADT…
ElementType
Top( Stack S )
{
if( !IsEmpty( S ) )
return S->Next->Element;
Error( "Empty stack" );
return 0; /* Return value used to avoid warning */
}
Running time?

The Stack ADT…
void
Pop( Stack S )
{
PtrToNode FirstCell;
if( IsEmpty( S ) )
else
{
FirstCell = S->Next;
S->Next = S->Next->Next;
free( FirstCell );
}
}
Running time?

The Stack ADT…
Linked List Implementation of Stacks
 The malloc and free instructions are expensive as
compared to the pointer manipulations
 Linked Lists carefully checks for errors
• Pop on an empty stack
• Push on a full stack

The Stack ADT…
Array Implementation of Stacks
 Need to declare an array size ahead of time
 Generally this is not a problem, because in typical
applications, even if there are a quite a few stack
operations, the actual number of elements in the
stack at any time never gets too large

The Stack ADT…
Array Implementation of Stacks…
 With each stack, TopOfStack is defined that stores
the array index of the top of the stack
• for an empty stack, TopOfStack is set to -1
 Push
• Increment TopOfStack by 1
• Set Stack[TopOfStack] = X
 Pop
• Set return value to Stack[TopOfStack]
• Decrement TopOfStack by 1
 These are performed in very fast constant time

The Stack ADT…
 On some machines, Pushes and Pops (of integers) can
be written in one machine instruction, operating on a
register with auto-increment and auto-decrement
addressing
TOS = -1
A TOS = 0
Stack[TOS]
A
B TOS = 1
Stack[TOS]

The Stack ADT…
Programming details #ifndef _Stack_h
#define _Stack_h
struct StackRecord;
typedef struct StackRecord *Stack;
int IsEmpty( Stack S );
int IsFull( Stack S );
Stack CreateStack( int MaxElements );
void DisposeStack( Stack S );
void MakeEmpty( Stack S );
void Push( ElementType X, Stack S );
ElementType Top( Stack S );
void Pop( Stack S );
ElementType TopAndPop( Stack S );
#endif /* _Stack_h */
struct StackRecord
{
int Capacity;
int TopOfStack;
ElementType* Array;
};
#define EmptyTOS ( -1 )
#define MinStackSize ( 5 )

The Stack ADT… Programming details…
Stack
CreateStack( int MaxElements )
{
Stack S;
/* 1*/ if( MaxElements < MinStackSize )
/* 2*/ Error( "Stack size is too small" );
/* 3*/ S = malloc( sizeof( struct StackRecord ) );
/* 4*/ if( S == NULL )
/* 6*/ S->Array = malloc( sizeof( ElementType ) * MaxElements );
/* 7*/ if( S->Array == NULL )
/* 9*/ S->Capacity = MaxElements;
/*10*/ MakeEmpty( S );
/*11*/ return S;
}

The Stack ADT…
Programming details
void
DisposeStack( Stack S )
{
if( S != NULL )
{
free( S->Array );
free( S );
}
}

The Stack ADT…
Programming details
int
IsEmpty( Stack S )
{
return S->TopOfStack == EmptyTOS;
}

The Stack ADT…
Programming details
void
MakeEmpty( Stack S )
{
S->TopOfStack = EmptyTOS;
}

The Stack ADT…
Programming details
void
Push( ElementType X, Stack S )
{
if( IsFull( S ) )
Error( "Full stack" );
else
S->Array[ ++S->TopOfStack ] = X;
}

The Stack ADT…
Programming details
ElementType
Top( Stack S )
{
if( !IsEmpty( S ) )
return S->Array[ S->TopOfStack ];
}

The Stack ADT…
Programming details
void
Pop( Stack S )
{
if( IsEmpty( S ) )
else
S->TopOfStack--;
}

The Stack ADT…
Programming details
ElementType
TopAndPop( Stack S )
{
if( !IsEmpty( S ) )
return S->Array[ S->TopOfStack-- ];
}

The Stack ADT…
Applications
 Balancing Symbols
 A problem in elementary algebra is to decide if an
expression containing several kinds of brackets,
such as [,] , {,}, (,), is correctly bracketed
 This is the case if
• There are same number of left and right
brackets of each kind, and
• When a right bracket appears, the most recent
preceding unmatched left bracket should be of
the same type

The Stack ADT…
 Symbol Balancing Algorithm
 Scan the expression from left to right
 When a left bracket is encountered , push it onto
the stack
 When a right bracket is encountered, stack is
popped (if stack is empty, too many right brackets)
and brackets are compared
 If they are of the same type, scanning continues
 Otherwise the expression is incorrectly bracketed
 At the end of expression, if the stack is empty, it is
correctly bracketed otherwise, there are too many
left brackets

The Stack ADT…
 Postfix Expressions or Reverse Polish Notations
 The expression x + y , where the operator is
present “in” between the operands is called infix
notation
• 4.99 x1.06 + 5.99 + 6.99 x1.06
 The expression x y +, where the operator is
present after the operands is called postfix or
reverse Polish notation
• 4.99 1.06 x 5.99 + 6.99 1.06 x +

The Stack ADT…
Advantages over infix notation
 Algebraic formulas can be expressed without
parentheses
 Evaluating formulas on computers with stacks is
convenient
 Infix operators have precedence which is arbitrary
• e.g. left shift has precedence over Boolean
AND? Who knows?

The Stack ADT…
A B + C x D + E F
+ G + /
((A + B) x C + D)/
(E + F + G)
A B x C /
A x B / C
A B + C D - /
(A + B) / (C - D)
A B x C D x +
A x B + C x D
A B x C +
A x B + C
A B C x +
A + B x C
RPN
Infix

The Stack ADT…
 Evaluating the Postfix expression with the Stack
 Read in the RPN input
 If the input is an operand, push onto the stack
 If the input is an operator, pop the top two
operands off stack, perform operation, and
 Push the result onto the stack

The Stack ADT…
 Infix to postfix conversion
 Several algorithms for converting the infix formula
into reverse Polish notation exist
 The following algorithm uses the stack for the
conversion

Example
 a + b * c + (d * e + f) * g -> infix
 a b c * + d e * f + g * + -> postfix

The Stack ADT…
 Conversion algorithm
 Read the infix expression as input
 If input is an operand, output the operand
 If input is an operator +, -, *, /, then pop and output
all operators of >= precedence , and push
operator onto the stack
 If input is (, then push it onto the stack
 If input is ), then pop and output all operators until
see a ( on the stack
 Pop the ( without output
 If no more input then pop and output all operators
on stack

The Stack ADT…
a b c * + d e * f + g * +
+
*
+ +
(
+
*
(
+
+
(
+ +
*
+
Output:
Stack:
Arrows represent
pop and output
Arrows represent
pop and output
a + b * c + (d * e + f) * g
Don’t remove an open
parentheses until a closed
parentheses

The Stack ADT…
 Function Calls
 In almost all programming languages, calling a
function involves the use of a stack
 To store the local variables
• These can accessed from inside the function
but cease to be accessible once the function
has returned ->an absolute memory address?
 To store the return address
 Stack frame = local variables + return address

The Stack ADT…
Function Calls…
func2(int param3, param4) {
int p5, p6;
}
func1(int param1, int param2) {
int p3, p4;
func2(p3, p4);
}
int main() {
int p1, p2;
func1(p1, p2);
}
Parameters
Return Address
Locals of main
Parameters
Locals of func1
Return Address
Parameters
Locals of func2
Return Address
stack frame
or
activation record
Call Stack

The Stack ADT…
 Stack in a real computer frequently grows from the
high end of your computer partition downward and
on many systems there is no checking for overflow
 program may crash
 Stack data may run into your program’s code 
corrupt
Stack data may run into your program’s data 
you may destroy your stack information

The Stack ADT…
 This routine which
prints out a linked list, is
perfectly legal and
actually correct
 However, if the list
consists of 20,000
elements, what would
happen?
void
PrintList (List L)
{
if( L != NULL)
{
PrintElement( L->Element );
PrintList( L->Next);
}
}
May run out of stack space
and the program may crash

The Stack ADT…
 Recursion in the
above program is
called tail recursion
as the recursive call
is made at the last
line
void
PrintList (List L)
{
top:
if( L != NULL)
{
PrintElement( L->Element );
L= L->Next;
goto top;
}
}

2 The List ADT
3 The Stack ADT
4 The Queue ADT

The Queue ADT
 A queue is a list with the restriction that insertions
take place at end of the list and deletions take place
at the start of the list according to the first-in-first-out
(FIFO) principle
 The end of the list is called rear
 The start of the list is known as front
Examples
 Keeping track of computing jobs e.g. printing
 Client-server model

The Queue ADT…
Operations
 Enqueue
• Inserts an element at the end of the list (called
rear)
 Dequeue
• Deletes (and returns) an element at the start of
the list (known as the front)
Remove
(Dequeue) rear
front
Insert
(Enqueue)

The Queue ADT…
Implementation of Queue
 Since queue is a list, so any list implementation is
legal for a queue
• Array implementation
• Linked List implementation

The Queue ADT…
Array Implementation
 For each queue data structure, we define
• an array Queue[]
• the ends of the queue, Front and Rear
• the number of elements that are actually in the
queue, Size

The Queue ADT…
 To Enqueue an element X
• Increment Size and Rear
• Set Queue[Rear] =X
 To Dequeue an element
• Set the return value to Queue[Front]
• Decrement Size and increment Front
rear
front
5 2 7 1

The Queue ADT…
 Problem with this implementation
 After 7 Enqueues, the queue appears to be full,
since Rear is now 7, and the next Enqueue would
be in a nonexistent position
• there might only be a few elements in the
queue because several elements may have
already been dequeued
rear
front
5 2 7 1

The Queue ADT…
rear
front
2 4
rear front
2 4
1
rear front
2 4
1 3
rear front
2 4
1 3
Initial state
After Enqueue(1)
After Enqueue(3)
After Dequeue

The Queue ADT…
After Dequeue
After Dequeue
After Dequeue
rear
front
2 4
1 3
rear
front
2 4
1 3
rear front
2 4
1 3

The Queue ADT…
Programming Details
#ifndef _Queue_h
#define _Queue_h
struct QueueRecord;
typedef struct QueueRecord *Queue;
int IsEmpty( Queue Q );
int IsFull( Queue Q );
Queue CreateQueue( int MaxElements );
void DisposeQueue( Queue Q );
void MakeEmpty( Queue Q );
void Enqueue( ElementType X, Queue Q );
ElementType Front( Queue Q );
void Dequeue( Queue Q );
ElementType FrontAndDequeue( Queue Q );
#endif /* _Queue_h */
struct QueueRecord
{
int Capacity;
int Front;
int Rear;
int Size;
ElementType *Array;
};

The Queue ADT…
int
IsEmpty( Queue Q )
{
return Q->Size == 0;
}

The Queue ADT...
void
MakeEmpty( Queue Q )
{
Q->Size = 0;
Q->Front = 1;
Q->Rear = 0;
}

The Queue ADT…
static int
Succ( int Value, Queue Q )
{
if( ++Value == Q->Capacity )
Value = 0;
return Value;
}

The Queue ADT…
void
Enqueue( ElementType X, Queue Q )
{
if( IsFull( Q ) )
Error( "Full queue" );
else
{
Q->Size++;
Q->Rear = Succ( Q->Rear, Q );
Q->Array[ Q->Rear ] = X;
}
}

Lists, Stacks, and Queues : Summary
Covered
 We have
 Learnt the concept of ADTs
 Illustrated the concept with three of the most
common ADTs
 the primary objective is to separate the
implementation of ADTs from their functions
 Lists, Stacks and Queues have their own uses as
documented through a host of examples

List,Stacks and Queues.pptx

Recommended

Recommended

More Related Content

Similar to List,Stacks and Queues.pptx

Similar to List,Stacks and Queues.pptx (20)

Recently uploaded

Recently uploaded (20)

List,Stacks and Queues.pptx