समय जटिलता एल्गोरिदम की विशेषताएं क्या हैं ?

Question

कभी-कभी किसी एल्गोरिथ्म के समय की जटिलता को पहचानना आसान होता है। दो नेस्टेड छोरों के साथ एल्गोरिदम स्पष्ट रूप से । एल्गोरिदम जो दो मूल्यों के समूहों के सभी संभावित संयोजनों का पता लगाते हैं, जाहिर है ।एन 2 एन 2 $N$$N^2$$N$$2^N$

हालाँकि मुझे नहीं पता कि जटिलता के साथ एक एल्गोरिथ्म को "स्पॉट" कैसे किया जाए । उदाहरण के लिए, एक पुनरावर्ती मर्जोर्ट कार्यान्वयन एक है। विलय या अन्य एल्गोरिदम की सामान्य विशेषताएं क्या हैं जो मुझे एक सुराग देगा अगर मैं एक का विश्लेषण कर रहा था?Θ ( एन लॉग एन $\Theta(N \log N)$$\Theta(N \log N)$

मुझे यकीन है कि एक से अधिक तरीके से एक एल्गोरिथ्म जटिलता का हो सकता है, इसलिए किसी भी और सभी उत्तरों की सराहना की जाती है। BTW मैं सामान्य विशेषताओं और युक्तियों की तलाश कर रहा हूं, कठोर प्रमाण नहीं।$\Theta(N \log N)$

Comments

अर्थ है वृक्ष। $O(\log n)$

— प्रतीक देवघर

संबंधित प्रश्न।

— जुहो

@PratikDeoghare: जरूरी नहीं।

— राफेल

@ राफेल मेरा ज्यादातर मतलब था! :)

— प्रतीक देवघर

Answer 1

आपका आर्कटिक एक डिवाइड-एंड-कॉनकॉर एल्गोरिथ्म है, जो रैखिक समय में काम को विभाजित करता है (और पुनर्संयोजित करता है) और टुकड़ों पर पुनरावृत्ति करता है। मर्ज तरह कि जिस तरह से काम करता है: खर्च हे ( एन ) समय बंटवारे दो लगभग बराबर टुकड़ों में इनपुट, रिकर्सिवली तरह प्रत्येक टुकड़ा है, और खर्च Θ ( n ) के संयोजन दो सॉर्ट किया आधा समय।$\Theta(n \log n)$$O(n)$$\Theta(n)$

सहज रूप से, विभाजित और जीत के विचार को जारी रखते हुए, प्रत्येक डिवीजन चरण में कुल समय रैखिक समय लेता है, क्योंकि टुकड़ों को विभाजित करने के लिए टुकड़ों की संख्या में वृद्धि वास्तव में टुकड़ों के आकार में कमी से मेल खाती है, क्योंकि विभाजन द्वारा लिया गया समय रैखिक है। कुल चलने का समय एक डिवीजन चरण की कुल लागत का उत्पाद है जिसे डिवीजन चरणों की संख्या से गुणा किया जाता है। के बाद से टुकड़े के आकार प्रत्येक समय में आधा कर दिया जाता है, देखते हैं , विभाजन चरणों तो कुल समय चल रहा है n ⋅ लॉग ( एन ) । (एक गुणक स्थिरांक तक, लघुगणक का आधार अप्रासंगिक है।)$\log_2(n)$$n \cdot \log(n)$

समीकरणों में यह लाना (), एक तरह से चल रहा है समय का अनुमान लगाने के : इस तरह के एक एल्गोरिथ्म के यह रिकर्सिवली व्यक्त करने के लिए है टी ( एन ) = 2 टी ( एन / 2 ) + Θ ( n ) । यह स्पष्ट है कि यह एल्गोरिथ्म रैखिक समय से अधिक लेता है, और हम देख सकते हैं कि n : T ( n ) द्वारा विभाजित करके कितना अधिक है$T(n)$$T(n) = 2 T(n/2) + \Theta(n)$$n$ जबnयुगल,टी(एन)/nएक निरंतर राशि से बढ़ जाती है:टी(एन)/nबढ़ जाती है लघुगणकीय, या दूसरे शब्दों में,टी(एन)=Θ(nलॉग इन करेंn)।

$$\frac{T(n)}{n} = \frac{T(n/2)}{n/2} + \Theta(1)$$ $n$$T(n)/n$$T(n)/n$$T(n) = \Theta(n \log n)$

यह एक अधिक सामान्य पैटर्न का एक उदाहरण है: मास्टर प्रमेय । किसी भी पुनरावर्ती एल्गोरिदम के लिए है कि विभाजित आकार के अपने इनपुट में एक आकार के टुकड़े n / ख और एक समय लगता है च ( एन ) के विभाजन और पुनर्संयोजन, चलने का समय संतुष्ट प्रदर्शन करने के लिए टी ( एन ) = एक ⋅ टी ( एन / बी ) + च ( n ) । यह एक बंद रूप की ओर जाता है जो a और b और के आकार के मूल्यों पर निर्भर करता है$n$$a$$n/b$$f(n)$$T(n) = a \cdot T(n/b) + f(n)$$a$$b$ । यदि एक = ख और च ( एन ) = Θ ( n ) , मास्टर प्रमेय कहा गया है कि टी ( एन ) = Θ ( n लॉग इन करें n ) ।$f$$a = b$$f(n) = \Theta(n)$$T(n) = \Theta(n \log n)$

Comments

संक्षेप में: एक समय में खोज स्थान के निरंतर अंशों के साथ दूर करने वाले एल्गोरिदम, लघुगणक शब्द प्रदर्शित करेंगे। अन्य कारक इस बात पर निर्भर करते हैं कि दूर करने में कितना समय लगता है।

— राफेल

उदाहरण: क्विकसॉर्ट औसत केस $O(n \log n)$

— vzn

Answer 2

एल्गोरिदम की दो अन्य श्रेणियां जो समय लेती हैं :$\Theta(n \log n)$

एल्गोरिदम जहां प्रत्येक आइटम को बदले में संसाधित किया जाता है, और प्रत्येक आइटम को संसाधित करने के लिए लॉगरिदमिक समय लगता है (जैसे हीप्सॉर्ट या कई प्लेन स्वीप कम्प्यूटेशनल ज्यामिति एल्गोरिदम)।

एल्गोरिदम जहां चल रहा समय एक छँटाई पूर्व प्रसंस्करण कदम का प्रभुत्व है। (उदाहरण के लिए, कम से कम फैले हुए पेड़ के लिए क्रुस्ल के एल्गोरिथ्म में, हम पहले चरण के रूप में वजन के आधार पर किनारों को सॉर्ट कर सकते हैं)।

Comments

पहले पैराग्राफ के लिए उत्कीर्ण। दूसरा बेमानी लगता है, क्योंकि हम जानते हैं कि रैखिक रैखिक छँटाई एल्गोरिदम या तो विभाजित और जीत या हीप्सोर्ट हैं। पहली श्रेणी के लिए एक उदाहरण आकार n की एक बाइनरी खोज ट्री (या सॉर्ट किए गए सरणी) में ऑब्जेक्ट्स की खोज है ; एक और अधिक सार स्तर पर, जिसे विभाजित और जीत के रूप में भी देखा जा सकता है। $n$$n$

— राफेल

@ राफेल मुझे पता है कि छंटनी पहले से ही दिए गए चल रहे समय की श्रेणियों के साथ बेमानी है। मुद्दा यह है कि छँटाई कभी-कभी "अड़चन" होती है और एल्गोरिदम जहाँ पहले ब्लश पर प्रश्न छँटाई के बारे में नहीं होता है वहाँ अभी भी रन-टाइम हो सकता है क्योंकि छँटाई की आवश्यकता होती है।

— जो

Answer 3

एक अन्य श्रेणी: एल्गोरिदम, जिसमें उत्पादन आकार की है , और इसलिए Θ ( n लॉग इन करें n ) समय चल रहा है रैखिक में उत्पादन आकार ।$\Theta(n \log n)$$\Theta(n \log n)$

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

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

एक ठोस उदाहरण के लिए, दो आयामी ऑर्थोगोनल रेंज प्रश्नों का उत्तर देने के लिए निर्मित रेंज-ट्री पर विचार करें । यद्यपि बाद में अंतरिक्ष में कुछ वस्तुओं को एक शब्द में पैक करने के लिए कुछ संपीड़न तकनीकों का उपयोग करके कम किया गया था, डेटा संरचना के पाठ्यपुस्तक (और सबसे सहज) संस्करण को स्थान की आवश्यकता होती है (प्रत्येक पत्ती प्रत्येक में एक सहायक संरचना में संग्रहीत होती है पत्ती से रूट पर, या ओ ( लॉग एन ) स्थानों में पथ पर नोड , और निर्माण एल्गोरिथ्म अंतरिक्ष की आवश्यकता में समय रैखिक लेता है ।$O(n \log n)$$O(\log n)$

Comments

एक उदाहरण एक छलनी का उपयोग करते हुए n-th प्राइम को खोजने के लिए होगा, क्योंकि आपको आकार की छलनी की आवश्यकता होगी । $\theta(n log n)$

— gnasher729

Answer 4

की एक जटिलता फूट डालो और जीत एल्गोरिदम, जो में अपने इनपुट को विभाजित से उत्पन्न होती है कश्मीर समय में लगभग बराबर आकार के टुकड़े हे ( एन ) , इन टुकड़ों रिकर्सिवली पर कार्य करते हैं, और फिर उन्हें समय में गठबंधन हे ( एन ) । यदि आप केवल कुछ टुकड़ों पर काम करते हैं, तो चलने का समय O ( n ) तक चला जाता है ।$O(n\log n)$$k$$O(n)$$O(n)$$O(n)$

Answer 5

वे आम तौर पर "विभाजित और जीत" विविधता के एल्गोरिदम हैं, जहां विभाजन को विभाजित करने और सदस्यता के संयोजन की लागत "बहुत बड़ी" नहीं है। पर एक नजर डालें इस FAQ देखने के लिए क्या पुनरावृत्ति के प्रकार इस व्यवहार को जन्म दे।

Answer 6

आमतौर पर, डिवाइड-एंड-कॉनवर्न एल्गोरिदम ओ (एन लॉग एन) जटिलता पैदा करेगा।

Answer 7

लूप का एक सामान्य उदाहरण ( प्रति एल्गोरिथ्म नहीं ) जो इसमें चलता है$O(n \log n)$ निम्नलखित में से कोई:

for (i = 0; i < constant; i++){
    for(j = 0; j < n; j++){
        // Do some O(1) stuff on the input
    }
}

// Alternative Variant:
for (i = 0; i < constant; i++){
    for(j = n; j < constant; j++){
        // Do some O(1) stuff on the input
    }
}

(ध्यान दें कि यह नेस्टेड लूप नहीं हैं $O(n^2)$। यह भी ध्यान दें कि यह विभाजित नहीं है और न ही पुनरावर्ती है।)

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

Comments

हां, ये दोनों हैं $O(n\log n)$लेकिन तुच्छ कारण के लिए बाध्य नहीं है। पहले वाला है$\Theta(n)$ और दूसरा है $\Theta(1)$ (या $\Theta(|n|)$ अगर $n$नकारात्मक हो सकता है)।

— डेविड रिचेर्बी

I thought it useful to mention, since it does come up in practice but every search for "$O(n \log n)$" is mostly "divide-and-conquer" examples like e.g. merge sort.

— Nicolas Miari

additionally, the original question didn't ask for big-theta.

— निकोलस मिआरी

ज़रूर लेकिन कोई भी एल्गोरिथ्म जो रैखिक या निरंतर समय में चलता है$O(n\log n)$, उतना अच्छा जितना है $O(2^{2^n})$ तथा $O(\text{almost anything else})$। आपके जवाब का लॉगरिथम से कोई लेना देना नहीं है। यदि आप उस बिंदु को बनाना चाहते हैं जिसके बारे में प्रश्न पूछना चाहिए$\Theta(n\log n)$ बजाय $O(n\log n)$ फिर या तो उस बिंदु को स्पष्ट रूप से प्रश्न के लिए टिप्पणी के रूप में बनाएं या, और भी बेहतर, प्रश्न को संपादित करें।

— डेविड रिचेर्बी

I wanted to make the point that I actually searched the internet for $O(n \log n)$ to see if the loop in my answer, that I had to come up with for an actual answer to an actual programming problem that was required to run in $O(n \log n)$, was actually $O(n \log n)$ or not. And most information around deals with divide-and-conquer algorithms, so it would be worth mentioning. I do not pretend my answer to be the archetypical $O(n \log n)$ algorithm.

— Nicolas Miari