dsa1.ppt

Data Structures and
Algorithms
N Radhakrishnan
Assistant Professor
Anna University, Chennai

19 July 2022 Anna University, Chennai - 600 025 2
Topics
 Revision of Previous Session
Contents
 Cursor-based Implementation of
Lists
 Stacks
 Queues
 Applications of Stacks and Queues
 Doubly Linked Lists

Cursor Implementation
Problems with linked list implementation:
 Same language do not support pointers!
• Then how can you use linked lists ?
 new and free operations are slow
• Actually not constant time
 SOLUTION: Implement linked list on an array -
called CURSOR

Cursor Implementation - Diagram

Cursor Implementation
If L = 5, then L represents list (A, B, E)
If M = 3, then M represents list (C, D, F)

Arrays - Pros and Cons
 Pros
• Directly supported by C
• Provides random access
 Cons
• Size determined at compile time
• Inserting and deleting elements is
time consuming

Linked Lists - Pros and Cons
 Pros
• Size determined during runtime
• Inserting and deleting elements is
quick
 Cons
• No random access
• User must provide programming
support

Application of Lists
 Lists can be used
 To store the records sequentially
 For creation of stacks and queues
 For polynomial handling
 To maintain the sequence of operations
for do / undo in software
 To keep track of the history of web sites
visited

How to change the direction ?

Turntable

Another Method

Stack

What is a Stack ?
 a stack is a particular kind of abstract data
type or collection in which the fundamental
(or only) operations on the collection are the
addition of an entity to the collection, known
as push and removal of an entity, known as
pop.

Basic Principle
 The relation between the push and pop
operations is such that the stack is a Last-In-
First-Out (LIFO) data structure.
 In a LIFO data structure, the last element
added to the structure must be the first one
to be removed.

Operations on Stack
 This is equivalent to the requirement that,
considered as a linear data structure, or
more abstractly a sequential collection, the
push and pop operations occur only at one
end of the structure, referred to as the top of
the stack.
 Often a peek or top operation is also
implemented, returning the value of the top
element without removing it.

Implementation
 A stack may be implemented to have a
bounded capacity. If the stack is full and
does not contain enough space to accept an
entity to be pushed, 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 results in an empty stack,
but, if the stack is empty, it goes into
underflow state, which means no items are
present in stack to be removed.

Restricted Data Structure
 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.

Examples

In Simple Words
 A stack
• Last-in, first-out (LIFO) property
 The last item placed on the stack will be
the first item removed
• Analogy
 A stack of dishes in a cafeteria
 A stack of Books
 A stack of Dosa
 A stack of Money

ADT Stack
 ADT stack operations
• Create an empty stack
• Destroy a stack
• Determine whether a stack is empty
• Add a new item
• Remove the item that was added most
recently
• Retrieve the item that was added most
recently
 A program can use a stack independently
of the stack’s implementation

Stack Operations
bool isEmpty() const;
// Determines whether a stack is empty.
// Precondition: None.
// Postcondition: Returns true if the
// stack is empty; otherwise returns
// false.

Stack Operations
bool push(StackItemType newItem);
// Adds an item to the top of a stack.
// Precondition: newItem is the item to
// be added.
// Postcondition: If the insertion is
// successful, newItem is on the top of
// the stack.

Stack Operations
bool pop(StackItemType& stackTop);
// Retrieves and removes the top of a stack
// Postcondition: If the stack is not empty,
// stackTop contains the item that was added
// most recently and the item is removed.
// However, if the stack is empty, deletion
// is impossible and stackTop is unchanged.

Stack Operations
bool getTop(StackItemType& stackTop) const;
// Retrieves the top of a stack.
// Postcondition: If the stack is not empty,
// stackTop contains the item that was added
// most recently. However, if the stack is
// empty, the operation fails and stackTop
// is unchanged. The stack is unchanged.

Implementation Using Arrays

The Stack Class - Public Contents
class Stack
{
public:
Stack() { size = 10; current = -1;}
int pop(){ return A[current--];}
void push(int x){A[++current] = x;}
int top(){ return A[current];}
int isEmpty(){return ( current == -1 );}
int isFull(){ return ( current == size-1);}

The Stack Class - Private Contents
private:
int object; // The data element
int current; // Index of the array
int size; // max size of the array
int A[10]; // Array of 10 elements
};

Stack - a Very Simple Application
 The simplest application of a stack is to
reverse a word.
 You push a given word to stack - letter
by letter - and then pop letters from the
stack.

Applications of Stack
 Recursion
 Decimal to Binary Conversion
 Infix to Postfix Conversion and
Evaluation of Postfix Expressions
 Rearranging Railroad Cars
 Quick Sort
 Function Calls
 Undo button in various software.

outputInBinary - Algorithm
function outputInBinary(Integer n)
Stack s = new Stack
while n > 0 do
Integer bit = n modulo 2
s.push(bit)
if s is full then
return error
end if
n = floor(n / 2)
end while
while s is not empty do
output(s.pop())
end while
end function

Algebraic Expressions
 Infix expressions
• An operator appears between its operands
 Example: a + b
 Prefix expressions
• An operator appears before its operands
 Example: + a b
 Postfix expressions
• An operator appears after its operands
 Example: a b +

A complicated example
 Infix expressions:
a + b * c + ( d * e + f ) * g
 Postfix expressions:
a b c * + d e * f + g * +
 Prefix expressions:
+ + a * b c * + * d e f g

Evaluation of Postfix Expression

Evaluation of Postfix Expression
 The calculation: 1 + 2 * 4 + 3 can be written
down like this in postfix notation with the
advantage of no precedence rules and
parentheses needed
 1 2 4 * + 3 +
 The expression is evaluated from the left to
right using a stack:
• when encountering an operand: push it
• when encountering an operator: pop two
operands, evaluate the result and push it.

Infix to Postfix Conversion

What’s this ?

Queue

Queue
 A stack is LIFO (Last-In First Out) structure.
In contrast, a queue is a FIFO (First-In First-
Out ) structure.
 In a FIFO data structure, the first element
added to the queue will be the first one to be
removed.
 A queue is a linear structure for which items
can be only inserted at one end and removed
at another end.

Operations on Queue
 We will dedicate once again six operations on
the Queue.
• You can add a person to the queue (enque),
• Look who is the first person to be serviced (front)
• Rremove the first person (dequeue) and
• Check whether the queue is empty (isEmpty).
• Also there are two more operations to create and
to destroy the queue.

Operations
 Queue create()
• Creates an empty queue
 boolean isEmpty(Queue q)
• Tells whether the queue q is empty
 enqueue(Queue q, Item e)
• Place e at the rear of the queue q
 destroy(Queue q)
• destroys queue q

Operations Continued
 Item front(Queue q)
• returns the front element in Queue q
without removing it
Precondition: q is not empty
 dequeue(Queue q)
• removes front element from the queue q
Precondition: q is not empty

Implementation Using Arrays
 If we use an array to hold queue elements,
dequeue operation at the front (start) of
the array is expensive.
 This is because we may have to shift up to
“n” elements.
 For the stack, we needed only one end; for
queue we need both.
 To get around this, we will not shift upon
removal of an element.

Snapshot of a Queue

enqueue()

enqueue() again

dequeue()

dequeue() again

Two more enqueue()

What’s Wrong ?
 We have inserts and removal running in
constant time but we created a new
problem.
 We cannot insert new elements even though
there are two places available at the start of
the array.
 Solution: allow the queue to “wrap around”.
Basic idea is to picture the array as a circular
array as show below.

Queue array wrap-around

enqueue(element)
void enqueue(int x)
{
rear = (rear+1)%size;
array[rear] = x;
noElements = noElements+1;
}

dequeue()
int dequeue()
{
int x = array[front];
front = (front+1)%size;
noElements = noElements-1;
return x;
}

isEmpty() and isFull()
int isFull()
{
return noElements == size;
}
int isEmpty()
{
return noElements == 0;
}

Pointer Based Implementation
 Possible implementations of a pointer-based
queue
• A linear linked list with two external references
 A reference to the front
 A reference to the back
• A circular linked list with one external reference
 A reference to the back

Queue - Linear and Circular List

Non-empty Queue - Insertion

Empty Queue - Insertion

Queue with more than 1 element -
Deletion

Applications of Queues
 Queue is used when things don’t have to be
processed immediatly, but have to be
processed in First In First Out order like
Breadth First Search.
 This property of Queue makes it also useful
in following kind of scenarios.

 When a resource is shared among multiple
consumers. Examples include CPU
scheduling, Disk Scheduling.
 When data is transferred asynchronously
(data not necessarily received at same rate
as sent) between two processes. Examples
include IO Buffers, pipes, file IO, etc.
 Operating systems often maintain a queue
of processes that are ready to execute or
that are waiting for a particular event to
occur.

 Computer systems must often provide a
“holding area” for messages between two
processes, two programs, or even two
systems. This holding area is usually called
a “buffer” and is often implemented as a
queue.
 Call center phone systems will use a queue
to hold people in line until a service
representative is free.

 Buffers on MP3 players and portable CD
players, iPod playlist. Playlist for jukebox -
add songs to the end, play from the front of
the list.
 Round Robin (RR) algorithm is an important
scheduling algorithm. It is used especially for
the time-sharing system. The circular queue
is used to implement such algorithms.

Why Doubly Linked List ?
 given only the pointer location, we cannot access its
predecessor in the list.
 Another task that is difficult to perform on a linear
linked list is traversing the list in reverse.
 Doubly linked list A linked list in which each node is
linked to both its successor and its predecessor
 In such a case, where we need to access the node
that precedes a given node, a doubly linked list is
useful.

Doubly Linked List
 In a doubly linked list, the nodes are linked
in both directions. Each node of a doubly
linked list contains three parts:
• Info: the data stored in the node
• Next: the pointer to the following node
• Back: the pointer to the preceding node

Operations on Doubly Linked Lists
 The algorithms for the insertion and deletion
operations on a doubly linked list are
somewhat more complicated than the
corresponding operations on a singly linked
list.
 The reason is clear: There are more pointers
to keep track of in a doubly linked list.

Inserting Item
 As an example, consider the Inserting an
item.
 To link the new node, after a given node, in a
singly linked list, we need to change two
pointers:
• newNode->next and
• location->next.
 The same operation on a doubly linked list
requires four pointer changes.

Singly Linked List Insertion

Doubly Linked List Insertion

The Order is Important

Doubly Linked List - Deletion
 One useful feature of a doubly linked list is
its elimination of the need for a pointer to a
node's predecessor to delete the node.
 Through the back member, we can alter the
next member of the preceding node to make
it jump over the unwanted node.
 Then we make the back pointer of the
succeeding node point to the preceding
node.

Doubly Linked List - Deletion

Special Cases of Deletion
 We do, however, have to be careful about the
end cases:
• If location->back is NULL, we are deleting the
first node
• if location->next is NULL, we are deleting the last
node.
• If both location->back and location->next are
NULL, we are deleting the only node.

Interaction

dsa1.ppt

More Related Content

Similar to dsa1.ppt (20)

More from ssuser0be977 (9)

Recently uploaded (20)

dsa1.ppt