Datastructures using c++

Gopinath D MSc(computer science) 1
Objectives:
 To understand the concept of data structures
 To understand the types of data structures
 To understand the operations on different data structures
 The implementation of different data structures
DATA STRUCTURES USING C++

Data Structure:
 Data is a collection of raw facts that are processed by computers.
 Data may contain single value or set of values.
 For example students name may contain three sub items like first name, middle
name, and last name, whereas students regno can be treated as a single item.
These data have to be processed to form information.
 Data structure means organization or structuring a collection of data items in
appropriate form so as to improve the efficiency of storage and processing.
 A data structure is a specialized format for organizing and storing data.

Data representation
 Computers memory is used to store the data which is required for processing.
This process is known as data representation.
 Data may be of same type or different types.
Data structure is a method of storing data in memory so that it can be used efficiently.
The study of data structure mainly deals with:
 Logical or mathematical description of structure.
 Implementation of structure on a computer.
 Analysis of structure which includes determining amount of space in memory and
optimization of time taken for processing.

Classification of data structure

Primitive data structures:
 Data structures that are directly operated upon by machine-level instructions are
known as primitive data structures.
 The integer, real (float), logical data, character data, pointer and reference are
primitive data structures.
Operations on primitive data structures:
The various operations that can be performed on primitive data structures are:
 Create
 Destroy
 Select
 Update

Create:
 Create operation is used to create a new data structure.
 This operation reserves memory space for the program elements.
 It can be carried out at compile time and run-time.
For example, int x;
Destroy:
 Destroy operation is used to destroy or remove the data structures from the memory
space.
 When the program execution ends, the data structure is automatically destroyed and
the memory allocated is eventually de-allocated.
 C++ allows the destructor member function destroy the object.

Select:
 Select operation is used by programmers to access the data within data structure.
 This operation updates or alters data.
Update:
 Update operation is used to change data of data structures.
 An assignment operation is a good example of update operation.
 For example, int x = 2; Here, 2 is assigned to x.
 Again, x = 4; 4 is reassigned to x.
 The value of x now is 4 because 2 is automatically replaced by 4, i.e. updated.

Non primitive data structures:
 Non-primitive data structures are more complex data structures.
 These data structures are derived from the primitive data structures.
Non-primitive data structures are classified as arrays, lists and files.
 Array is the collection of homogenous elements under the same name.
 The different types of arrays are one-dimensional, two-dimensional and
multidimensional.
Data structures under lists are classified as linear and non-linear data structures

Linear data structure:
 Linear data structures are a kind of data structure that has homogenous elements.
 Each element is referred to by an index.
 The linear data structures are Stack, Queues and Linked Lists.
 Data elements of linear data structures will have linear relationship between data
elements.
 One of the methods is to have linear relationship between elements by means of
sequential memory locations.

Non-linear data structure:
 A non-linear data structure is a data structure in which a data item is connected to
several other data items.
 The data item has the possibility to reach one or more data items.
 Every data item is attached to several other data items in a way that is specific for
reflecting relationships.
 The data items are not arranged in a sequential structure.
 Trees and Graphs are the examples of non-linear data structures.

Operations on linear data structure
The basic operations on non-linear data structures are as follows:
 Traversal: The process of accessing each data item exactly once to perform some
operation is called traversing.
 Insertion: The process of adding a new data item into the given collection of data
items is called insertion.
 Deletion: The process of removing an existing data item from the given collection of
data items is called deletion.
 Searching: The process of finding the location of a data item in the given collection of
data items is called as searching.
 Sorting: The process of arrangement of data items in ascending or descending order
is called sorting.
 Merging: The process of combining the data items of two structures to form a single
structure is called merging.

Arrays
 An array is a collection of homogeneous elements with unique name and the
elements are arranged one after another in adjacent memory location.
 The data items in an array are called as elements.
 These elements are accessed by numbers called as subscripts or indices.
 Since the elements are accessed using subscripts, arrays are also called as
subscripted variables.
Types of Arrays:
There are three types of array:
 One-dimensional Array
 Two-dimensional Array
 Multi-dimensional array

One-dimension Array
 An array with only one row or column is called one-dimensional array.
 It is finite collection of n number of elements of same type such that
 Elements are stored in contiguous locations
 Elements can be referred by indexing Array can be denoted as:
data type Arrayname[size];
Here, size specifies the number of elements in the array and the index (subscript)
values ranges from 0 to n-1.

Features:
 Array size should be positive number only.
 String array always terminates with null character (‘0’).
 Array elements are counted from 0 to n-1.
 Useful for multiple reading of elements.
Calculating the length of Array
 Arrays can store a list of finite number (n) of data items of same data type in
consecutive locations.
 The number n is called size or length of the array.
 The length of an array can be calculated by L = UB – LB + 1
Here, UB is the largest index and LB is the smallest index of an array.
Example: If an array A has values 10, 20, 30, 40, 50, 60 stored in locations 0, 1, 2, 3, 4,
5 then UB = 5 and LB= 0 Size of the array L = 5 – 0 + 1 = 6

Representation of one-dimensional arrays in memory
 Elements of linear array are stored in consecutive memory locations.
 Let P be the location of the element.
 Address of first element of linear array A is given by Base(A) called the Base address
of A. Using this we can calculate the address of any element of A by the formula
LOC(A[P]) = Base(A) + W(P – LB) Here W is the number of words per memory cell.
Example: Suppose if a string S is used to store a string
ABCDE in it with starting address at 1000, one can find
the address of fourth element as follows:
Now the address of element S[3] can be calculated as
follows:
Address(S[3]) = Base(S) + W(P - LB)Here W = 1 for
characters = 1000 + 1(3 - 0) = 1003

Basic operations on one-dimensional arrays
The following operations are performed on arrays:
1. Traversing: Accessing each element of the array exactly once to do some
operation.
2. Searching: Finding the location of an element in the array.
3. Sorting: Arranging the elements of the array in some order.
4. Insertion: Inserting an element into the array.
5. Deletion: Removing an element from the array.
6. Merging: Combining one or more arrays to form a single array.

Traversing a Linear Array
Traversing is the process of visiting each subscript at least once from the beginning to
last element.
For example, to find the maximum element of the array we need to access each element
Algorithm: Let A be a linear array with LB and UB as lower bound and upper bound. This
algorithm traverses the array A by applying the operation PROCESS to each element of A.
1. for LOC = LB to UB
PROCESS A[LOC]
End of for
2. Exit

To input and output the elements of the
array.
#include<iostream.h>
#include<iomanip.h>
#include<conio.h>
void main()
{
int a[10], i, n;
clrscr();
cout<<“How many elements? “;
cin>>n;
cout<<“Enter the elements: “;
for(i=0; i<n; i++)
cin>>a[i];
cout<<“The elements are “;
for(i=0; i<n; i++)
cout<<setw(4)<<a[i];
getch();
}
OUTPUT:
How many elements? 5
Enter the elements 5 10 20 15 10
The elements are 5 10 20 15 10

Searching an element
 It refers to finding the location of the element in a linear array.
 There are many different algorithms.
 But the most common methods are linear search and binary search.
Linear Search
 This is the simplest method in which the element to be searched is compared with
each element of the array one by one from the beginning till end of the array.
 Since searching is one after the other it is also called as sequential search or linear
search.

Algorithm:
A is the name of the array with N elements.
ELE is the element to be searched.
This algorithm finds the location loc where the search ELE element is stored.
Step 1: LOC = -1
Step 2: for P = 0 to N-1
if( A[P] = ELE)
LOC = P
GOTO 3
End of if
End of for
Step 3: if(LOC >= 0)
PRINT LOC
else
PRINT “Search is unsuccessful”
Step 4: Exit

Program: To find the location of an
element
#include<conio.h>
#include<iomanip.h>
void main( )
{
int a[50], i, pos, ele, n;
clrscr( );
cout<<“Enter the number of elements:
cin>>n;
for(i=0; i<n; i++)
cin>>a[i];
cout<<“Enter the search element: “;
cin>>ele;
pos=-1;
for(i=0; i<n ;i++)
if(ele == a[i])
{
pos = i;
break;
}
if(pos>= 0)
cout<<ele<<“ is present at position
“<<pos<<endl;
else
cout<<ele<<“ is not present”<<endl;
getch( );
}
OUTPUT:
Enter the number of elements: 5
Enter the elements: 10 20 50 40 30
Enter the search element: 40
40 is present at position 3

Binary Search:
 When the elements of the array are in sorted order, the best method of searching is
binary search.
 This method compares the element to be searched with the middle element of the
array.
 If the comparison does not match the element is searched either at the right-half of
the array or at the left-half of the array.
 Let B and E denote the beginning and end locations of the array.
 The middle element A[M] can be obtained by first finding the middle location M by
M = int(B+E)/2, where int is the integer value of the expression.
 If A[M] = ELE, then search is successful.
Otherwise a new segment is found as follows:
1. If ELEA[M], searching is continued at the right-half of the segment.
2. Reset B = M + 1.
3. If ELE not found then we get a condition B>E.
4. This results in unsuccessful search.

COMPARISON BETWEEN LINEAR SEARCH AND BINARY SEARCH

Algorithm:
A is the sorted array with LB as lower bound and UB as the upper bound respectively.
Let B, E, M denote beginning, end and middle locations of the segments of A.
Step 1: set B = 0, E = n-1 LOC=-1
Step 2: while (B <= E)
M= int(B+E)/2
if(ELE = A[M]
loc = M
GOTO 4
else
if(ELE <A[M])
E = M-1
else
B = M+1
End of while
Step 3: if(LOC >= 0)
PRINT LOC
else
PRINT “Search is unsuccessful”
Step 4: Exit

Program: To find the location of an
element.
void main()
{
int a[10], i, n, m, loc, b, e, pos, ele;
cin>>n;
for(i=0; i<n; i++)
cin>>a[i];
cout<<“Enter the search element “;
cin>>ele;
pos=-1;
b=0;
e=n-1;
while(b<=e)
{
m=(b+e)/2;
if(ele==a[m])
{
pos=m;
break;
}
else
if(ele<a[m])
e=m-1;
else
b=m+1;
}
if(pos>=0)
cout<<“Position= “<<pos;
else
cout<<“Search is unsuccessful”;
}
OUTPUT:
Enter the elements: 10 20 30 40 50 60 70
Enter the search element 60
Position= 5

Insertion an element
 Insertion refers to inserting an element into the array.
 A new element can be done provided the array should be large enough to
accommodate the new element.
 When an element is to be inserted into a particular position, all the elements from the
asked position to the last element should be shifted into the higher order positions.
Example:
Let A be an array with items 10, 20, 40, 50 and 60 stored at consecutive locations.
Suppose item=30 has to be inserted at position 2.
The following procedure is applied.
 Move number 60 to position 5.
 Move number 40 to position 3
 Position 2 is blank.
Insert 30 into the position 2. i.e., A[2] = 30

Algorithm:
A is the array with N elements.
ITEM is the element to be inserted in
the position P.
Step 1: for I = N-1 down to P
A[I+1] = A[I]
End of for
Step 2: A[P] = ITEM
Step 3: N = N+1
Step 4: Exit

Program: To insert an element into the array.
#include<iomanip.h>
void main()
{
int a[10], i, n, ele, p;
cout<<"How many elements? ";
cin>>n;
cout<<"Enter the elements: ";
for(i=0; i<n; i++)
cin>>a[i];
cout<<"Enter the element to be
inserted: ";
cin>>ele;
cout<<"Enter the position ( 0 to
"<<n<<"): ";
cin>>p;
if(p > n)
cout<<"Invalid position";
else
{
for(i=n-1; i>=p; i--)
a[i+1] = a[i];
a[p] = ele;
n = n+1;
cout<<"The elements after the insertion are ";
for(i=0; i<n; i++)
}
}
OUTPUT:
Enter the element to be inserted: 3
Enter the position ( 0 to 5): 2
The elements after the insertion are 1 2 3 4 5 6

Deleting an element from the array
Deletion refers to removing an element into the array.
When an element is to be deleted from a particular position, all the subsequent shifted
into the lower order positions.
Example: Let A be an array with items 10, 20, 30, 40 and 50 stored at consecutive
locations.
Suppose item=30 has to be deleted at position 2.
The following procedure is applied.
 Copy 30 to Item. i.e., Item = 30

Algorithm:
A is the array with N elements.
ITEM is the element to be deleted in
the position P and it is stored into the
variable Item.
Step 1: Item = A[P]
Step 2: for I = P to N-1
A[I] = A[I+1]
End of for
Step 3: N = N-1
Step 4: Exit

Program: To delete an element from the
array.
#include<iomanip.h>
void main()
{
int a[10], i, n, ele, p;
cin>>n;
for(i=0; i<n; i++)
cin>>a[i];
cout<<“Enter the position (0 to “<<n-1<<“):
“;
cin>>p;
if(p > n-1)
cout<<“Invalid position”;
else
{
ele = a[p];
for(i=p; i<n; i++)
a[i] = a[i+1];
n = n-1;
cout<<“The elements after the deletion
is “;
for(i=0; i<n; i++)
}
}
OUTPUT:
Enter the position (0 to 4): 2
The elements after the deletion is 10
20 40 50

Sorting the elements
 Sorting is the arrangement of elements of the array in some order.
 There are various methods like bubble sort, shell sort, selection sort,
quick sort, heap sort, insertion sort etc.
Insertion Sort:
 The first element of the array is assumed to be in the correct position.
 The next element is considered as the key element and compared with
the elements before the key element and is inserted in its correct
position.

Example: Consider the following list of numbers 70 30 40 10 80 stored in the consecutive
locations.
Step 1: Assuming 30 in correct position 70 is compared with 30 .
Since 30 is less the list now is 30 70 40 10 8 0
Step 2: Now 40 is the key element.
First it is compared with 70.
Since 40 is less than 70 it is inserted before 70.
The list now is 30 40 70 10 80
Step 3: Now 10 is the key element.
First it is compared with 70. Since it is less it is exchanged.
Next it is compared with 40 and it is exchanged.
Finally it is compared with 30 and placed in the first position.
The list now is 10 30 40 70 80
Step 4:
Now 80 is the key element and compared with the sorted elements and placed in
the position.
Since 80 is greater than 70 it retains its position.

Algorithm:
Let A be an array with N unsorted elements.
The following algorithm sorts the elements in order.
Step 1: for I = 1 to N-1
Step 2: J = I While ( J >= 1 )
If( A[J] < A[J-1])
temp = A[J]
A[J] = A[J-1]
A[J-1] = temp
If end
J = J-1
While end
for end
Step 3: Exit

Two-dimensional arrays
A two dimensional array is a collection of elements and each element is identified
by a pair of indices called as subscripts.
The elements are stored in contiguous memory locations.
The number of elements can be obtained by multiplying number of rows and number
of columns.
the total number of elements in the array
would be,
rows x columns = 3 x 3 =9-elements

Representation of 2-dimensional array in memory
Suppose A is the array of order m x n. To store m*n number of elements, we need m*n
memory locations. The elements should be in contiguous memory locations.
There are two methods:
 Row-major order
 Column-major order
Row-major order Let A be the array of order m x n.
In row-major order, all the first-row elements are stored in sequential memory locations
and then all the second-row elements are stored and so on.
Base(A) is the address of the first element.
The memory address of any element A[I][J] can be obtained by the formula
LOC(A[I][J]) = Base(A) + W[n(I-LB) + (J-LB)]
where W is the number of words per memory location.

Example: Consider the array of order 3 x 3.

Column-major order
Let A be the array of order m x n.
In column-major order, all the first column elements are stored in sequential memory
locations and then all the second-column elements are stored and so on.
Base(A) is the address of the first element.
The memory address of any element A[I][J] can be obtained by the formula
LOC(A[I][J]) = Base(A) + W[(I-LB) + m(J-LB)] where W is the number of words per memory
location.
example: Consider the array of order 3 x 3

Program: To read and print the elements in column-major
order.
#include<iomanip.h>
void main()
{
int a[5][5], i, j, r, c;
cout<<“Enter the order: “;
cin>>r>>c;
cout<<“Enter the elements: “<<endl;
for(i=0; i<c; i++)
for(j=0; j<r; j++)
cin>>a[j][i];
cout<<“The matrix in column-major order is: “<<endl;
for(i=0; i<r; i++)
{
for(j=0; j<c; j++)
cout<<setw(4)<<a[i][j];
cout<<endl;
}
}
OUTPUT:
Enter the order: 2 3
Enter the elements:
1 2 3
4 5 6
The matrix in column-
major order is:
1 2 3
4 5 6

Example: Consider the array A of order 25 x 4 with base value 2000 and one word per
memory location.
Find the address of A[12][3] in row-major order and column-major order.
Solution: Given Base(A) = 2000, m = 25, n = 4 LB = 0 W = 1, I = 12, J = 3
Row-major order:
LOC(A[I][J]) = Base(A) + W[n(I-LB) + (J-LB)]
LOC(A[12][3]) = 2000 + 1[4(12-0)+(3-0)]
= 2000 + 4(12) + 3 = 2000 + 48 + 3
= 2051
Column-major order:
LOC(A[I][J]) = Base(A) + W[ (I-LB) + m(J-LB)]
LOC(A[12][3]) = 2000 + 1[(12-0)+25(3-0)]
= 2000 + 1(12 + 75)
= 2000 + 87
= 2087

Applications of arrays
 Arrays are used to implement other data structures such as heaps, hash
tables, queues, stacks and strings etc.
 Arrays are used to implement mathematical vectors and matrices.
 Many databases include one-dimensional arrays whose elements are records.
Advantages of arrays
 It is used to represent multiple data items of same type by using only single
name.
 It can be used to implement other data structures like linked lists, stacks,
queues, trees, graphs etc.
 Two-dimensional arrays are used to represent matrices.

Disadvantages of arrays
 We must know in advance that how many elements are to be stored in array.
 Array is static structure. It means that array is of fixed size. The memory which is
allocated to array cannot be increased or reduced.
 Since array is of fixed size, if we allocate more memory than requirement then
the memory space will be wasted. If we allocate less memory than requirement,
then it will create problem.
 The elements of array are stored in consecutive memory locations. So insertions
and deletions are very difficult and time consuming.

STACK
 stack is an ordered collection of items where the addition of new items and the
removal of existing items always take place at the same end.
 This end is commonly referred to as the “top”. The end opposite to top is known as the
base.
 Stack follows LIFO (last in, first out) order or approach in which the operations are
performed.
 This means that the element which was added last to the stack will be the first
element to be removed from the stack.
Many examples of stacks occur in everyday situations.
 Almost any cafeteria has a stack of trays or plates where you take the one at the top,
uncovering a new tray or plate for the next customer in line.

 Imagine a stack of books on a desk.
 The only book whose cover is visible is the one on top.
 To access others in the stack, we need to remove the ones that are placed on top of
them.

 Stacks are fundamentally important, as they can be used to reverse the order of
items.
 The order of insertion is the reverse of the order of removal.
 For example, every web browser has a Back button. As you navigate from web page to
web page, those pages are placed on a stack (actually it is the URLs that are going on
the stack).
 The current page that you are viewing is on the top and the first page you looked at is
at the base. If you click on the Back button, you begin to move in reverse order
through the pages.

Representation of stacks in memory The representation of a stack in the memory can
be done in two ways.
 Static representation using arrays
 Dynamic representation using linked lists
Array Representation of a Stack
 Stack can be represented using a one-dimensional array.
 A block of memory is allocated which is required to accommodate the items to the
full capacity of the stack.
 The items into the stack are stored in a sequential order from the first location of
the memory block.

 A pointer TOP contains the location of the top element of the stack.
 A variable MAXSTK contains the maximum number of elements that can be stored in
the stack.
 The condition TOP = MAXSTK indicates that the stack is full and TOP = NULL indicates
that the stack empty.
 Dynamic creation of a stack is not possible using arrays. This requires linked lists.

Linked list representation of a Stack
 The size of the array needs to be fixed to store the items into the stack.
 If the stack is full we cannot insert an additional item into the array. It gives an
overflow exception.
 But in linked list we can increase the size at runtime by creating a new node.

Insertion
 Insertion operation refers to Inserting an element into stack. We create a new node
and insert an element into the stack.
 To follow the stack principle “Last-in-first-out”, a node need to be created from the end
of the Linked list and element need to be inserted into the node from the end of the
linked list.

Deletion
 Deletion operation is to delete an element or node from the Linked list.
 Deletion can be done by deleting the top-most item from the stack as the last item
inserted is the first item that needs to be deleted as per stack principle.
 So the recently inserted item i.e, top item must be deletes from the linked list to
perform as stack deletion.

Operation on Stack
 stack() creates a new stack that is empty. It needs no parameters and returns an
empty stack.
 push(item) adds a new item to the top of the stack. It needs the item and returns
nothing.
 pop() removes the top item from the stack. It needs no parameters and returns
the item. The stack is modified.
 peek() returns the top item from the stack but does not remove it. It needs no
parameters. The stack is not modified.
 isEmpty() tests whether the stack is empty. It needs no parameters and returns a
Boolean value.
 size() returns the number of items on the stack. It needs no parameters and
returns an integer.

Algorithm for PUSH Operation: PUSH(STACK ,
TOP, SIZE, ITEM )
STACK is the array that contains N elements
and TOP is the pointer to the top element of
the array. ITEM the element to be inserted.
This procedure inserts ITEM into the STACK.
Step 1: If TOP = N -1then [check overflow]
PRINT “Stack is full”
Exit
End of If
Step 2: TOP = TOP + 1 [Increment the TOP]
Step 3: STACK[TOP] = ITEM [Insert the ITEM]
Step 4: Return
Algorithm for POP Operation: POP(STACK ,
TOP, ITEM)
STACK is the array that store N items. TOP is
the pointer to the top element of the array.
This procedure deleted top element from
STACK.
Step 1: If TOP = NULL then [check underflow]
PRINT “Stack is empty”
Exit
End of If
Step 2: ITEM = STACK[TOP] [Copy the top
element]
Step 3: TOP = TOP – 1 [Decrement the top]
Step 4: Return
PUSH POP

Application of Stacks
 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.
 Another application is an “undo” mechanism in text editors; this operation is
accomplished by keeping all text changes in a stack.
 Backtracking-This is a process when you need to access the most recent data element
in a series of elements. Think of a labyrinth or maze - how do you find a way from an
entrance to an exit? Once you reach a dead end, you must backtrack. But backtrack to
where? to the previous choice point. Therefore, at each choice point you store on a stack
all possible choices. Then backtracking simply means popping a next choice from the
stack.
 Language processing:
 Space for parameters and local variables is created internally using a stack.
 Compiler’s syntax check for matching braces is implemented by using stack.
 support for recursion

 Conversion of decimal number into binary
 To solve tower of Hanoi
 Expression evaluation and syntax parsing
 Conversion of infix expression into prefix and postfix.
 Rearranging railroad cars
 Quick sort
 Stock span problem
 Runtime memory management

QUEUES
Introduction
 A queue is an ordered collection of items where the addition of new items
and the removal of existing items always take place at different ends.
 A queue is an ordered collection of items where an item is inserted at one
end called the “rear,” and an existing item is removed at the other end, called
the “front.” Queues maintain a FIFO ordering property.
 Insertion and deletion is performed according to the first-in first-out (FIFO)
principle.
 An excellent example of a queue is a line of students in the food court of a
canteen.
 In the queue only two operations are allowed enqueue and dequeue.

 Queue is also called as FIFO list, i.e. First-In-First-Out. Here insertions are limited to
one end of the list called the rear, whereas deletions are limited to other end called
as front.

Types of queues
Queue can be of four types:
1. Simple Queue
2. Circular Queue
3. Priority Queue
4. Dequeue (Double Ended queue)
1. Simple Queue: In Simple queue insertion occurs at the rear end of the list, and
deletion occurs at the front end of the list.

2. Circular Queue: A circular queue is a queue in which all nodes are treated as circular
such that the last node follows the first node.
3. Priority Queue: A priority queue is a queue that contains items that have some preset
priority. An element can be inserted or removed from any position depending on some
priority.

4. Dequeue (Double Ended queue): It is a queue in which insertion and deletion takes
place at both the ends.

Operations on queue
The queue abstract data type is defined by the following structure and operations.
The queue operations are given below.
 Queue() creates a new queue that is empty. It needs no parameters and returns an
empty queue.
 enqueue(item) adds a new item to the rear of the queue. It needs the item and
returns nothing. This operation is generally called as push.
 dequeue() removes the front item from the queue. It needs no parameters and
returns the item. The queue is modified. This operation is generally called as pop.
 isEmpty() tests to see whether the queue is empty. It needs no parameters and
returns a Boolean value.
 size() returns the number of items in the queue. It needs no parameters and
returns an integer.

Memory representation of a queue using arrays
Queue is represented in memory linear array.
Let QUEUE be a linear queue.
 Two pointer variables called FRONT and REAR are maintained.
 The pointer variable FRONT contains the location of the element to be removed and
the pointer variable REAR contains location of the last element inserted.
 The condition FRONT = NULL indicates that the queue is empty and the condition
REAR = N indicates that the queue is full.

Memory representation of a queue using linked list
Queues are also represented using linked lists.
In queues an item should be inserted from rear end and an item should be removed
from the front end.
The pointer front contains location of the first node of the linked list and another
pointer rear contains location of the last node.

Algorithm for insertion Algorithm:
Let QUEUE be the linear array consisting of N
elements. FRONT is the pointer that contains the
location of the element to be deleted and REAR
contains the location of the inserted element.
Step 1: If REAR = N-1 Then [Check for overflow]
PRINT “Overflow”
Exit
Step 2: If FRONT = NULL Then [Check whether
QUEUE is empty]
FRONT = 0
REAR = 0
Else
REAR = REAR + 1 [Increment REAR
Pointer]
Step 3: QUEUE[REAR] = ITEM [Copy ITEM to REAR
position]
Step 4: Return
Algorithm for deletion Algorithm:
Let QUEUE is the linear array consisting of N elements.
FRONT is the pointer that contains the location of the
element to be deleted and REAR contains the location of
the inserted element. This algorithm deletes the
element at FRONT position.
Step 1: If FRONT = NULL Then [Check whether QUEUE is
empty]
PRINT “Underflow”
Exit
Step 2 : ITEM = QUEUE[FRONT]
Step 3: If FRONT = REAR
Then [If QUEUE has only one element]
FRONT = NULL
REAR = NULL
Else
FRONT = FRONT + 1 [Increment FRONT pointer]
Step 4: Return
QUEUE INSERTION QUEUE DELETION

Applications of queues
 Simulation
 Various features of operating system. [Operating systems often maintain a queue
of processes that are ready to execute or that are waiting for a particular event
to occur.]
 Multi-programming platform system
 Different type of scheduling algorithm
 Round robin technique or Algorithm
 Printer server routines
 Various applications software is also based on queue data structure
 Operating systems often maintain a queue of processes that are ready to
execute or that are waiting for a particular event to occur.

Linked Lists
Linked list A linked list is a linear collection of data elements called nodes and the
linear order is given by means of pointers.
Each node contains two parts fields:
the data and a reference to the next node.
The first part contains the information and the second part contains the address of the
next node in the list. This is also called the link field.

Types of linked lists
There are three types of linked lists.
1. Singly linked list (SLL)
2. 2. Doubly linked list (DLL)
3. 3. Circular linked list (CLL)
Single linked list
A singly linked list contains two fields in each node – the data field and link field.
The data field contains the data of that node while the link field contains address of the
next node. Since there is only one link field in each node, the linked list is called as
singly linked list.

Circular linked lists:
In a singly linked list, a pointer is available to access all the succeeding nodes, but
not preceding nodes.
In the singly linked lists, the link field of the last node contains NULL.
In circular lists, if the link field of the last node contains the address of the first node
first node, such a linked list is called as circular linked list. In a circular linked list, it
is possible to reach any node from any other node.

Doubly linked lists:
It is a linked list in which each node is points both to the next node and also to the
previous node.
In doubly linked list each node contains three parts – FORW, BACK and INFO.
BACK: It is a pointer field containing the address of the previous node.
FORW: It is a pointer field that contains the address of the next node.
INFO: It contains the actual data.

In the first node, if BACK contains NULL, it indicates that it is the first node in the list.
The node in which FORW contains NULL indicates that the node is the last node in the
linked list.

Operations on linked lists:
The operations that are performed on linked lists are
1. Creating a linked list
2. Traversing a linked list
3. Inserting an item into a linked list
4. Deleting an item from the linked list
5. Searching an item in the linked list
6. Merging two or more linked lists
Creating a linked list
Linked list is linear data structure which contains a group of nodes and the nodes
are sequentially arranged.
Nodes are composed of data and address of the next node or reference of the next
node. These nodes are sequentially or linearly arrayed that is why the Linked list is
a linear data structure.
The pointer START contains the location of the first node. Also the next pointer field
of the last node must be assigned to NULL.

The nodes of a linked list can be created by the following structure declaration.
struct Node
{
int data;
OR Node* link;
}
Node *node1, *node2;
struct Node
{
int data;
Node* link;
}
*node1, node2;

Here data is the information field and link is the link
field. The link field contains a pointer variable that
refers the same node structure. Such a reference is
called as self-addressing pointer.
To dynamically allocate memory, C++ language use the operators new and delete.
 Operator new allocates space.
 Operator new[] allocates memory space for array.
 Operator delete deallocate storage space.
 Operator delete[] deallocate memory space for array.

Operator new and new[]
Dynamic memory is allocated using operator
new. new is followed by a data type specifier
and, if a sequence of more than one element is
required, the number of these within brackets [].
It returns a pointer to the beginning of the new
block of memory allocated.
Syntax:
pointer = new type
pointer = new type [number_of_elements]
The first expression is used to allocate memory
to contain one single element of the required
data type. The second one is used to allocate a
block (an array) of elements of data type type,
where number_of_elements is an integer value
representing the amount of these.
For example, int *tmp;
tmp = new int [5]
Operator delete and delete[]
In most cases, memory allocated
dynamically is only needed during specific
periods of time within a program; once it is
no longer needed, it can be freed so that the
memory becomes available again for other
requests of dynamic memory. For this
purpose the operator delete is used.
Syntax:
delete pointer;
delete [] pointer;
The first statement releases the memory of
a single element allocated using new, and
the second one releases the memory
allocated for arrays of elements using new
and a size in brackets [].
Dynamically the memory space is allocated for
the linked list using new operator as follows:
Node *newNode;
p = new Node;
data(p) = num;
link(p) = NULL;

Traversing a linked list
Traversing is the process of accessing each node of the linked list exactly once to
perform some operation.
To traverse a linked list, steps to be followed are given here.
1. To begin with, move to the first node.
2. Fetch the data from the node and perform the required operation depending on the
data type.
3. Advance the pointer to the next node.
4. Step 2 and step 3 is repeated until all the nodes are visited.

Algorithm:
This algorithm traverses the linked list.
Here START contains the address of the first node. Another pointer p is temporarily
used to visit all the nodes from the beginning to the end of the linked list.
Step 1: p = START [Initialize p to first node]
Step 2: while p != NULL
Step 3: PROCESS data(p) [Fetch the data]
Step 4: p = link(p) [Advance p to next node]
Step 5: End of while
Step 6: Return

Memory allocation to a linked list
The operating system of the computer maintains a special list called AVAIL list that
contains only the unused deleted nodes.
AVAIL list is linked list that contains only the unused nodes. Whenever a node is deleted
from the linked list, its memory is added to the AVAIL list and whenever a node is to be
inserted into the linked list, a node is deleted from the AVAIL list and is inserted into the
linked list. AVAIL list is also called as the free storage list or free-pool.
Inserting a node into the linked list
A node can be inserted into the linked list only if there are free nodes available in the
AVAIL list. Otherwise, a node cannot be inserted. Accordingly there are three types of
insertions.
1. Inserting a node at the beginning of the linked list
2. Inserting a node at the given position.
3. Inserting a node at the end of the linked list

Inserting a node at beginning of the linked list
START is pointer that contains the memory address of the first node.
To insert an ITEM into the linked list, the following procedure is used.
1. Create a new node.
2. Fill data into the data field of the new node.
3. Mark its next pointer field as NULL.
4. Attach this newly created node to START.
5. Make the new node as the STARTing node.
Algorithm (inst-beg): This algorithm inserts a node at the beginning of the linked list.
1. p ->new Node;
2. data(p) ->num;
3. link(p) -> START
4. START -> p
5. Return

Inserting a node at the end of the linked list
We can insert a node at the end of the linked list. To insert at the end, we have to traverse
the liked list to know the address of the last node.
Algorithm (inst-end): Inserting a node at the end of the linked list.
1. START
2. [Identify the last node in the list]
a. p<- START
b. while p != NULL p<-next(p)
while end
3. N <-new Node [Create new node copy the address to the pointer N]
4. data(N) <- item
5. link(N) <- NULL
6. link(p) <- N 7. RETURN

Inserting a node at a given position
We can insert a node at a given position. The following procedure inserts a node at the
given position.
Algorithm (INST-POS): This algorithm inserts item into the linked list at the given position pos.
1. START
2. [[Initialize] count <- 0
p1 <- START
3. while (p1 != NULL)
count <- count +1
p1<- link(p1)
while end
4. a. if (pos = 1) call function INST-BEG()
else
b. if (pos = count +1) call function INST-END()
else
c. if( pos <= count)
p1 <- START
for (i = 1; i <= pos; i++ )
p1 <- next(p1)
For end
d. [create] P2<- new node
data(p2) <-item link
(p2) <- link(p1)
link(p1)<- p2
else
e. PRINT “ Invalid position “ 5. RETURN

Garbage collection:
 If a node is deleted from the linked list or if a linked list is deleted, we require the space
to be available for future use.
 The memory space of the deleted nodes is immediately reinserted into the free-storage
list.
 The operating system of the computer periodically collects all the deleted space into the
free-storage list. This technique of collecting deleted space into free-storage list is
called as garbage collection.
Deleting an item from the linked list:
The deletion operation is classified into three types:
1. Deletion of the first node
2. Deletion of the last node
3. Deletion of the node at the given position
Underflow
If we try to delete a node from the linked list which is empty, the condition is called as
underflow.

Deletion of the first node:
We can easily delete the first node of the linked list by changing the START to point to the
second node of the linked list. If there is only one node in the liked list, the START can be
stored with NULL.
Algorithm (DELE-BEG): This algorithm first copy data in the first node to a variable and
deletes the first node of the linked list.
Step1. START
Step2. p <- START
Step3. PRINT data(p)
Step4. START<- link(p)
Step5. free(p)
Step6. RETURN

Deleting a node at the end (DELE-END)
To delete the last node, we should find location of the second last node. By assigning
NULL to link field of the second last node, last node of the linked list can be deleted.
Algorithm (DELE-END): This used two pointers p1 and p2. Pointer p1 is used to traverse
the linked list and pointer p2 keeps the location of the previous node of p1.
1. START
2. p2 <- START
3. while ( link(p2) != NULL)
p1 <- p2
p2 <- link(p2)
while end
4. PRINT data(p2)
5. link(p1) <- NULL free(p1)
6. STOP

Deleting a node at the given position
To delete a node at the given position, the following procedure is used.
1. Find location of the node to be deleted and the previous node.
2. Delete the node to be deleted by changing the location of the previous node of the node
to be deleted.
Non-linear data structure
 A non-linear data structure is a data structure in which a data item is connected to
several other data items, so that a given data item has the possibility to reach one-
or-more data items.
 The data items in a non-linear data structure represent hierarchical relationship.
Each data item is called a node.
 Examples of non-linear data structures are Graphs and Trees.

TREES
A tree is a data structure consisting of nodes organized as a hierarchy

TERMINOLOGY
A node is a structure which may contain a value, a
condition, or represent a separate data structure
(which could be a tree of its own).
Each node in a tree has zero or more child nodes,
which are below it in the tree (by convention, trees are
drawn growing downwards).
A node that has a child is called the parent node (or
ancestor node, or superior). A node has at most one
parent.
Nodes that do not have any children are called leaf
nodes. They are also referred to as terminal nodes.
The height of a node is the length of the longest
downward path to a leaf from that node.
The depth of a node is the length of the path to its root
(i.e., its root path).

An internal node or inner node is any node of a tree that has child nodes and is thus not a
leaf node.
A subtree of a tree T is a tree consisting of a node in T and all of its descendants in T
Binary trees
The simplest form of tree is a binary tree.
 A binary tree is a tree in which each node has at most two descendants - a node can
have just one but it can’t have more than two.
 A binary tree consists of
 a node (called the root node) and
 left and right sub-trees.
 Both the sub-trees are themselves binary trees. The importance of a binary tree is that
it can create a data structure that mimics a “yes/no” decision making process.

Root Node: Node at the “top” of a tree - the one from which all operations on the tree
commence. The root node may not exist (a NULL tree with no nodes in it) or have 0, 1 or 2
children in a binary tree.
Leaf Node: Node at the “bottom” of a tree - farthest from the root. Leaf nodes have no
children.
Complete Tree: Tree in which each leaf is at the same distance from the root. i.e. all the
nodes have maximum two subtrees.
Height: Number of nodes which must be traversed from the root to reach a leaf of a tree.

GRAPHS
 A graph is a set of vertices and edges which connect them.
 A graph is a collection of nodes called vertices, and the connections between them,
called edges.
Undirected and directed graphs When the edges in a graph have a direction, the graph
is called a directed graph or digraph, and the edges are called directed edges or arcs

Neighbors and adjacency
A vertex that is the end point of an edge is called a neighbor of the vertex, that is its
starting-point. The first vertex is said to be adjacent to the second.
The following diagram shows a graph with 5 vertices and 7 edges. The edges between A
and D and B and C are pairs that make a bidirectional connection, represented here by a
double-headed arrow.

Datastructures using c++

More Related Content

What's hot (20)

Similar to Datastructures using c++ (20)

Recently uploaded (20)

Datastructures using c++