कभी-कभी मैं I (n) को अजीब with प्रतीक के साथ इसके बीच में कुछ के साथ देखता हूं, और कभी-कभी O (n)। क्या यह केवल टाइप करने का आलस्य है क्योंकि कोई भी इस प्रतीक को टाइप करना नहीं जानता है, या इसका मतलब कुछ अलग है?
कभी-कभी मैं I (n) को अजीब with प्रतीक के साथ इसके बीच में कुछ के साथ देखता हूं, और कभी-कभी O (n)। क्या यह केवल टाइप करने का आलस्य है क्योंकि कोई भी इस प्रतीक को टाइप करना नहीं जानता है, या इसका मतलब कुछ अलग है?
जवाबों:
यदि कोई एल्गोरिथ्म Θ (g (n)) का है, तो इसका मतलब है कि एल्गोरिथ्म का n (इनपुट आकार) के रूप में चलने का समय g (n) के समानुपाती है।
यदि एक एल्गोरिथ्म O (g (n)) का है, तो इसका अर्थ है कि एल्गोरिथ्म का रनिंग समय जितना बड़ा होता है , वह g (n) के समानुपाती होता है।
आम तौर पर, यहां तक कि जब लोग ओ (जी (एन)) के बारे में बात करते हैं तो उनका वास्तव में मतलब होता है ((जी (एन)) लेकिन तकनीकी रूप से, एक अंतर होता है।
O (n) ऊपरी सीमा का प्रतिनिधित्व करता है। Means (n) का मतलब है टाइट बाउंड। Represents (n) कम बाउंड का प्रतिनिधित्व करता है।
f (x) = Θ (g (x)) iff f (x) = O (g (x)) और f (x) = x (g (x))
असल में जब हम कहते हैं कि एक एल्गोरिथ्म हे (एन) की है, यह भी है O (n 2 हे (एन), 1000000 ) हे (2 n ), ... लेकिन एक Θ (एन) एल्गोरिथ्म है नहीं Θ (एन 2 ) ।
वास्तव में, च के बाद से (n) =, (g (n)) का मतलब एन के पर्याप्त रूप से बड़े मानों के लिए होता है, f (n) c के कुछ मानों के लिए c 1 g (n) और c 2 g (n) के भीतर बांधा जा सकता है। 1 और c 2 , अर्थात f की वृद्धि दर asymptotically g के बराबर है: g एक कम बाध्य और f की ऊपरी सीमा हो सकती है। इसका सीधा तात्पर्य है f एक निचला बाउंड और g का ऊपरी बाउंड भी हो सकता है। इसके फलस्वरूप,
f (x) = Θ (g (x)) iff g (x) = f (f (x))
इसी तरह, f (n) = Θ (g (n)) को दिखाने के लिए, यह g को दिखाने के लिए पर्याप्त है f की ऊपरी सीमा है (यानी f (n) = O (g (n))) और f का निचला भाग है g (यानी f (n) = Ω (g (n)) जो g (n) = O (f (n)) के समान सटीक है। संक्षेप में,
f (x) = Θ (g (x)) iff f (x) = O (g (x)) और g (x) = O (f (x))
ω
एक समारोह के ढीले ऊपरी और ढीले निचले सीमा का प्रतिनिधित्व करने वाले छोटे-ओह और छोटे-ओमेगा ( ) नोटेशन भी हैं।
संक्षेप में:
f(x) = O(g(x))
(बड़ा, ओह) का मतलब है कि की वृद्धि दरf(x)
asymptotically है की तुलना में कम या बराबर की विकास दर के लिएg(x)
।
f(x) = Ω(g(x))
(बड़े ओमेगा) का मतलब है कि की वृद्धि दरf(x)
asymptotically है से अधिक या उसके बराबर की विकास दरg(x)
f(x) = o(g(x))
(थोड़ा-ऊँ) का अर्थ है कि विकास की दर की वृद्धि दर की तुलना मेंf(x)
विषमता से कम हैg(x)
।
f(x) = ω(g(x))
(लिटिल-ओमेगा) का मतलब है कि विकास दर की वृद्धि दर की तुलना मेंf(x)
विषमता से अधिक हैg(x)
f(x) = Θ(g(x))
(थीटा) का मतलब है कि की वृद्धि दरf(x)
asymptotically है के बराबर की विकास दरg(x)
अधिक विस्तृत चर्चा के लिए, आप विकिपीडिया पर परिभाषा पढ़ सकते हैं या कॉर्मेन एट अल द्वारा परिचय जैसे एल्गोरिथ्म में एक क्लासिक पाठ्यपुस्तक से परामर्श कर सकते हैं ।
>= \Omega(...)
मतलब है? मैं समझता हूं कि यदि हम कहते हैं कि यह इसका सदस्य है \Omega(...)
, लेकिन यदि यह इससे अधिक है तो? क्या समझ में आता है?
एक सरल तरीका है (एक चाल, मुझे लगता है) याद करने के लिए कि किस संकेतन का अर्थ है।
सभी बिग-ओ नोटेशन को एक बार माना जा सकता है।
जब एक Ω को देखते हैं, तो पट्टी नीचे होती है, इसलिए यह एक (असममित) निचला भाग होता है।
जब एक looking को देखते हैं, तो बार स्पष्ट रूप से बीच में होता है। तो यह एक (विषम) तंग बाध्य है।
जब हे लिखावट होती है, तो आप आमतौर पर शीर्ष पर समाप्त होते हैं, और एक स्क्विगल ड्रा करते हैं। इसलिए O (n) फ़ंक्शन की ऊपरी सीमा है। निष्पक्ष होने के लिए, यह सबसे फोंट के साथ काम नहीं करता है, लेकिन यह नामों का मूल औचित्य है।
एक बड़ा "O" है
एक बिग थीटा है
http://en.wikipedia.org/wiki/Big_O_notation
बिग ओ का अर्थ है कि आपका एल्गोरिदम दिए गए अभिव्यक्ति की तुलना में अधिक चरणों में निष्पादित नहीं करेगा (n ^ 2)
बिग ओमेगा का अर्थ है कि आपका एल्गोरिदम दिए गए अभिव्यक्ति की तुलना में कम चरणों में निष्पादित करेगा (n ^ 2)
जब दोनों ही स्थिति एक ही अभिव्यक्ति के लिए सही हैं, तो आप बड़े थीटा नोटेशन का उपयोग कर सकते हैं ...।
सैद्धांतिक परिभाषा प्रदान करने के बजाय, जो पहले से ही यहां संक्षेप में प्रस्तुत किए गए हैं, मैं एक सरल उदाहरण दूंगा:
का रन टाइम मान लिया f(i)
है O(1)
। नीचे एक कोड टुकड़ा है जिसका एसिमेटोटिक रनटाइम है Θ(n)
। यह हमेशा फ़ंक्शन f(...)
n
समय को कॉल करता है। निचला और ऊपरी दोनों बाउंड n है।
for(int i=0; i<n; i++){
f(i);
}
नीचे दिए गए दूसरे कोड के टुकड़े में स्पर्शोन्मुख रनटाइम है O(n)
। यह f(...)
ज्यादातर n
समय फ़ंक्शन को कॉल करता है । ऊपरी बाउंड n है, लेकिन निम्न बाउंड हो सकता है Ω(1)
या Ω(log(n))
, इस पर निर्भर करता है कि अंदर क्या होता है f2(i)
।
for(int i=0; i<n; i++){
if( f2(i) ) break;
f(i);
}
Θ(n)
, n बढ़ के रूप में रैखिक रूप से बढ़ेगा, जैसे रनटाइम टी को टी (एन) = ए * एन + बी के रूप में व्यक्त किया जा सकता है। N के छोटे मानों के लिए (जैसे n = 1 या 2) यह व्यवहार का वर्णन करने का सबसे अच्छा तरीका नहीं हो सकता है - शायद आपके पास कुछ आरंभीकरण कोड है जो च (i) की तुलना में बहुत अधिक समय लेता है।
थीटा एक विशेष संतृप्ति का जिक्र करने का एक संक्षिप्त तरीका है जहां बड़े ओ और ओमेगा समान हैं।
इस प्रकार, यदि कोई दावा करता है The Theta is expression q
, तो वे जरूरी दावा भी कर रहे हैं Big O is expression q
और Omega is expression q
।
किसी न किसी सादृश्य:
यदि: थीटा दावा करता है, "उस जानवर के 5 पैर हैं।" तब यह इस प्रकार है: बिग ओ सच है ("उस जानवर की लंबाई 5 फीट से कम या बराबर है।") और ओमेगा सच है ("उस जानवर के पास 5 फीट से अधिक या बराबर है।"
यह केवल एक मोटा सादृश्य है क्योंकि भाव आवश्यक रूप से विशिष्ट संख्याएँ नहीं हैं, बल्कि परिमाण के भिन्न-भिन्न क्रमों जैसे लॉग (n), n, n ^ 2, (आदि) के कार्य हैं।
एक चार्ट पिछले उत्तरों को समझने में आसान बना सकता है:
अंग्रेजी में,
बाईं ओर, ध्यान दें कि एक ऊपरी बाउंड और एक निचला बाउंड है जो दोनों एक ही क्रम के परिमाण (यानी g (n) ) के हैं। स्थिरांक को अनदेखा करें, और यदि ऊपरी सीमा और निचली सीमा में परिमाण का समान क्रम है, तो कोई व्यक्ति वैध रूप से f (n) = n (g (n)) या f (n) को g (n) के बड़े थीटा में कह सकता है ।
सही, सरल उदाहरण से शुरू करते हुए, यह कह रहा है कि ऊपरी बाध्य जी (एन) केवल परिमाण का क्रम है और निरंतर सी को अनदेखा करता है (जैसे सभी बड़े ओ अंकन करता है)।
f(n)
के रूप में O(n)
सकारात्मक मौजूद है, तो संबंधित हैk
f(n)<=k*n
f(n)
के अंतर्गत आता है Θ(n)
, तो सकारात्मक मौजूद है k1
, k2
के रूप मेंk1*n<=f(n)<=k2*n
आइए विचार करें f(n) > 0
और g(n) > 0
सभी के लिए n
। इस पर विचार करना ठीक है, क्योंकि सबसे तेज़ वास्तविक एल्गोरिथ्म में कम से कम एक ऑपरेशन होता है और शुरुआत के बाद इसका निष्पादन पूरा करता है। यह पथरी को सरल करेगा, क्योंकि हम f(n)
निरपेक्ष मान ( |f(n)|
) के बजाय मूल्य ( ) का उपयोग कर सकते हैं ।
f(n) = O(g(n))
सामान्य:
f(n)
0 ≤ lim ──────── < ∞
n➜∞ g(n)
के लिए g(n) = n
:
f(n)
0 ≤ lim ──────── < ∞
n➜∞ n
उदाहरण:
Expression Value of the limit
------------------------------------------------
n = O(n) 1
1/2*n = O(n) 1/2
2*n = O(n) 2
n+log(n) = O(n) 1
n = O(n*log(n)) 0
n = O(n²) 0
n = O(nⁿ) 0
जवाबी उदाहरण:
Expression Value of the limit
-------------------------------------------------
n ≠ O(log(n)) ∞
1/2*n ≠ O(sqrt(n)) ∞
2*n ≠ O(1) ∞
n+log(n) ≠ O(log(n)) ∞
f(n) = Θ(g(n))
सामान्य:
f(n)
0 < lim ──────── < ∞
n➜∞ g(n)
के लिए g(n) = n
:
f(n)
0 < lim ──────── < ∞
n➜∞ n
उदाहरण:
Expression Value of the limit
------------------------------------------------
n = Θ(n) 1
1/2*n = Θ(n) 1/2
2*n = Θ(n) 2
n+log(n) = Θ(n) 1
जवाबी उदाहरण:
Expression Value of the limit
-------------------------------------------------
n ≠ Θ(log(n)) ∞
1/2*n ≠ Θ(sqrt(n)) ∞
2*n ≠ Θ(1) ∞
n+log(n) ≠ Θ(log(n)) ∞
n ≠ Θ(n*log(n)) 0
n ≠ Θ(n²) 0
n ≠ Θ(nⁿ) 0
निष्कर्ष: हम बड़े ओ, बड़े θ और बड़े Ω को एक ही चीज मानते हैं।
क्यों? मैं नीचे कारण बताऊंगा:
सबसे पहले, मैं एक गलत कथन को स्पष्ट करूंगा, कुछ लोग सोचते हैं कि हम सबसे खराब समय की जटिलता की परवाह करते हैं, इसलिए हम हमेशा बड़े θ के बजाय बड़े O का उपयोग करते हैं। मैं कहूंगा कि यह आदमी बकवास कर रहा है। ऊपरी और निचले बाउंड का उपयोग एक फ़ंक्शन का वर्णन करने के लिए किया जाता है, जिसका उपयोग समय की जटिलता का वर्णन करने के लिए नहीं किया जाता है। सबसे खराब समय समारोह की ऊपरी और निचली सीमा होती है; सबसे अच्छे समय समारोह की ऊपरी और निचली सीमा भी होती है।
बड़े ओ और बड़े big के बीच के संबंध को स्पष्ट रूप से समझाने के लिए, मैं पहले बड़े ओ और छोटे ओ के बीच के संबंध की व्याख्या करूंगा। परिभाषा से, हम आसानी से जान सकते हैं कि छोटा ओ बड़े O का सबसेट है। उदाहरण के लिए can
T (n) = n ^ 2 + n, हम T (n) = O (n ^ 2), T (n) = O (n ^ 3), T (n) = O (n ^ 4) कह सकते हैं। लेकिन छोटे ओ के लिए, टी (एन) = ओ (एन ^ 2) छोटे ओ की परिभाषा को पूरा नहीं करता है। तो बस टी (एन) = ओ (एन ^ 3), टी (एन) = ओ (एन ^ 4) छोटे ओ के लिए सही हैं। निरर्थक T (n) = O (n ^ 2) क्या है? यह बड़ा θ है!
आम तौर पर, हम कहते हैं कि O O (n ^ 2) है, मुश्किल से T (n) = O (n ^ 3), T (n) = O (n ^ 4)। क्यों? क्योंकि हम बड़े ओ को बड़े as अवचेतन रूप से मानते हैं।
इसी तरह, हम भी बड़े big को बड़े also अवचेतन रूप से मानते हैं।
एक शब्द में, बड़ा O, बड़ा θ और बड़ा itions परिभाषाओं से समान नहीं हैं, लेकिन वे हमारे मुंह और मस्तिष्क में एक ही चीज हैं।