विषम कार्य क्या हैं? क्या एक asymptote है, वैसे भी?
एक फ़ंक्शन f (n) को देखते हुए एक एल्गोरिथ्म द्वारा खपत संसाधनों (CPU समय, रैम, डिस्क स्थान, आदि) की मात्रा का वर्णन करता है जब n के आकार के इनपुट पर लागू किया जाता है , तो हम इसके प्रदर्शन का वर्णन करने के लिए तीन स्पर्शोन्मुख संकेतन तक परिभाषित करते हैं बड़े एन ।
एक asymptote (या asymptotic समारोह) बस है कुछ अन्य समारोह (या संबंध नहीं) जी (एन) कि च (एन) तेजी से के रूप में के करीब हो जाता n अधिकाधिक बढ़ता है, लेकिन कभी पूर्ण पहुंच। स्पर्शोन्मुख कार्यों के बारे में बात करने का लाभ यह है कि वे आम तौर पर बात करने के लिए बहुत सरल होते हैं, भले ही एफ (एन) के लिए अभिव्यक्ति बेहद जटिल हो। असममित कार्यों को बाउंडिंग नोटेशन के भाग के रूप में उपयोग किया जाता है जो f (n) को ऊपर या नीचे प्रतिबंधित करते हैं।
(ध्यान दें: यहाँ नियोजित अर्थ में, कुछ निरंतर नॉनज़रो फैक्टर को सही करने के बाद एसिम्प्टोटिक फ़ंक्शंस केवल मूल फ़ंक्शन के करीब हैं, क्योंकि सभी तीन बड़े-ओ / Θ / ations नोटेशन अपने विचार से इस निरंतर कारकों की उपेक्षा करते हैं।)
तीन स्पर्शोन्मुख बाउंडिंग संकेतन क्या हैं और वे कैसे भिन्न हैं?
सभी तीन संकेतन इस तरह उपयोग किए जाते हैं:
f (n) = O (g (n))
जहाँ f (n) यहाँ ब्याज का कार्य है, और g (n) कुछ अन्य स्पर्शोन्मुख कार्य है जिसे आप f (n) के साथ अनुमानित करने का प्रयास कर रहे हैं । यह एक कठोर अर्थ में एक समानता के रूप में नहीं लिया जाना चाहिए, लेकिन कितनी तेजी के बीच एक औपचारिक बयान च (एन) के संबंध में बढ़ता एन की तुलना में जी (एन) , के रूप में एन बड़ा हो जाता है। शुद्धतावादी अक्सर वैकल्पिक संकेतन f (n) g O (g (n)) का उपयोग इस बात पर जोर देने के लिए करेंगे कि प्रतीक O (g (n)) वास्तव में एक सामान्य वृद्धि दर साझा करने वाले कार्यों का एक पूरा परिवार है।
बिग-equal (थीटा) संकेतन एक स्थिर कारक (अधिक बाद में) तक च (एन) के विकास पर एक समानता बताता है । यह विकास दर के लिए एक ऑपरेटर के समान व्यवहार करता है ।=
Big-O संकेतन f (n) की वृद्धि पर एक ऊपरी- अंतर्वेशन का वर्णन करता है । यह वृद्धि दर के लिए एक ऑपरेटर के समान व्यवहार करता है ।≤
बिग- lower (ओमेगा) संकेतन f (n) की वृद्धि पर एक कम- इनबाउंड का वर्णन करता है । यह ≥वृद्धि दर के लिए एक ऑपरेटर के समान व्यवहार करता है ।
रहे हैं कई अन्य asymptotic अंकन , पर वे कंप्यूटर विज्ञान साहित्य में लगभग के रूप में अक्सर नहीं होती है।
बिग-ओ नोटेशन और इसके ilk अक्सर समय की जटिलता की तुलना करने के तरीके के रूप में होते हैं ।
समय जटिलता क्या है?
समय जटिलता टी की मात्रा के लिए एक फैंसी शब्द है (n) यह एक एल्गोरिथ्म को इसके इनपुट आकार n के एक फ़ंक्शन के रूप में निष्पादित करने के लिए लेता है । यह वास्तविक समय (जैसे सेकंड) की मात्रा, सीपीयू निर्देशों की संख्या आदि में मापा जा सकता है। आमतौर पर यह माना जाता है कि एल्गोरिथ्म आपके रोजमर्रा के वॉन न्यूमैन आर्किटेक्चर कंप्यूटर पर चलेगा । लेकिन निश्चित रूप से आप अधिक जटिल कंप्यूटिंग सिस्टम के बारे में बात करने के लिए समय की जटिलता का उपयोग कर सकते हैं, जहां चीजें अलग हो सकती हैं!
बिग-ओ नोटेशन का उपयोग करके अंतरिक्ष की जटिलता के बारे में बात करना भी आम है। अंतरिक्ष जटिलता एल्गोरिथ्म को पूरा करने के लिए आवश्यक मेमोरी (स्टोरेज) की मात्रा है, जो रैम, डिस्क आदि हो सकती है।
यह मामला हो सकता है कि एक एल्गोरिथ्म धीमा है, लेकिन कम मेमोरी का उपयोग करता है, जबकि दूसरा तेज है लेकिन अधिक मेमोरी का उपयोग करता है। प्रत्येक अलग परिस्थितियों में अधिक उपयुक्त हो सकता है, अगर संसाधन अलग तरीके से विवश हैं। उदाहरण के लिए, एक एम्बेडेड प्रोसेसर में सीमित मेमोरी हो सकती है और धीमी एल्गोरिथ्म का पक्ष ले सकती है, जबकि डेटा सेंटर में सर्वर में बड़ी मात्रा में मेमोरी हो सकती है और तेज़ एल्गोरिथम का पक्ष ले सकती है।
बिग-ϴ की गणना
एल्गोरिथ्म के बिग-ϴ की गणना एक ऐसा विषय है जो एक छोटी पाठ्यपुस्तक या स्नातक कक्षा के लगभग आधे सेमेस्टर को भर सकता है: यह खंड मूल बातें कवर करेगा।
Pseudocode में एक फ़ंक्शन f (n) दिया गया:
int f(n) {
int x = 0;
for (int i = 1 to n) {
for (int j = 1 to n) {
++x;
}
}
return x;
}
समय जटिलता क्या है?
बाहरी लूप n बार चलता है। प्रत्येक बार बाहरी लूप चलता है, आंतरिक लूप n बार चलता है। यह रनिंग टाइम को T (n) = n 2 पर रखता है ।
एक दूसरे समारोह पर विचार करें:
int g(n) {
int x = 0;
for (int k = 1 to 2) {
for (int i = 1 to n) {
for (int j = 1 to n) {
++x;
}
}
}
return x;
}
बाहरी लूप दो बार चलता है। मध्य लूप n बार चलता है। हर बार मध्य लूप चलता है, आंतरिक लूप n बार चलता है। यह रनिंग टाइम को T (n) = 2n 2 पर रखता है ।
अब प्रश्न यह है कि दोनों कार्यों का असममित रूप से चलने का समय क्या है ?
इसकी गणना करने के लिए, हम दो चरण करते हैं:
- स्थिरांक निकालें। चूंकि इनपुट्स के कारण एल्गोरिदम समय में वृद्धि करते हैं, अन्य शर्तें रनिंग टाइम पर हावी होती हैं, जिससे वे महत्वहीन हो जाते हैं।
- सभी निकालें लेकिन सबसे बड़ा शब्द। जैसा कि n अनंत तक जाता है, n 2 तेजी से outpaces n ।
वे यहाँ प्रमुख शब्दों पर ध्यान केंद्रित करते हैं, और उन शर्तों को सरल करते हैं ।
T (n) = n 2 ∈ n (n 2 )
T (n) = 2n 2 ϴ ϴ (n 2 )
यदि हमारे पास कई शर्तों के साथ एक और एल्गोरिथ्म है, तो हम समान नियमों का उपयोग करके इसे सरल करेंगे:
T (n) = 2n 2 + 4n + 7 2 2 (n 2 )
इन सभी एल्गोरिदम के साथ हम सबसे बड़ी शर्तों पर ध्यान केंद्रित करते हैं और स्थिरांक को हटाते हैं । हम वास्तविक समय में नहीं देख रहे हैं, लेकिन सापेक्ष जटिलता ।
बिग-ating और बिग-ओ की गणना
सबसे पहले, चेतावनी दी जानी चाहिए कि अनौपचारिक साहित्य में , "बिग-ओ" को अक्सर बिग-Greek के पर्याय के रूप में माना जाता है , शायद इसलिए कि ग्रीक अक्षर टाइप करने के लिए मुश्किल हैं। इसलिए अगर नीले रंग का कोई व्यक्ति एल्गोरिथम के बिग-ओ के लिए आपसे पूछता है, तो वे शायद इसका बिग- the चाहते हैं।
अब अगर आप वास्तव में बिग-you और बिग-ओ की गणना पहले से परिभाषित औपचारिक इंद्रियों में करना चाहते हैं , तो आपको एक बड़ी समस्या है: किसी भी फ़ंक्शन के लिए असीम रूप से कई बिग-want और बिग-ओ विवरण हैं! यह पूछने की तरह है कि 42 से कम या उसके बराबर कौन-सी संख्याएँ हैं। रहे हैं कई संभावनाओं।
T (n) ∈ algorithm (n 2 ) के साथ एक एल्गोरिथ्म के लिए, निम्न में से कोई भी औपचारिक रूप से मान्य कथन बनाने के लिए हैं:
- T (n) (O (n 2 )
- T (n) (O (n 3 )
- T (n) (O (n 5 )
- T (n) (O (n 12345 × e n )
- T (n) ∈ ∈ (n 2 )
- T (n) ∈ ∈ (n)
- T (n) (∈ (लॉग (n))
- T (n) ∈ ∈ (लॉग (लॉग)))
- T (n) ∈ ∈ (1)
लेकिन T (n) n O (n) या T (n) incorrect Ω (n 3 ) बताना गलत है ।
सापेक्ष जटिलता क्या है? एल्गोरिदम के कौन से वर्ग हैं?
यदि हम दो अलग-अलग एल्गोरिदम की तुलना करते हैं, तो इनपुट की अनंतता के रूप में उनकी जटिलता सामान्य रूप से बढ़ जाएगी। यदि हम अलग-अलग प्रकार के एल्गोरिदम देखते हैं, तो वे अपेक्षाकृत समान रह सकते हैं (जैसे, एक स्थिर कारक द्वारा भिन्न होना) या बहुत विचलन हो सकता है। यह बिग-ओ विश्लेषण करने का कारण है: यह निर्धारित करने के लिए कि क्या एल्गोरिथ्म बड़े इनपुट के साथ यथोचित प्रदर्शन करेगा।
एल्गोरिदम की कक्षाएं निम्नानुसार हैं:
- (1) - स्थिर। उदाहरण के लिए, किसी सूची में पहला नंबर चुनने पर हमेशा उतना ही समय लगेगा।
- (n) - रेखीय। उदाहरण के लिए, किसी सूची को पुनरावृत्त करना हमेशा सूची आकार, एन के लिए आनुपातिक लगेगा ।
N (लॉग (एन)) - लॉगरिदमिक (सामान्य रूप से आधार कोई फर्क नहीं पड़ता)। बाइनरी खोज जैसे प्रत्येक चरण पर इनपुट स्थान को विभाजित करने वाले एल्गोरिदम उदाहरण हैं।
Log (n × log (n)) - रैखिक समय लघुगणक ("रैखिक")। ये एल्गोरिदम आम तौर पर विभाजित करते हैं और जीतते हैं ( लॉग (एन) ) जबकि इनपुट के सभी ( एन ) पुनरावृत्त होते हैं । कई लोकप्रिय सॉर्टिंग एल्गोरिदम (मर्ज सॉर्ट, Timsort) इस श्रेणी में आते हैं।
Θ (एन एम ) - बहुपद ( एन किसी भी निरंतर उठाया मीटर )। यह एक बहुत ही सामान्य जटिलता वर्ग है, जिसे अक्सर नेस्टेड छोरों में पाया जाता है।
- (एम एन ) - घातांक (किसी भी स्थिर मीटर को एन तक उठाया गया )। कई पुनरावर्ती और ग्राफ़ एल्गोरिदम इस श्रेणी में आते हैं।
) (N!) - भाज्य। कुछ ग्राफ और कॉम्बिनेटरियल एल्गोरिदम तथ्यात्मक जटिलता हैं।
क्या इसका सबसे अच्छा / औसत / सबसे खराब मामले से कोई लेना देना है?
सं। बिग-ओ और इसके परिवार के परिवार एक विशिष्ट गणितीय कार्य के बारे में बात करते हैं । वे गणितीय उपकरण हैं जिन्हें एल्गोरिदम की दक्षता को चित्रित करने में मदद करने के लिए नियोजित किया गया है, लेकिन सर्वोत्तम / औसत / सबसे खराब स्थिति की धारणा यहां वर्णित विकास दर के सिद्धांत से असंबंधित है।
एल्गोरिथ्म के बिग-ओ के बारे में बात करने के लिए, किसी को एक एल्गोरिथ्म के एक विशिष्ट गणितीय मॉडल के लिए प्रतिबद्ध होना चाहिए n, जो कि किसी भी अर्थ में, इनपुट के "आकार" का वर्णन करना चाहिए। लेकिन वास्तविक दुनिया में, इनपुट की संरचना केवल उनकी लंबाई की तुलना में बहुत अधिक है। यह एक छँटाई एल्गोरिथ्म था, तो मैं तार में खिलाने सकता है "abcdef", "fedcba"या "dbafce"। उनमें से सभी की लंबाई 6 है, लेकिन उनमें से एक पहले से ही हल है, एक उलट है, और आखिरी सिर्फ एक यादृच्छिक गड़बड़ी है। कुछ सॉर्टिंग एल्गोरिदम (जैसे Timsort) बेहतर काम करते हैं अगर इनपुट पहले से ही सॉर्ट हो जाए। लेकिन कोई इस अमानवीयता को एक गणितीय मॉडल में कैसे शामिल करता है?
विशिष्ट दृष्टिकोण बस यह मान लेना है कि इनपुट कुछ यादृच्छिक, संभाव्य वितरण से आता है। फिर, आप लंबाई के साथ सभी इनपुट पर एल्गोरिथ्म की जटिलता को औसत करते हैं n। यह आपको एल्गोरिथम का एक औसत-केस जटिलता मॉडल देता है। यहां से, आप औसत केस व्यवहार का वर्णन करने के लिए बिग-ओ / Ω / as नोटेशन का हमेशा की तरह उपयोग कर सकते हैं।
लेकिन अगर आप सेवा से वंचित होने के बारे में चिंतित हैं, तो आपको अधिक निराशावादी होना पड़ सकता है। इस मामले में, यह मान लेना सुरक्षित है कि एकमात्र इनपुट वे हैं जो आपके एल्गोरिथ्म में सबसे अधिक दुःख का कारण बनते हैं। यह आपको एल्गोरिथ्म का सबसे खराब मामला जटिलता मॉडल देता है। बाद में, आप सबसे खराब स्थिति वाले मॉडल के बिग-ओ / Ω / talk आदि के बारे में बात कर सकते हैं ।
इसी तरह, आप अपनी रुचि को विशेष रूप से उन इनपुटों पर केंद्रित कर सकते हैं जो आपके एल्गोरिथ्म को सर्वश्रेष्ठ-केस मॉडल पर पहुंचने के लिए कम से कम परेशानी है , फिर बिग-ओ / Θ / Ω आदि देखें।