2. It is a logical way of storing data and it also define
mechanism of retrieve data.
Characteristics of a Data Structure
• Correctness − Data structure implementation
should implement its interface correctly.
• Time Complexity − Running time or the
execution time of operations of data structure
must be as small as possible.
• Space Complexity − Memory usage of a data
structure operation should be as little as possible.
3. Need for Data Structure
As applications are getting complex and data rich,
there are three common problems that applications
• Data Search − Consider an inventory of 1 million(106)
items of a store. If the application is to search an item,
it has to search an item in 1 million(106) items every
time slowing down the search. As data grows, search
will become slower.
• Processor Speed − Processor speed although being
very high, falls limited if the data grows to billion
• Multiple Requests − As thousands of users can search
data simultaneously on a web server, even the fast
server fails while searching the data.
4. Types of Data Structure
LINEAR & NON LINEAR Data Structures
Traversing: Accessing each record exactly once so
that certain item in the record may be processed.
Searching: finding the location of the record with a
given key value .
Insertion : add a new record to the structure
Deletion : removing a record from the structure.
9. A Stack is a list of elements in which an
element may be inserted or deleted at one
end which is known as TOP of the stack.
Operations Performed on stack
• Push: add an element in stack
• Pop: remove an element in stack
11. A queue is a linear list of element in which
insertion can be done at one end which is
known as front and deletion can be done
which is known as rear.
Operations Performed on Queue
• Insertion : add a new element in queue
• Deletion: Removing an element in queue
13. A Linked list is a linear collection of data elements.
It has two part one is info and other is link part.
Info part gives information and link part is
address of next node.
Operations Perfomed on Linked List
17. A graph data structure may also associate to
each edge some edge value, such as a
symbolic label or a numeric attribute (cost,
capacity, length, etc.).
Operations Performed on graph
20. Linear Arrays
A linear array is a list of a finite number of n
homogeneous data elements ( that is data
elements of the same type) such that
– The elements of the arrays are referenced
respectively by an index set consisting of n
– The elements of the arrays are
storedrespectively in successive memory
21. The number n of elements is called the
length or size of the array.
• The index set consists of the integer 1,
2, … n
• Length or the number of data elements of
the array can be obtained from the index
Length = UB – LB + 1 where UB is the
largest index called the upper bound and
LB is the smallest index called the lower
bound of the arrays
22. • Element of an array A may be denoted
– Subscript notation A1, A2, , …. , An
– Parenthesis notation A(1), A(2), …. , A(n)
– Bracket notation A, A, ….. , A[n]
• The number K in A[K] is called subscript
or an index and A[K] is called a
23. Representation of Linear Array in Memory
• Let LA be a linear array in the memory of the
• LOC(LA[K]) = address of the element LA[K] of
the array LA
• The element of LA are stored in the successive
• Computer does not need to keep track of
the address of every element of LA, but
need to track only the address of the first
element of the array denoted by Base(LA)
called the base address of LA
24. Insertion Algorithm
INSERT (LA, N , K , ITEM) [LA is a linear array with N
elements and K is a positive integers such that K ≤ N.
This algorithm inserts an element ITEM into the K th
position in LA ]
1. [Initialize Counter] Set J := N
2. Repeat Steps 3 and 4 while J ≥ K
3. [Move the Jth element downward ] Set LA[J + 1]:= LA[J]
4. [Decrease Counter] Set J := J -1
5 [Insert Element] Set LA[K] := ITEM
6. [Reset N] Set N := N +1;
25. Deletion Algorithm
DELETE (LA, N , K , ITEM) [LA is a linear array with N
elements and K is a positive integers such that K ≤
N. This algorithm deletes Kth element from LA ]
1. Set ITEM := LA[K]
2. Repeat for J = K+1 to N:[Move the Jth element
upward] Set LA[J-1] :=LA[J]
3. [Reset the number N of elements] Set N := N - 1;
26. Two-Dimensional Array
• A Two-Dimensional m x n array A is a
collection of m . n data elements such that
each element is specified by a pair of integers
(such as J, K) called subscripts with property
that 1 ≤ J ≤ m and 1 ≤ K ≤ n.
• The element of A with first subscript Jand
second subscript K will be denoted by AJ,K or
27. 2D Arrays
The elements of a 2-dimensional array
a is shown as below
• a a a a
• a a a a
• a a a a
• Stack is an abstract data type with bounded
(predefined) capacity. It is a simple
data structure that allows adding and removing
elements in a particular order.
• Every time an element is added, it goes on the
top of the stack, the only element that can be
removed is the element that was at the top of
the stack, just like a pile of objects.
30. Basic Operations
• Stack operations may involve initializing the stack, using it and
then de-initializing it. Apart from these basic stuffs, a stack is
used for the following two primary operations −
• push() − Pushing (storing) an element on the stack.
• pop() − Removing (accessing) an element from the stack.
• To use a stack efficiently, we need to check the status of stack
as well. For the same purpose, the following functionality is
added to stacks
• isFull() − check if stack is full.
• isEmpty() − check if stack is empty.
31. Algorithm for PUSH Operation
begin procedure push: stack, data
if stack is full
top ← top + 1
stack[top] ← data
32. Algorithm for Pop Operation
if stack is empty
data ← stack[top]
top ← top – 1
• Queue is also an abstract data type or a linear
data structure, in which the first element is
inserted from one end called REAR(also called
tail), and the deletion of existing element
takes place from the other end called as
FRONT(also called head).
• This makes queue as FIFO(First in First Out)
data structure, which means that element
inserted first will also be removed first.
34. Basic Operations
• Queue operations may involve initializing or defining
the queue, utilizing it, and then completely erasing it
from the memory.
operations associated with queues −
• enqueue() − add (store) an item to the queue.
• dequeue() − remove (access) an item from the queue.
• Few more functions are required to make the above-
mentioned queue operation efficient.These are −
• isfull() − Checks if the queue is full.
• isempty() − Checks if the queue is empty.
35. Algorithm for enqueue Operation
if queue is full
rear ← rear + 1
queue[rear] ← data
36. Algorithm for dequeue Operation
if queue is empty
data = queue[front]
front ← front + 1
37. Drawback of Linear Queue
Once the queue is full, even though
few elements from the front are
deleted and some occupied space is
relieved, it is not possible to add
anymore new elements, as the rear
has already reached the Queue’s rear
38. Circular Queue
• This queue is not linear but
• Its structure can be like the
• In circular queue, once the
Queue is full the "First" element of
the Queue becomes the"Rear"
most element, if and only if
the"Front"has moved forward.
otherwise it will again be a "Queue
39. Algorithms for Insert and Delete
Operations in Circular Queue
For Insert Operation
Insert-Circular-Q(CQueue, Rear, Front, N, Item)
CQueue is a circular queue where to store data. Rear represents the location
in which the data element is to be inserted and Front represents the
location from which the data element is to be removed. Here N is the
maximum size of CQueue and finally, Item is the new item to be added.
Initailly Rear = 0 and Front = 0.
1. If Front = 0 and Rear = 0 then Set Front := 1 and go to step 4.
2. If Front =1 and Rear = N or Front = Rear + 1
then Print: “Circular Queue Overflow” and Return.
3. If Rear = N then Set Rear := 1 and go to step 5.
4. Set Rear := Rear + 1
5. Set CQueue [Rear] := Item.
40. For Delete Operation
Delete-Circular-Q(CQueue, Front, Rear, Item)
Here, CQueue is the place where data are stored. Rear represents the
location in which the data element is to be inserted and Front
represents the location from which the data element is to be
removed. Front element is assigned to Item.
Initially, Front = 1.
1. If Front = 0 then
Print: “Circular Queue Underflow” and Return. /*..Delete without
2. Set Item := CQueue [Front]
3. If Front = N then Set Front = 1 and Return.
4. If Front = Rear then Set Front = 0 and Rear = 0 and Return.
5. Set Front := Front + 1
41. Example: Consider the following circular queue with N = 5.
1. Initially, Rear = 0, Front = 0. 2. Insert 10, Rear = 1, Front = 1.
3. Insert 50, Rear = 2, Front = 1. 4. Insert 20, Rear = 3, Front = 1
42. 5. Insert 70, Rear = 4, Front = 1. 6. Delete front, Rear = 4, Front = 2.
7. Insert 100, Rear = 5, Front = 2. 8. Insert 40, Rear = 1, Front = 2.
43. 9. Insert 140, Rear = 1, Front = 2.
As Front = Rear + 1, so Queue overflow.
Delete front, Rear = 1, Front = 3.
11. Delete front, Rear = 1, Front = 4.
12. Delete front, Rear = 1, Front = 5.
45. Priority Queue
• A priority queue is a data structure for
maintaining a set S of elements, each with
an associated value called a key.
• Heap can be used to implement a priority
There are two kinds of priority queue
• max-priority queue
• min-priority queue
46. Applications of priority queue
• Job scheduling on a shared computer
• Event-driven simulation
• You will still remove from front of queue, but
insertions are governed by a priority. But, we
want to insert quickly. Must go into proper
47. Implementation of Priority Queues
Implemented using heaps and leftist trees
• Heap is a complete binary tree that is
efficiently stored using the array-based
• Leftist tree is a linked data structure suitable
for the implementation of a priority queue