बाइनरी खोज जटिलता की गणना कैसे करें

144

मैंने किसी को यह कहते हुए सुना कि चूंकि द्विआधारी खोज खोज के लिए आवश्यक इनपुट को रोक देती है इसलिए यह लॉग (n) एल्गोरिथ्म है। चूंकि मैं गणित की पृष्ठभूमि से नहीं हूं, इसलिए मैं इससे संबंधित नहीं हूं। क्या कोई इसे थोड़ा और विस्तार से समझा सकता है? क्या इसे लघुगणक श्रृंखला के साथ कुछ करना है?

— बनी खरगोश
स्रोत

1

यह आपकी मदद कर सकता है: stackoverflow.com/a/13093274/550393

— 2cupsOfTech

385

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

सवाल यह है कि जब तक आपके पास 1 है, तब तक आप कितनी बार एन को 2 से विभाजित कर सकते हैं? यह अनिवार्य रूप से कह रहा है, एक द्विआधारी खोज (आधा तत्व) करें जब तक आप इसे नहीं मिला। एक सूत्र में यह होगा:

1 = एन / 2 ^एक्स

2 ^{x से} गुणा करें :

2 ^एक्स = एन

अब लॉग _{2 करें} :

log ₂ (2 ^x ) = log ₂ N
x * log ₂ (2) = log ₂ N
x * 1 = log ₂ N लॉग करें

इसका मतलब है कि आप लॉग एन को तब तक विभाजित कर सकते हैं जब तक कि आपके पास सब कुछ विभाजित न हो। जिसका अर्थ है कि आपको लॉग एन ("द्विआधारी खोज कदम") को विभाजित करना होगा जब तक कि आपको अपना तत्व नहीं मिला।

— duedl0r
स्रोत

मैंने अभी इसकी गणना t (n) = (2 ^ 2) * K की है। इसे लॉग इन फॉर्म कैसे बनाएं?

— शान खान

1

उसी अवधारणा को रेखांकन द्वारा

— 2cupsOfTech

जो हिस्सा मुझे याद आ रहा है, अगर आपके पास 7 प्रविष्टियों के साथ एक BST है, तो इसका सूत्र क्या है? log2 (7)? मैंने हर संभव परिणाम के साथ एक क्रूर बल गणना की, और एक जवाब आया कि लॉग 2 (7) के बराबर नहीं था, इसलिए मैं क्या गलत कर रहा हूं?

— पेरी मोनशचू

1

बाइनरी ट्री स्पष्टीकरण की तुलना में बहुत आसान है।

— नोनेम

1

बहुत अच्छा जवाब

— VHS

22

बाइनरी खोज के लिए, टी (एन) = टी (एन / 2) + ओ (1) // पुनरावृत्ति संबंध

कंप्यूटिंग के लिए मास्टर्स प्रमेय लागू करें पुनरावृत्ति संबंधों की रन समय जटिलता: टी (एन) = ए टी (एन / बी) + एफ (एन)

यहां, एक = 1, बी = 2 => लॉग (एक आधार बी) = 1

यहाँ भी, f (N) = n ^ c लॉग ^ k (n) // k = 0 & c = लॉग (एक आधार b)

तो, टी (एन) = ओ (एन ^ सी लॉग ^ (के + 1) एन) = ओ (लॉग (एन))

स्रोत: http://en.wikipedia.org/wiki/Master_theorem

— abstractKarshit
स्रोत

1

क्यों लॉग (एक आधार बी) 1 है जब एक = 1 और बी = 2, यह 0 नहीं होना चाहिए?

— GAURANG VYAS

16

टी (एन) = टी (एन / 2) +1

T (n / 2) = T (n / 4) + 1 + 1

ऊपर (n / 2) के मान को T (n) = T (n / 4) + 1 + 1 से ऊपर रखें। । । । टी (एन / 2 ^ ट) + 1 + 1 + 1 + 1 .....

= T (2 ^ k / 2 ^ k) + 1 + 1 .... + 1 to k

= टी (1) + K

जैसा कि हमने 2 ^ k = n लिया

के = लॉग एन

तो समय जटिलता हे (लॉग एन)

— धीरेन बिरेन
स्रोत

10

यह आधा खोज समय नहीं है, जो इसे लॉग (n) नहीं बनाएगा। यह इसे कम करता है। एक पल के लिए इस बारे में सोचो। यदि आपके पास किसी तालिका में 128 प्रविष्टियाँ हैं और आपको अपने मूल्य के लिए रैखिक रूप से खोजना है, तो संभवतः आपके मूल्य को खोजने के लिए औसतन लगभग 64 प्रविष्टियाँ होंगी। यह n / 2 या रैखिक समय है। एक द्विआधारी खोज के साथ, आप प्रत्येक पुनरावृत्ति को संभावित प्रविष्टियों को 1/2 समाप्त कर देते हैं, जैसे कि अधिक से अधिक यह आपके मूल्य को खोजने के लिए केवल 7 की तुलना करेगा (लॉग बेस 2 की 128 7 या 2 से 7 की शक्ति 128 है।) यह द्विआधारी खोज की शक्ति।

— माइकल डोरगन
स्रोत

नेक्रोपोस्ट के लिए क्षमा करें, लेकिन 128 समान रूप से भरा हुआ पेड़ नहीं है। मैंने इसके चारों ओर अपना सिर प्राप्त करने के लिए एक मूल उदाहरण का उपयोग किया, और मैंने पाया कि 7 प्रविष्टियां समान रूप से 3 परतों वाले एक पेड़ को भरती हैं। मैंने गणना की कि जटिलता 17/7 (तुलना के कुल योग का मतलब) होनी चाहिए जो कि 2.43 है। लेकिन log2 (7) 2.81 है। तो मैं यहाँ क्या याद कर रहा हूँ?

— पेरी मोनशचू

दो उत्तर - पहले एक यहाँ: भले ही गणित में कोई त्रुटि न हो, हम देख सकते हैं कि 2.43 औसत अभी भी रैखिक के लिए 3.5 औसत से बेहतर है, और यह कम मूल्य पर है। एक बार जब आप 100 प्रविष्टियों में प्रवेश करते हैं, तो log2 () रैखिक की तुलना में बहुत बेहतर होता है। मुझे लगता है कि आप इसे देखते हैं, इसलिए अगले पर।

— माइकल डोरगन

1

दूसरा जवाब: मुझे यकीन नहीं है कि आपके पास किस तरह का पेड़ है जहां 7 में सब कुछ भर गया है। जब मैं 8 प्रविष्टियों के एक परिपूर्ण पेड़ के बारे में सोचता हूं, तो मुझे 8 कुल पत्तियों के साथ 3 स्तर का गहरा पेड़ दिखाई देता है। इस पेड़ में, कोई भी बात नहीं जो आप खोजते हैं, यह जड़ से पत्ती तक पहुंचने के लिए कुल 3 तुलना करता है। 7 प्रविष्टियों के लिए, रास्तों में से एक की तुलना में कम 20/7 होगी (3 तुलनाओं के 6 नोड्स, 2 तुलनाओं के 1 नोड) जो कि ~ 2.85 है। Log2 (7) ~ 2.81 है। मेरे पास .04 के अंतर को समझाने के लिए गणित की पृष्ठभूमि नहीं है, लेकिन मुझे लगता है कि यह उपलब्ध नहीं है आंशिक अंश उपलब्ध होने या कुछ अन्य जादू के साथ :)

— माइकल डोरगन

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

— पेरी मोनशचू

5

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

बयानों को साबित करने में सक्षम होने के लिए यह केवल औपचारिक गणितीय लिंगो है, आदि इसकी बहुत सीधी व्याख्या है। जब n बहुत बड़ा हो जाता है, तो लॉग एन फ़ंक्शन को निष्पादित करने में लगने वाले समय को बढ़ा देगा। "इनपुट सेट" का आकार, n, सूची की लंबाई मात्र है।

सीधे शब्दों में कहें, तो बाइनरी सर्च ओ (लॉग एन) में है कि यह प्रत्येक पुनरावृत्ति में इनपुट सेट को रोक देता है। रिवर्स स्थिति में इसके बारे में सोचना आसान है। एक्स पुनरावृत्तियों पर, कितनी लंबी सूची बाइनरी सर्च एल्गोरिथ्म को अधिकतम जांच कर सकती है? उत्तर 2 ^ x है। इससे हम देख सकते हैं कि रिवर्स यह है कि औसतन बाइनरी सर्च एल्गोरिदम को लंबाई n की सूची के लिए log2 n पुनरावृत्तियों की आवश्यकता है।

अगर यह ओ (लॉग एन) है और ओ (लॉग 2 एन) नहीं है, तो यह इसलिए है क्योंकि बस फिर से डाल दिया जाता है - बड़े ओ नोटेशन स्थिरांक का उपयोग करना गिनती नहीं है।

— vidstige
स्रोत

4

यहाँ विकिपीडिया प्रविष्टि है

यदि आप सरल पुनरावृत्त दृष्टिकोण को देखते हैं। आप अभी तक खोजे जा रहे तत्वों में से आधे को खत्म कर रहे हैं, जब तक कि आपको अपनी जरूरत का तत्व नहीं मिल जाता।

यहाँ हम सूत्र के साथ कैसे आए इसका स्पष्टीकरण दिया गया है।

शुरू में कहें कि आपके पास तत्वों की संख्या एन है और फिर आप पहले प्रयास के रूप में ⌋N / 2 a क्या कर रहे हैं। जहाँ N, कम बाउंड और अपर बाउंड का योग है। N का पहला समय मान (L + H) के बराबर होगा, जहां L पहली सूची (0) है और H उस सूची का अंतिम सूचकांक है जिसे आप खोज रहे हैं। यदि आप भाग्यशाली हैं, तो आप जिस तत्व को खोजने की कोशिश करेंगे, वह मध्य में होगा [उदा। आप सूची में 18 को खोज रहे हैं {16, 17, 18, 19, 20} तब आप ⌊ (0 + 4) / 2 0 = 2 की गणना करते हैं जहां 0 कम बाउंड है (सरणी के पहले तत्व का एल - इंडेक्स) और 4 उच्च बाउंड (सरणी के अंतिम तत्व का एच-इंडेक्स) है। उपरोक्त मामले में L = 0 और H = 4. अब 2 तत्व 18 का सूचकांक है जिसे आप खोज रहे हैं। बिंगो! आपने ढूंढ लिया।

यदि मामला एक अलग सरणी {15,16,17,18,19} था, लेकिन आप अभी भी 18 की खोज कर रहे थे, तो आप भाग्यशाली नहीं होंगे और आप पहले N / 2 (जो ⌊ (0 + 4) /) करेंगे 2 = 2 और उसके बाद तत्व 2 का एहसास करें कि इंडेक्स 2 में वह नंबर नहीं है जिसे आप खोज रहे हैं। अब आप जानते हैं कि आपको पुनरावृत्त तरीके से खोज करने के लिए अपने अगले प्रयास में कम से कम आधे सरणी की तलाश नहीं करनी है। खोज का प्रयास आधा किया जाता है। इसलिए मूल रूप से, आप उन तत्वों की आधी सूची नहीं खोजते हैं जिन्हें आपने पहले खोजा था, हर बार जब आप उस तत्व को खोजने की कोशिश करते हैं जिसे आप अपने पिछले प्रयास में नहीं खोज पाए थे।

तो सबसे खराब स्थिति होगी

[एन] / २ + [(एन / २)] / २ + (((एन / २) / २)] / २ .....
अर्थात:
एन / २ ^१ + एन / २ ^२ + एन / २ ^३ + ..... + N / 2 ^x … ..

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

यह दर्शाता है कि सबसे खराब स्थिति तब होती है जब आप N / 2 ^x तक पहुँचते हैं जहाँ x ऐसा होता है कि 2 ^x = N

अन्य मामलों में N / 2 ^x जहां x ऐसा है कि 2 ^x <N ^{x का} न्यूनतम मान 1 हो सकता है, जो सबसे अच्छा मामला है।

अब चूंकि गणितीय रूप से सबसे खराब स्थिति तब है जब
2 ^x = N
=> लॉग ₂ (2 ^x ) = लॉग ₂ (N)
=> x * log ₂ (2) = लॉग ₂ (N)
=> x * 1 = लॉग का मान ₂ (एन)
=> अधिक औपचारिक रूप से Nlog ₂ (N) + 1 =

— RajKon
स्रोत

1

आप वास्तव में अधिक औपचारिक संस्करण कैसे प्राप्त करते हैं?

— कलल

एक फर्श फ़ंक्शन का उपयोग किया जाता है। विवरण उत्तर में दिए गए विकी लिंक ( en.wikipedia.org/wiki/Binary_search_algorithm ) के प्रदर्शन अनुभाग में हैं ।

— RajKon

3

लॉग 2 (एन) एक बाइनरी खोज में कुछ खोजने के लिए आवश्यक खोज की अधिकतम संख्या है। औसत मामले में log2 (n) -1 खोज शामिल है। यहाँ अधिक जानकारी है:

http://en.wikipedia.org/wiki/Binary_search#Performance

— जोनाथन एम
स्रोत

2

मान लीजिए कि बाइनरी सर्च में पुनरावृति k पुनरावृत्तियों के बाद समाप्त हो गई है। प्रत्येक पुनरावृत्ति पर, सरणी को आधे से विभाजित किया जाता है। तो मान लें कि किसी भी पुनरावृत्ति पर सरणी की लंबाई n पर Iteration 1 है,

Length of array = n

Iteration 2 पर,

Length of array = n⁄2

Iteration 3 में,

Length of array = (n⁄2)⁄2 = n⁄22

इसलिए, Iteration k के बाद,

Length of array = n⁄2k

इसके अलावा, हम जानते हैं कि बाद कश्मीर डिवीजनों के बाद, सरणी की लंबाई 1 हो जाता है इसलिए

Length of array = n⁄2k = 1
=> n = 2k

दोनों तरफ लॉग फंक्शन लागू करना:

=> log2 (n) = log2 (2k)
=> log2 (n) = k log2 (2)
As (loga (a) = 1)

इसलिए,

As (loga (a) = 1)
k = log2 (n)

इसलिए बाइनरी सर्च की समय जटिलता है

log2 (n)

— SirPhemmiey
स्रोत

1

एक द्विआधारी खोज आधे से बार-बार समस्या को विभाजित करके काम करती है, कुछ इस तरह (विवरण छोड़ा गया):

उदाहरण के लिए [4,1,3,8,5] में 3

अपने आइटमों की सूची का आदेश दें [1,3,4,5,8]
मध्य वस्तु को देखो (4),
- यदि यह वह है जिसे आप खोज रहे हैं, तो रोकें
- यदि यह अधिक है, तो पहले छमाही को देखें
- यदि यह कम है, तो दूसरी छमाही को देखें
नई सूची [1, 3] के साथ चरण 2 को दोहराएं, 3 खोजें और रोकें

यह एक द्वि -खोज है जब आप समस्या को 2 में विभाजित करते हैं।

सही मान खोजने के लिए खोज को केवल log2 (n) चरणों की आवश्यकता है।

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

— सिलास पार्कर
स्रोत

1

चूंकि हम हर बार किसी सूची को आधे में काटते हैं, इसलिए हमें केवल यह जानने की जरूरत है कि हम कितने चरणों में 1 प्राप्त करते हैं क्योंकि हम सूची को दो से विभाजित करते हैं। नीचे दी गई गणना में x एक संख्या को तब तक विभाजित करता है जब तक हमें एक तत्व नहीं मिलता है (सबसे खराब स्थिति में)।

1 = एन / 2x

2x = एन

Log2 लेना

log2 (2x) = log2 (N)

x * log2 (2) = log2 (N)

x = log2 (N)

— अब्दुल मलिक
स्रोत

1

टी (एन) = टी (एन / 2) + १

T (N) = T (N / 2) + 1 = (T (N / 4) + 1) + 1

...

T (N) = T (N / N) + (1 + 1 + 1 + ... + 1) = 1 + logN (आधार 2 लॉग) = 1 + logN

तो बाइनरी खोज की समय जटिलता हे (logN)

— TizeeU0U
स्रोत

0

ok see this
for(i=0;i<n;n=n/2)
{
i++;
}
1. Suppose at i=k the loop terminate. i.e. the loop execute k times.

2. at each iteration n is divided by half.

2.a n=n/2                   .... AT I=1
2.b n=(n/2)/2=n/(2^2)
2.c n=((n/2)/2)/2=n/(2^3)....... aT I=3
2.d n=(((n/2)/2)/2)/2=n/(2^4)

So at i=k , n=1 which is obtain by dividing n  2^k times
n=2^k
1=n/2^k 
k=log(N)  //base 2

— पीयूष जैन
स्रोत

0

एक उदाहरण से आप सभी के लिए इसे आसान बना देता हूँ।

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

१ २ ३ ४ ५ ६ ... ३२

मान लें कि हम 32 की खोज कर रहे हैं। पहली यात्रा के बाद, हम साथ रह जाएंगे

१ १ 17 १ ९ २० .... ३२

दूसरी पुनरावृत्ति के बाद, हमें छोड़ दिया जाएगा

२५ २६ २ 27 २ 28 .... ३२

तीसरी पुनरावृत्ति के बाद, हमें छोड़ दिया जाएगा

29 30 31 32

चौथी पुनरावृत्ति के बाद, हमें छोड़ दिया जाएगा

३१ ३२

पांचवें पुनरावृत्ति में, हम मान 32 पाएंगे।

इसलिए, यदि हम इसे गणितीय समीकरण में बदलते हैं, तो हम प्राप्त करेंगे

(३२ X (१/२ ^५ )) = १

=> n X (2 ^-k ) = 1

=> (2 ^k ) = एन

=> k लॉग ₂ 2 = लॉग ₂ एन

=> k = लॉग ₂ एन

इसलिए प्रमाण।

— सुमुखा एच.एस.
स्रोत

0

यहाँ पठनीय LaTeX के साथ मास्टर प्रमेय का उपयोग कर समाधान है।

बाइनरी खोज के लिए पुनरावृत्ति संबंध में प्रत्येक पुनरावृत्ति के लिए, हम समस्या को रनटाइम टी (एन / 2) के साथ, एक उपप्रकार में परिवर्तित करते हैं। इसलिए: