एक एल्गोरिथ्म की समय जटिलता कैसे खोजें

889

प्रश्न

एक एल्गोरिथ्म की समय जटिलता कैसे खोजें?

SO पर प्रश्न पोस्ट करने से पहले मैंने क्या किया है?

मैं इस , इस और कई अन्य लिंक से गुजरा हूं

लेकिन नहीं, जहां मैं समय जटिलता की गणना करने के लिए एक स्पष्ट और सीधे आगे स्पष्टीकरण खोजने में सक्षम था।

मुझे क्या पता ?

नीचे दिए गए कोड को सरल के रूप में कहें:

char h = 'y'; // This will be executed 1 time
int abc = 0; // This will be executed 1 time

नीचे दिए गए एक जैसे लूप के लिए कहें: 

for (int i = 0; i < N; i++) {        
    Console.Write('Hello World !');
}

int i = 0; इसे केवल एक बार निष्पादित किया जाएगा । समय i=0की घोषणा वास्तव में की जाती है न कि घोषणा से।

मैं <एन; इसे N + 1 बार निष्पादित किया जाएगा

मैं ++; यह एन बार निष्पादित किया जाएगा

तो इस लूप द्वारा आवश्यक संचालन की संख्या है

{++ (एन + 1) + एन} = २ एन + २

नोट: यह अभी भी गलत हो सकता है, क्योंकि मैं समय की जटिलता की गणना पर अपनी समझ के बारे में आश्वस्त नहीं हूं

मै क्या जानना चाहता हूँ ?

ठीक है, इसलिए मुझे लगता है कि मुझे पता है कि इन छोटे बुनियादी गणना, लेकिन ज्यादातर मामलों में मैंने समय की जटिलता को देखा है

ओ (एन), ओ (एन 2), ओ (लॉग एन), ओ (एन!) .... और कई अन्य ।

क्या कोई मुझे यह समझने में मदद कर सकता है कि कोई एल्गोरिथ्म की समय जटिलता की गणना कैसे करता है? मुझे यकीन है कि मेरे जैसे बहुत से नए लोग हैं जो यह जानना चाहते हैं।

algorithm  time-complexity  complexity-theory 
— यासर शेख
स्रोत
138
रुचि रखने वालों के लिए बोनस: द बिग ओ चीट शीट bigocheatsheet.com
— msanford
4
इस ब्लॉग को देखें: mohalgorithmsorbit.blogspot.com । इसमें पुनरावर्ती और (विशेषकर) पुनरावृत्ति एल्गोरिदम दोनों शामिल हैं।
— मोहम्मद एन्नहदी एल इदरीसी
1
Console.Write ('हैलो वर्ल्ड!') क्यों है; मशीन निर्देश नहीं है?
— चेतन
संबंधित / शायद डुप्लिकेट: बिग ओ, आप इसकी गणना कैसे करते / करते हैं?
— बर्नहार्ड बार्कर
1
@ चेतन अगर आपका मतलब है कि आप Console.Writeजटिलता की गणना करते समय विचार करें , तो यह सच है, लेकिन इस मामले में कुछ हद तक अप्रासंगिक भी है, क्योंकि यह केवल एक स्थिर कारक को बदलता है, जो कि बड़े-हे उपेक्षा (उत्तर देखें), इसलिए अंतिम परिणाम अभी भी है O (N) की एक जटिलता।
— बर्नहार्ड बार्कर

जवाबों:

394

एक एल्गोरिथ्म की समय जटिलता कैसे खोजें

आप जोड़ते हैं कि यह अपने इनपुट के आकार के एक फ़ंक्शन के रूप में कितने मशीन निर्देशों को निष्पादित करेगा, और फिर अभिव्यक्ति को सबसे बड़ा (जब एन बहुत बड़ी है) शब्द को सरल करता है और किसी भी सरलीकृत स्थिर कारक को शामिल कर सकता है।

उदाहरण के लिए, यह देखने के लिए कि कैसे हम 2N + 2मशीन निर्देशों को सरल बनाते हैं, इसका वर्णन करें O(N)।

हम दोनों को क्यों हटाते हैं 2?

हम एल्गोरिथ्म के प्रदर्शन में रुचि रखते हैं क्योंकि N बड़ा हो जाता है।

दो शब्दों 2N और 2 पर विचार करें।

N के बड़े होते ही इन दोनों शब्दों का सापेक्ष प्रभाव क्या है? मान लीजिए कि एन एक मिलियन है।

तब पहला कार्यकाल 2 मिलियन और दूसरा कार्यकाल केवल 2 है।

इस कारण से, हम बड़े एन के लिए सभी लेकिन सबसे बड़ी शर्तें छोड़ देते हैं।

तो, अब हम से चले गए हैं 2N + 2करने के लिए 2N।

परंपरागत रूप से, हम केवल निरंतर कारकों तक के प्रदर्शन में रुचि रखते हैं ।

इसका मतलब यह है कि अगर एन बड़े होने पर प्रदर्शन में कुछ निरंतर अंतर है, तो हमें वास्तव में परवाह नहीं है। 2N की इकाई वैसे भी पहले स्थान पर अच्छी तरह से परिभाषित नहीं है। इसलिए हम सरलतम अभिव्यक्ति के लिए एक स्थिर कारक से गुणा या भाग कर सकते हैं।

तो 2Nबस बन जाता है N।

— एंड्रयू टोमाज़ोस
स्रोत
53
हे मुझे यह बताने के लिए धन्यवाद "क्यों ओ (2 एन + 2) से ओ (एन)" बहुत अच्छी तरह से समझाया, लेकिन यह केवल बड़े सवाल का एक हिस्सा था, मैं चाहता था कि कोई किसी छिपे हुए संसाधन के लिए कुछ लिंक की ओर इशारा करे या में सामान्य तौर पर मैं जानना चाहता था कि आप ओ (एन), ओ (एन 2), ओ (लॉग एन), ओ (एन!), आदि जैसे समय की जटिलताओं से कैसे निपटते हैं। मुझे पता है कि मैं बहुत कुछ पूछ सकता हूं, लेकिन फिर भी मैं कोशिश कर सकता हूं: {)
— यासर शेख
3
वैसे कोष्ठक में जटिलता सिर्फ एल्गोरिथ्म में कितनी देर लगती है, मेरे द्वारा बताई गई विधि का उपयोग करके सरल किया जाता है। हम यह पता लगाते हैं कि एल्गोरिथ्म को कितनी देर तक मशीन निर्देशों की संख्या को जोड़कर इसे निष्पादित करेगा। हम केवल सबसे व्यस्त छोरों को देखकर और निरंतर कारकों द्वारा विभाजित करके सरल कर सकते हैं जैसा कि मैंने समझाया है।
— एंड्रयू टोमाज़ोस
4
इन-आंसर उदाहरण देने से भविष्य के पाठकों के लिए बहुत मदद मिली होगी। बस एक लिंक सौंपना जिसके लिए मुझे साइनअप करना है, वास्तव में मेरी मदद नहीं करता है जब मैं सिर्फ कुछ अच्छी तरह से समझाए गए पाठ के माध्यम से जाना चाहता हूं।
— bad_keypoint
2
मैं डॉ। नवीन गर्ग (IIT दिल्ली प्रो।) वीडियो देखने का सुझाव दूंगा यदि आप डीएस और टाइम जटिलता पर अच्छा ज्ञान प्राप्त करना चाहते हैं। लिंक को चेक करें। nptel.ac.in/courses/106102064
— रोहित
2
(प्रतियोगिता।) इस पदानुक्रम में लॉग एन के क्रम में एक ऊँचाई होगी। ओ के लिए (एन!) मेरी उपमाओं में कटौती की संभावना नहीं होगी, लेकिन क्रमबद्धता उस क्रम पर है - यह निषिद्ध रूप से खड़ी है, किसी भी बहुपद से अधिक या घातीय। बिल्कुल 10 हैं! छह सप्ताह में सेकंड लेकिन ब्रह्मांड 20 से कम है! सेकंड पुराना है।
— जॉन पी
389

यह एक उत्कृष्ट लेख है: http://www.daniweb.com/software-development/computer-science/threads/13488/time-complexity-of-algorithm

नीचे दिए गए उत्तर को ऊपर से कॉपी किया गया है (यदि उत्कृष्ट लिंक बस्ट जाता है)

समय जटिलता की गणना के लिए सबसे आम मीट्रिक बिग ओ अंकन है। यह सभी स्थिर कारकों को हटा देता है ताकि एन के संबंध में एन के संबंध में चलने के समय का अनुमान लगाया जा सके। सामान्य तौर पर आप इसे इस तरह से सोच सकते हैं:

statement;

स्थिर है। N के संबंध में कथन का चलन समय नहीं बदलेगा।

for ( i = 0; i < N; i++ )
     statement;

रैखिक है। लूप का रनिंग टाइम सीधे N के समानुपाती होता है। जब N डबल्स करता है, तो रनिंग टाइम होता है।

for ( i = 0; i < N; i++ ) {
  for ( j = 0; j < N; j++ )
    statement;
}

द्विघात है। दो छोरों का रनिंग टाइम N के वर्ग के समानुपाती होता है। जब N डबल्स होता है, तो रनिंग टाइम N * N से बढ़ जाता है।

while ( low <= high ) {
  mid = ( low + high ) / 2;
  if ( target < list[mid] )
    high = mid - 1;
  else if ( target > list[mid] )
    low = mid + 1;
  else break;
}

लघुगणक है। एल्गोरिथ्म का रनिंग समय N की संख्या से विभाजित किया जा सकता है 2 के आनुपातिक है। ऐसा इसलिए है क्योंकि एल्गोरिथ्म कार्य क्षेत्र को प्रत्येक पुनरावृत्ति के साथ आधे में विभाजित करता है।

void quicksort ( int list[], int left, int right )
{
  int pivot = partition ( list, left, right );
  quicksort ( list, left, pivot - 1 );
  quicksort ( list, pivot + 1, right );
}

एन * लॉग (एन) है। रनिंग टाइम में एन लूप्स (पुनरावृत्त या पुनरावर्ती) होते हैं जो लॉगरिदमिक होते हैं, इस प्रकार एल्गोरिथ्म रैखिक और लॉगरिदमिक का एक संयोजन है।

सामान्य तौर पर, प्रत्येक आइटम के साथ एक आयाम में कुछ करना रेखीय होता है, दो आयामों में प्रत्येक आइटम के साथ कुछ करना द्विघात होता है, और कार्य क्षेत्र को आधा भाग में विभाजित करना लघुगणकीय है। घन, घातीय और वर्गमूल जैसे अन्य बिग ओ उपाय हैं, लेकिन वे लगभग आम नहीं हैं। बिग ओ संकेतन के रूप में वर्णित है O ( <type> )जहां <type>माप है। Quicksort एल्गोरिथ्म के रूप में वर्णित किया जाएगा O ( N * log ( N ) )।

ध्यान दें कि इसमें से कोई भी सबसे अच्छा, औसत और सबसे खराब स्थिति के उपायों को ध्यान में नहीं रखा गया है। प्रत्येक का अपना बिग ओ अंकन होगा। यह भी ध्यान दें कि यह एक बहुत ही सरल विवरण है। बिग ओ सबसे आम है, लेकिन यह भी अधिक जटिल है जो मैंने दिखाया है। बड़े ओमेगा, छोटे ओ, और बड़े थीटा जैसे अन्य नोटेशन भी हैं। आप शायद उन्हें एल्गोरिथम विश्लेषण पाठ्यक्रम से बाहर नहीं करेंगे। ;)

— Achow
स्रोत
10
Quicksort हालांकि इस व्यवहार दुर्लभ है सबसे खराब स्थिति में एल्गोरिथ्म, एन ^ 2 के चलने का समय है।
— नबर
2
IIRC, छोटे ओ और बड़े ओमेगा का उपयोग सर्वश्रेष्ठ और औसत केस जटिलता (बड़े ओ सबसे खराब मामले के साथ) के लिए किया जाता है, इसलिए "सबसे अच्छा, औसत और सबसे खराब मामला उपाय। प्रत्येक का अपना बिग ओ अंकन होगा।" गलत होगा। अधिक विशिष्ट अर्थों के साथ और भी अधिक प्रतीक हैं, और CS हमेशा सबसे उपयुक्त प्रतीक का उपयोग नहीं कर रहा है। मैं इन सभी को Landau प्रतीकों btw नाम से जानने के लिए आया था । +1 वैसे भी बी / सी सबसे अच्छा जवाब।
— hiergiltdiestfu
@hiergiltdiestfu बिग-ओ, बिग-ओमेगा, आदि किसी भी एल्गोरिथम के चलने वाले सबसे अच्छे, औसत या सबसे खराब मामले में लागू किया जा सकता है। O और do सबसे खराब और सबसे अच्छे मामले से कैसे संबंधित हैं?
— बर्नहार्ड बार्कर
इसके अलावा, अगर किसी को भी किसी भी विधि के लिए बड़े ओ की गणना करने की तलाश है: stackoverflow.com/a/60354355/4260922
— OhadM
सबसे अच्छा स्पष्टीकरण में से एक।
— शिवराज पाटिल
172

यहाँ से लिया गया - एक एल्गोरिथ्म के समय जटिलता का परिचय

1। परिचय

कंप्यूटर विज्ञान में, एल्गोरिथ्म का समय जटिलता इनपुट का प्रतिनिधित्व करने वाले स्ट्रिंग की लंबाई के एक फ़ंक्शन के रूप में चलाने के लिए एक एल्गोरिथ्म द्वारा लिए गए समय की मात्रा को निर्धारित करता है।

2. बिग ओ संकेतन

एल्गोरिथ्म की समय जटिलता आमतौर पर बड़े ओ नोटेशन का उपयोग करके व्यक्त की जाती है, जो गुणांक और निचले क्रम की शर्तों को बाहर करती है। जब इस तरह से व्यक्त किया जाता है, तो समय की जटिलता को विषमता से वर्णित किया जाता है, अर्थात, इनपुट आकार अनंत तक जाता है।

उदाहरण के लिए, यदि आकार n के सभी इनपुट पर एल्गोरिथ्म के लिए आवश्यक समय अधिकतम 5n 3 + 3n है, तो स्पर्शोन्मुख समय जटिलता O (n 3 ) है। उस पर और बाद में।

कुछ और उदाहरण:

  • 1 = ओ (एन)
  • n = O (n 2 )
  • log (n) = O (n)
  • 2 एन + 1 = ओ (एन)

3. ओ (1) लगातार समय:

एक एल्गोरिथ्म को निरंतर समय में चलाने के लिए कहा जाता है यदि उसे इनपुट आकार की परवाह किए बिना उसी समय की आवश्यकता होती है।

उदाहरण:

  • सरणी: किसी भी तत्व तक पहुँचने
  • निश्चित आकार का ढेर: धक्का और पॉप तरीके
  • निश्चित आकार की कतार: enqueue और dequeue विधियाँ

4. ओ (एन) रैखिक समय

एक एल्गोरिथ्म को रैखिक समय में चलाने के लिए कहा जाता है यदि इसका समय निष्पादन इनपुट आकार के सीधे आनुपातिक होता है, अर्थात इनपुट आकार में वृद्धि के रूप में समय रैखिक रूप से बढ़ता है।

निम्नलिखित उदाहरणों पर विचार करें, नीचे मैं एक तत्व के लिए रैखिक खोज कर रहा हूं, इसमें O (n) की समय जटिलता है।

int find = 66;
var numbers = new int[] { 33, 435, 36, 37, 43, 45, 66, 656, 2232 };
for (int i = 0; i < numbers.Length - 1; i++)
{
    if(find == numbers[i])
    {
        return;
    }
}

और ज्यादा उदाहरण:

  • सरणी: रैखिक खोज, ट्रैवर्सिंग, न्यूनतम खोजें आदि
  • ArrayList: विधि शामिल है
  • कतार: विधि शामिल है

5. हे (लॉग एन) लॉगरिदमिक समय:

एक एल्गोरिथ्म को लघुगणक समय में चलाने के लिए कहा जाता है यदि इसका समय निष्पादन इनपुट आकार के लघुगणक के समानुपाती होता है।

उदाहरण: बाइनरी सर्च

"बीस प्रश्न" खेल को याद करें - कार्य एक अंतराल में एक छिपी हुई संख्या के मूल्य का अनुमान लगाना है। हर बार जब आप एक अनुमान लगाते हैं, तो आपको बताया जाता है कि आपका अनुमान बहुत अधिक है या बहुत कम है। बीस सवाल का खेल एक ऐसी रणनीति का अर्थ है जो अंतराल आकार को आधा करने के लिए आपके अनुमान संख्या का उपयोग करता है। यह बाइनरी खोज के रूप में ज्ञात सामान्य समस्या-समाधान विधि का एक उदाहरण है

6. ओ (एन 2 ) द्विघात समय

एक एल्गोरिथ्म को द्विघात समय में चलाने के लिए कहा जाता है यदि इसका समय निष्पादन इनपुट आकार के वर्ग के आनुपातिक है।

उदाहरण:

7. कुछ उपयोगी लिंक

— यासर शेख
स्रोत
17
नोट: पहला लिंक टूट गया है।
— Ziezi
2
भ्रम से बचने के लिए O (n2) को O (n ^ 2) लिखा जाना चाहिए।
— रिज़्की हादीतुर्रसिद
100

हालांकि इस सवाल के कुछ अच्छे जवाब हैं। मैं यहाँ कई उदाहरणों के साथ एक और उत्तर देना चाहूंगा loop।

  • O (n) : एक लूप के टाइम कॉम्प्लेक्सिटी को O (n) माना जाता है, यदि लूप वेरिएबल्स को एक स्थिर राशि द्वारा बढ़ा / घटाया जाता है। उदाहरण के लिए निम्नलिखित कार्यों में O (n) समय की जटिलता है।

    // Here c is a positive integer constant   
for (int i = 1; i <= n; i += c) {  
    // some O(1) expressions
}

for (int i = n; i > 0; i -= c) {
    // some O(1) expressions
}

  • O (n ^ c) : नेस्टेड लूप्स की समय जटिलता उस अंतरतम स्टेटमेंट को निष्पादित करने की संख्या के बराबर है। उदाहरण के लिए निम्नलिखित नमूना छोरों में O (n ^ 2) समय जटिलता है

    for (int i = 1; i <=n; i += c) {
   for (int j = 1; j <=n; j += c) {
      // some O(1) expressions
   }
}

for (int i = n; i > 0; i += c) {
   for (int j = i+1; j <=n; j += c) {
      // some O(1) expressions
}

    उदाहरण के लिए चयन सॉर्ट और प्रविष्टि सॉर्ट में O (n ^ 2) समय जटिलता है।

  • O (लोगन) एक लूप की टाइम कॉम्प्लेक्सिटी को O (लोगन) के रूप में माना जाता है यदि लूप वेरिएबल को एक स्थिर राशि से विभाजित / गुणा किया जाता है।

    for (int i = 1; i <=n; i *= c) {
   // some O(1) expressions
}
for (int i = n; i > 0; i /= c) {
   // some O(1) expressions
}

    उदाहरण के लिए बाइनरी सर्च में O (लोगन) समय की जटिलता है।

  • O (LogLogn) एक लूप के टाइम कॉम्प्लेक्सिटी को O (LogLogn) माना जाता है, यदि लूप वेरिएबल्स को स्थिर मात्रा से कम / बढ़ाया जाता है।

    // Here c is a constant greater than 1   
for (int i = 2; i <=n; i = pow(i, c)) { 
   // some O(1) expressions
}
//Here fun is sqrt or cuberoot or any other constant root
for (int i = n; i > 0; i = fun(i)) { 
   // some O(1) expressions
}

समय जटिलता विश्लेषण का एक उदाहरण

int fun(int n)
{    
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j < n; j += i)
        {
            // Some O(1) task
        }
    }    
}

विश्लेषण :

For i = 1, the inner loop is executed n times. For i = 2, the inner loop is executed approximately n/2 times. For i = 3, the inner loop is executed approximately n/3 times. For i = 4, the inner loop is executed approximately n/4 times. ……………………………………………………. For i = n, the inner loop is executed approximately n/n times.

तो उपरोक्त एल्गोरिथम की कुल समय जटिलता है (n + n/2 + n/3 + … + n/n), जो बन जाती हैn * (1/1 + 1/2 + 1/3 + … + 1/n)

श्रृंखला के बारे में महत्वपूर्ण बात O (लोगन) के(1/1 + 1/2 + 1/3 + … + 1/n) बराबर है । तो उपरोक्त कोड की समय जटिलता O (nLogn) है ।

रेफरी: १ २ ३

— zangw
स्रोत
1
@ साइमन, क्या आप यह पता लगा सकते हैं कि कौन सा हिस्सा गलत है?
— ज़ंगव
पूछने के लिए धन्यवाद। मैंने कोड को गलत बताया। मैंने अपनी टिप्पणी हटा दी। माफ़ करना!
— साइमन
74

उदाहरणों के साथ समय की जटिलता

1 - मूल संचालन (अंकगणित, तुलना, सरणी के तत्वों तक पहुंचना, असाइनमेंट): रनिंग टाइम हमेशा स्थिर रहता है (1)

उदाहरण :

read(x)                               // O(1)
a = 10;                               // O(1)
a = 1.000.000.000.000.000.000         // O(1)

2 - यदि फिर कोई और कथन: केवल दो या अधिक संभावित कथनों से अधिकतम चलने का समय लिया जा रहा है।

उदाहरण:

age = read(x)                               // (1+1) = 2
if age < 17 then begin                      // 1
      status = "Not allowed!";              // 1
end else begin
      status = "Welcome! Please come in";   // 1
      visitors = visitors + 1;              // 1+1 = 2
end;

तो, उपरोक्त छद्म कोड की जटिलता टी (n) = 2 + 1 + अधिकतम (1, 1 + 2) = 6. इस प्रकार, इसका बड़ा ओह अभी भी निरंतर T (n) = O (1) है।

3 - लूपिंग (के लिए, जबकि, बार-बार): इस कथन के लिए चल रहा समय उस लूपिंग के अंदर संचालन की संख्या से गुणा किए गए लूपिंग की संख्या है।

उदाहरण:

total = 0;                                  // 1
for i = 1 to n do begin                     // (1+1)*n = 2n
      total = total + i;                    // (1+1)*n = 2n
end;
writeln(total);                             // 1

तो, इसकी जटिलता T (n) = 1 + 4n + 1 = 4n + 2. इस प्रकार, T (n) = O (n) है।

4 - नेस्टेड लूप (लूपिंग के अंदर लूपिंग): चूंकि मुख्य लूपिंग के अंदर कम से कम एक लूपिंग होता है, इस कथन के चलने का समय O (n ^ 2) या O (n ^ 3) का उपयोग करता है।

उदाहरण:

for i = 1 to n do begin                     // (1+1)*n  = 2n
   for j = 1 to n do begin                  // (1+1)n*n = 2n^2
       x = x + 1;                           // (1+1)n*n = 2n^2
       print(x);                            // (n*n)    = n^2
   end;
end;

कॉमन रनिंग टाइम

एल्गोरिथ्म का विश्लेषण करते समय कुछ सामान्य चलने वाले समय होते हैं:

  1. O (1) - कांस्टेंट टाइम कांस्टेंट टाइम का मतलब है कि रनिंग टाइम स्थिर है, यह इनपुट साइज से प्रभावित नहीं है ।

  2. O (n) - रैखिक समय जब एक एल्गोरिथ्म n इनपुट आकार को स्वीकार करता है, तो यह n संचालन भी करेगा।

  3. O (log n) - Logarithmic Time Algorithm जिसमें O (log n) चल रहा समय O (n) से थोड़ा तेज है। आमतौर पर, एल्गोरिथ्म समस्या को समान आकार में उप समस्याओं में विभाजित करता है। उदाहरण: बाइनरी खोज एल्गोरिथ्म, बाइनरी रूपांतरण एल्गोरिथ्म।

  4. O (n log n) - रैखिक समय यह समय अक्सर "डिवाइड एंड विन एल्गोरिदम" में पाया जाता है जो समस्या को उप समस्याओं में पुन: विभाजित करता है और फिर उन्हें n समय में विलय कर देता है। उदाहरण: मर्ज सॉर्ट एल्गोरिथ्म।

  5. O (n 2 ) - द्विघात समय देखो बुलबुला सॉर्ट एल्गोरिथ्म!

  6. ओ (एन 3 ) - क्यूबिक टाइम इसका ओ (एन 2 ) के साथ एक ही सिद्धांत है ।

  7. O (2 n ) - घातीय समय यह बहुत धीमा है क्योंकि इनपुट बड़ा हो जाता है, यदि n = 1000.000, T (n) 21000.000 होगा। ब्रूट फोर्स एल्गोरिदम का यह रनिंग टाइम है।

  8. O (n!) - सबसे छोटा समय !!! उदाहरण: ट्रैवल सेल्समैन समस्या (TSP)

इस लेख से लिया गया । बहुत अच्छी तरह से समझाया गया है एक पढ़ने देना चाहिए।

— यासर शेख
स्रोत
अपने दूसरे उदाहरण में, आपने लिखा visitors = visitors + 1है 1 + 1 = 2। क्या आप मुझे समझा सकते हैं कि आपने ऐसा क्यों किया?
— साजिब आचार्य
3
@ सजीब आचार्य इसे दाएं से बाएं देखें। पहला चरण: visitors + 1 दूसरे चरण की गणना करें : पहले चरण से मान असाइन करें visitors इसलिए, ऊपर की अभिव्यक्ति दो बयानों से बनती है; पहला चरण + दूसरा चरण => 1 + 1 = 2
— बोजीदार सिकंजिक
@nbro क्यों यह 1 + 1 हैage = read(x) // (1+1) = 2
— हम्टी
@BozidarSikanjic क्यों यह 1 + 1 में हैage = read(x) // (1+1) = 2
— हम्टी
1
@Humty इस उत्तर की शुरुआत की जाँच करें: read(x) // O(1) a = 10; // O(1)पहला फ़ंक्शन कॉल है => O (1) ///// दूसरा असाइनमेंट है, जैसा कि nbro ने कहा, लेकिन 10 निरंतर है, इसलिए दूसरा है => O (1) ...
— बोझिदार सिकंजिक
41

जब आप कोड का विश्लेषण कर रहे होते हैं, तो आपको इसे लाइन द्वारा लाइन का विश्लेषण करना होता है, हर ऑपरेशन को गिनना / समय की जटिलता को पहचानना होता है, अंत में, आपको इसे पूरी तस्वीर प्राप्त करने के लिए योग करना होगा।

उदाहरण के लिए, आपके पास रैखिक जटिलता के साथ एक सरल लूप हो सकता है , लेकिन बाद में उसी कार्यक्रम में आपके पास एक ट्रिपल लूप हो सकता है घन जटिलता है , इसलिए आपके कार्यक्रम में घन जटिलता होगी । विकास का कार्य क्रम यहीं आता है।

आइए देखें कि एल्गोरिथ्म की समय जटिलता के लिए क्या संभावनाएं हैं, आप ऊपर बताए गए विकास के क्रम को देख सकते हैं:

  • लगातार समय में वृद्धि का क्रम होता है1, उदाहरण के लिए:a = b + c :।

  • लॉगरिदमिक समय में वृद्धि का क्रम होता हैLogN होता है, यह आमतौर पर तब होता है जब आप कुछ को आधे में विभाजित कर रहे हैं (द्विआधारी खोज, पेड़, यहां तक ​​कि लूप), या उसी तरह से कुछ को गुणा करना।

  • Nउदाहरण के लिए, रेखीय , विकास का क्रम है

    int p = 0;
for (int i = 1; i < N; i++)
  p = p + 2;

  • वंशानुक्रम , विकास का क्रम हैn*logN, आमतौर पर एल्गोरिदम को विभाजित और जीतता है।

  • घन , विकास का क्रमN^3, क्लासिक उदाहरण एक ट्रिपल लूप है जहां आप सभी ट्रिपल की जांच करते हैं:

    int x = 0;
for (int i = 0; i < N; i++)
   for (int j = 0; j < N; j++)
      for (int k = 0; k < N; k++)
          x = x + 2

  • घातीय , वृद्धि का क्रम2^N, आमतौर पर तब होता है जब आप संपूर्ण खोज करते हैं, उदाहरण के लिए कुछ सेट के सबसेट की जाँच करें।

— अलेक्जेंडर मकरगी
स्रोत
यदि ऐसा होता, तो जटिलता क्या होती? for (int i = 0; i <N; i ++) for (int j = i + 1; j <n; j ++) के लिए (int k = j + 1; k <n; k ++) x = x + 2
— user3156040
35

धीरे-धीरे बोलना, समय की जटिलता यह बताने का एक तरीका है कि इनपुट का आकार बढ़ने पर एल्गोरिदम के संचालन या रन-टाइम की संख्या कैसे बढ़ती है।

जीवन में ज्यादातर चीजों की तरह, एक कॉकटेल पार्टी हमें समझने में मदद कर सकती है।

पर)

जब आप पार्टी में पहुंचते हैं, तो आपको हर किसी का हाथ हिलाना पड़ता है (हर आइटम पर एक ऑपरेशन करें)। जैसे-जैसे उपस्थित लोगों की संख्या Nबढ़ती जाती है, वैसे-वैसे सभी के हाथों को हिलाने में लगने वाला समय / कार्य बढ़ता जाएगाO(N) ।

क्यों O(N)और क्या नहींcN ?

लोगों के साथ हाथ मिलाने में लगने वाले समय में भिन्नता है। आप इसे औसत कर सकते हैं और इसे स्थिर रूप से कैप्चर कर सकते हैं c। लेकिन यहां मौलिक ऑपरेशन --- सभी के साथ हाथ मिलाना --- हमेशा आनुपातिक होगा O(N), चाहे जो भी होc । यह बहस करते हुए कि क्या हमें कॉकटेल पार्टी में जाना चाहिए, हम अक्सर इस तथ्य में अधिक रुचि रखते हैं कि हमें उन बैठकों के मिनट विवरण की तुलना में हर किसी से मिलना होगा।

हे (एन ^ 2)

कॉकटेल पार्टी का मेजबान आपको एक मूर्खतापूर्ण खेल खेलना चाहता है जहां हर कोई हर किसी से मिलता है। इसलिए, आपको N-1अन्य लोगों से मिलना चाहिए और, क्योंकि अगला व्यक्ति आपसे पहले ही मिल चुका है, उन्हें N-2लोगों से मिलना चाहिए , और इसी तरह। इस श्रृंखला का योग है x^2/2+x/2। जैसे ही उपस्थित लोगों की संख्या बढ़ती है, यह x^2शब्द बड़ा तेज़ हो जाता है , इसलिए हम बस बाकी सब छोड़ देते हैं।

हे (एन ^ 3)

आपको हर किसी से मिलना है और, प्रत्येक बैठक के दौरान, आपको कमरे में बाकी सभी के बारे में बात करनी चाहिए।

हे (1)

मेजबान कुछ घोषणा करना चाहता है। वे एक शराब का गिलास मरते हैं और जोर से बोलते हैं। हर कोई उन्हें सुनता है। यह पता चलता है कि इसमें कितने उपस्थित हैं, इससे कोई फर्क नहीं पड़ता है, इस ऑपरेशन में हमेशा उतना ही समय लगता है।

O (लॉग एन)

होस्ट ने सभी को वर्णमाला क्रम में टेबल पर रखा है। डैन कहाँ है? आप कारण यह है कि वह एडम और मैंडी के बीच कहीं होना चाहिए (निश्चित रूप से मैंडी और जैच के बीच नहीं!)। यह देखते हुए, क्या वह जॉर्ज और मैंडी के बीच है? नहीं, वह एडम और फ्रेड के बीच और सिंडी और फ्रेड के बीच होना चाहिए। और इसी तरह ... हम आधे सेट और फिर उस सेट के आधे हिस्से को देखकर डैन को कुशलता से ढूँढ सकते हैं। अंततः, हम O (log_2 N) व्यक्तियों को देखते हैं।

ओ (एन लॉग एन)

आप पा सकते हैं कि ऊपर एल्गोरिथ्म का उपयोग करके टेबल पर कहां बैठना है। यदि बड़ी संख्या में लोग एक समय पर एक टेबल पर आए, और सभी ने ऐसा किया, तो ओ (एन लॉग एन) समय लगेगा। यह पता चलता है कि किसी भी आइटम को संग्रहित करने में कितना समय लगता है जब उनकी तुलना की जानी चाहिए।

सबसे अच्छा / सबसे खराब मामला

आप पार्टी में पहुंचते हैं और इनइगो को खोजने की जरूरत है - इसमें कितना समय लगेगा? यह आपके आने पर निर्भर करता है। यदि हर कोई आपके आस-पास मिल रहा है, तो आप सबसे खराब स्थिति में हैं: इसमें O(N)समय लगेगा। हालाँकि, यदि हर कोई टेबल पर नीचे बैठा है, तो इसमें केवल O(log N)समय लगेगा। या हो सकता है कि आप मेजबान के ग्लासग्लास-चिल्लाने की शक्ति का लाभ उठा सकते हैं और इसमें केवल O(1)समय लगेगा।

मेज़बान की अनुपलब्धता को देखते हुए, हम कह सकते हैं कि इनिगो-खोजने वाले एल्गोरिदम में आपके पास आने पर पार्टी की स्थिति के आधार पर एक निचली-बाउंड O(log N)और एक ऊपरी-बाउंड होता है O(N)।

अंतरिक्ष और संचार

एल्गोरिदम अंतरिक्ष या संचार का उपयोग कैसे करते हैं, इसे समझने के लिए एक ही विचार लागू किया जा सकता है।

नूथ ने पूर्व शीर्षक "द कॉम्प्लेक्सिटी ऑफ़ सोंग्स" के बारे में एक अच्छा पेपर लिखा है ।

प्रमेय 2: वहाँ जटिलता ओ (1) के लंबे गाने मौजूद हैं।

PROOF: (केसी और सनशाइन बैंड के कारण)। Sk (15) द्वारा परिभाषित गानों पर विचार करें, लेकिन साथ

V_k = 'That's the way,' U 'I like it, ' U
U   = 'uh huh,' 'uh huh'

सभी के लिए।

— रिचर्ड
स्रोत
आपने इसे रद्द कर दिया, अब जब भी मैं किसी कॉकटेल पार्टी में जाता हूं तो मैं अवचेतन रूप से किसी भी मजेदार घटनाओं के टाइम कॉम्प्लेक्सिटी को खोजने की कोशिश करूंगा। इस तरह के हास्य उदाहरण के लिए धन्यवाद।
— सबुनकर तेजस सुहैलेश
5

मुझे पता है कि यह सवाल एक तरह से वापस आ गया है और यहां कुछ उत्कृष्ट जवाब हैं, फिर भी मैं गणितीय रूप से दिमाग वाले लोगों के लिए एक और बिट साझा करना चाहता था जो इस पोस्ट में ठोकर खाएंगे। मास्टर प्रमेय एक और उपयोगी बात पता करने के लिए जब जटिलता का अध्ययन है। मैंने अन्य उत्तरों में इसका उल्लेख नहीं किया।

— जेंटियन कासा
स्रोत
2

O (n) एक एल्गोरिथ्म की समय जटिलता लिखने के लिए उपयोग किया जाने वाला बड़ा O अंकन है। जब आप किसी अल्गोरिथम में निष्पादन की संख्या जोड़ते हैं, तो आपको 2N + 2 जैसे परिणाम मिलेंगे, इस अभिव्यक्ति में एन हावी है शब्द (अभिव्यक्ति पर सबसे बड़ा प्रभाव होने वाला शब्द अगर इसका मूल्य बढ़ता है या घटता है)। अब O (N) टाइम कॉम्प्लेक्सिटी है जबकि N का टर्म हावी है। उदाहरण

For i= 1 to n;
  j= 0;
while(j<=n);
  j=j+1;

यहां आंतरिक लूप के लिए निष्पादन की कुल संख्या n + 1 है और बाहरी लूप के लिए निष्पादन की कुल संख्या n (n + 1) / 2 है, इसलिए संपूर्ण एल्गोरिथ्म के लिए निष्पादन की कुल संख्या n + 1 + n (n + 1/2) हैं ) = (एन ^ 2 + 3 एन) / 2। यहाँ n ^ 2 वर्चस्वकारी शब्द है इसलिए इस एल्गोरिथ्म के लिए समय जटिलता O (n ^ 2) है

— इफरा खान
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.