Data Structures and Algorithms

(CS210A)

Lecture 7:
• Data structure for Range-minima problem
Compact and fast

1
 Data structures
•  
AIM:
To organize a data in the memory
so that any query can be answered efficiently.

Example:
Data: A set S of numbers
Query: “Is a number present in S ?”

A trivial solution: sequential search

  O() time per query

A Data structure solution:

• Sort S   O(log ) time to build sorted array.
• Use binary search for answering query
  O(log ) time per query
2
 Data structures
AIM:
To organize a data in the memory
so that any query can be answered efficiently.

Important assumption:
No. of queries to be answered will be … many.

Parameters of Efficiency
• Query time
• Space
• Preprocessing time

3
RANGE-MINIMA Problem

4
 Range-Minima Problem

•  
Given: an array A storing numbers,
Aim: a data structure to answer a sequence of queries of the following type
Range-minima() : report the smallest element from A[],…,A[]

Let A store one million numbers

Let the number of queries be 10 millions

  Range-Minima() = -6

A 3 5 1 8 19 0 -1 30 99 -6 10 2 40 27 44 67

 =4  =11
 Range-Minima Problem
Size of B is too large to be kept in RAM.
Solution 1 So we shall haveSolution
to keep most2of it in
the Hard disk drive.
•   (brute force) •  it will take
Hence (store
a fewallmilliseconds
𝒋
answers) per 
query.
Range-minima-trivial()
{ temp  ;
min  A[];  𝒊 3
While(temp <= )
{ if (min > A[temp])
min  A[temp];
temp temp+1; B
}
return min
}
Time complexity for one query: O() Space : O()
(a few hours for 10 million queries) Impractical 6
 Range-Minima Problem

•  
Query:
Report_min(A,) : report smallest element from {A[],…,A[]}

 𝟏  𝒊  𝒋  𝒏

A 3.1 29 99 781 41.5 67.4

Aim :
• compact data structure
• O() Query time for any ≤ < ≤ .
   Why does O() bound on
space appear so hard to break
if we want O(1) query time?

… Because of artificial hurdles

8
 Artificial hurdle

• we
If   want to answer each query in O(1) time,
 we must store its answer explicitly.

 Since there are around O() queries,

so O() space is needed.

Spend some time to find the origin of this hurdle.…

9
 Artificial hurdle

•    𝒊   -1
A 3.1 29 99 781 41.5 67.4

… If we fix the first parameter for all queries, we need O() space. True Fact

   because it assumes that

data structure for an index
will work in total isolation
for all , we need O() space. A wrong inference of others.
Collaboration (team effort)
works in real life

Why not try

collaboration for the
given problem ?

11
 Range-minima problem:
 
Breaking the O() barrier using collaboration
•An  Overview:

• Keep tiny data structures:

Each index stores minimum only for a few .

• For a query Range-minima(),

if the answer is not stored in the tiny data structure of ,
look up tiny data structure of some index (chosen carefully).

12
HOW DOES COLLABORATION WORK
IN THIS PROBLEM ?

13
 Range-minima problem:
 
Breaking the O() barrier using collaboration
  We may use the tiny data
structure of index to
answer Range-Minima()

 𝒊  𝒋

A
 𝟏  𝒊  𝒒  𝒏

  stores answers for this range   stores answers for this range
DETAILS OF TINY DATA STRUCTURES

15
 Range-minima problem :
 
Details of tiny data structure stored at each
𝒕
𝟐
 

8
4

2
1

A
1  𝒊  𝒏

Tiny
  data structure of Index stores
minimum element for {A[],…,A[+ ]}
for each ≤
 Answering Range-minima query for index :
  works
Collaboration

𝒌 +𝟏
𝟐
 

𝒌
𝟐
 

A
1  𝒊  𝒋  𝒏

 𝒋 −𝟐𝒌
 We shall use two additional arrays

•  
Definition :
Power-of-2[] : the greatest number of the form such that ≤ .
Examples: Power-of-2[5] = 4,
Power-of-2[19]= 16,
Power-of-2[32]=32.

Definition :
Log[] : the greatest integer such that ≤ .
Examples: Log[5] = 2,
Log[19]= 4,
Log[32]=5.

Homework: Design O() time algorithm to compute arrays Power-of-2[] and

Log[] of size .
18
 FINAL SOLUTION FOR
RANGE MINIMA PROBLEM

19
 Range-Minima Problem:
Data structure with O( log ) space and O(1) query time

•  
Data Structure:
– × log matrix B where B[][] stores …   minimum of {A[],A[+1],…, A[+]}

– Array Power-of-2[]
– Array Log[] 0 1 𝐥𝐨
  𝐠𝟐 𝒏
0
Range-minima-() 1
{ L; …
 Power-of-2[L];
B
 Log[L];
  B[][];
If ( = L) return ??;
else return min(   B[][]
?? ,   B[][];
?? ); 𝒏  −𝟏
}

20
•  
Theorem:
There is a data structure for range-minima problem that takes
O( log ) space and O(1) query time.

Preprocessing time:
O( log ) : Trivial
O( log ) : Doable with little hints

21
•Homework:
 
Design an O( log ) time algorithm
to build the × log matrix B used in data structure of Range-Minima problem.

Hint: (Inspiration from iterative algorithm for Fibonacci numbers).

Spend some time before looking at

the more explicit hint below. (it is just
a click away)…You can do it…

  To compute B[][], you need to know only two entries from column **.

22
 Range Minima Problem:
further extensions
•  
Dynamic Range Minima Problem:
 O(log ) update and query time.

Extension to 2-dimensions ?
 O(log ) query time.

Question: Can we achieve O() space and O(1) query time ?

Yes.
The students whose aim is more than just a
good grade should ponder over it.
I shall be happy to give them suitable hints.
23
 Data structures
(To be discussed in the course)
•
• Arrays
 Linked Lists
•
Elementary
• Stacks
• Queues

Tree Data Structures:

 Binary heap
 Binary Search Trees
 Augmented Data structures

Data Structures for integers:

 Hash Tables
 Searching in O(log log ) time (if time permits)
24