Algorithm Analysis

Pataasin ang iyong marka sa homework at exams ngayon gamit ang Quizwiz!

Recursive Algorithm

Alg. that breaks problem into smaller subproblems and applies the alg. itself to solve smaller subproblems o Must have a base case → Completes w/o applying itself to smaller subproblem → Ensures that recursive alg. eventually terminates o Not synonymous w/error-checking case.

Worst case

Algorithm does the max possible number of operations

Best case

Algorithm does the min possible number of operations

Growth of Functions and Complexity

Algorithm w/runtime complexity T(N) → Lower/Upper bound enclose all possible runtimes for alg. - Asymptotic Notation

Constant Time Operations

Always operates in the same amount of time regardless of input - Any constant # of constant time ops collectively 1 constant time ops

Runtime complexity of any recursive func. split into 2 parts:

- Operations done directly by functions - Operations done by recursive calls made by function

Analyzing the time complexity of recursive algorithms

- Recurrence Relations - Recursion trees

Lower bound

A function f(N) that is ≤ the best case T(N), for all values of N ≥ 1

Upper bound

A function f(N) that is ≥ the worst case T(N), for all values of N ≥ 1

Operations

Any statement(s) w/constant runtime O(1) → Precisely counting # of constant operations in a finite sequence is not needed

Asymptotic Notation

Classification of runtime complexity: O, Ω, Θ

Big O Notation

Describing how function (running time of alg.) generally behaves in relation to input size o All functions that have the same growth → Highest order term of the function in Big O

Runtime Growth Analysis

Efficiency of alg is most critical factor large inputs (Greater runtime) - For large N, difference in computational time varies greatly w/rate of growth of function

Recurrence Relations: Recurrence relation

Function f(N) is defined in terms of the same function operating on a value < N.

Recursive Function

Function that calls itself → To implement recursive algorithms

Algorithm Analysis

How runtime of an alg. scales as input size increases 1. Determine how many ops the alg. executes for input size N 2. Big O Notation for func. is determined - Focus on worse-case runtime

Determine Big O Notation

If f(N) = Sum of several terms → Highest order is kept and others are discarded. Ex: 5 + 13·N + 7·N^2 to O(N^2) - All constants are omitted.

Efficient algorithm aims to:

Lower algorithm runtime

Algorithm Efficiency

Measured by algorithm computational complexity → Used to identify/avoid using algorithms w/ - Long runtimes or high memory usage

Nested loops

N*N (according to number of nests)

Ω notation

Provides a growth rate for an algorithm's lower bound.

O notation

Provides a growth rate for an algorithm's upper bound.

Θ notation

Provides growth rate that is both upper and lower bound.

Root node

Represents k operations inside the first function call.

computational complexity

Resources used by the algorithm → resources: runtime and memory usage.

Recurrence Relations

Runtime complexity T(N) of a recursive function → function T on both sides of the equation. Ex: Binary search T(N) = O(1) + T(N / 2) → recurrence relation Using O-notation to express runtime complexity of recursive function requires solving the recurrence relations

Worst case runtime

Runtime complexity for an input results in longest execution

Recursive Algorithm: Binary search

Searches a sorted list for a key by comparing the key to the middle element in the list and searching half of the remaining list until key is found.

Auxiliary space complexity

Space complexity w/o input data → S(N) = K - w/k as constant

Recursion trees

Tool for solving recurrences: → Root node → Recursive ops. are represented below the node - 1st also does k operations. → # of nodes corresponds to # of recursive calls

Space Complexity

function S(N) → # of fixed-size memory units used by the alg. for an input of size N - Ex: S(N) = N + k Includes input data & additional memory allocated by the alg. - Auxiliary space complexity

Runtime complexity

function T(N) → # of constant-time operations performed by input of size N - Varies based on the input - Identify best and worst-case scenarios

Algorithm

method to solve a computational problem

Recursive Algorithm: Fibonacci Sequence

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

Analysis of Algorithm

runtime = # of constant time operations


Kaugnay na mga set ng pag-aaral

CH.4 Managing Marketing Information to Gain Customer Insights

View Set

conversion and somatic symptom disorder

View Set

AHS 205 - Study Guide CH Test 1-4

View Set

Chapter C9 Partnership Formation and Operation

View Set

Direkt 2 Lektion 1 Verben mit Präpositionen Fragen - Sachen, Personen

View Set

biology lab chemical composition of cells

View Set

QUIZ 2 PEDIATRICS CHAPETRS 18,19,20

View Set