L1 - Recap.pdf

Lecture 1
Introduction & Recap

Class Information
2
Introduction
• Course materials and updates will
be posted in Google Classroom
➢Theory: axfdwfw
➢Lab: 4jtui4k
• If you have any course related
query, you can talk to me in the
office or email me at:
iftekharul.islam@bu.edu.bd

Course Title: Algorithm
Course Code: CSE-2201
Credit: 3.00
Contact
Hours:
3 Hrs./Week
Total Marks: 100
Course Information
3
Introduction

Prerequisites
4
Introduction
Programming
(CSE 1201)
Data Structure
(CSE 2103)
Discrete Math
(CSE 2105)
Strong conceptual clarity
will be assumed
Recursion will come into
play in various chapters

Resources
5
Textbooks:
✓ ‘Introduction to Algorithms’ (3rd Edition)
by Cormen, Leiserson, Rivest and Stein
✓ ‘Fundamentals of Computer
Algorithms’ by Horowitz, Sahni,
Rajasekaran
Recommended Online Reads:
✓ https://www.tutorialspoint.com/design_an
d_analysis_of_algorithms/index.htm
Introduction
Note: Materials from other resources may also be used
in the course for better conceptual clarity.

Evaluation
6
Introduction
Sl
No.
Description
Marks
distribution
1 Mid-term examination 30
2 Assignments/Viva 10
3 Attendance 10
4 Final term examination 50
Total 100

Evaluation (Lab)
7
Introduction
Sl
No.
Description
Marks
distribution
1 Assignments (3-4) 40-80%
2 Viva/Quiz 10%
3 Attendance 10%
4 Final Evaluation 0-40%
Total 100

Tips for Doing Well in this Course
8
Introduction
Review the lecture
topics at home
(using your notes, books
and online resources)
Attend all classes &
be attentive
Take good notes
(during and after class)
Complete given
readings and
assignments
A lot of topics to cover! 😄
(Click here to have a glance)

Data Structure
• The logical or mathematical model of a particular
organization of data is called a data structure.
Data Structures Recap 9
• Linear DS
• the elements are stored in a
linear or sequential order
(logically or conceptually)
• Examples:
• Array
• Linked list
• Stack
• Queue
• Non-linear DS
• the elements are not stored
in a linear or sequential order
(logically or conceptually)
• Examples:
• Tree
• Graph

Classification of Data Structure
Array
• An array is a collection of similar data elements
• stored in consecutive memory locations
• referenced by an index (subscript)
✓ Subscript Notation:
• A1, A2, A3, . . . , An
✓ Parenthesis Notation
• A(1), A(2), A(3),. . . , A(n)
✓ Bracket Notation
• A[1], A[2], A[3], . . . , A[n]
10
An array named A with 8 elements (integers).
Data Structures Recap

Linked List
• A linked list or one way list is a linear collection of data elements,
called nodes, where the linear order is given by means of pointers.
• Each node is divided into two parts:
– The first part - the data of the element/node
– The second part- the address of the next node
• special pointer: Start (or Head)
11

Stack
• Last-in-First-out (LIFO)
• A linear list in which
insertion and deletions can
take place only at one end,
called the top.
12
A stack of dishes
https://en.wikipedia.org/wiki/Stack_(abstract_data_type)
TOP

Queue
• First-in-First-out (FIFO)
• A linear list in which
– Deletions (or dequeue) can take place only at one end of the list (The
front of the list)
– Insertion (or enqueue) can take place only at the other end of the list
(The rear of the list)
13
REAR FRONT

Tree
• A tree is a non-linear data
structure which consists of a
collection of nodes arranged in
a hierarchical order.
• One of the nodes is designated
as the root node, and the
remaining nodes can be
partitioned into disjoint sets
such that each set is a sub-tree
of the root.
14
Directory Structure in a computer
https://comp.chem.nottingham.ac.uk

Graphs
• A graph is a non-linear data structure which is a collection of vertices
(also called nodes) and edges that connect these vertices.
• A graph is often viewed as a generalization of the tree structure,
where instead of a purely parent-to-child relationship between tree
nodes, any kind of complex relationships between the nodes can exist.
15
A Graph

Summary
of
Time
Complexities
for
various
DS
(worst
case)
Data structure Access Search Insertion Deletion
Array O(1) O(N)
at the
beginning
in the
middle
at the end
from the
beginning
from the
middle
from the
end
O(N) O(N) O(1) O(N) O(N) O(1)
Singly Linked list O(N) O(N) O(1) O(N)
O(N) or
O(1)
O(1) O(N) O(N)
Doubly Linked List O(N) O(N) O(1) O(N) O(1) O(1) O(N) O(1)
Stack O(N) O(N) O(1) O(1)
Queue O(N) O(N) O(1) O(1)
Binary Search Tree O(N) O(N) O(N) O(N)
AVL Tree O(log N) O(log N) O(log N) O(log N)

Summary
of
Time
Complexities
for
various
DS
(worst
case)
Graph Storage Add Vertex Add Edge
Remove
Vertex
Remove Edge
Adjacency Matrix O( 𝑉 2) O( 𝑉 2) O(1) O( 𝑉 2) O(1)
Adjacency List O(|V| + |E|) O(1) O(1) O(|V| + |E|) O(|E|)

Recursion: What and Why
• Recursion: A programming technique where a function calls itself
continuously until a termination condition is met
• Algorithmically, it is a way of designing solutions to problems by divide
and conquer or decrease and conquer.
• reduce a problem to simpler versions of the same problem
• Many problems can be elegantly specified or solved in a recursive
manner.

Example
• Line in ticket counter
1
2
3
4
5
6
7
8
9
10
Recursive calls Base case

General Structure of a Recursive Function
• Two major cases in a recursive function:
➢Base case: no further calls to the same function is made.
➢Recursive case: the function calls itself again (recursive call). The
recursive calls should progress in such a way that every time a
recursive call is made it comes closer to the base criteria.

General Structure of a Recursive Function
rec( input )
{
if ( condition ) {
// base case
.
.
.
}
else {
// recursive case
.
.
.
rec( smaller input );
.
.
.
}
}
[ Note: There can be
multiple base and
recursive cases. ]
Recursive
call

The Working of Function Call
General Memory Layout of a Program:
• When we run a program, it takes up space in
the memory.
• Each running program has its own memory
layout, separated from other programs. The
layout consists of different segments,
including:
1. stack: stores local variables
2. heap: dynamic memory for programmer to
allocate
3. data: stores global variables, separated into
initialized and uninitialized
4. text: stores the code being executed
stack
heap
uninitialized data
data
initialized data
text

Use of Stack in Function Call
Whenever a function is called a new activation frame is created with all the
function’s data and this activation frame is pushed in the program stack,
and the stack pointer that always points the top of the program stack
points the activation frame pushed as it is on the top of the program stack.
• Program Stack: the stack which holds all the function calls, with bottom
elements as the main function
• Activation Frame: a buffer memory that is an element of program stack
and has data of the called function i.e., Return Address, Input Parameters,
Local Variables etc.
• Stack Pointer: the pointer that points to the top of program stack i.e., the
most recent function called.

void printHi(int n) {
int i;
for(i=1; i<=n; i++)
printf(“Hi! n”);
}
int main() {
int x = 3;
printHi(x);
return 0;
}
Program stack

int i;
for(i=1; i<=n; i++)
}
int main() {
int x = 3;
printHi(x);
return 0;
}
Program stack

int i;
for(i=1; i<=n; i++)
}
int main() {
int x = 3;
printHi(x);
return 0;
}
main
Program stack

int i;
for(i=1; i<=n; i++)
}
int main() {
int x = 3;
printHi(x);
return 0;
}
main
3
x
.
.
.
Program stack

int i;
for(i=1; i<=n; i++)
}
int main() {
int x = 3;
printHi(x);
return 0;
}
main
3
x
.
.
.
printHi
3
n
Program stack

int i;
for(i=1; i<=n; i++)
}
int main() {
int x = 3;
printHi(x);
return 0;
}
main
3
x
.
.
.
printHi
3
n
.
.
.
i
Program stack

int i;
for(i=1; i<=n; i++)
}
int main() {
int x = 3;
printHi(x);
return 0;
}
main
3
x
.
.
.
printHi
3
n
.
.
.
1
i
Program stack

int i;
for(i=1; i<=n; i++)
}
int main() {
int x = 3;
printHi(x);
return 0;
}
main
3
x
.
.
.
printHi
3
n
.
.
.
1
i
Program stack
Output:
Hi!

int i;
for(i=1; i<=n; i++)
}
int main() {
int x = 3;
printHi(x);
return 0;
}
main
3
x
.
.
.
printHi
3
n
.
.
.
2
i
Output:
Hi!
Program stack

int i;
for(i=1; i<=n; i++)
}
int main() {
int x = 3;
printHi(x);
return 0;
}
main
3
x
.
.
.
printHi
3
n
.
.
.
2
i
Output:
Hi!
Hi!
Program stack

int i;
for(i=1; i<=n; i++)
}
int main() {
int x = 3;
printHi(x);
return 0;
}
main
3
x
.
.
.
printHi
3
n
.
.
.
3
i
Output:
Hi!
Hi!
Program stack

int i;
for(i=1; i<=n; i++)
}
int main() {
int x = 3;
printHi(x);
return 0;
}
main
3
x
.
.
.
printHi
3
n
.
.
.
3
i
Output:
Hi!
Hi!
Hi!
Program stack

int i;
for(i=1; i<=n; i++)
}
int main() {
int x = 3;
printHi(x);
return 0;
}
main
3
x
.
.
.
printHi
3
n
.
.
.
4
i
Output:
Hi!
Hi!
Hi!
Program stack

int i;
for(i=1; i<=n; i++)
}
int main() {
int x = 3;
printHi(x);
return 0;
}
main
3
x
.
.
.
Output:
Hi!
Hi!
Hi!
Program stack

int i;
for(i=1; i<=n; i++)
}
int main() {
int x = 3;
printHi(x);
return 0;
}
Output:
Hi!
Hi!
Hi!
Program stack

• Since a recursive function repeatedly calls itself, it makes use of the
program stack to temporarily store the return address, local
variables and other information of the calling function.
• Consequently, recursive algorithms require more memory and
computation compared with iterative algorithms, but they are
simpler and for many cases a natural way of thinking about the
problem.

Tracing Recursion
Ex.1: Determine output of the following function for test(3).
void test(int n) {
if (n > 0)
{
printf(“%d”, n);
test(n-1);
}
} Check lecture notes

Tracing Recursion
void test(int n) {
if (n > 0)
{
test(n-1);
}
} Check lecture notes

Tracing Recursion
void test(int n) {
if (n > 0)
{
test(n-1);
test(n-1);
}
}
Check lecture notes

Try Yourself!
Ex.4: Determine output of the
following functions for test(3).
void test(int n) {
if (n > 0)
{
test(n-1);
test(n-1);
}
}
Ex.5: Determine output of the
following functions for test(3).
void test(int n) {
if (n > 0)
{
test(n-1);
test(n-1);
}
}

References & Other Resources
➢ Data Structures (Seymour Lischutz)
• Chapter 6
➢ https://www.enjoyalgorithms.com/blog/recursion-explained-how-
recursion-works-in-programming

L1 - Recap.pdf

More Related Content

Similar to L1 - Recap.pdf (20)

Recently uploaded (20)

L1 - Recap.pdf