क्या वास्तविक-विश्व एल्गोरिदम जो नीचे की कक्षा में बहुत बेहतर प्रदर्शन करते हैं, मौजूद हैं? [बन्द है]

Question

कल रात मैं एक और प्रोग्रामर के साथ चर्चा कर रहा था कि भले ही O (1) कुछ हो सकता है, एक ऑपरेशन जो O (n) हो सकता है, अगर O (1) एल्गोरिथ्म में एक बड़ा स्थिरांक है तो वह इसे बेहतर बना सकता है। वह असहमत था, इसलिए मैं इसे यहां लाया हूं।

क्या एल्गोरिदम के उदाहरण हैं जो इससे नीचे के वर्ग में बहुत बेहतर प्रदर्शन करते हैं? उदाहरण के लिए, O (n) O (1) या O (n ² ) O (n) से तेज होना।

गणितीय रूप से इसे एक विषम ऊपरी सीमा वाले फ़ंक्शन के लिए प्रदर्शित किया जा सकता है, जब आप लगातार कारकों की उपेक्षा करते हैं, लेकिन क्या ऐसे एल्गोरिदम जंगली में मौजूद हैं? और मुझे उनके उदाहरण कहां मिलेंगे? वे किस प्रकार की स्थितियों के लिए उपयोग किए जाते हैं?

Comments

यहां तक ​​कि "बड़े" एल्गोरिदम के लिए, छोटा जरूरी बेहतर नहीं है। उदाहरण के लिए, गाऊसी उन्मूलन O (n ^ 3) है, लेकिन ऐसे एल्गोरिदम हैं जो इसे O (n ^ 2) में कर सकते हैं, लेकिन द्विघात समय के लिए गुणांक algo इतना विशाल है कि लोग बस O (n ^) के साथ जाते हैं ३) एक।

— ब्लैकजैक

आपको "... वास्तविक दुनिया की समस्याओं के लिए" या कुछ इस तरह से इसे एक समझदार प्रश्न बनाना है। अन्यथा आपको केवल nनिरंतर की भरपाई करने के लिए पर्याप्त बड़ा बनाने की आवश्यकता है (जो कि बड़े-ओ अंकन का बिंदु है)।

— स्टारब्लू

गति के लिए बड़ा-ओ अंकन न लें।

— कोडिज्म

बिग-ओ नोटेशन की बात आपको यह बताने के लिए नहीं है कि एल्गोरिथ्म कितनी तेजी से चलता है, लेकिन यह कितना अच्छा है।

— ब्लूराजा - डैनी पफ्लुगुएफ्ट

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

— ccoakley

Answer 1

बहुत छोटे, निश्चित डेटा तालिकाओं में लुकअप। एक अनुकूलित हैश तालिका ओ (1) हो सकती है और फिर भी द्विआधारी खोज की तुलना में धीमी हो सकती है या यहां तक ​​कि गणना की लागत के कारण एक रैखिक खोज भी हो सकती है।

Comments

अधिक सटीक रूप से, हैशटेबल लुकिंग O (m) है जहाँ m कुंजी का आकार है। आपको केवल उस O (1) को कॉल करना है, यदि कुंजी का आकार स्थिर है। इसके अलावा, आमतौर पर यह परिशोधन होता है - अन्यथा तालिका बढ़ती / सिकुड़ नहीं सकती है। टर्नरी पेड़ अक्सर संदर्भों में स्ट्रिंग लुक के लिए हैश टेबल को हरा सकते हैं जहां तार अक्सर नहीं पाए जाते हैं - टर्नरी ट्री खोज में अक्सर पता चलेगा कि कुंजी अभी भी मौजूद नहीं है, जबकि स्ट्रिंग के पहले चरित्र या दो की जांच कर रही है, जहां हैशटेबल संस्करण ने अभी तक हैश की गणना नहीं की है।

— स्टीव 314

मुझे लोरेन Pechtel का जवाब और स्टीव 314 की पहली टिप्पणी पसंद है। मैंने वास्तव में ऐसा होते देखा है। यदि आप एक जावा वर्ग बनाते हैं जिसमें एक हैशकोड () विधि है जो हैश मान को वापस करने के लिए बहुत लंबा समय लेता है (और इसे कैश नहीं कर सकता / सकती), तो हैश-प्रकार के संग्रह में ऐसी कक्षा के उदाहरणों का उपयोग करना (जैसे) HashSet) एक सरणी प्रकार संग्रह (जैसे ArrayList) की तुलना में उस संग्रह को बहुत धीमा कर देगा।

— शिवन ड्रैगन

@ स्टीव ३१४: आप यह क्यों मानते हैं कि हैश फ़ंक्शन O (m) हैं जहाँ m कुंजी का आकार है? यदि आप स्ट्रिंग्स (या अन्य जटिल प्रकार) के साथ काम कर रहे हैं, तो भी हैश फ़ंक्शन ओ (1) हो सकता है। कोई बहुत अधिक मूल्य नहीं है इसे औपचारिक परिभाषा में रखने की तुलना में बस हैश फ़ंक्शन को महसूस करने से जटिलता में काफी बदलाव हो सकता है यदि आपके इनपुट के लिए एक गलत डेटा संरचना (हैश टेबल) चुना गया है (कुंजी आकार अप्रत्याशित है)।

— कोडिज्म

@ स्टीव ३१४: ध्यान दें कि मैंने निश्चित डेटा टेबल कहा था। वे विकसित नहीं होते हैं। इसके अलावा, आपको केवल हैश तालिका से O (1) प्रदर्शन मिलता है यदि आप यह सुनिश्चित करने के लिए कुंजी को अनुकूलित कर सकते हैं कि कोई टक्कर न हो।

— लोरेन Pechtel

@ लॉरेन - सख्ती से, यदि टेबल का एक निश्चित आकार है, तो एक निरंतर अधिकतम समय है जब आप एक खाली स्थान की तलाश में खर्च कर सकते हैं। यही है, अधिकतम पर, आपको n-1 पहले से भरे हुए स्लॉट की जांच करने की आवश्यकता हो सकती है जहां n निरंतर तालिका आकार है। तो एक निश्चित आकार की हैश तालिका वास्तव में O (1) है, बिना परिशोधन विश्लेषण की आवश्यकता के। इसका मतलब यह नहीं है कि आप तालिका के भरने के रूप में धीमी हो रही पहुंच के बारे में परवाह नहीं करते हैं - केवल यह कि यह बड़ा ओ व्यक्त नहीं करता है।

— स्टीव 314

Answer 2

मैट्रिक्स गुणन। भोले O (n ^ 3) एल्गोरिथ्म का उपयोग अक्सर छोटे-ईश मैट्रिस के लिए स्ट्रैसन ओ (n ^ 2.8) की तुलना में तेजी से किया जाता है; और स्ट्रैसेन का उपयोग O (n ^ 2.3) के बजाय Coppersmith-Winograd एल्गोरिथ्म में बड़े मैट्रिसेस के लिए किया जाता है।

Comments

en.wikipedia.org/wiki/…

— starblue

Coppersmith-Winograd का उपयोग कभी नहीं किया जाता है। इसे लागू करना अपने आप में एक भयावह कार्य होगा और निरंतर इतना बुरा है कि यह आधुनिक वैज्ञानिक मैट्रिक्स की समस्याओं के लिए भी संभव नहीं होगा।

— tskuzzy

Answer 3

एक सरल उदाहरण विभिन्न छंटाई एल्गोरिदम के बीच का अंतर है। मर्जसॉर्ट, हीप्सोर्ट, और कुछ अन्य लोग ओ (एन लॉग एन) हैं । Quicksort O (n ^ 2) सबसे खराब स्थिति है। लेकिन अक्सर क्विकर तेजी से होता है, और वास्तव में यह ओ (एन लॉग एन) की तरह औसतन प्रदर्शन करता है । अधिक जानकारी ।

एक अन्य उदाहरण एकल फाइबोनैचि संख्या की पीढ़ी है। पुनरावृत्ति एल्गोरिथ्म O (n) है , जबकि मैट्रिक्स-आधारित एल्गोरिथ्म O (लॉग एन) है । फिर भी, हजार फाइबोनैचि संख्याओं के पहले जोड़े के लिए, पुनरावृत्त एल्गोरिथ्म शायद तेज है। यह भी पाठ्यक्रम के कार्यान्वयन पर निर्भर करता है!

एक बेहतर स्पर्शोन्मुख प्रदर्शन वाले एल्गोरिदम में महंगे ऑपरेशन शामिल हो सकते हैं जो एक एल्गोरिथ्म के साथ बदतर प्रदर्शन के साथ-साथ सरल ऑपरेशन के लिए आवश्यक नहीं हैं। अंत में, ओ- नोटेशन हमें केवल प्रदर्शन के बारे में कुछ बताता है जब यह जिस तर्क पर संचालित होता है वह नाटकीय रूप से बढ़ता है (अनन्तता पर पहुंचता है)।

Comments

यह बिग-ओ की एक महान व्याख्या है, लेकिन प्रश्न के मांस को संबोधित करने में विफल रहता है, जो विशिष्ट मामलों के लिए है जहां एक ओ (एन) एल्गोरिथ्म एक ओ (1) से तेज होगा।

— काइलवैप्पड

फिबोनाची नंबर एक से थोड़ा दूर है। आउटपुट आकार इनपुट आकार में घातांक है, इसलिए यह O (lg n * e ^ n) बनाम O (lg lg n * e ^ n) के बीच अंतर है।

— पीटर टेलर

परिशिष्ट: सबसे अच्छा। मैट्रिक्स-आधारित एल्गोरिथ्म 1.5 ^ n के क्रम पर संख्याओं के साथ गुणा करता है, इसलिए O (lg lg n * ne ^ n) सर्वोत्तम बाध्य सिद्ध हो सकता है।

— पीटर टेलर

क्विकॉर्ट को आमतौर पर ओ (एन लॉग एन) अपेक्षित प्रदर्शन के रूप में वर्णित किया जाता है - सबसे खराब स्थिति यादृच्छिक इनपुट के लिए बहुत संभावना नहीं है, और कुछ यादृच्छिकता को एक प्रीपास या पिवट चयन में बनाने का मतलब है कि कुल मिलाकर सबसे खराब स्थिति महत्वपूर्ण इनपुट आकारों के लिए बहुत संभावना नहीं है। सबसे खराब स्थिति इस तथ्य से कम प्रासंगिक है कि क्विकसॉर्ट (1) बहुत सरल है, और (2) बहुत कैश-फ्रेंडली है, दोनों ही कई अन्य सॉर्टिंग एल्गोरिदम की तुलना में काफी बेहतर लगातार कारक हैं।

— स्टीव 314

(2) ठीक उस बाहरी विचार की तरह है जिसे बड़े-ओ प्रदर्शन को देखते समय ध्यान में रखा जाना चाहिए। अल्गोरिदमिक रूप से, मर्जसोर्ट को क्विकॉर्ट को हमेशा बेहतर बनाना चाहिए , लेकिन संसाधन उपयोग और कैशे इलाके आमतौर पर उनके वास्तविक दुनिया के प्रदर्शन पदों को उलट देते हैं।

— Dan Lyons

Answer 4

नोट: कृपया नीचे और अन्य गुरुओं द्वारा @ back2dos की टिप्पणियों को पढ़ें, क्योंकि वे वास्तव में मेरे द्वारा लिखे गए की तुलना में अधिक सहायक हैं - सभी योगदानकर्ताओं के लिए धन्यवाद।

मुझे लगता है कि नीचे दिए गए चार्ट से लिया गया है: बिग ओ संकेतन , "एल्गोरिदम की निराशावादी प्रकृति:") की खोज करें, आप देख सकते हैं कि ओ (लॉग एन) हमेशा कहने से बेहतर नहीं है , ओ (एन)। इसलिए, मुझे लगता है कि आपका तर्क मान्य है।

Comments

प्रश्न एल्गोरिदम के विशिष्ट वास्तविक दुनिया उदाहरण चाहते थे। यह खड़ा है के रूप में किसी भी नहीं है।

— मेगन वाकर

आप उस ग्राफ पर कुछ भी नहीं देख सकते हैं, जो प्रश्न का उत्तर देगा। यह भ्रामक है। यह ग्राफ़ केवल फ़ंक्शन y = 1, y = log xऔर इतने पर और के चौराहे को प्लॉट करता है y = 1और y = xवास्तव में बिंदु है (1,1)। यदि यह वास्तव में सही थे, तो यह आपको बताएगा, कि उच्च जटिलता के एल्गोरिदम 0 से 2 प्रविष्टियों के लिए तेज़ हो सकते हैं, जो कि कुछ लोग शायद ही इसकी देखभाल करेंगे। क्या ग्राफ़ पूरी तरह से ध्यान में रखने में विफल रहता है (और प्रश्न में क्या उल्लेखनीय प्रदर्शन अंतर है) निरंतर कारक है।

— बैकऑडोस

@ शमूएल वाकर, टिप्पणी के लिए धन्यवाद। दिए गए लिंक (लिंक -1) में प्रति श्रेणी एल्गोरिदम के कुछ उदाहरण हैं।

— NoChance

@ back2dos: इसका स्वयं का ग्राफ प्रश्न का उत्तर नहीं देता है, लेकिन इसका उत्तर देने के लिए उपयोग किया जा सकता है। प्रत्येक प्रदर्शित फ़ंक्शन का आकार किसी भी पैमाने और स्थिर कारक के लिए समान है। इसके साथ यह ग्राफ़ दिखाता है कि कार्यों के संयोजन को देखते हुए, आदानों की एक सीमा होती है, जिसके लिए एक छोटा होता है और एक इनपुट की श्रेणी जिसके लिए दूसरा होता है।

— Jan Hudec

@dan_waterworth, आप सही हैं, मैं उस बिंदु को स्वीकार करूंगा और उस टिप्पणी को हटा दूंगा। फिर भी, उत्तर दो अर्थों में गलत या भ्रामक है: 1) बिग-ओ का संपूर्ण बिंदु यह है कि यह जटिलता पर एक ऊपरी बाध्यता देता है; यह केवल बड़े n के लिए सार्थक है क्योंकि हम स्पष्ट रूप से छोटे शब्दों को टॉस करते हैं जो n ग्रो के रूप में सबसे बड़े शब्द से अभिभूत हैं। 2) प्रश्न का बिंदु दो एल्गोरिदम के उदाहरणों को ढूंढना है, जहां उच्च बिग-ओ बाध्य आउटपरफॉर्म के साथ कम बाउंड के साथ एक है। यह उत्तर विफल हो जाता है क्योंकि यह ऐसा कोई उदाहरण नहीं देता है।

— कालेब

Answer 5

nहां, के व्यावहारिक मूल्यों के लिए । यह सीएस सिद्धांत में बहुत ऊपर आता है। अक्सर एक जटिल एल्गोरिथ्म होता है जिसमें तकनीकी रूप से बेहतर बड़े-ओह प्रदर्शन होते हैं, लेकिन निरंतर कारक इतने बड़े होते हैं कि यह अव्यवहारिक हो जाता है।

मैंने एक बार अपने कम्प्यूटेशनल ज्यामिति के प्रोफेसर को रेखीय समय में बहुभुज को त्रिभुज बनाने के लिए एक एल्गोरिथम का वर्णन किया था, लेकिन वह "बहुत जटिल था। मुझे नहीं लगता कि किसी ने वास्तव में इसे लागू किया है" (!!)।

इसके अलावा, सामान्य हीप की तुलना में रिट्रेसमेंट हीप्स की बेहतर विशेषताएँ हैं, लेकिन बहुत लोकप्रिय नहीं हैं क्योंकि वे नियमित हीप्स के रूप में अच्छी तरह से अभ्यास नहीं करते हैं । यह अन्य एल्गोरिदम का उपयोग कर सकता है, जो ढेर का उपयोग करता है - उदाहरण के लिए, डायजेक्स्ट्रा का सबसे छोटा रास्ता गणितीय रूप से एक हाईपर है, लेकिन आमतौर पर व्यवहार में नहीं होता है।

Comments

यह 100,000 या इतने लंबों के क्रम पर विशाल रेखांकन के लिए तेज़ है।

— 19

फाइबोनैचि ढेर मेरे पहले (वास्तव में, दूसरे) भी थे।

— कोनराड रुडोल्फ

Answer 6

एक लिंक्ड सूची में डालने और एक resizable सरणी में डालने की तुलना करें।

लिंक की गई सूची O (1) के सार्थक होने के लिए डेटा की मात्रा काफी बड़ी होनी चाहिए।

एक लिंक की गई सूची में अगले पॉइंटर्स और डीरेफेरेंस के लिए अतिरिक्त ओवरहेड है। एक resizable सरणी के आसपास डेटा की प्रतिलिपि बनाने के लिए है। वह नकल ओ (एन) है, लेकिन व्यवहार में बहुत तेज है।

Comments

हर बार भरने पर आकार बदलने योग्य सरणी दोगुनी हो जाती है, इसलिए प्रति प्रविष्टि को आकार देने की औसत लागत O (1) है।

— केविन क्लाइन

@kevincline, हाँ, लेकिन O (n) सम्मिलन बिंदु को आगे बढ़ाने के बाद सभी तत्वों को स्थानांतरित करने से आता है। आवंटन O (1) समय में परिशोधन है। मेरा कहना है कि यह आंदोलन अभी भी बहुत तेज़ है, इसलिए व्यवहार में आमतौर पर जुड़ी हुई सूचियाँ हैं।

— विंस्टन एवर्ट

प्रोसेसर कैशिंग के कारण लिंक किए गए सूचियों की तुलना में कारण सन्निहित सरणियाँ बहुत तेज़ हैं। लिंक की गई सूची को ट्रेस करने से हर तत्व के लिए कैश मिस हो जाएगा। दोनों दुनिया का सर्वश्रेष्ठ पाने के लिए आपको एक अनियंत्रित लिंक्ड सूची का उपयोग करना चाहिए ।

— dan_waterworth

रिज़र्व करने योग्य सरणियाँ हमेशा कॉपी नहीं होती हैं। यह इस बात पर निर्भर करता है कि यह क्या चल रहा है और अगर रास्ते में कुछ भी है। दोहरीकरण आकार के लिए भी, कार्यान्वयन विशिष्ट। रोल ओवर रोल ऑन ए बात हालांकि एक समस्या है। लिंक्ड लिस्ट आमतौर पर अज्ञात आकार की कतारों के लिए सबसे अच्छी होती हैं, हालांकि रोटरी बफ़र कतारों को अपने पैसे के लिए एक रन देते हैं। अन्य मामलों में लिंक की गई सूची उपयोगी है क्योंकि आवंटन या विस्तार बस आपको हर समय सन्निहित सामान नहीं देने देता है, इसलिए आपको एक संकेतक की आवश्यकता होगी।

— jgmjgm

@jgmjgm, यदि आप एक रिज़ॉल्यूशन सरणी के बीच में सम्मिलित करते हैं, तो इसके तत्वों को इसके बाद पूरी तरह से कॉपी करता है।

— विंस्टन एर्वर्ट

Answer 7

बिग-ओह संकेतन का उपयोग किसी फ़ंक्शन के विकास-दर का वर्णन करने के लिए किया जाता है, इसलिए यह संभव है कि एक ओ (1) एल्गोरिथ्म तेज होगा, लेकिन केवल एक निश्चित बिंदु (स्थिर कारक) तक।

सामान्य सूचनाएं:

O (1) - पुनरावृत्तियों की संख्या (कभी-कभी आप इसे फ़ंक्शन द्वारा खर्च किए गए उपयोगकर्ता-समय के रूप में संदर्भित कर सकते हैं) इनपुट के आकार पर निर्भर नहीं है, और वास्तव में स्थिर है।

O (n) - पुनरावृत्तियों की संख्या इनपुट के आकार के रैखिक अनुपात में बढ़ती है । अर्थ - यदि एल्गोरिथ्म किसी भी इनपुट एन, 2 * एन बार के माध्यम से पुनरावृत्ति करता है, तो इसे अभी भी ओ (एन) माना जाता है।

O (n ^ 2) (द्विघात) - पुनरावृत्तियों की संख्या इनपुट आकार चुकता है।

Comments

अन्यथा उत्कृष्ट उत्तर के लिए एक उदाहरण जोड़ने के लिए: एक O (1) विधि में 37 वर्ष प्रति कॉल लग सकते हैं, जबकि एक O (n) विधि में प्रति कॉल 16 * n माइक्रोसेकंड लग सकते हैं। कौन सा तेज है?

— काज ड्रैगन

मैं यह देखने में पूरी तरह से विफल हूं कि यह सवाल का जवाब कैसे देता है।

— अवकर

मैं बडा-ओ समझ गया। यह वास्तविक प्रश्न को संबोधित नहीं करता है, जो उन कार्यों के विशिष्ट उदाहरण हैं जहां एक कम बड़े-ओ के साथ एल्गोरिदम एक उच्च बिग-ओ वाले लोगों द्वारा बेहतर प्रदर्शन करते हैं।

— काइलवैप्पड

जब आप प्रश्न को "क्या उदाहरण हैं ..." के रूप में रखते हैं, तो कोई व्यक्ति अनिवार्य रूप से "हां" का जवाब देने वाला है। बिना किसी को दिए।

— राकसलिस

@ क्रालिस: शायद। हालाँकि यह साइट आपके द्वारा दिए गए किसी भी बयान के स्पष्टीकरण (या बेहतर अभी तक सबूत) की मांग करती है। अब सबूत के लिए सबसे अच्छा तरीका है, कि इस तरह के उदाहरण एक देने के लिए हैं;)

— back2dos

Answer 8

रेगेक्स लाइब्रेरी आमतौर पर बैकट्रैकिंग करने के लिए कार्यान्वित की जाती हैं, जिसमें डीएफए पीढ़ी की बजाय सबसे खराब स्थिति होती है, जिसकी जटिलता होती है O(nm)।

Naive backtracking एक बेहतर परफ़ॉर्मर हो सकता है जब इनपुट तेज़ पथ पर रहता है या बिना अत्यधिक पीछे जाने की आवश्यकता के विफल हो जाता है।

(हालांकि यह निर्णय केवल प्रदर्शन आधारित नहीं है, यह भी संदर्भों की अनुमति देने के लिए है।)

Comments

मुझे लगता है कि यह आंशिक रूप से ऐतिहासिक है - एक डीएफए में एक नियमित अभिव्यक्ति को बदलने के लिए एल्गोरिथ्म का पेटेंट कराया गया था जब पहले के कुछ उपकरण (sed और grep, मुझे लगता है) विकसित किए जा रहे थे। बेशक, मैंने अपने कंपाइलर प्रोफेसर से इसे सुना, जो पूरी तरह से निश्चित नहीं था, इसलिए यह तीसरे हाथ का खाता है।

— तिखन जेल्विस

Answer 9

एक O(1)एल्गोरिथ्म:

def constant_time_algorithm
  one_million = 1000 * 1000
  sleep(one_million) # seconds
end

एक O(n)एल्गोरिथ्म:

def linear_time_algorithm(n)
  sleep(n) # seconds
end

स्पष्ट रूप से, किसी भी मूल्य के लिए, nजहाँ n < one_million, O(n)उदाहरण में दिया गया एल्गोरिथम एल्गोरिथम से अधिक तेज़ होगा O(1)।

जबकि यह उदाहरण थोड़ा मुखर है, यह निम्नलिखित उदाहरण में आत्मा के बराबर है:

def constant_time_algorithm
  do_a_truckload_of_work_that_takes_forever_and_a_day
end

def linear_time_algorithm(n)
  i = 0
  while i < n
    i += 1
    do_a_minute_amount_of_work_that_takes_nanoseconds
  end
end

आप चाहिए स्थिरांक और अपने में गुणांक पता Oअभिव्यक्ति है, और आप चाहिए की उम्मीद सीमा पता है nनिर्धारित करने के लिए, क्रम में एक प्रायोरी जो एल्गोरिथ्म तेजी से किया जा रहा है खत्म हो जाएगा।

अन्यथा, आपको अपेक्षित सीमा के मूल्यों के साथ दो एल्गोरिदम को बेंचमार्क करना होगाn ताकि एक पश्चगामी निर्धारित किया जा सके कि एल्गोरिथ्म तेजी से समाप्त हो रहा है।

Answer 10

क्रमबद्ध करना:

सम्मिलन सॉर्ट O (n ^ 2) है, लेकिन अन्य ओ (n * लॉग (n)) तत्वों की छोटी संख्या के लिए सॉर्टिंग एल्गोरिदम को आउटपरफॉर्म करता है।

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

देखें Timsort अजगर और जावा 7 कि इस तकनीक का उपयोग छँटाई की वर्तमान डिफ़ॉल्ट कार्यान्वयन।

Answer 11

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

एक बहुपद एकीकरण एल्गोरिथ्म है , लेकिन यह अभ्यास में बहुत धीमा है।

Answer 12

स्मृति में बबल्सर्ट क्विकसॉर्ट को बेहतर बना सकता है जब प्रोग्राम को डिस्क पर स्वैप किया जा रहा हो या तुलना करते समय डिस्क से हर आइटम को पढ़ने की आवश्यकता हो।

यह एक उदाहरण होना चाहिए जिससे वह संबंधित हो सकता है।

Comments

क्विकॉर्ट्स और बबलोर्ट पर उद्धृत जटिलताएं ओ (1) यादृच्छिक मेमोरी एक्सेस नहीं मानती हैं? यदि यह अब मामला नहीं है, तो जटिलता को तेज नहीं किया जा सकता है?

— विक्टर डाहल

@ViktorDahl, आइटम एक्सेस टाइम पारंपरिक एल्गोरिथ्म की तरह सॉर्ट एल्गोरिथ्म में मापा जा रहा है का हिस्सा नहीं है, इसलिए "O (1)" यहां शब्दों का सही विकल्प नहीं है। इसके बजाय "निरंतर समय" का उपयोग करें। PHK ने कुछ समय पहले सॉर्ट एल्गोरिदम के बारे में एक लेख लिखा था, जिसमें यह जान लिया गया था कि कुछ आइटम दूसरों (वर्चुअल मेमोरी) की तुलना में दोबारा उपयोग करने के लिए अधिक महंगे हैं - queue.acm.org/detail.cfm?id=1814327 - आपको यह दिलचस्प लग सकता है।

मुझे अब अपनी गलती दिख रही है। एक आमतौर पर तुलना की संख्या को मापता है, और निश्चित रूप से वे भंडारण माध्यम की गति से प्रभावित नहीं होते हैं। इसके अलावा, लिंक के लिए धन्यवाद।

— विक्टर डाहल

Answer 13

अक्सर अधिक उन्नत एल्गोरिदम निश्चित मात्रा में (महंगे) सेटअप करते हैं। यदि आपको इसे केवल एक बार चलाने की आवश्यकता है, तो आप ब्रूट-फोर्स विधि के साथ बेहतर हो सकते हैं।

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

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

Answer 14

डिक्रिप्शन अक्सर 0 (1) है। उदाहरण के लिए डीईएस के लिए प्रमुख स्थान 2 ^ 56 है, इसलिए किसी भी संदेश का डिक्रिप्शन एक निरंतर समय ऑपरेशन है। इसका सिर्फ इतना है कि आपके पास 2 ^ 56 का कारक है, इसलिए यह वास्तव में एक बड़ा स्थिरांक है।

Comments

संदेश O ( n ) का डिक्रिप्शन नहीं है , जहां n संदेश के आकार के समानुपाती है? जब तक आपके पास सही कुंजी है, कुंजी का आकार भी ध्यान में नहीं आता है; कुछ एल्गोरिदम में न्यूनतम या कोई महत्वपूर्ण सेटअप / विस्तार प्रक्रिया नहीं है (DES, RSA - ध्यान दें कि प्रमुख पीढ़ी अभी भी एक जटिल कार्य हो सकती है, लेकिन इसका कुंजी विस्तार से कोई लेना-देना नहीं है) जबकि अन्य अत्यंत जटिल हैं (ब्लोफिश का ध्यान रखना आता है), लेकिन एक बार यह हो जाने के बाद, वास्तविक कार्य करने का समय संदेश के आकार के समानुपाती होता है, इसलिए O (n)।

— बजे एक CVn

आप शायद डिक्रिप्शन के बजाय क्रिप्टानानैलिसिस का मतलब है?

— 11

ठीक है, हाँ, ऐसी कोई भी चीज़ है जिसे आप निरंतर बना सकते हैं और एक एल्गोरिथ्म को O (1) घोषित कर सकते हैं। [छँटाई का अर्थ है कि तत्वों की तुलना करने के लिए एक निरंतर मात्रा में समय लगता है, उदाहरण के लिए, या गैर-बाइनम नंबरों के साथ किसी भी गणित में]

— रैंडम 832

Answer 15

मेरे दिमाग में सेट वसंत के विभिन्न कार्यान्वयन। सबसे भोली में से एक इसे एक वेक्टर के ऊपर लागू कर रहा है, जिसका अर्थ है और removeसाथ ही containsइसलिए addसभी ओ (एन) भी लेते हैं।
एक विकल्प यह है कि इसे कुछ सामान्य प्रयोजन हैश पर लागू किया जाए, जो इनपुट हैश को इनपुट मानों में मैप करता है। इस तरह का एक सेट कार्यान्वयन O (1) के लिए करता है add, containsऔर remove।

यदि हम मानते हैं कि एन लगभग 10 या तो है, तो पहला कार्यान्वयन संभवतः तेज है। एक तत्व को खोजने के लिए सभी को 10 मानों की तुलना करना पड़ता है।
अन्य कार्यान्वयन को सभी प्रकार के चतुर परिवर्तनों को शुरू करना होगा, जो कि 10 तुलना करने की तुलना में बहुत अधिक महंगा हो सकता है। सभी ओवरहेड के साथ, आपके पास कैश मिस भी हो सकते हैं और फिर यह वास्तव में कोई फर्क नहीं पड़ता कि आपका समाधान सिद्धांत में कितनी तेजी से है।

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

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

Answer 16

हाँ, उपयुक्त रूप से छोटे N के लिए। हमेशा एक N होगा, जिसके ऊपर आपके पास हमेशा O (1) <O (lg N) <O (N) <O (N log N) <O (N ^ c) होगा। ) <O (c ^ N) (जहां O (1) <O (lg N) का अर्थ है कि O (1) एल्गोरिथ्म में कम संचालन तब होगा जब N उपयुक्त रूप से बड़ा हो और c कुछ निश्चित स्थिर हो जो 1 से अधिक हो )।

एक विशेष O (1) एल्गोरिदम को ठीक से f (N) = 10 ^ 100 (एक गोगोल) संचालन कहते हैं और एक O (N) एल्गोरिथ्म बिल्कुल g (N) = 2 N + 5 संचालक लेता है। O (N) एल्गोरिथ्म तब तक अधिक प्रदर्शन देगा, जब तक कि N लगभग एक गूगोल (वास्तव में जब N> (10 ^ 100 - 5) / 2) नहीं हो जाता है, इसलिए यदि आप केवल N को 1000 से एक बिलियन की सीमा में होने की उम्मीद करते हैं O (1) एल्गोरिथ्म का उपयोग करके एक प्रमुख दंड भुगतना होगा।

या यथार्थवादी तुलना के लिए, मान लें कि आप n-अंकीय संख्याओं को एक साथ गुणा कर रहे हैं। Karatsuba एल्गोरिथ्म ज्यादा से ज्यादा 3 n है ^ संचालन (3 एलजी) (मोटे तौर पर यह है कि O (n ^ 1.585)), जबकि Schönhage-Strassen एल्गोरिथ्म हे (एन लॉग एन लॉग लॉग एन) जो एक है तेजी से आदेश है, लेकिन उद्धृत करने के लिए विकिपीडिया:

व्यवहार में स्चॉन्ज-स्ट्रैसोन एल्गोरिथ्म पुरानी विधियों जैसे कि करतसुबा और टूम-कुक गुणा से आगे संख्या के लिए 2 ^ 2 ^ 15 से 2 ^ 17 (10,000 से 40,000 दशमलव अंक) से आगे बढ़ना शुरू कर देता है। [4] [5] [६] ]

इसलिए यदि आप 500 अंकों की संख्याओं को एक साथ बढ़ा रहे हैं, तो एल्गोरिथ्म का उपयोग करने का कोई मतलब नहीं है जो कि बड़े ओ तर्कों द्वारा "तेज" है।

EDIT: आप g (N) की तुलना में f (N) निर्धारित कर सकते हैं, सीमा N-> अनंत (f) (N) / g (N) की सीमा लेकर। यदि सीमा 0 है तो f (N) <g (N), यदि सीमा अनंत है तो f (N)> g (N), और यदि सीमा कुछ अन्य स्थिर है तो f (N) ~ g (N) बड़े ओ संकेतन के संदर्भ में।

Answer 17

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

हालांकि, व्यवहार में, सिम्पलेक्स विधि के लिए घातीय सबसे खराब स्थिति सामने नहीं आती है - सिम्पलेक्स विधि तेज और विश्वसनीय है, जबकि प्रारंभिक आंतरिक बिंदु एल्गोरिदम प्रतिस्पर्धी होने के लिए बहुत धीमी गति से थे। (अब अधिक आधुनिक इंटीरियर बिंदु एल्गोरिदम, जो कर रहे हैं कर रहे हैं - भी लेकिन सिंप्लेक्स विधि है ... प्रतिस्पर्धी)

Answer 18

प्रत्यय के निर्माण के लिए उकोकोन की एल्गोरिथ्म हे (एन लॉग एन) है। इसका "ऑन-लाइन" होने का लाभ है - अर्थात, आप अधिक पाठ को बढ़ा सकते हैं।

हाल ही में, अन्य अधिक जटिल एल्गोरिदम ने अभ्यास में तेज होने का दावा किया है, बड़े पैमाने पर क्योंकि उनकी मेमोरी एक्सेस में उच्च स्थानीयता है, इस प्रकार प्रोसेसर कैश उपयोग में सुधार और सीपीयू पाइपलाइन स्टालों से बचना है। उदाहरण के लिए देखें, यह सर्वेक्षण , जो दावा करता है कि 70-80% प्रसंस्करण समय स्मृति के इंतजार में बिताया जाता है, और यह पेपर "wotd" एल्गोरिथम का वर्णन करता है।

प्रत्यय की कोशिश आनुवांशिकी (जीन अनुक्रमों के मिलान के लिए) में महत्वपूर्ण है और, स्क्रैबल शब्दकोशों के कार्यान्वयन में कुछ हद तक महत्वपूर्ण है।

Answer 19

किसी भी अच्छी तरह से परिभाषित समस्या के लिए हमेशा सबसे तेज और सबसे छोटा एल्गोरिदम है । यह केवल विशुद्ध रूप से सैद्धांतिक रूप से (asymptotically) सबसे तेज़ एल्गोरिथम है।

एक समस्या के किसी भी विवरण दिया पी है कि समस्या के लिए और एक उदाहरण मैं , यह सब संभव एल्गोरिदम विश्लेषण करता है एक और सबूत पीआर , ऐसे प्रत्येक जोड़ी है कि क्या के लिए जाँच पीआर मान्य प्रमाण यह है कि एक के लिए asymptotically सबसे तेजी से एल्गोरिथ्म है पी । यदि यह इस तरह का प्रमाण पाता है, तो यह I पर A निष्पादित करता है ।

इस समस्या-प्रूफ जोड़ी की खोज में जटिलता O (1) (निश्चित समस्या P के लिए ) है, इसलिए आप हमेशा समस्या के लिए asymptotically सबसे तेज़ एल्गोरिथम का उपयोग करते हैं। हालाँकि, चूँकि यह स्थिरांक लगभग सभी मामलों में इतना अकड़ा हुआ है, इसलिए यह विधि व्यवहार में पूरी तरह से बेकार है।

Answer 20

कई भाषाएं / रूपरेखाएँ KMP के बजाय स्ट्रिंग्स से मेल खाने के लिए भोली पैटर्न का उपयोग करती हैं । हम टॉम, न्यूयॉर्क की तरह स्ट्रिंग की तलाश में हैं, न कि अबाबाबबबबबबबबबब।