UNIT-I

Topics to be covered 1.Introduction to data structures. 2. Abstract data type (ADT) 3. Stacks and queues 4. Circular queues and their implementation with arrays. 5. Stack applications: 5.1. infix to post fix conversion 5.2. postfix expression evaluation. 6. Applications of queues

1.Introduction to data structures.

Definition:- A data structure is an arrangement of data in a computers memory or even on disk storage. It has a different way of storing and organizing data in a computer. Concept of data structure:- manipulation of real-life data requires the following essential tasks1.storage representation of user data 2. Retrieval of stored data 3. transformation of user data

Mathematical definition of data structure is D=(d,f,a) where D= data structure d= a set of variables (data objects). f= a set of functions a= set of rules to implement the functions.

2. Abstract data type (ADT)

Data structure is implemented around the concept of an abstract data type that defines the both data organization and data hiding operations. ADT refers to the basic mathematical concept that defines the data type. ADT is also called as user defined data type. Only tells about what are the data values required and what operations performed on those objects.

Overview of data structures

Several data structures are available in the computer science and used based on their applications. Data structures are classified into different types.

Data structure
Linear ds Arrays Linked list stack queues Non Linear ds Trees Graphs

Linear data structure- all the elements are stored in sequential order or linear order. Non linear data structure- no such sequence in elements, rather all the elements are distributed over a plane.

Applications of data structures

Implementing data bases of different organizations (ds used is B-Trees) Implement compilers for different languages (ds used is hash tables). Used in every program and software system.

3. Stacks and queues

What is a stack?

Stores a set of elements in a particular order A stack is an ordered collection of homogeneous data elements where the insertion and deletion takes place at one end Stack principle: LAST IN FIRST OUT = LIFO It means: the last element inserted is the first one to be removed Example
Which is the first element to pick up?

Stack maintains a pointer called top, which keeps track of the top most element in the stack. Any insertions or deletions should be based upon the value of top. It works on the basis of LIFO (Last in First out). According to the definition, new elements are inserted from top and the elements are deleted from same end i.e again top. This suggests that the element inserted most recently can only be deleted. In the stack, the elements are removed in the reverse order of that in which they were added to the stack i.e last element inserted is to be deleted first.
So it is called last in first out.

Ex: Elements are inserted in the order as A,B,C,D. It represents the stack of 4 elements. The top most element in the stack is E.

If we want to delete element only D has to be deleted first.

If deletion operation is performed on stack continuously then the order in which the elements are deleted is D,C,B,A.

Last In First Out

C B A top B A

top

D C B A

top C B A top B A top

top

Basic operations: The basic operations are insertion, deletion and display.

In stacks, special terms are given for insert and delete. i.e push for insert and pop is for delete. Push: inserting or adding element into the stack is called push. Pop: deleting or removing element from the stack is called pop.

3 2 1 0 TOP=-1 (Empty stack) 3 TOP-> 2 1 0 30 20 10 Push 30

3
2 1 TOP-> 0 10 Push 10

3 2 TOP-> 1 0 20 10 Push 20

TOP-> 3 2 1 0

40 30 20 10 Push 40

TOP-> 3 2 1 0

40 30 20 10 Push 50 (Overflow)

3
TOP-> 2 1 0 30 20 10

3 2 TOP-> 1 0 20 10 pop 3 2

pop

3 2 1 TOP-> 0 10 pop

1 0
pop (TOP=-1) underflow

Implementing stack using arrays

Algorithm for inserting element into the stack: Algorithm push() 1. if top=(size) then write (stack overflow) Return 2. read item 3. toptop+1 4. stack[top] item 5. stop

Explanation:

The stack is of size max. This procedure inserts an element item on to the top of a stack which is represented by an array stack. The first step of this algorithm checks for an overflow condition. Overflow means inserting element into a stack which is full. If the top value reaches to maximum size of the stack then elements cannot be inserted into the stack i.e. stack is full. Otherwise top is incremented by one and element is inserted into the stack.

Algorithm to delete element from the stack: Algorithm pop() 1. if top=0 then write (stack underflow) 2. item stack[top] 3. top top-1

Explanation: This procedure deletes an element from the stack.

The first step of this algorithm checks for underflow condition.

If the top value is 0 then stack is empty. Deleting element from the stack is known as underflow. Takeout the element from the location where, the top is pointing and store it in the variable then decrement top by one.

Display of stack: Printing the contents of stack after push and pop operations. Algorithm print() 1. if top=-1 then write (stack empty) 2. Repeat for i top to 0 print(stack[i]) 3. stop

Queue

A queue is like a line of people waiting for a bank teller. The queue has a front and a rear.

$ $

Front Rear

The Queue Operations

New people must enter the queue at the rear.

$ $

Front
Rear

The Queue Operations

When an item is taken from the queue, it always comes from the front.
$ $

Front

Rear

Queues

A queue is special type of data structure in which insertions take place from one end called rear end and deletions take place from other end called front end i.e insertions and deletions take place from different ends. A queue is special type of data structure in which insertions take place from one end called rear end and deletions take place from other end called front end i.e insertions and deletions take place from different ends.

This type of data structure is used in time sharing systems where many user jobs will be waiting in the system queue for processing. These jobs may request the services of CPU, main memory or external devices such as printer. A queue can be represented using sequential allocation (using arrays or using Linked List).

First In First Out

C rear B front A D rear C B front A rear

rear front

B A

D C front B

rear front

Classification of queue: Ordinary queue or Linear queue. Circular queue. Double ended queue. Priority queue.

Basic operations on queue: The operations that can be performed on queue are Insertion Deletion Display

Queue maintains two pointers rear and front. From rear end elements are inserted and from front elements are deleted.

Working of a linear queue:i) Initially front=rear=-1. It indicates queue is empty. 0 1 2 3 4

front=rear=-1 ii) Add 10 0 10 1 2 3 4 iii) Add 20 1 0 10 20 2 3 4

front rear iv) Add 30

front

rear

v) Add 40

0 10

1 2 3 20 30

0 10

2 3 20 30 40

front

rear

front

rear

vi) Add 50 0 1 10 20 2 3 30 40 4 50

vii) Add 60 (overflow)

0 10 1 20 2 30 3 40 4 50

front

rear

front

rear

viii) delete (10 is removed) 0 1 20 2 30 3 40 4 50

ix) delete (20 is removed) 0 1 2 30 3 40 4 50

front

rear

front

rear

x) delete (30 is removed)

0 1 2 3 40 4 50

xi) delete (40 is removed)

0 1 2 3 4 50

front rear

front rear

xii) delete (50 is removed)

0 1 2 3 4

ix) delete (underflow)

0 1 2 3 4

front=rear=-1

front=rear=-1

Implementation of queue using array

Algorithm add() 1. If rear size-1 then write (overflow) 2. Read item 3. rear rear + 1 3. queue[rear] item 5. stop

Explanation: This procedure adds an element item to the queue.

First it checks for an overflow condition.

If the rear value reaches or exceeds size of the queue then elements cannot be inserted into the queue. ie. Overflow. Whenever element is inserted into the queue, rear is increment by one and place the element in the location where rear is pointing.

Algorithm to delete element from the queue

Algorithm delete() 1. If front= rear+1 then write (queue underflow) item queue [front] 2. front front + 1

Explanation: This procedure deletes an element from the queue.

The first step of this algorithm checks for underflow condition. If the front value is 0 then queue is empty. Deleting element from the empty queue is known as underflow.

Take out the element from the location where, the front is pointing and store it in the variable, then increment front by one.

Drawback in queue
-> in a queue when the rear pointer reaches to the end of the queue, insertion would be denied even if room is available at the front one way to remove this is using the circular queue ( circular array)

Circular queues
EMPTY QUEUE
[2] [1] [3] [4] [1] J1 [2] J2 J3 [3] [4]

[0]

[5]

[0]

[5]

front = 0 rear = 0

front = 0 rear = 3

Can be seen as a circular queue

How to test whether circular queue is empty or full? The circular q is controlled by the MOD operation. Circular queue is empty when front =0 rear=0 Circular queue is full front = (rear+1)% length

Implementation of circular queue using array

Algorithm for insertion 1. If (front=0) print queue is empty front=0,rear=0. cq[front]=item. 2.Else rear= (rear+1) % length 3. If rear!=front cq[rear]= ithem 4. stop

Algorithm for deletion 1.if front=0 print queue is empty 2. else 2.1 item=cq [front] 2.2 if front=rear front=0,rear=0; 3. Else 3.1 front=(front+1)length 4. stop