Big- & Big- Big-O ที่ใช้อธิบายการเติบโตของฟังก์ชัน แต่จะมีข้อจำกัด โดยเฉพาะ เมื่อ f(x) มี O(g(x)) ก็จะมีเฉพาะขอบเขตบน(Upper bound)คือ g(x) เมื่อ f(x) โตขึ้นด้วยค่า x แต่ Big-O ไม่มีขอบเขตล่าง (Lower bound) Donald Knuth ได้แนะนำ Big- & Big- โดย Big- จะมีทั้งขอบเขตบนและขอบเขตล่างของ 𝑓(𝑥)

Big- Def. เมื่อ f และ g เป็นฟังก์ชันจากเซตของจำนวนเต็มหรือเซตของจำนวนจริงไปยังเซตของจำนวนจริง เรากล่าวว่า 𝑓(𝑥) มี Ω 𝑔 𝑥 ถ้ามีค่าคงที C และ k ที่เป็นจำนวนเต็มบวกที่ทำให้ 𝑓(𝑥) ≥𝐶 𝑔 𝑥 เมื่อ 𝑥>𝑘 ในกรณีนี้จะอ่านว่า "𝑓 𝑥 𝑖𝑠 𝑏𝑖𝑔−𝑂𝑚𝑒𝑔𝑎 𝑜𝑓 𝑔 𝑥 "

Ex: Big- ฟังก์ชัน 𝑓 𝑥 =8 𝑥 3 +5 𝑥 2 +7 𝑖𝑠 Ω 𝑔 𝑥 โดยที่ 𝑔 𝑥 = 𝑥 3 ตัวอย่างนี้เห็นได้ชัดว่า 𝑓 𝑥 =8 𝑥 3 +5 𝑥 2 +7 ≥8 𝑥 3 , ∀𝑥∈𝑅 ซึ่งสมมูลกับ 𝑔 𝑥 = 𝑥 3 𝑖𝑠 𝑂 𝑓 𝑥 จะเห็นว่า Big- กับ Big-O ของ 𝑓 𝑥 มีความเชื่อมโยงกัน นั่นคือ 𝑓 𝑥 𝑖𝑠 Ω 𝑔 𝑥 ≡𝑔 𝑥 𝑖𝑠 𝑂 𝑓 𝑥

Big- เมื่อ 𝑓 𝑥 มี Θ 𝑔 𝑥 ย่อมหมายความถึง g 𝑥 มี Θ 𝑓 𝑥 ด้วยเหตุนี้ 𝑓 𝑥 𝑖𝑠Θ 𝑔 𝑥 ↔𝑔 𝑥 𝑖𝑠Θ 𝑓 𝑥

Algorithmic Complexity An analysis of the time required to solve a problem of a particular size involves the time complexity of the algorithm. An analysis of the computer memory required involves the space complexity of the algorithm. Measure running time by counting the number of “basic operations”.

Running Time Basic steps— Assignment Increment Comparison Negation Return Random array access Function output access etc. In a particular problem, may tell you to consider other operations (e.g. multiplication) and ignore all others

Algorithm 1 Finding the Maximum int fMax(int a[n] ) //หาค่าสูงสุดในอะเรย์ ที่ยังไม่ได้เรียงลำดับข้อมูล { int max = a1; for(i =2; i<=n, i++) //i<=n เปรียบเทียบ n-1 ครั้ง if(max > ai) //max>ai เปรียบเทียบ n-1 ครั้ง max = ai //+1 } return max; 2(n-1)+1 = 2n-1 ⟹Θ 𝑛

//ในลูปมีการเปรียบเทียบสองครั้ง //เมื่อพบข้อมูล=> จะมีการเปรียบเทียบ //2i+1 ครั้ง //เมื่อไม่พบข้อมูล(Worst-case complexity) //จะมีการเปรียบเทียบ 2n+1+1 ครั้ง +1 มาจาก else

Example 4

จากการพิสูจน์ด้วยอุปนัย

Recursive Algorithms long factorial(int n) { if (n<=0) return 1; return n*factorial(n-1); }

Recursive Algorithms Compute 5! long factorial(int n){ if (n<=0) return 1; return n*factorial(n-1); } Compute 5!

Recursive Algorithms long factorial(int n){ if (n<=0) return 1; return n*factorial(n-1); } f(5)=5·f(4)

Recursive Algorithms long factorial(int n){ if (n<=0) return 1; return n*factorial(n-1); } f(4)=4·f(3) f(5)=5·f(4)

Recursive Algorithms long factorial(int n){ if (n<=0) return 1; return n*factorial(n-1); } f(3)=3·f(2) f(4)=4·f(3) f(5)=5·f(4)

Recursive Algorithms long factorial(int n){ if (n<=0) return 1; return n*factorial(n-1); } f(2)=2·f(1) f(3)=3·f(2) f(4)=4·f(3) f(5)=5·f(4)

Recursive Algorithms long factorial(int n){ if (n<=0) return 1; return n*factorial(n-1); } f(1)=1·f(0) f(2)=2·f(1) f(3)=3·f(2) f(4)=4·f(3) f(5)=5·f(4)

Recursive Algorithms long factorial(int n){ if (n<=0) return 1; return n*factorial(n-1); } f(0)= 1 f(1)=1·f(0) f(2)=2·f(1) f(3)=3·f(2) f(4)=4·f(3) f(5)=5·f(4)

Recursive Algorithms long factorial(int n){ if (n<=0) return 1; return n*factorial(n-1); } 1·1= 1 f(2)=2·f(1) f(3)=3·f(2) f(4)=4·f(3) f(5)=5·f(4)

Recursive Algorithms long factorial(int n){ if (n<=0) return 1; return n*factorial(n-1); } 2·1= 2 f(3)=3·f(2) f(4)=4·f(3) f(5)=5·f(4)

Recursive Algorithms long factorial(int n){ if (n<=0) return 1; return n*factorial(n-1); } 3·2= 6 f(4)=4·f(3) f(5)=5·f(4)

Recursive Algorithms long factorial(int n){ if (n<=0) return 1; return n*factorial(n-1); } 4·6= 24 f(5)=5·f(4)

Recursive Algorithms long factorial(int n){ if (n<=0) return 1; return n*factorial(n-1); } 4·6= 24 f(5)=5·f(4)

Recursive Algorithms long factorial(int n){ if (n<=0) return 1; return n*factorial(n-1); } 5·24= 120

Recursive Algorithms long factorial(int n){ if (n<=0) return 1; return n*factorial(n-1); } Return 5! = 120

Running time of 1st algorithm boolean isOnto( function f: (1, 2,…, n)  (1, 2,…, m) ){ if( m > n ) return false soFarIsOnto = true for( j = 1 to m ){ soFarIsOnto = false for(i = 1 to n ){ if ( f(i ) == j ) soFarIsOnto = true if( !soFarIsOnto ) return false } return true; 1 step OR: 1 step (assigment) m loops: 1 increment plus 1 step (assignment) n loops: 1 increment plus 1 step possibly leads to: 1 step (return) possibly 1 step

Running time of 1st algorithm 1 step (m>n) OR: 1 step (assigment) m loops: 1 increment plus 1 step (assignment) n loops: 1 increment plus 1 step possibly leads to: 1 step (return) possibly 1 step WORST-CASE running time: Number of steps = 1 OR 1+ 1 + m · (1+ 1 + n · (1+1 + 1 + 1 ) = 1 (if m>n) OR 5mn+3m+2