Data structure 6.pptx

CS261
DATA STRUCTURES & ALGORITHMS
(WEEK-6)
LECTURE-11 & 12
INTRODUCTION TO DATA STRUCTURES &
ALGORITHMS
Lecturer
Azka Aziz
Azka.a@scocs.edu.pk

Data structures & Algorithms
Lecture#11 Link List & Array uses

Course contents
Link List
Uses
Advantages
Disadvantages
Applications

Linked Lists Advantages
 Dynamic data structure
We only need to create a linked list instance and later memory is
allocated dynamically for its nodes
Grow & shrink at run time
When a new node is created, memory is allocated for it
increasing overall size of linked list
When an existing node is deleted, memory is de-allocated
decreasing overall size of linked list
Theoretically, memory allocation has no limitations. It can grow
as much as total memory available in the system
Memory usage is efficient
Memory is allocated only when an node is created (i.e. no pre-
allocation)
Memory is only allocated that is really required by application

Stack / Queue implementation
Linked lists can be used to implement data structures like Stack and Queue
Insertion operation is very efficient
Insertion at the start of list can be done in constant time no matter what the length
of list is
Insertion after some node (identified at runtime) can be done in linear time
No shifting of elements is required like arrays while performing insertion operation
over lists

Linear Time Search Operation
Search operation can be performed in linear time
Every search operation requires the inspection of N/2 nodes (as an average)
Linked List Memory is not Contigous
List elements do not have to sit side by side in memory like arrays making better use
of memory
Heterogineous Nodes
All list nodes do not need to be of same type

Linked Lists disAdvantages
Extra Memory for Pointers
Every node of simple linked list requires extra memory to store pointer for next
node
In case of double linked list every node needs two pointers (one for next node,
second for previous node) requiring even more memory
No Random Access to List Nodes
Linked list elements can be accesed in linear fashion only
Random access (in arrays) can be done in constant time but in case of linked lists it
can be done in linear time making it a slow process

Heap Size Limitation
Dynamic memory for linked list nodes is allocated from heap. Hence heap size
practically dictates the size of memory allocated for linked list
If heap does not have more memory left, no memory will be allocated for linked list
nodes
Reverse Traversing is Difficult
Simple linked list elements are connected in one way only making traversal in
backward direction very difficult
In case of double linked list backward traversal is easier but it involves one extra
pointer per node requiring more effort to maintain and more memory for storage

Courting Linked List Elements
Simple implementation of linked lists require a linear time function to calculate the
number of elements in the list

Linked Lists Applications
Implement other Data Structures
Linked lists can be used to implement other data structures like queue, stack and
graph etc
Using list to implement said data structures is quite straight forward
Implement any List involving Application
Linked lists can be used to implement any list involving application e.g. list of
patients in a hospital (randomly being added to a list), list of planes willing to land
on an airport, list of applicants applying for some resource etc.

Round Robin Scheduling Algorithm
Any application requiring to accessing certain ordered resources in circular manner
can use circular linked list for its purpose
Implement Multiplayer Games
Any multiplayer board game that requires its players to make moves in some order
again and again (until the game or a round of game is over) can make use of circular
linked list
Order Processing
An order can contain order items presented as a linked list

Implement Todo List
One can implement a todo list of items as a linked list
Items can be traversed again and again in an order to keep track of which items have
been done and which ones are not
Response to Database Like Queries
Queries to database or database like repositories can be managed (implemented)
using linked list
Neighboring Nodes for Graph
Neighboring list for any graph node can be implemented using linked list

Data structures & Algorithms
Lecture#12 Searching

Lecture Contents
Sequential Search
Binary Search
Iterative
Recursive

Searching
It is often required to look for an element in some collection (typically an array, a
list, a BST etc.)
If the collection has no order associated with it, we have to search for required
element sequentially
Collection elements are matched with required key value one by one
Search exhausts if either required elements is found inside the collection or all
elements have been searched and none of them matched with required key

Sequential Search
proc sequentialSearch(A, key)
n  |A|
for j1 to n do
if A[j] = key then
return j
end if
next
return -1
end proc

Sequential Search … Demonstration (Best Case)
The Algorithm
Line
#
A n j A[j] Key
{12, 53, 18, 33, 48, 97, 6, 10} 12
Note: For sequential search best case is the
one when required key value is found at first
index of the array

The Algorithm
Line
#
A n j A[j] Key
1 {12, 53, 18, 33, 48, 97, 6, 10} 8 12
1. A = {12, 53, 18, 33, 48, 97, 6, 10}
2. key = 12
3. n is initialized to 8 (length of A)

The Algorithm
Line
#
A n j A[j] Key
2 {12, 53, 18, 33, 48, 97, 6, 10} 8 1 12
1. A = {12, 53, 18, 33, 48, 97, 6, 10}
2. key = 12
4. J is initialized to 1 (loop condition is TRUE)

The Algorithm
Line
#
A n j A[j] Key
3 {12, 53, 18, 33, 48, 97, 6, 10} 8 1 12 12
1. A = {12, 53, 18, 33, 48, 97, 6, 10}
2. key = 12
5. key = 12  A[j] is equal to key  if
condition is TRUE

The Algorithm
Line
#
A n j A[j] Key
4 {12, 53, 18, 33, 48, 97, 6, 10} 8 1 12 12
1. A = {12, 53, 18, 33, 48, 97, 6, 10}
2. key = 12
5. key = 12
6. 1 is returned as required index value

Sequential Search … Calculating Cost (Best Case)
The Algorithm
A = {12, 53, 18, 33, 48, 97, 6, 10}
Key = 12
T(n) = 1+1+1+1 = 4 = C(constant)
= Ω(C)

Sequential Search … Demonstration (Worst Case)
The Algorithm
Line
#
A n j A[j] Key
{12, 53, 18, 33, 48, 97} 25
Note: For sequential search worst case is the
one when required key value is not found in
the array i.e. all values are compared with key
one by one but every comparison returns
FALSE
At the end of execution, -1is returned
indicating the required key value is not
present in array

The Algorithm
Line
#
A n j A[j] Key
1 {12, 53, 18, 33, 48, 97} 6 25
1. A = {12, 53, 18, 33, 48, 97}
2. key = 25
3. n = 6 (length of A)

The Algorithm
Line
#
A n j A[j] Key
2 {12, 53, 18, 33, 48, 97} 6 1 12
1. A = {12, 53, 18, 33, 48, 97}
2. key = 25
4. J = 1

The Algorithm
Line
#
A n j A[j] Key
3 {12, 53, 18, 33, 48, 97} 6 1 12 25
1. A = {12, 53, 18, 33, 48, 97}
2. key = 25
4. J = 1
5. A[J] = 12
6. A[j] is compared with Key and if condition
returns FALSE as both values are not same i.e.
control transfers to for-loop header again

The Algorithm
Line
#
A n j A[j] Key
2 {12, 53, 18, 33, 48, 97} 6 2 12
1. A = {12, 53, 18, 33, 48, 97, 6, 10}
2. key = 25
3. n = 6
4. J = 2

The Algorithm
Line
#
A n j A[j] Key
3 {12, 53, 18, 33, 48, 97} 6 2 12 25
1. A = {12, 53, 18, 33, 48, 97}
2. key = 25
4. J = 2
5. A[J] = 53
6. A[j] is compared with Key and if condition
returns FALSE as both values are not same i.e.

The Algorithm
Line
#
A n j A[j] Key
2 {12, 53, 18, 33, 48, 97} 6 3 12
1. A = {12, 53, 18, 33, 48, 97}
2. key = 25
3. n = 6
4. J = 3

The Algorithm
Line
#
A n j A[j] Key
3 {12, 53, 18, 33, 48, 97} 6 3 12 25
1. A = {12, 53, 18, 33, 48, 97}
2. key = 25
4. J = 3
5. A[J] = 18
6. A[j] is compared with Key and returns
FALSE as both values are not same i.e.

The Algorithm
Line
#
A n j A[j] Key
2 {12, 53, 18, 33, 48, 97} 6 4 12
1. A = {12, 53, 18, 33, 48, 97}
2. key = 25
3. n = 6
4. J = 4

The Algorithm
Line
#
A n j A[j] Key
3 {12, 53, 18, 33, 48, 97} 6 4 12 25
1. A = {12, 53, 18, 33, 48, 97}
2. key = 25
4. J = 4
5. A[J] = 33

The Algorithm
Line
#
A n j A[j] Key
2 {12, 53, 18, 33, 48, 97} 6 5 12
1. A = {12, 53, 18, 33, 48, 97}
2. key = 12
3. n = 6
4. J = 5

The Algorithm
Line
#
A n j A[j] Key
3 {12, 53, 18, 33, 48, 97} 6 5 12 25
1. A = {12, 53, 18, 33, 48, 97}
2. key = 25
4. J = 5
5. A[J] = 48

The Algorithm
Line
#
A n j A[j] Key
2 {12, 53, 18, 33, 48, 97} 6 6 12
1. A = {12, 53, 18, 33, 48, 97}
2. key = 12
3. n = 6
4. J = 6

The Algorithm
Line
#
A n j A[j] Key
3 {12, 53, 18, 33, 48, 97} 6 6 12 25
1. A = {12, 53, 18, 33, 48, 97}
2. key = 97
4. J = 6
5. A[J] = 97

The Algorithm
Line
#
A n j A[j] Key
2 {12, 53, 18, 33, 48, 97} 6 7 12
1. A = {12, 53, 18, 33, 48, 97}
2. key = 12
3. n = 6
4. J = 7
5. At this point for-loop exhausts shifting
control to line 5

The Algorithm
Line
#
A n j A[j] Key
5 {12, 53, 18, 33, 48, 97} 6 7 12
1. A = {12, 53, 18, 33, 48, 97}
2. key = 12
3. n = 6
4. J = 7
5. -1 is returned as response to this procedure

T(n) = 1 + n+1 + n + 1 = 2n+3 = O(n)

Sequential Search … Demonstration (AVeRAGE
Case)

Binary Search
If collection (array) is sorted, binary search algorithm can be applied
During every iteration of binary search:
Algorithm keeps track of lower bound and upper bound of elements to be searched
Algorithm compares the middle element (mid point of lower bound and upper
bound) with key value
If key value is equal to middle element’s value, its index is returned as result
If middle element is smaller than key value, binary search algorithm iterates again
for half of the elements (beyond middle element)
Otherwise, binary search algorithm iterates again for half of the elements (before
middle element)
Every iteration of binary search algorithm halves the size of array to be searched
Binary search algorithm is a very strong algorithm offering the worst case
complexity of O(log n); n being the size of array

Binary Search … Iterative Algorithm
proc binarySearch(A, key, low, upper)
while low ≤ upper do
mid  (low+upper)/2
if A[mid] = key then
return mid
else if A[mid] < key then
low mid +1
else
upper  mid -1
end if
next
return -1
end proc

Binary Search … Demo (Best Case)
Iterative Binary Search
Best case is the one in which key value
is found on middle of the array (to be
searched)
Suppose A ={17, 23, 28, 46, 54, 72, 95}

searched)
A ={17, 23, 28, 46, 54, 72, 95}
low =1
upper =7
key =46

Binary Search … Demo(Best Case)
searched)
A ={17, 23, 28, 46, 54, 72, 95}
low =1
upper =7
key =46

searched)
A ={17, 23, 28, 46, 54, 72, 95}
low =1
upper =7
key =46
While low ≤ upper is TRUE i.e. control
shifts inside the loop body

Binary Search … Demo(Best Case)
searched)
A ={17, 23, 28, 46, 54, 72, 95}
low =1
upper =7
key =46
mid =(1+7)/2 = 4
If A[4] = key is TRUE i.e. line 4
executes and returns 4 as required
index

Binary Search … Complexity (Best Case)
T(n) = 1+1+1+1 = 4
= C(constant)
= Ω(C)

Binary Search … Demo (Worst Case)
Worst case is the one in which key value is
not present in the array (to be searched)
A ={17, 23, 28, 46, 54, 72, 95, 112, 125}
low =1
upper =9
key =44
While Low ≤ upper is TRUE i.e. control shifts
to line 2

A ={17, 23, 28, 46, 54, 72, 95, 112, 125}
low =1
upper =9
key =44
mid = (1+9)/2 = 5
A[5] = 54

A ={17, 23, 28, 46, 54, 72, 95, 112, 125}
low =1
upper =9
key =44
mid = (1+9)/2 = 5
A[5] = 54
If condition at line 3 is FALSE i.e. control
shifts to line 5

A ={17, 23, 28, 46, 54, 72, 95, 112, 125}
low =1
key =44
mid = (1+9)/2 = 5
A[5] = 54
shifts to line 7 where upper is updated
upper = 4 and we move to next iteration of
while loop

Iteration 2
A ={17, 23, 28, 46, 54, 72, 95, 112, 125}
low =1
upper =4
key =44
to line 2

Binary Search … Demo(Worst Case)
Iteration 2
A ={17, 23, 28, 46, 54, 72, 95, 112, 125}
low =1
upper =4
key =44
mid =(1+4)/2 = 2
March 31, 2020 (12:30 - 14:00) University of Lahore

Iteration 2
A ={17, 23, 28, 46, 54, 72, 95, 112, 125}
low =1
upper =4
key =44
mid = 2
A[mid] = 23
shifts to line 5

A ={17, 23, 28, 46, 54, 72, 95, 112, 125}
upper =4
key =44
mid = 2
A[mid] = 23
If condition at line 5 is TRUE i.e. control
shifts to line 6 where low is updated i.e.
low = 3 and we move to next iteration of
while loop

Iteration 3
A ={17, 23, 28, 46, 54, 72, 95, 112, 125}
low =3
upper =4
key =44
to line 2

Iteration 3
A ={17, 23, 28, 46, 54, 72, 95, 112, 125}
low =3
upper =4
key =44
mid =(3+4)/2 = 3

Iteration 3
A ={17, 23, 28, 46, 54, 72, 95, 112, 125}
low =3
upper =4
key =44
mid = 3
A[mid] = 28
shifts to line 5

Iteration 3
A ={17, 23, 28, 46, 54, 72, 95, 112, 125}
upper =4
key =44
mid = 3
A[mid] = 28
If condition at line 5 is TRUE i.e. control
shifts to line 6 where low is updated i.e.
low = 4
we move to next iteration of while loop

Iteration 4
A ={17, 23, 28, 46, 54, 72, 95, 112, 125}
low =4
upper =4
key =44
to line 2

Iteration 4
A ={17, 23, 28, 46, 54, 72, 95, 112, 125}
low =4
upper =4
key =44
mid =(4+4)/2 = 4

Iteration 4
A ={17, 23, 28, 46, 54, 72, 95, 112, 125}
low =4
upper =4
key =44
mid = 4
A[mid] = 46
shifts to line 5

Iteration 4
A ={17, 23, 28, 46, 54, 72, 95, 112, 125}
upper =4
key =44
mid = 4
A[mid] = 46
shifts to line 7 where upper is updated i.e.
upper = 3
we move to next iteration of while loop

Iteration 5
A ={17, 23, 28, 46, 54, 72, 95, 112, 125}
low =4
upper =3
key =44
While Low ≤ upper is FALSE i.e. control shifts
to line 8
On line 8, -1 is returned as response of
procedure indicating the required value is
not present in the array

Binary Search … Complexity(Worst Case)
1. Array (unsearched array) size is
halved during every failed iteration of
while loop i.e. a maximum of log N
iterations
2. During every iteration when key value
is not found two if-conditions are
FALSE and either lower or upper is
modified. Moreover, mid is also
updated on line 2
3. At end -1 is return on line 8
T(n) = log N (4) + 1 = O(log N)

Binary Search … Recursive Algorithm
proc binarySearch(A, key, low, high)
if low > high then
return -1
else
mid  (low + high)/2
return mid
return binarySearch(A, key, mid+1, high)
else
return binarySearch(A, key, low, high-1)
end if
end if
end proc

Binary Search … Recursive Algorithm
proc binarySearch(A, key, low, high)
if low > high then
return -1
else
mid  (low + high)/2
return mid
return binarySearch(A, key, mid+1, high)
else
return binarySearch(A, key, low, high-1)
end if
end if
end proc
1. Demonstrate it yourself
2. Also calculate its complexity

Data structure 6.pptx

Recomendados

Recomendados

Más contenido relacionado

Similar a Data structure 6.pptx

Similar a Data structure 6.pptx (20)

Más de SajalFayyaz

Más de SajalFayyaz (9)

Último

Último (17)

Data structure 6.pptx