data structure and algorithm Array.pptx btech 2nd year

Department of Computer Science and Engineering (CSE)
ADVANCED DATA STRUCTURES
&
ALGORITHMS
(20CST-624,20CST-633)
Prepared By :DIVYA SINGH

ARRAYS
2
CO
Number
Title Level
CO1 To understand role of algorithms
in science and practice of
computing..
Remem
ber
CO2 To gain familiarization with
different algorithm design
techniques.
Understa
nd
CO3 To apply different algorithm design
techniques for solving engineering
and related problems and study their
performance.
Analysis
and
applicati
on
Course Outcome
Will be covered in
this lecture

Lecture Outcomes
 To understand the concept of arrays.
 To study the various operations on arrays.

Syllabus/Topics To be Covered
 Basic terminology
 Linear arrays and their representation, Traversing Linear
Array, Insertion & Deletion in arrays
 Searching – linear search, binary search
 Multi-dimensional arrays and their representation

Arrays
Linear array (One dimensional array) : A list of finite
number n of similar data elements referenced respectively by a
set of n consecutive numbers, usually 1, 2, 3,…..n. That is a
specific element is accessed by an index.
Let, Array name is A then the elements of A is : a1,a2….. An or by
the bracket notation A[1], A[2], A[3],…………., A[n].The number
k in A[k] is called a subscript and A[k] is called a subscripted
variable.

Arrays...
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
Linear arrays are called one dimensional arrays because each
element in such an array is referenced by one subscript.
(Two dimensional array) : Two dimensional array is a collection of
similar data elements where each element is referenced by two
subscripts.
Such arrays are called matrices in mathematics.
Multidimensional arrays are defined analogously
1
2
1 2 3 4
3
4
MATRICES
Here, MATRICES[3,3]=11

Array (con…)
Array Data Structure
1. It can hold multiple values of a single type.
2. Elements are referenced by the array name and an ordinal index.
3. Each element is a value
4. Indexing begins at zero in C.
5. The array forms a contiguous list in memory.
6. The name of the array holds the address of the first array element.
7. We specify the array size at compile time, often with a named constant or
at run time using calloc(), malloc() & realloc() in C and new in C++.
Arrays – Advantage & disadvantage
1. Fast element access.
2. Impossible to resize. Many applications require resizing so linked
list was introduced.

Traversing linear arrays
Print the contents of each element of DATA or Count the number of elements
of DATA with a given property. This can be accomplished by traversing DATA,
That is, by accessing and processing (visiting) each element of DATA exactly
once.
Algorithm: Given DATA is a linear array with lower bound LB and
upper bound UB . This algorithm traverses DATA applying an operation
PROCESS to each element of DATA.
1. Set K : = LB.
2. Repeat steps 3 and 4 while K<=UB:
3. Apply PROCESS to DATA[k]
4. Set K : = K+1.
5. Exit.

Linear Arrays
A linear array is a list of finite number n of homogeneous data elements(i.e. data
elements of same type)
a) The elements of the array are referenced respectively by an index set
b) The elements of the array are stored respectively in successive memory
locations.
Let, Array name is A then the elements of A is : a1,a2….. an
Or by the bracket notation A[1], A[2], A[3],…………., A[n]
1
2
3
4
5
6
247
56
429
135
87
156
DATA[1] = 247
DATA[2] = 56
DATA[3] = 429
DATA[4] = 135
DATA[5] = 87
DATA[6] = 156

Representation of linear array in memory
Let LA be a linear array in the memory of the computer. The memory of the
computer is a sequence of addressed locations.
1000
1001
1002
1003
1004
1005
LA
Fig : Computer memory
The computer does not need to keep track of the
address of every element of LA, but needs to keep
track only of the first element of LA, denoted by
Base(LA)
called the base address of LA. Using this address
Base(LA), the computer calculates the address of any
element of LA by the following formula :
LOC(LA[k]) = Base(LA) + w(K – lower bound)
Where w is the number of words per memory cell for
the array LA

Representation of linear array in memory
Example :
An automobile company uses an array AUTO to record
the number of auto mobile sold each year from 1932
through 1984. Suppose AUTO appears in memory as
pictured in fig A . That is Base(AUTO) = 200, and w = 4
words per memory cell for AUTO. Then,
LOC(AUTO[1932]) = 200, LOC(AUTO[1933]) =204
LOC(AUTO[1934]) = 208
the address of the array element for the year K = 1965
can be obtained by using :
LOC(AUTO[1965]) = Base(AUTO) + w(1965 – lower
bound)
=200+4(1965-1932)=332
200
201
202
203
204
205
206
207
208
209
210
211
212
AUTO[1932]
AUTO[1933]
AUTO[1934]
INDEX

Representation of linear array
in memory(contd.)
200 202 204 206 208 210 212 214 216 218 220 222 224 226 228 230
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Example:
LOC(LA[6])=200+2(6-0) = 200+12 = 212
LOC(LA[9])=200+2(9-0) = 200+18 = 218
LOC(LA[15])=200+2(15-0) = 200+30 = 230

Traversing linear arrays
Example :
An automobile company uses an array AUTO to record the number of auto
mobile sold each year from 1932 through 1984.
a) Find the number NUM of years during which more than 300 automobiles
were sold.
b) Print each year and the number of automobiles sold in that year
1. Set NUM : = 0.
2. Repeat for K = 1932 to 1984:
if AUTO[K]> 300, then : set NUM : = NUM+1
3. Exit.
1. Repeat for K = 1932 to 1984:
Write : K, AUTO[K]
2. Exit.

Insertion in an array
INSERTING AN ELEMENT INTO AN ARRAY:
Insert (LA, N, K, ITEM)
Here LA is linear array with N elements and K(position) is a positive integer
such that K<=N.This algorithm inserts an element ITEM into the Kth
position in LA.
ALGORITHM
Step 1. [Initialize counter] Set J:=N
Step 2. Repeat Steps 3 and 4 while J>=K
Step 3. [Move Jth element downward] Set LA [J+1]: =LA [J]
Step 4. [Decrease counter] Set J:=J-1
[End of step 2 loop]
Step 5 [Insert element] Set LA [K]: =ITEM
Step 6. [Reset N] Set N:=N+1
Step 7. Exit

Deletion from an array
DELETING AN ELEMENT FROM A LINEAR ARRAY
Delete (LA, N, K, ITEM)
Here LA is a linear array with N elements and k is a positive integer such that
K<=N. This algorithm deletes the Kth element from LA.
ALGORITHM
Step 1. Set ITEM: = LA [K]
Step 2. Repeat for steps 3&4 for J=K to N-1:
Step 3. [Move J+1st element upward] Set LA [J]: =LA [J+1]
Step4. [Increment counter] J=J+1
[End of step2 loop]
Step 5. [Reset the number N of elements in LA] Set N:=N-1
Step 6. Exit

Linear Search :
Algorithm : A linear array DATA with N elements and a specific ITEM of
information are given. This algorithm finds the location LOC of ITEM in
the array DATA or sets LOC = 0.
1. Set K : = 1, LOC : =0.
2. Repeat steps 3 and 4 while LOC = 0 and K<=N:
3. If ITEM = DATA[K], then : Set LOC : =K .
4. Set K : = K+1.
5. [Successful?]
If LOC = 0, then :
Write : ITEM is not in the array DATA.
Else :
Write : LOC is the location of ITEM.
[End of if structure]
6. Exit.
Searching – Linear search

Linear Search Program
if(c= =1)
{
cout<<"Number found at position: "<<l
}
else
{
cout<<"Number is not in the list";
}
getch( );
}
#include<iostream.h>
#include<conio.h>
void main( )
{
int a[100],n,i;
clrscr( );
cout << "Enter the size of an array:";
cin >> n;
cout <<"The elemets are:" << endl;
for( i=0; i<n; i++ )
{
cin >> a[i];
}
cout<<"Enter the element you want to search";
cin>>item;
for(i=0;i<n;i++)
{
if(arr[i]==item)
{
c=1;
loc=i;
break;
}
}

Linear Search complexity
 Linear Search :
 Best Case: Find at first place - one comparison
 Average case: There are n cases that can occur, i.e. find at the
first place, the second place, the third place and so on up to
the nth place.
average = (1+2+3.....+n)/n = n(n+1)/2n=(n+1)/2
where the result was used that 1+2+3 ...+n is equal to
n(n+1)/2.
 Worst case: Find at nth place or not at all - n comparisons

Searching –Binary Search
 Binary Search:
 Algorithm: Binary(DATA,LB,UB,ITEM): Here data is a
sorted array with lower bound LB and upper bound
UB and ITEM is an element to be searched. The
variables BEG,END and MID denote, resp, the
beginning, end and middle locations of a segment of
elements of DATA. This algorithm find the location
LOC of ITEM in DATA or sets LOC=NULL.

Binary Search Algorithm
BINARY(DATA, LB, UB, ITEM, LOC)
1. Set BEG=LB; END=UB; and MID=INT((BEG+END)/2).
2. Repeat step 3 and 4 while BEG ≤ END and DATA[MID] ≠ ITEM
3. If ITEM < DATA[MID] then
Set END= MID - 1
Else:
Set BEG= MID+1
[end of if structure]
4. Set MID= INT((BEG+END)/2)
5. If ITEM = DATA[MID] then
Set LOC= MID
Else:
Set LOC= NULL
[end of if structure]
6. Exit.

Binary Search example (Seek for 123)

Binary Search - Complexity
 O(log2 n) . Each comparison reduces the sample size in half. Hence we
require at most log2 n comparisons to locate ITEM. For Ex, there are 100
elements, so maximum number of comparisons to find the element will be:
log2 n = log2 100 => 2? =100
=> 27 =100
i.e. 7(6.643856) comparisons on 100 elements
 Limitations:
 The list must be sorted

Binary Search Program
#include<iostream.h>
#include<conio.h>
#include<stdlib.h>
#include<abstarry.h>
void main()
{
int a[20],n,beg,end,mid,f=0,element;
cout<<"nEnter number of elements:";
cin>>n;
cout<<"nEnter elements in sorted order:n";
for(int i=0;i<n;i++)
cin>>a[i];
cout<<"n You have entered:";
for(i=0;i<n;i++)
cout<<a[i]<<" ";
cout<<"nEnter element you want to search:";
cin>>element;
beg=0;
end=n-1;
while(beg<=end)
{
mid=(beg+end)/2;
if(element<a[mid])
beg=mid-1;
else if (element>a[mid])
beg=mid+1;
else if(element==a[mid])
{
cout<<"!..................!";
cout<<"nposition is:"<<mid;
cout<<"n!..................!";
f=1;
break;
}
}
if(f==0)
cout<<"nElement does not exist";
getch();
}

Multidimensional arrays
Two – dimensional Arrays
 Array having more than one subscript variable is called Multi-Dimensional array.
 A Two – dimensional Arrays 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 I, J), called subscripts.
 The element of A with first subscript I and second subscript J will be denoted by A[I,J]
A[3, 1] A[3, 2] A[3, 3]
A[1, 1] A[1, 2] A[1, 3]
A[2, 2]
A[2, 1] A[2, 3]
1
2
3
1 2 3
Rows
Columns
Fig: Two dimensional 3 x 3 array A

Declaration and Use of Two
Dimensional Array
 Declaration :
int a[3][4];
 Use :
for(i=0;i<3;i++)
{
for(j=0;j<4;j++)
{
cout<<a[i][j]<<“ “;
}
cout<<“n”;
}
Meaning of Two Dimensional Array :
1. Matrix is having 3 rows ( i takes value
from 0 to 2 )
2. Matrix is having 4 Columns ( j takes
value from 0 to 3 )
3. Above Matrix 3×4 matrix will have 12
blocks having 3 rows & 4 columns.
4. Name of 2-D array is ’a’ and each block is
identified by the row & column number.
5. Row number and column number starts
from 0.

Memory Representation of 2-D
array
 2-D arrays are Stored in contiguous memory location row
wise.
 Consider 3×3 Array is stored in contiguous memory
location which starts from some base address(e.g.4000) .
 Array element a[1][1] will be stored at address 4000, again
a[1][2]will be stored to next memory location i.e elements
stored row-wise.
 After Elements of First Row are stored in appropriate
memory location, then second row and so on.
 If we are taking integer array , then each element will
require 2 bytes of memory.

Array Representation of 2-D
array
 Column-major
 Row-major
 Arrays may be represented in Row-major form or Column-
major form.
 In Row-major form, all the elements of the first row are
printed, then the elements of the second row and so on up
to the last row.
 In Column-major form, all the elements of the first column
are printed, then the elements of the second column and so
on up to the last column.

Array Representation(contd..)
Index Memory Location Element
a[1][1] 4000 1
a[1][2] 4002 2
a[1][3] 4004 3
a[2][1] 4006 4
a[2][2] 4008 5
a[2][3] 4010 6
a[3][1] 4012 7
a[3][2] 4014 8
a[3][3] 4016 9
Index Memory Location Element
a[1][1] 4000 1
a[2][1] 4002 4
a[3][1] 4004 7
a[1][2] 4006 2
a[2][2] 4008 5
a[3][2] 4010 8
A[1][3] 4012 3
a[2][3] 4014 6
a[3][3] 4016 9
ARRAY
1 2 3
1
2
3
ROW-MAJOR
COLUMN-MAJOR

data structure and algorithm Array.pptx btech 2nd year

Recommended

More Related Content

Similar to data structure and algorithm Array.pptx btech 2nd year (20)

Recently uploaded (20)

data structure and algorithm Array.pptx btech 2nd year