PPT Lecture 2.2.1 onn c++ data structures

DISCOVER . LEARN . EMPOWER
Arrays
INSTITUTE - UIE
DEPARTMENT- ACADEMIC UNITS
Bachelor of Engineering (Computer Science & Engineering)
Subject Name: Elementary Data Structure Using C++
Code:23CSH-103

Elementary Data
Structure Using C++
Course Objectives
2
• To enable the students to understand various stages
and constructs of C++ programming language.
• To improve their ability to analyze and address variety
of problems in C++.
• To understand the concept of data structures and
various operations on them.
• To understand the properties of various data structures
and able to identify the strengths and weaknesses of
different data structures.
• To analyze and compare the efficiency of algorithms
and learn to design efficient algorithms for solving
computing problems

3
CO
Number
Course Outcome
CO1 Understand the concepts of object-oriented programming including
programming process and compilation process.
CO2 Apply different techniques to decompose a problem and
programmed a solution with various concepts of object-oriented
programming language.
CO3 Analyse and explain the behaviour of linear data structure
operations using the programming addressed in the course.
CO4 Implement and evaluate the programs using the syntax and
semantics of object-oriented programming.
CO5 Design the solution of real-world problems in order to determine
that the program performs as expected.
Course Outcomes

• An array is a collection of items stored at
contiguous memory locations. The idea is
to store multiple items of the same type
together.
• This makes it easier to calculate the
position of each element by simply adding
an offset to a base value, i.e., the memory
location of the first element of the array
(generally denoted by the name of the
array).
5
Arrays
http://www.mathcs.emory.edu/~cheung/Courses/171/
Syllabus/1-intro/rev=arrays.html

• 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
• Array Data Structure
• It can hold multiple values of a single type.
• Elements are referenced by the array name and an ordinal
index.
• Each element is a value.
• Indexing begins at zero in C.
• The array forms a contiguous list in memory.
6
Arrays
https://www.chegg.com/homework-help/questions-and-
answers/matrix-array-vector-rows-data-frame-table-columns-
lists-r-data-types-true-true-true-true-f-q28713018

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.
Traversing a linear structure means moving
through it sequentially, node by node.
Processing the data element of a node may be
complex, but the general pattern is as follows:
Begin at the first node
Repeat until there are no more nodes
Process the current node
Move to the next node
7
Traversing linear
Arrays
https://www.sqa.org.uk/e-learning/LinkedDS02CD/page_46.htm

To implement array data
structure, memory bytes must be reserved and
the accessing functions must be coded. In case
of linear arrays, the declaration statements tell
how many cells are needed to store the array.
Each box represents the amount
of memory needed to hold one array element.
Pointers hold the memory address of other
data and are represented by a black disk with
an arrow pointing to the data it references.
The actual array variable, a in this example, is
a pointer to the memory for all of its elements.
8
Representation of
linear array in
memory
https://slideplayer.com/slide/7853049/

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.
9

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
10

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
11

Linear & Binary Search
• 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
• 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.
12

Searching – Linear Search Algorithm
• 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.
Set K : = 1, LOC : =0.
1. Repeat steps 3 and 4 while LOC = 0 and K<=N:
2. If ITEM = DATA[K], then : Set LOC : =K .
3. 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.
13

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.
14

Applications
• Array can be used for sorting elements, can perform matrix
operation & can be used in CPU scheduling.
• Stack is used in Expression evaluation
• Disk Scheduling.
15

• Application:
Two of the most essential applications performs on an array or a
record are searching and sorting.
• Searching: Each index in a parallel array corresponds to the data
belonging to the same entity in a record. Thus, for searching an entity
based on a specific value of an attribute, e.g. we need to find the
name of a person having height >200 cms in the above example.
Thus, we search for the index in the height array having value greater
than 200. Now, once we have obtained the index, we print the values
of the index in the first_name and last_name arrays. This way
searching becomes an easy task in parallel array.
• Sorting: Now, using the same fact that each index corresponds to
data items in different arrays corresponding to the same entity. Thus,
we sort all arrays based on the same criteria. For example, in the
above-displayed example, we need to sort the people in increasing
order of their respective heights. Thus, when we swap the two
heights, we even swap the corresponding values in other arrays using
the same index. 16

REFERENCES
• Lipschutz, Seymour, “Data Structures”, Schaum's Outline Series, Tata McGraw Hill.
• Goodrich, Michael T., Tamassia, Roberto, and Mount, David M., “Data Structures and Algorithms in C++”, Wiley
Student Edition.
• https://www.tutorialspoint.com/data_structures_algorithms/algorithms_basics.htm
• https://www.cs.utexas.edu/users/djimenez/utsa/cs1723/lecture2.html
• Gilberg/Forouzan,” Data Structure with C ,Cengage Learning.
• Augenstein,Moshe J , Tanenbaum, Aaron M, “Data Structures using C and C++”, Prentice Hall of India
17

PPT Lecture 2.2.1 onn c++ data structures

More Related Content

Similar to PPT Lecture 2.2.1 onn c++ data structures

Recently uploaded

PPT Lecture 2.2.1 onn c++ data structures