3.1.6
Intuition Ek sentence mein pictureAgar O itne se zyada slow nahi hoga," toh Ω itne se zyada fast nahi hoga," aur Θ dono agree karte hain — growth ek hi function ki do copies ke beech trap ho jaati hai.
Akela Big-O ceiling ka promise hai. Yeh kehna ki "yeh sort O ( n 2 ) O ( n ) O ( n 2 ) O loose ho sakta hai. Yeh kehne ke liye ki "yeh growth exactly n 2 floor (Ω O tight bound Θ
Toh yeh family hai:
O Ω Θ
Hum functions f ( n ) g ( n ) n n 2 n log n n → ∞ n shape maayane rakhti hai.
Hum chahte hain "f g kisi point ke baad , f scaled copy of g
f ( n ) = O ( g ( n )) ⟺ ∃ c > 0 , n 0 > 0 : 0 ≤ f ( n ) ≤ c g ( n ) ∀ n ≥ n 0
c n 0 c constant factors ko khatam karta hai (2× slow machine se class nahi badlni chahiye). n 0 small-n ko khatam karta hai (startup overhead, pehla slow iteration). Hum sirf eventual trend judge karte hain.
"f g zyada slow nahi badhta" — inequality ko flip karo:
Ω f ( n ) = Ω ( g ( n )) ⟺ ∃ c > 0 , n 0 > 0 : 0 ≤== c g ( n ) ≤ f ( n ) == ∀ n ≥ n 0 f g upar rehta hai. Toh g f floor hai.
Agar g dono hai — ceiling bhi aur floor bhi (possibly alag constants ke saath) — toh growth pin ho jaati hai:
Θ f ( n ) = Θ ( g ( n )) ⟺ ∃ c 1 , c 2 > 0 , n 0 > 0 : == 0 ≤ c 1 g ( n ) ≤ f ( n ) ≤ c 2 g ( n ) == ∀ n ≥ n 0 f = Θ ( g ) ⟺ f = O ( g ) AND f = Ω ( g )
Worked example 1) Dikhao ki3 n 2 + 5 n + 7 = Θ ( n 2 ) Upper: n ≥ 1 3 n 2 + 5 n + 7 ≤ 3 n 2 + 5 n 2 + 7 n 2 = 15 n 2 c 2 = 15 Yeh step kyun? Humne lower-order terms 5 n , 7 n 2 ≤ Lower: 3 n 2 + 5 n + 7 ≥ 3 n 2 n ≥ 0 c 1 = 3 Kyun? Positive terms drop karne se expression sirf chhota hota hai, jo ek clean floor deta hai.
Conclude: 3 n 2 ≤ f ( n ) ≤ 15 n 2 n ≥ 1 f = Θ ( n 2 ) c 1 = 3 , c 2 = 15 , n 0 = 1
Worked example 2) Dikhao kin 2 = O ( n ) n 2 = Ω ( n ) Θ ( n ) nahi
Maano n 2 ≤ c n n > 0 n ≤ c Yeh step kyun? Sab bade n c n O ( n ) n 2 ≥ 1 ⋅ n n ≥ 1 n 2 = Ω ( n ) tight nahi . ∎
Worked example 3) Ek problem ka lower bound vs ek algorithmComparison-based sorting ko Ω ( n log n ) problem ke liye har possible algorithm par bound hai (decision-tree height log 2 ( n !) = Θ ( n log n ) O ( n log n ) optimal hai: Θ ( n log n ) Yeh kyun important hai: Problem par Ω
Ω Kyun sahi lagta hai: "lower" sun ke lagta hai "fastest/easiest input." Sach: O , Ω , Θ T ( n ) best/worst/average ek alag axis hai (kaun sa input choose kiya). Tum keh sakte ho "worst-case time Ω ( n log n ) worst case ka lower bound hai. Fix: decide karo (1) kaun sa case analyze kar rahe ho, phir (2) us case ke function ko O Ω Θ
O Ω Kyun sahi lagta hai: worst "highest" hai, best "lowest" hai, words se match karta hai. Fix: Wahi upar wala — bound symbols ≠ case selection. Ek algorithm worst case mein Θ ( n 2 ) Θ ( n )
Common mistake "Har algorithm ka ekΘ Kyun sahi lagta hai: functions ka usually ek clean shape hota hai. Sach: agar best aur worst order mein differ karte hain, toh poore runtime ke liye koi single Θ Θ ( n ) Θ ( n 2 ) O ( n 2 ) Ω ( n ) Θ nahi . Fix: Θ O Ω
f = O ( g ) O ( g ) = f Kyun sahi lagta hai: "=" symmetric lagta hai. Fix: "=" ek one-way "is a member of" hai. Θ sirf symmetric hai (f = Θ ( g ) ⟺ g = Θ ( f )
Recall Feynman: 12-saal ke bachche ko samjhaoSocho ek bachche ki height guess kar rahe ho. Big-O Ω Θ kaafi exactly pata hai. Hum baby photos (small n
Mnemonic Shapes yaad rakhoO verhead = O = ceiling (≤). Ω ek ulte cup jaisa dikhta hai jo cheezein upar pakde = floor (≥). Θ ke beech mein bar hai = beech mein pin hua = th eta = tight .
f = Ω ( g ) ∃ c > 0 , n 0 > 0 : 0 ≤ c g ( n ) ≤ f ( n ) n ≥ n 0
f = Θ ( g ) ∃ c 1 , c 2 , n 0 > 0 : 0 ≤ c 1 g ( n ) ≤ f ( n ) ≤ c 2 g ( n ) n ≥ n 0
Θ O Ω f = Θ ( g ) ⟺ f = O ( g ) and f = Ω ( g )
Limit test: agar lim f / g = 0 f = O ( g ) Ω ( g ) o ( g )
Limit test: agar lim f / g = ∞ f = Ω ( g ) O ( g ) ω ( g )
Limit test: agar 0 < lim f / g < ∞ f = Θ ( g )
Kya n 2 = O ( n ) Nahi; n ≤ c n n 2 = Ω ( n )
Ω Bound symbols ek function ki growth measure karte hain; best/worst/average ek alag axis hai (kaun sa input).
Comparison sorting ka lower bound kya hai, aur kyun? Ω ( n log n ) log 2 ( n !) = Θ ( n log n )
Kaun si Big-notation relation symmetric hai? Θ f = Θ ( g ) ⟺ g = Θ ( f )
Insertion sort: runtime ka ek single Θ Nahi — best Θ ( n ) Θ ( n 2 ) O ( n 2 ) Ω ( n )
c n 0 c n 0 n
kills constants and small-n noise
f n cost vs g n reference
constant c and threshold n0
