Subject : BCS-303 Data Structure & Algorithms

Class : SYBSc (CS) – Semester III

Lecturer : Ms. Madhvi V. Oza
Unit II : Array, Records & Pointers
 Linear Array & its representation
 Traversing Linear Array
 Inserting & Deleting
 Searching Methods [Linear & Binary Search]
 Sorting Methods [Bubble Sort, Insertion Sort, Selection Sort]

 Linear Array and its representation in Memory :

A linear array, is a list of finite homogeneous data elements such that –
i. Elements of the array are referenced by consecutive index numbers.
ii. Elements of the array stored respectively at continuous memory locations.
The total number of elements in the array is the length of an array. It can be calculated
using the formula :
Length = UB – LB + 1
Where, UB = Upper Bound(Largest index number of array) & LB = Lower Bound(Smallest
index number of array).
An array can be declared as :
int x[5] = {10,20,30,40,50}; (Declaration & Initialization)
OR
int x[5]; (Declaration)

For the given array, Length can be calculated as :

Length = UB – LB + 1
Length(x) = 4 – 0 + 1
Length(x) = 5
1
A Computer does not keep track of every element in the array, but needs to keep track of
address of only first element called the base address.
We can perform various operations on a linear array, as :
1. Traversing
2. Inserting
3. Deleting
4. Searching
5. Sorting

 Traversing in Linear Array :

Traversing refers to visiting or processing each element atleast once. Traversal is done by
starting with the first element of the array and reaching to the last.
For e.g. To print all the elements of an array, To count the number of elements of the
array.
Algorithm : TraverseLA(LA, LB, UB)
Description : Here, Consider ‘LA’ is the Linear array with Lower Bound ‘LB’ and Upper
Bound ‘UB’. This algorithm traverses array LA applying an operation ‘PROCESS’ to each
element of ‘LA’ .

Step 1 : [Initialize Counter] Set k := LB

Step 2 : Repeat Steps 3 & 4 while k<=UB
Step 3 : [Visit Element] Apply PROCESS to LA[k]
Step 4 : [Increase Counter] Set k := k+1
Step 5 : Exit
We also can use alternative form of algorithm which uses a repeat-for loop instead of the
repeat-while loop.

OR
Step 1 : Repeat for K= LB to UB
Step 2 : Apply PROCESS to LA[K]
[End of Loop].
Step 3 : Exit
2
Write a program to traverse & print all the elements of a linear array.
#include<stdio.h>
#include<conio.h>
void main()
{
int LA[5];
clrscr();
for(int k=0;k<=4;k++)
{
printf(“%d”,LA[k]);
}
getch();
}

 Insertion in Linear Array :

Insertion is the operation in which a new value is added at a particular place in an array.
Inserting element into the array is the process of adding an element to the existing
elements of the array.
Insertion in Linear Array involves three cases, as :
1. At the beginning
2. At a given location
3. At the end
Insertion involves movement of all the existing elements one position backwards & empty
the given location to insert new element.
Algorithm : InsertLA (DATA, N, ITEM, LOC)
Description : This algorithm inserts new element ITEM in linear array DATA with N
elements.
When LOC=1/0 it means the element has to be inserted at the beginning.
When LOC = J, it means the elements have to be inserted at J-th (given) Location.
When LOC =N+1 it means the element have to be inserted at the end.

3
Step 1 : [Initialize counter k with index of last element] Set k :=N-1
Step 2 : While k>=LOC repeat steps 3 and 4
Step 3 : [Move the current element one position backwards]
DATA[k+1] :=DATA[k]
Step 4 : [Decrement counter k] Set k :=k-1
Step 5 : [Insert new element at the Location] DATA[LOC] :=ITEM
Step 6 : [Update total number of array elements] Set N:=N+1

For e.g. Consider an array with 5 elements.

4
Write a Program to insert new element in array.
#include<iostream.h>
#include<conio.h>
void main()
{
int DATA[50],N,ITEM,LOC=0;
clrscr();
cout<<"Enter size of Array : ";
cin>>N;
cout<<"Enter array elements : ";
for(int k=0;k<N;k++)
{
cin>>DATA[k];
}
cout<<"\nArray elements before insertion : ";
for(k=0;k<N;k++)
{
cout<<DATA[k]<<"\t";
}
for(k=N-1;k>=LOC;k--)
{
DATA[k+1]=DATA[k];
}
cout<<"\nEnter element to be inserted :";
cin>>ITEM;
DATA[LOC]=ITEM;
cout<<"\nArray elements after insertion : ";
for(k=0;k<N;k++)
{
cout<<DATA[k]<<"\t";
}
N++;
getch();
}

 Deletion in Linear Array :

Deletion refers to removing an existing element from the array and re-organizing all
elements of an array.

5
Deletion in Linear Array involves three cases, as :
1. At the beginning
2. At a given location
3. At the end
Delete the element and shift the rest of the elements to left by one position.
Algorithm : DeleteLA (DATA, N, ITEM, LOC)
Description : This algorithm deletes an element at given position in a linear array DATA
with N elements and stores in ITEM.
When LOC=1/0 it means the element to be deleted is at the beginning
When LOC =N it means the element to be deleted is at the end
When LOC = N-1 it means the element to be deleted is at J-th (given) location.

Step 1 : [Initialize counter k with index of element to be deleted] Set k:=LOC

Step 2 : [Store the element to be deleted in ITEM]
ITEM:=DATA[LOC]
Step 3 : While k<N repeat steps 4 and 5
Step 4 : [Move the current element one position forward]
DATA[k]=DATA[k+1]
Step 5 : [Increment counter k] Set k:=k+1
Step 6 : [Update total number of array elements] Set N:=N-1

6
Write a Program to delete existing element from linear array.
#include<iostream.h>
#include<conio.h>
void main()
{
int DATA[50],N,ITEM,LOC=2;
clrscr();
cout<<"Enter Size of Array : ";
cin>>N;
cout<<"\nEnter Array elements : ";
for(int k=0;k<N;k++)
{
cin>>DATA[k];
}
cout<<"\nArray elements before deletion : ";
for(k=0;k<N;k++)
{
cout<<DATA[k]<<"\t";
}
ITEM=DATA[LOC];
for(k=LOC;k<N;k++)
{
DATA[k]=DATA[k+1];
}
cout<<"\nArray elements after deletion : ";
for(k=0;k<N;k++)
{
7
cout<<DATA[k]<<"\t";
}
getch();
}

 Searching Methods - Linear & Binary Search :

Searching in data structure refers to the process of finding location LOC of an element in
a list.
It is the process of finding a given value position in a list of values.
Any search is said to be successful or unsuccessful depending upon whether the element
that is being searched is found or not.
To search an element in a given array, two popular algorithms are available:

1. Linear Search [Sequential Search] :

Linear search is the simplest searching algorithm that searches for an element in a list in
sequential order. We start at one end and check every element until the desired element
is not found.
It compares the element to be searched with all the elements present in the array. When
the element is matched successfully, it returns the index of the element in the array, else
it return -1 or NULL.
It can be applied on both Sorted or Unsorted array, yet highly used for unsorted array.
The time complexity of the linear search is O(N) because each element in an array is
compared only once.

For e.g. : Consider x=20

If we need to search the element 20, it will go step by step in a sequential order, thus it is
also called sequential search.

8
Algorithm : LinearSearch (DATA, LB, UB, ITEM)
Description : This algorithm traverses & searches for the given element ITEM in the
linear array DATA with Lower Bound LB & Upper Bound UB.
Step 1 : [Initialize Counter k to the first index] Set k:=LB
Step 2 : Repeat Step 3 While k<=UB
Step 3 : [Check if the ITEM is equal with the array element]
IF DATA[k] = ITEM THEN
Set LOC := k
ELSE
Set k := k+1
Step 4 : If LOC != k then Set LOC :=NULL
Step 5 : Exit

Write a Program to perform Linear search for a given value in an unsorted

list.
#include<iostream.h>
#include<conio.h>
void main()
{
int DATA[50],N,ITEM,LOC=0;
clrscr();
cout<<"Enter Size of Array : ";
cin>>N;
cout<<"Enter Array Elements : ";
for(int k=0;k<N;k++)
{
cin>>DATA[k];
}
cout<<"\n\nArray Elements : ";
for(k=0;k<N;k++)
{
cout<<DATA[k]<<"\t";
}
cout<<endl<<"Enter item to be searched : ";

9
cin>>ITEM;
k=0;
while(k<N)
{
if(DATA[k]==ITEM)
{
LOC=k;
break;
}
else
{
k++;
}
}
if(LOC!=0)
{
cout<<"Item to be searched is at location : "<<LOC;
}
else
{
cout<<"Search Unsuccessful";
}
getch();
}

10
 2. Binary Search In Linear Array :
When the given data structure has large no. of data elements, the efficiency of linear
search decreases. Thus, another searching technique can be used as Binary Search.
Binary search follows divide and conquer approach in which, the list is divided into two
halves. The element to be searched may be either in the first half or the second half. The
algorithm goes on dividing each part into its two sub-parts for searching.
Due to this, the no. of comparisons to be performed are automatically reduced. For binary
search the data structure should be in the sorted form.
In Binary Search, the Smallest index is called BEGINNING and the Largest index is called
END, while the MIDDLE element index is called MID.
To divide the array into two halves, i.e. to get the middle index value of array, a formula is
used as :
MID = INT((BEG + END)/2)
 IF the ITEM to be searched is equal to the value of MID, LOC is set to MID, as :
If ITEM=DATA[MID] then
LOC=MID

 IF the ITEM to be searched is greater than the value of MID, Set BEG = MID + 1, as :
If ITEM>DATA[MID] then
BEG = MID + 1

 IF the ITEM to be searched is less than the value of MID, Set END=MID – 1, as :
If ITEM<DATA[MID] then
END=MID – 1
For e.g. Let DATA be the Linear Array with 10 elements.
DATA[10] = { 11,22,30,33,40,44,50,60,66,77 }
Find LOC of 44 using Binary Search?
DATA[10] = { 11,22,30,33,40,44,50,60,66,77 }
Solution : Here ITEM = 44,
Set BEG=1, End=10
11
MID = INT((BEG + END)/2)
= INT((1+10)/2)
= INT(11/2)
= INT(5.5)
MID = 5, thus DATA[5] = 40
Since ITEM > DATA[MID]
i.e. 44 > 40
Thus, BEG = MID + 1
= 5+1
BEG = 6
Now,
MID = INT((BEG + END)/2)
= INT(( 6+10 )/2)
= INT (16 / 2)
= INT(8)
MID = 8, thus DATA[8] = 60
Since ITEM < DATA[MID]
i.e. 44 < 60
Thus, END = MID - 1
= 8-1
END = 7

Now,
MID = INT((BEG + END)/2)
= INT(( 6+7 )/2)
= INT (13 / 2)
= INT(6.5)
MID = 6, thus DATA[6] = 44
Since ITEM = DATA[MID]
i.e. 44 = 44
Thus, LOC = MID
LOC = 6
The search is successful.

Algorithm : BinarySearch (DATA, LB, UB, ITEM, BEG, END, MID)

Description : This algorithm uses binary search method to search a given element ITEM in
the sorted linear array DATA by dividing the array into two parts until the element is found.

Here, DATA is sorted array with lower bound LB & upper bound UB. The variables BEG,
END & MID denotes the Beginning, End & Middle locations of the array.
12
This algorithm finds the location of LOC or sets LOC=NULL if the search is unsuccessful.

Step 1 : [Initialize Segment Variables] Set BEG:=LB, END:=UB &

MID:=INT((BEG+END)/2)

Step 2 : Repeat Steps 3 & 4 while BEG<=END & DATA[MID]!=ITEM

Step 3 : If ITEM < DATA[MID] then
Set END := MID-1
Else
Set BEG := MID+1
Step 4 : Set MID:=INT((BEG+END)/2)
Step 5 : If DATA[MID]=ITEM then
Set LOC:=MID [Search Successful]
Else
Set LOC:=NULL [Search Unsuccessful]
Write a program to perform Binary Search for a given value in a sorted list.
#include<iostream.h>
#include<conio.h>
void main()
{
int DATA[50],N,ITEM,LOC=0;
int BEG,END,MID=int((BEG+END)/2);
clrscr();
cout<<"Enter Size of Array : ";
cin>>N;
cout<<"Enter Array Elements : ";
for(int k=0;k<N;k++)
{
cin>>DATA[k];
}
cout<<"\n\nArray Elements : ";
13
for(k=0;k<N;k++)
{
cout<<DATA[k]<<"\t";
}
cout<<endl<<"Enter item to be searched : ";
cin>>ITEM;
while(BEG<=END && DATA[MID]!=ITEM)
{
if(ITEM<DATA[MID])
{
END=MID-1;
}
else
{
BEG=MID+1;
}
MID=int((BEG+END)/2)
}
if(DATA[MID]==ITEM)
{
LOC=MID;
cout<<"Item is at location : "<<LOC;
}
else
{
cout<<"Search Unsuccessful";
}
getch();
}

14
  Sorting in Linear Array :
Sorting Operation is used to arrange the data items in some logical order. Sorting is
ordering a list of objects. A Sorting Algorithm is used to rearrange a given array or list
elements in ascending or descending order or either in alphanumeric order.
There are various methods for sorting linear arrays, some of them are :
1. Bubble Sort
2. Insertion Sort
3. Selection Sort
Let us describe each of these methods in detail, as :

 Bubble Sort : Bubble Sort is the simplest sorting algorithm for small list.
It compares the adjacent elements and swaps their positions if they are not in the
desired order.
Starting from the first index, it compares the first and the second element. If the
first element is greater than the second element, they are swapped. If we have
total N elements, we need to repeat this process for N-1 times.
It is known as bubble sort, because with every complete iteration the largest
element in the given array, bubbles up towards the last place or the highest index,
just like a water bubble rises up to the water surface.
For e.g. Let DATA be array in memory as follows :
DATA[4] = {9,5,7,11}
Sort the given array using Bubble sort.

15
Algorithm : BubbleSort(DATA, PTR, K, N)
Description : Here, DATA is the linear array with N elements. PTR is the pointer variable
that executes the passes and K is the counter variable that iterates the loop from lower
bound to upper bound of the array.
This algorithm sorts the given array in increasing numerical order.

Step 1 : [Initialize counter variable] Repeat steps 2 & 3 for k = 0 to N-1

Step 2 : [Initialize Pass Pointer] Set PTR := 0
Step 3 : [Execute Pass] Repeat while PTR<=N-k
a) If DATA[PTR]>DATA[PTR+1] then
SWAP DATA[PTR] & DATA[PTR+1]
b) Set PTR :=PTR+1
Step 4 : Exit
Write a Program that implement Bubble Sort, to sort a given list of integers
in ascending order.
#include<iostream.h>
#include<conio.h>
void main()
{
int DATA[50],N,TEMP,ptr;
clrscr();
cout<<"Enter the size of array : ";
cin>>N;
cout<<"\nEnter Array Elements : ";
for(int k=0;k<N;k++)
{
16
cin>>DATA[k];
}
cout<<"\nArray before sorting : ";
for(k=0;k<N;k++)
{
cout<<DATA[k]<<"\t";
}
for(k=0;k<N;k++)
{
for(ptr=0;ptr<N-k;ptr++)
{
if(DATA[ptr]>DATA[ptr+1])
{
TEMP=DATA[ptr];
DATA[ptr]=DATA[ptr+1];
DATA[ptr+1]=TEMP;
}
}
}
cout<<"\n\nArray after Bubble Sort : ";
for(k=0;k<N;k++)
{
cout<<DATA[k]<<"\t";
}
getch();
}

 Selection Sort : Selection sort is an algorithm that selects the smallest element from
an unsorted list in each iteration and places that element at the beginning.
First, find the smallest element of the array and place it on the first position. Then,
find the second smallest element of the array and place it on the second position.
The process continues until we get the sorted array.
The array with n elements is sorted by using n-1 pass of selection sort algorithm.
For e.g. Let DATA be array in memory as follows :
DATA[6] = {40,20,60,10,50,30}
Sort the given array using Selection sort.

17
Algorithm : SelectionSort(DATA, N, k, MIN, TEMP, PTR,LOC)
Description : Here, DATA is the linear array with N elements. PTR is the pointer variable to
execute the passes and TEMP is the temporary variable that stores the value of elements.
LOC stores the location of value to be swapped.
This algorithm sorts the array DATA by repeatedly finding the minimum element
(considering ascending order) from the list and putting it at the beginning.
Step 1 : Repeat Steps 2,3 and 4 for k=0 to N-1
Step 2 : Set MIN := DATA[k]
Step 3 : Repeat for ptr = k+1,k+2, _ _ _ _, k+N
If DATA[ptr] < MIN then
MIN = DATA[ptr] & LOC=ptr

Step 4 : Set TEMP := DATA[k]

DATA[k] := DATA[LOC]
DATA[LOC] := TEMP
Step 5 : Exit

Write a Program that implement Selection Sort, to sort a given list of integers
in ascending order.
#include<iostream.h>
#include<conio.h>
void main()
{
int DATA[50],N,TEMP,ptr,LOC,MIN;
clrscr();
18
cout<<"Enter size of array : ";
cin>>N;
cout<<"\nEnter Array Elements : ";
for(int k=0;k<N;k++)
{
cin>>DATA[k];
}
cout<<"\n\nArray before sorting : ";
for(k=0;k<N;k++)
{
cout<<DATA[k]<<"\t";
}
for(k=0;k<N;k++)
{
MIN=DATA[k];
for(ptr=k+1;ptr<N;ptr++)
{
if(DATA[ptr]<MIN)
{
MIN=DATA[ptr];
LOC=ptr;
}
}
if(MIN!=DATA[k])
{
TEMP=DATA[k];
DATA[k]=DATA[LOC];
DATA[LOC]=TEMP;
}
}
cout<<"\n\nArray after Selection Sort :";
for(k=0;k<N;k++)
{
cout<<DATA[k]<<"\t";
}
getch();
}

19
  Insertion Sort : Insertion sort works similarly as we sort cards in our hand in a card
game. We assume that the first card is already sorted then we select an unsorted
card. If the unsorted card is greater than the card in hand, it is placed on the right
otherwise, to the left.
In the same way, other unsorted cards are taken and put at their right place. A
similar approach is used by insertion sort.
Insertion sort is a sorting algorithm that places an unsorted element at its suitable
place in each iteration. It is efficient for smaller data sets.
For e.g. Let DATA be array in memory as follows :
DATA[5] = {4,8,6,2,3}
Sort the given array using Insertion sort.

Algorithm : InsertionSort(DATA, N, k, TEMP, PTR)

Description : Here, DATA is the linear array with N elements. PTR is the pointer variable to
execute the passes and TEMP is the temporary variable that stores the value of elements.
This algorithm sorts the array DATA by comparing adjacent elements and shifting their
location as required.

20
Step 1 : Repeat steps 2 to 4 for k=1,2,_ _ _, N-1
Step 2 : Set TEMP :=DATA[k] & PTR :=k-1
Step 3 : Repeat while PTR>=0 && TEMP < DATA[PTR]
a) Set DATA[PTR+1] := DATA[PTR]
b) Set PTR := PTR – 1
Step 4 : [Insert element at proper position]
Set DATA[PTR+1] :=TEMP
Step 5 : Exit
Write a Program that implement Insertion Sort, to sort a given list of integers
in ascending order.
#include<iostream.h>
#include<conio.h>
void main()
{
int DATA[50],N,TEMP,ptr;
clrscr();
cout<<"Enter size of array : ";
cin>>N;
cout<<"\nEnter Array Elements : ";
for(int k=0;k<N;k++)
{
cin>>DATA[k];
}
cout<<"\n\nArray before sorting : ";
for(k=0;k<N;k++)
{
cout<<DATA[k]<<"\t";
}
for(k=0;k<N;k++)
{
TEMP=DATA[k];
ptr=k-1;
while(ptr>=0 && TEMP<DATA[ptr])
{
DATA[ptr+1]=DATA[ptr];
21
 ptr--;
}
DATA[ptr+1]=TEMP;
}
cout<<"\n\nArray after Insertion Sort : ";
for(k=0;k<N;k++)
{
cout<<DATA[k]<<"\t";
}
getch();
}

22
PROGRAMS FOR PRACTICE :
Q. Write a program to get input of size of array & array elements & sort them.
Also ask user which sorting technique to be used to sort the array.
#include<iostream.h>
#include<conio.h>
void main()
{
int DATA[50],N,TEMP,ptr,ch,MIN,LOC;
clrscr();
cout<<"Enter the size of array : ";
cin>>N;
cout<<"\nEnter Array Elements : ";
for(int k=0;k<N;k++)
{
cin>>DATA[k];
}
cout<<"\nArray before sorting : ";
for(k=0;k<N;k++)
{
cout<<DATA[k]<<"\t";
}
cout<<"\n\nEnter sorting technique to be used : 1.Bubble Sort\t2.Selection
Sort\t3.Insertion Sort : ";
cin>>ch;
switch(ch)
{
case 1:
for(k=0;k<N;k++)
{
for(ptr=0;ptr<N-k;ptr++)
{
if(DATA[ptr]>DATA[ptr+1])
{
TEMP=DATA[ptr];
DATA[ptr]=DATA[ptr+1];
DATA[ptr+1]=TEMP;
}
}
}
cout<<"\n\nArray after Bubble Sort : ";
for(k=0;k<N;k++)

23
{
cout<<DATA[k]<<"\t";
}
break;
case 2:
for(k=0;k<N;k++)
{
MIN=DATA[k];
for(ptr=k+1;ptr<N;ptr++)
{
if(DATA[ptr]<MIN)
{
MIN=DATA[ptr];
LOC=ptr;
}
}
if(MIN!=DATA[k])
{
TEMP=DATA[k];
DATA[k]=DATA[LOC];
DATA[LOC]=TEMP;
}
}
cout<<"\n\nArray after Selection Sort :";
for(k=0;k<N;k++)
{
cout<<DATA[k]<<"\t";
}
break;
case 3:
for(k=0;k<N;k++)
{
TEMP=DATA[k];
ptr=k-1;
while(ptr>=0 && TEMP<DATA[ptr])
{
DATA[ptr+1]=DATA[ptr];
ptr--;
}
DATA[ptr+1]=TEMP;
}
cout<<"\n\nArray after Insertion Sort : ";
for(k=0;k<N;k++)
24
{
cout<<DATA[k]<<"\t";
}
break;
default :
cout<<”Invalid Choice”;
}
getch();
}

Q. Write a Program to reverse the elements of an array with its algorithm.

Step 1 : Take input of array elements.
Step 2 : Traverse the array
Step 3 : Print the array elements in reverse loop.

#include<iostream.h>
#include<conio.h>
void main()
{
int DATA[10],N,k;
clrscr();
cout<<”Enter the size of array : “;
cin>>N;
cout<<”\nEnter Array Elements : “;
for(k=0;k<N;k++)
{
cin>>DATA[k];
}
for(k=N-1;k>=0;k--)
{
cout<<DATA[k];
}
getch();
}

25
Q. Write a program to find the sum of ten numbers in a given array with its
algorithm.
Step 1 : Take input of 10 array elements.
Step 2 : Traverse the array
Step 3 : Add all the array elements in a variable sum.

#include<iostream.h>
#include<conio.h>
void main()
{
int DATA[10],k,sum=0;
clrscr();
cout<<”\nEnter Array Elements : “;
for(k=0;k<9;k++)
{
cin>>DATA[k];
}
for(k=0;k<9;k++)
{
sum=sum+DATA[k];
}
cout<<”Sum of all array elements = “<<sum;
getch();
}

26