Data Structures for Media Introduction. Dr. Minming Li Department of Computer Science Room :Y6426 Phone :27889538 Email: [email protected], [email protected]

Data Structures for MediaData Structures for MediaIntroductionIntroduction

Dr. Minming Li

Department of Computer Science

Room Room :: Y6426Y6426

Phone Phone :: 2788953827889538

EmailEmail : : [email protected]@cs.cityu.edu.hk, ,

[email protected]@cityu.edu.hk

Mail boxMail box : : P16(P16(Outside CS General Office, Yellow zone, 6/FOutside CS General Office, Yellow zone, 6/F))

LecturerLecturer

mailto:[email protected]



What you can find at the course webpage:What you can find at the course webpage:http://www.cs.cityu.edu.hk/~minmli/course.htmhttp://www.cs.cityu.edu.hk/~minmli/course.htm

Lecture SlidesLecture Slides

Ready at least 24 hours before the lectureReady at least 24 hours before the lecture

Tutorial ExercisesTutorial Exercises

Selected questions are to be done during tutorials or Selected questions are to be done during tutorials or as homeworkas homework

Assignments and solutionsAssignments and solutions

Announcement from the teacherAnnouncement from the teacher

Important ones will also be distributed through email Important ones will also be distributed through email

Tutorial Class Room changed to MMW-2478Tutorial Class Room changed to MMW-2478

Q&AQ&A

Course Web PageCourse Web Page

http://www.cs.cityu.edu.hk/~minmli/course.htm

Weiss M.Weiss M. Data Structures & Algorithm AnData Structures & Algorithm Analysis in C++.alysis in C++. 3rd Ed. 3rd Ed. Addison WesleyAddison Wesley (19 (1999)99)

Hanan Samet Hanan Samet The Design and Analysis of The Design and Analysis of Spatial Data StructuresSpatial Data Structures Addison WesleyAddison Wesley (1989)(1989)

Harvey M. Deitel, Paul J. DeitelHarvey M. Deitel, Paul J. Deitel. . Visual C+Visual C++.NET :How to Program +.NET :How to Program Prentice HallPrentice Hall (2 (2003)003)

Reference BooksReference Books

Assessment PatternAssessment Pattern

Compulsory: exam mark >= 30Exam (70%)

2 Tests (7% +8%)

2 Assignments (6% + 9%)

Tutorial exercises (0%)

Better not read the textbook ahead of timeBetter not read the textbook ahead of time Try to keep up with the lectureTry to keep up with the lecture Read the materials carefully after the lectureRead the materials carefully after the lecture Do the assignments on your ownDo the assignments on your own

You may discuss with each otherYou may discuss with each other You may study materials available on internetYou may study materials available on internet You may refer to any bookYou may refer to any book But the details should be entirely your workBut the details should be entirely your work

Respond in time if you have any suggestions Respond in time if you have any suggestions to the course or problems with the courseto the course or problems with the course

How to learn this course?How to learn this course?

OVERVIEW OF CONTENTSOVERVIEW OF CONTENTS

Why Data Structures?Why Data Structures? What to do when we have a large What to do when we have a large

amount of data to deal with?amount of data to deal with? Organize it in ways easy to understandOrganize it in ways easy to understand Space efficiencySpace efficiency Time efficiencyTime efficiency Easy to display and transformEasy to display and transform

OverviewOverview

Linked Linked ListList

TreeTree StackStack QueueQueue HashingHashing

OverviewOverview

Data Data DataDataLabel

OverviewOverview PART IPART I Program ComplexitiesProgram Complexities Abstract Data TypesAbstract Data Types

Linked listsLinked lists TreesTrees StacksStacks QueuesQueues HeapsHeaps Hash tablesHash tables

OverviewOverview PART IIPART II Vectors and BitmapsVectors and Bitmaps

Quadtrees and OctreesQuadtrees and Octrees The handling of 2D and 3D dataThe handling of 2D and 3D data

Geometric StructuresGeometric Structures Spatial LayoutSpatial Layout Shape and AttributesShape and Attributes Connectivity of ComponentsConnectivity of Components

Data Structures for MediaData Structures for MediaProgram ComplexitiesProgram Complexities

What is an algorithm?What is an algorithm? A sequence of elementary computational steps that A sequence of elementary computational steps that transform the transform the inputinput into the into the outputoutput

What for?What for?A tool for solving well-specified A tool for solving well-specified computational problemscomputational problems, , e.g., Sorting, Matrix Multiplicatione.g., Sorting, Matrix Multiplication

What do we need to do with an algorithm?What do we need to do with an algorithm? Correctness Proof:Correctness Proof:

for every input instance, it halts with the correct outputfor every input instance, it halts with the correct output Performance Analysis:Performance Analysis:

How does the algorithm behave as the problem size gets How does the algorithm behave as the problem size gets largelarge

both in both in running timerunning time and and storage requirementstorage requirement

AlgorithmsAlgorithms

Input : Input : <a<a00, a, a11, … , a, … , an-1n-1>>

Output: Output: A permutation (re-ordering) <a’A permutation (re-ordering) <a’00, a’, a’11, … , a’, … , a’n-1n-1> > ofof

the input sequence such that a’the input sequence such that a’0 0 a’ a’1 1 … … a’ a’n-1n-1

Example:Example:

<22, <22, 5151, 34, , 34, 4444, 67, , 67, 1111> => <> => <1111, 22, 34, , 22, 34, 4444, , 5151, 67>, 67>

A Sorting ProblemA Sorting Problem

55, , 33, 1, 2, 6, 4, 1, 2, 6, 4

33, 5, 5, , 11, 2, 6, 4, 2, 6, 4

11, 3, 5, 3, 5, , 22, 6, 4, 6, 4

1, 1, 22, 3, 5, 3, 5, , 66, 4, 4

1, 2, 3, 5, 1, 2, 3, 5, 66, , 44

1, 2, 3, 1, 2, 3, 44, 5, 6, 5, 6

Insertion SortInsertion SortNote that when we are dealing with kth number, the first k-1 numbers are alrea

dy sorted

To sort A[0,1,…,n-1] in placeTo sort A[0,1,…,n-1] in place Steps:Steps:

Pick element A[j]Pick element A[j] Move A[j-1,…,0] to the right unMove A[j-1,…,0] to the right un

til proper position for A[j] is foutil proper position for A[j] is foundnd

Insertion SortInsertion Sort

Currently sorted part

Currently unsorted

part

j0 … j+1 . . 11 3 5 3 5 22 6 4 6 4

1 3 1 3 55 5 6 4 5 6 4

1 1 33 3 5 6 4 3 5 6 4

1 1 22 3 5 6 4 3 5 6 4

55, , 33, 1, 2, 6, 4, 1, 2, 6, 4

33, 5, 5, , 11, 2, 6, 4, 2, 6, 4

11, 3, 5, 3, 5, , 22, 6, 4, 6, 4

1, 1, 22, 3, 5, 3, 5, , 66, 4, 4

1, 2, 3, 5, 1, 2, 3, 5, 66, , 44

1, 2, 3, 1, 2, 3, 44, 5, 6, 5, 6 Example11 3 5 3 5 22 6 4 6 4

Insertion SortInsertion SortInsertion-Sort (A)Insertion-Sort (A) 1. for j=1 to n-11. for j=1 to n-1 2. 2. key=A[j]key=A[j] 3. 3. i=j-1i=j-1 4. 4. while i>=0 and A[i]>keywhile i>=0 and A[i]>key 5. 5. A[i+1]=A[i]A[i+1]=A[i] 6. 6. i=i-1i=i-1

7. 7. A[i+1]=keyA[i+1]=key

j=1j=1 5 5 33 1 2 6 4 1 2 6 4

j=2j=2 33 5 5 11 2 6 4 2 6 4

j=3j=3 11 3 5 3 5 22 6 4 6 4

j=4j=4 1 1 22 3 5 3 5 66 4 4

j=5j=5 1 2 3 5 1 2 3 5 66 44

1 2 3 1 2 3 44 5 6 5 6

A[0] A[1] A[2] A[3] A[4] A[5]

11 3 5 3 5 22 6 4 6 4

1 3 1 3 55 5 6 4 5 6 4

1 1 33 3 5 6 4 3 5 6 4

1 1 22 3 5 6 4 3 5 6 4

j=3

We only consider algorithms with loopsWe only consider algorithms with loops Find a property as Find a property as loop invariantloop invariant

How to show something is loop invariant?How to show something is loop invariant? InitializationInitialization: :

It is true prior to the first iteration of the loopIt is true prior to the first iteration of the loop MaintenanceMaintenance: :

If it is true before an iteration, it remains true If it is true before an iteration, it remains true before the next iterationbefore the next iteration

TerminationTermination::

When the loop terminates, the invariant gives When the loop terminates, the invariant gives a useful property that helps to show the a useful property that helps to show the algorithm is correctalgorithm is correct

Correctness of AlgorithmCorrectness of Algorithm

Correctness of Insertion SortCorrectness of Insertion Sort loop invariantloop invariant

At start of each iteration of At start of each iteration of forfor loop, A[0..j-1] consists of the el loop, A[0..j-1] consists of the elements originally in A[0..j-1] but in sorted orderements originally in A[0..j-1] but in sorted order

InitializationInitialization Before the first iteration, j=1. Before the first iteration, j=1.

=> A[0 .. j-1] contains only A[0]. => A[0 .. j-1] contains only A[0]. => Loop invariant holds prior to the first iteration.=> Loop invariant holds prior to the first iteration.

MaintenanceMaintenance In each iteration, the algorithm moves A[j-1],A[j-2],A[j-3] .. to tIn each iteration, the algorithm moves A[j-1],A[j-2],A[j-3] .. to t

he right until the proper position for A[j] is found. he right until the proper position for A[j] is found. Then A[j] is inserted. Then A[j] is inserted. => if the loop invariant is true before an iteration, it remains tr=> if the loop invariant is true before an iteration, it remains true before next iteration.ue before next iteration.

TerminationTermination The outer loop ends with j=n. The outer loop ends with j=n.

Substituting n for j in the loop invariant, we get “A[______] cSubstituting n for j in the loop invariant, we get “A[______] consists of the n sorted elements.”onsists of the n sorted elements.”

The running time T(n) = c1*n+c2*(n-1)+c3*(n-1)+c4*(j=1..n-1 (tj+1))+c5*(j=1..n-1 tj)+c6*(j=1..n-1 tj)+c7*(n-1)

tj = no. of times that line 5,6 are executed, for each j.

Insertion-Sort(A)

1 for j = 1 to n-1

2 key = A[j]

3 i = j-1

4 while i >= 0 and A[i] > key

5 A[i+1] = A[i]

6 i = i - 1

7 A[i+1] = key

n

n-1

n-1

j=1..n-1 (tj+1)

j=1..n-1 tj

j=1..n-1 tj

n-1

c1

c2

c3

c4

c5

c6

c7

timesCost

c1, c2, .. = running time for executing line 1, line 2, etc.

Running time of Insertion Running time of Insertion SortSort

T(n) = c1*n+c2*(n-1)+c3*(n-1)+c4*(j=1..n-1 (tj+1))+c5*(j=1..n-1 tj)+c6*(j=1..n-1 tj)+c7*(n-1)

Worse case:

Reversely sorted

inner loop body executed for all previous elements.

tj=j.

T(n) = c1*n+c2*(n-1)+c3*(n-1)+c4*(j=1..n-1 (j+1))+c5*(j=1..n-1 j)+c6*(j=1..n-1 j)+c7*(n-1)

T(n) = An2+Bn+C

T(n) = c1*n+c2*(n-1)+c3*(n-1)+c4*(j=1..n-1 (j+1))+c5*(j=1..n-1 j)+c6*(j=1..n-1 j)+c7*(n-1)

Note: j=1..n-1 j = n(n-1)/2 j=1..n-

1 (j+1) = (n+2)(n-1)/2

Analyzing Insertion SortAnalyzing Insertion Sort

T(n)=T(n)=cc11*n+c*n+c22*(n-1)+c*(n-1)+c33*(n-1)+c*(n-1)+c44*(*(j=1..n-1j=1..n-1 (t (tjj+1))+c+1))+c55*(*(j=1..n-1j=1..n-1 t tjj)+c)+c66*(*(j=1..n-1j=1..n-1 t tjj)+c)+c77*(n-1)*(n-1)

Worst caseWorst case Reverse sorted Reverse sorted inner loop body executed for all previ inner loop body executed for all previous elements. So, tous elements. So, tjj=j.=j.

T(n) is quadratic (square): T(n)=AnT(n) is quadratic (square): T(n)=An22+Bn+C+Bn+C

Average caseAverage case Half elements in A[0..j-1] are less than A[j]. So, tHalf elements in A[0..j-1] are less than A[j]. So, t jj = j/2 = j/2 T(n) is also quadratic: T(n)=AnT(n) is also quadratic: T(n)=An22+Bn+C+Bn+C

Best caseBest case Already sorted Already sorted inner loop body never executed. So, t inner loop body never executed. So, t jj

=0.=0.

T(n) is linear: T(n)=An+BT(n) is linear: T(n)=An+B

Analyzing Insertion SortAnalyzing Insertion Sort

(Usually) Worst case Analysis:(Usually) Worst case Analysis:T(n) = max time on any input of size nT(n) = max time on any input of size n

Knowing it gives us a guarantee about the upper Knowing it gives us a guarantee about the upper bound.bound.

In some cases, worst case occurs fairly oftenIn some cases, worst case occurs fairly often

((Sometimes) Average case Analysis:Sometimes) Average case Analysis:T(n) = average time over all inputs of size nT(n) = average time over all inputs of size n

Average case is often as bad as worst case.Average case is often as bad as worst case.There really exists “good” exampleThere really exists “good” example

(Rarely) Best case Analysis:(Rarely) Best case Analysis:Cheat with slow algorithm that works fast on some input.Cheat with slow algorithm that works fast on some input.Good only for showing bad lower bound.Good only for showing bad lower bound.(New) Smoothed Analysis(New) Smoothed AnalysisAverage in the local region instead of all inputsAverage in the local region instead of all inputs

Kinds of AnalysisKinds of Analysis

Kinds of AnalysisKinds of Analysis

Worst Case: maximum valueWorst Case: maximum value Average Case: average valueAverage Case: average value Best Case: minimum valueBest Case: minimum value

Worst case

Average caseBest case

0 1 2 3 4 n

Order of GrowthOrder of Growth

f(n)f(n) n=20n=20 n=40n=40 n=60n=60

LogLog22nn

Sqrt(n)Sqrt(n)

nn

n logn log22nn

nn22

nn44 12.96 sec

22nn

n!n!

5.32 * 10-6sec4.32 * 10-6sec 5.91 * 10-6sec

6.32 * 10-6sec4.47 * 10-6sec 7.75 * 10-6sec

40 * 10-6sec20 * 10-6sec 60 * 10-6sec

213 * 10-6sec86 * 10-6sec 354 * 10-6sec

1600 * 10-6sec400 * 10-6sec 3600 * 10-6sec

2.56 sec0.16 sec

12.73 days1.05 sec 36571 years

2.56 * 1034 years77147 years 2.64 * 1068 years

Examples:Examples:Running time of algorithm in microseconds(in term of data size n)

Algorithm A

Algorithm B

Algorithm C

Algorithm D

Algorithm E

Algorithm F

Algorithm G

Algorithm H

11

mic

rose

con

ds

f(n)log2n

Sqrt n

n

nlog2n

n2

n4

2n

n!0

10000

20000

30000

40000

50000

60000

70000

80000

90000

1 3 5 7 9 13 15 17 19

n

Assume: an algorithm can solve a problem of size n in f(n) Assume: an algorithm can solve a problem of size n in f(n) microseconds (10microseconds (10-6-6 seconds). seconds).

Note: for example,Note: for example,For all f(n) in For all f(n) in (n(n44), ), the shapes of their curves are the shapes of their curves are nearlynearly the same as f(n)=n the same as f(n)=n44..

Order of GrowthOrder of Growth

Asymptotic Tight Bound: f(n)= (g(n)) Intuitively like “=” f(n) grows as fast as g(n)

Asymptotic Upper Bound: f(n)= O (g(n)) Intuitively like “≤” f(n) grows not faster than g(n)

Asymptotic Lower Bound Ω f(n)= Ω(g(n)) Intuitively like “≥” f(n) grows not slower than g(n)

Asymptotic NotationAsymptotic Notation

Formal formulations:

(We’ll not go into details of these equations.)

O(g(n))O(g(n)) = { = {f(n): there exist positive f(n): there exist positive constants c and nconstants c and n00 such that 0 such that 0 f(n) f(n) cg(n) cg(n) for all n for all n n n0 0 }}

f(n)

cg(n)

n0 f(n) is O(g(n))

f(n)

c1g(n)

c2g(n)

n0 f(n) is (g(n))

(g(n))(g(n)) = { = {f(n): there exist positive f(n): there exist positive constants cconstants c11, c, c22, n, n00 such that such that

0 0 c c11g(n) g(n) f(n) f(n) c c22g(n) g(n)

for all n for all n n n0 0 }}

Asymptotic NotationAsymptotic NotationNote that:Note that:Running time of Insertion Sort is Running time of Insertion Sort is (n(n22)) is incorrect.is incorrect.Why?Why?

Worst case running time of Insertion Sort is Worst case running time of Insertion Sort is (n(n22)) -- -- correct / incorrect*correct / incorrect*Best case running time of Insertion Sort is Best case running time of Insertion Sort is (n) (n) -- -- correct / incorrect*correct / incorrect*Running time of Insertion Sort is O(nRunning time of Insertion Sort is O(n22) ) -- -- correct / incorrect*correct / incorrect*

Asymptotic Tight Bound: Intuitively like “=”Asymptotic Upper Bound: Intuitively like “≤”Asymptotic Lower Bound Ω Intuitively like “≥” What about “<”?

o versus O : o means better e.g. nlogn=o(n2) means nlogn grows slower than n2

Relationship between typical functionsRelationship between typical functions log n = o (n)log n = o (n) n = o (n log n)n = o (n log n) nncc = o (2 = o (2nn) where n) where ncc may be n may be n22, n, n44, etc., etc. If f(n)=n+log n, we call log n lower order termsIf f(n)=n+log n, we call log n lower order terms(You are not required to analyze, but remember these relations)(You are not required to analyze, but remember these relations)log n < sqrt(n) < n < nlog n < nlog n < sqrt(n) < n < nlog n < n22 < n < n44 < 2 < 2nn < n! < n!

Rule of combination (for positive function)Rule of combination (for positive function) f(n) = O (g(n)) and h(n) = O (k(n))f(n) = O (g(n)) and h(n) = O (k(n))

f(n)h(n) = O (g(n)k(n))f(n)h(n) = O (g(n)k(n)) f(n)+h(n) = O (g(n)+k(n))f(n)+h(n) = O (g(n)+k(n))


When calculating asymptotic running timeWhen calculating asymptotic running time Drop lower order termsDrop lower order terms Ignore leading constantsIgnore leading constants

Example 1: T(n) = AnExample 1: T(n) = An22+Bn+C+Bn+C AnAn22

T(n) = O(nT(n) = O(n22)) Example 2: T(n) = Anlogn+BnExample 2: T(n) = Anlogn+Bn22+Cn+D+Cn+D

BnBn22

T(n) = O(nT(n) = O(n22))

Remember: We can write T(n)=O(nRemember: We can write T(n)=O(n22); T(n)= ); T(n)= (n(n22), but not T(n) ), but not T(n) ≤ O(nO(n22););


Insertion-Sort(A)

1 for j = 1 to n-1

2 key = A[j]

3 i = j-1

4 while i >= 0 and A[i] > key

5 A[i+1] = A[i]

6 i = i – 1

7 A[i+1] = key

Very often the algorithm complexity can be observed directly from simple algorithms

O(n2)

There are 4 very useful rules for such Big-Oh analysis ...

Asymptotic PerformanceAsymptotic Performance

General rules for Big-Oh Analysis:

Rule 1. FOR LOOPS

The running time of a for loop is at most the running time of the statements inside the for loop (including tests) times no. of iterations

Rule 2. NESTED FOR LOOPS

The total running time of a statement inside a group of nested loops is the running time of the statement multiplied by the product of the sizes of all the loops.

for (i=0;i<N;i++)for (j=0;j<N;j++)

k++; O(N2)

for (i=0;i<N;i++)a++; O(N)

Rule 3. CONSECUTIVE STATEMENTS

Count the maximum one.

for (i=0;i<N;i++)a++;

for (i=0;i<N;i++)for (j=0;j<N;j++)

k++;

O(N2)

Rule 4. IF / ELSE

For the fragment:If (condition)

S1 else

S2,

take the test + the maximum for S1 and S2.


Example of Big-Oh Analysis:

void function1(int n){ int i, j;

int x=0;

for (i=0;i<n;i++)x++;

for (i=0;i<n;i++)for (j=0;j<n;j++)

x++;}

This function is O(__)

void function2(int n){ int i;

int x=0;

for (i=0;i<n/2;i++)x++;

}





int x=0;

for (i=0;i<10;i++)for (j=0;j<n/2;j++)

x--;}


int x=0;

if (n>10)for (i=0;i<n/2;i++)

x++;else{ for (i=0;i<n;i++)

for (j=0;j<n/2;j++)x--;

}}





void function5(int n)

{ int i;

for (i=0;i<n;i++)

if (IsSignificantData(i))

SpecialTreatment(i);

}

This function is O(____)

Suppose IsSignificantData is O(n),SpecialTreatment is O(n log n)


RecursionRecursionint Power(int base,int pow){ if (pow==0) return 1;

else return base*Power(base,pow-1); }

ExampleExample3322=9=9Power(3,2)=3*Power(3,1)Power(3,2)=3*Power(3,1)Power(3,1)=3*Power(3,0)Power(3,1)=3*Power(3,0)Power(3,0)=1Power(3,0)=1

T(n): the number of multiplications needed to compute Power(3,T(n): the number of multiplications needed to compute Power(3,n)n)

T(n)=T(n-1)+1; T(0)=0T(n)=T(n-1)+1; T(0)=0T(n)=nT(n)=nRunning time of function Power(3,n) is O(n)Running time of function Power(3,n) is O(n)

Asymptotic Performance Asymptotic Performance

Why recursion?Why recursion? Can’t we just use iteration (loop)?Can’t we just use iteration (loop)?

The reason for recursionThe reason for recursion Easy to program in some situationsEasy to program in some situations

DisadvantageDisadvantage More time and space requiredMore time and space required

Example:Example: Tower of Hanoi ProblemTower of Hanoi Problem

Asymptotic Performance Asymptotic Performance

Given some rods for stacking disks.Given some rods for stacking disks.

Rules:

(1) The disks must be stacked in order of size.

(2) Each time move 1 disk.

The problem:The problem:Use fewest steps to move all diskUse fewest steps to move all disks from the source rod to the targes from the source rod to the target without violating the rules throt without violating the rules through the whole process (given one ugh the whole process (given one intermediate rod for buffering)?intermediate rod for buffering)?

a source rod an intermediate rod a target rod

Tower of HanoiTower of Hanoi

Suppose you can manage the n-1 disksSuppose you can manage the n-1 disks How do you solve the n disks case?How do you solve the n disks case? A recursive solution:A recursive solution:

Step 1: Move the top n-1 disks from source rod to Step 1: Move the top n-1 disks from source rod to intermediate rod via target rodintermediate rod via target rod

Step 2: Move the largest disk from source rod to target Step 2: Move the largest disk from source rod to target rodrod

Step 3: Move the n-1 disks from intermediate rod to Step 3: Move the n-1 disks from intermediate rod to target rod via source rodtarget rod via source rod


void Towers (int n, int Source, int Target, int Interm) { if (n==1)

Console::Write(S“\nFrom {0} to {1}”, Source.ToString(), Target.ToString());else{ Towers(n-1, Source, Interm, Target); Towers(1, Source, Target, Interm); Towers(n-1, Interm, Target, Source);}

}

How many “Console::Write” are executed?T(n)=2T(n-1)+1T(n)=2T(n-1)+1


Towers (3,’A’,’C’,’B’)

Towers (2,’A’,’B’,’C’)

Towers (1,’A’,’C’,’B’)

Towers (2,’B’,’C’,’A’)

T(n)=T(n-1)+A; T(1)=1T(n)=T(n-1)+A; T(1)=1 T(n)=O(n)T(n)=O(n)

T(n)=T(n-1)+n; T(1)=1T(n)=T(n-1)+n; T(1)=1 T(n)=O(nT(n)=O(n22))

T(n)=2T(n/2) + n; T(1)=1T(n)=2T(n/2) + n; T(1)=1 T(n)=O(n log n)T(n)=O(n log n)

T(n)=2T(n-1)+1T(n)=2T(n-1)+1 T(n)=O(2T(n)=O(2nn))

More general form: T(n)=aT(n/b)+cnMore general form: T(n)=aT(n/b)+cn Master’s Theorem Master’s Theorem

(You are not required to know)(You are not required to know)

Recursive RelationRecursive Relation

Introduction / Insertion sortIntroduction / Insertion sort Correctness of algorithmCorrectness of algorithm Worst /Average case analysisWorst /Average case analysis Order of growthOrder of growth Asymptotic PerformanceAsymptotic Performance

4 rules for asymptotic analysis4 rules for asymptotic analysis Recursive programsRecursive programs

SummarySummary

Documents

Data Structures for Media Introduction. Dr. Minming Li Department of Computer Science Room :Y6426 Phone :27889538 Email: [email protected], [email protected]