ओ (के) मेमोरी ओ (एन) समय के साथ दिए गए अनुक्रम से सबसे छोटा तत्व खोजना

मान लीजिए कि हमने एक- एक करके संख्याओं का क्रम पढ़ा । केवल सेल मेमोरी और रैखिक समय ( ) का उपयोग करने के साथ 'th सबसे छोटा तत्व कैसे खोजें । मुझे लगता है कि हमें अनुक्रम के पहले शब्दों को सहेजना चाहिए और जब 'th शब्द प्राप्त होता है, तो एक शब्द हटाएं, जो हमें यकीन है कि यह ' th सबसे छोटा तत्व नहीं हो सकता है और फिर 'th शब्द को सहेजें । इसलिए हमारे पास एक संकेतक होना चाहिए जो प्रत्येक चरण में इस अनुपयोगी शब्द को दर्शाता है और इस सूचक को प्रत्येक चरण में जल्दी से अपडेट किया जाना चाहिए। मैंने "अधिकतम" के साथ शुरू किया ; लेकिन यह जल्दी से अद्यतन नहीं कर सकता; इसका मतलब है कि अगर हम अधिकतम पर विचार करते हैं $n$ $k$ $O(k)$ $O(n)$ $k$ $k+1$ $k$ $k+1$ तब पहली विलोपन में हम अधिकतम याद करते हैं और हमें और उसके कारण समय में अधिकतम खोज करनी चाहिए कि यह रैखिक नहीं है। हो सकता है कि हमें पहले के क्रम को अधिक समझदारी से सहेजना चाहिए । $O(k)$ $(n-k)\times O(k)$ $k$

मैं इस समस्या का समाधान कैसे कर सकता हूं।

data-structures search-algorithms quicksort

— Shahab_HK
स्रोत

क्या आप एक ऑनलाइन एल्गोरिथ्म में रुचि रखते हैं, या कोई भी एल्गोरिथम करेगा?

— युवल फिल्मस

यदि तो आप इसे ऑर्डर सांख्यिकी एल्गोरिथ्म का उपयोग करके कर सकते हैं। यदि तो आप इसे मेमोरी और समय किसी भी ऊंचाई के संतुलित पेड़ों का उपयोग करके कर सकते हैं।

k = θ (n)

$k = \theta(n)$

k = o (n)

$k = o(n)$

O (k)

$O(k)$

O (n \log k)

$O(n\log k)$

— श्रेयश

इसे चयन समस्या कहा जाता है en.wikipedia.org/wiki/Selection_algorithm

— xavierm02

इन-प्लेस एल्गोरिदम में रैखिक समय होता है, जिसे आप Google कर सकते हैं, लेकिन वे कुछ जटिल हैं।

— युवल फिल्मस

@ xavierm02 यह चयन समस्या की पहचान नहीं है। क्योंकि स्मृति सीमा बाधा है।

— Shahab_HK

जवाबों:

आकार का बफर बनाएँ । सरणी से तत्वों में पढ़ें । बफर को विभाजित करने के लिए एक रैखिक-समय चयन एल्गोरिथ्म का उपयोग करें ताकि सबसे छोटे तत्व पहले हों; इसमें समय लगता है। अब बफर में अपने सरणी से एक और आइटम में पढ़ें , बफर में सबसे बड़ी वस्तुओं की जगह , बफर को पहले की तरह विभाजित करें, और दोहराएं। $2k$ $2k$ $k$ $O(k)$ $k$ $k$

यह समय और स्थान लेता है। $O(k * n/k) = O(n)$ $O(k)$

— jbapple
स्रोत

+1, यह पूछी गई स्पर्शोन्मुखता पर फिट बैठता है। कहा जा रहा है, मेरा मानना है कि यह एक एकल रैखिक समय चयन एल्गोरिथ्म करने की तुलना में तेज है ... जब एक छोटा सा स्थिर होता है, तब यह एक दिलचस्प परिप्रेक्ष्य प्रदान करता है। उदाहरण के लिए यह एल्गोरिथ्म फ़ंक्शन का निर्माण करता है।

k

$k$

k = 1

$k = 1$ min

— orlp

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

— jbapple

वे मान्य बिंदु हैं।

— orlp

आप में यह कर सकते हैं स्मृति और पहले से एक निश्चित आकार अधिकतम-ढेर के गठन से समय में तत्वों समय है, तो अधिक सरणी के बाकी पुनरावृत्ति और एक धक्का नया तत्व और फिर कुल समय = देने वाले प्रत्येक तत्व के लिए लिए पॉपिंग । $O(k)$ $O(n \log k)$ $k$ $O(k)$ $O(\log k)$ $O(k + n\log k)$ $O(n \log k)$

आप इसे सहायक मेमोरी और समय में माध्यिका-चयनकर्ताओं के एल्गोरिथ्म का उपयोग करके, चयन करके , और पहले तत्वों को वापस करके कर सकते हैं। एसिम्पोटिक्स में कोई बदलाव नहीं होने से आप औसत मामले में तेजी लाने के लिए इंट्रोसेप्ट का उपयोग कर सकते हैं। यह आपकी समस्या को हल करने के लिए विहित तरीका है। $O(\log n)$ $O(n)$ $k$ $k$

अब तकनीकी रूप से और अतुलनीय हैं। हालाँकि मेरा तर्क है कि व्यवहार में बेहतर है, क्योंकि यह प्रभावी रूप से निरंतर है कि कोई कंप्यूटर सिस्टम से अधिक मेमोरी का न हो, । इस बीच जितना बड़ा हो सकता है । $O(\log n)$ $O(k)$ $O(\log n)$ $2^{64}$ $\log 2^{64}= 64$ $k$ $n$

— orlp
स्रोत

ध्यान दें कि आप ढेर-आधारित एल्गोरिथ्म की जटिलता को सुधारने के लिए उपयोग कर सकते हैं।

O (n \times \log min (k, n - k))

$O(n \times \log\min (k, n - k))$

— 15

@ xavierm02 = । प्रमाण: का सबसे खराब मामला । के लिए सबसे खराब स्थिति है । वे एक स्थिर कारक के भीतर समान हैं, इस प्रकार = ।

O (m i n (k, n - k))

$O(min(k, n-k))$

O (k)

$O(k)$

k

$k$

n

$n$

m i n (k, n - k)

$min(k, n-k)$

\frac{n}{2}

$n \over 2$

O (m i n (k, n - k))

$O(min(k, n-k))$

O (k)

$O(k)$

— orlp

@ xavierm02 कहा जा रहा है, यह अभी भी एक अच्छा गति है :)

— orlp

u_{n, k} = k

$u_{n,k}=k$ है , लेकिन यह नहीं है। मान लीजिए कि यह है। फिर कुछ और कुछ ताकि हर , हमारे पास , जो स्पष्ट रूप से गलत है (क्योंकि हम ले सकते हैं तो ।

O (k)

$O(k)$

O (min (k, n - k))

$O(\min (k, n-k))$

C

$C$

M

$M$

M \leq k \leq n

$M\le k\le n$

k \leq C (n - k)

$k\le C (n-k)$

n = k \to + \infty) .

$n=k \to +\infty).$

O (min (k, n - k)) ⊊ O (k)

$O(\min(k, n-k))\subsetneq O(k)$

— xavierm02

@ xavierm02 मैं आपके संकेतन से अपरिचित हूं । निष्पक्ष होने के लिए, मैं सामान्य रूप से बहुआयामी बड़े- अंकन के साथ काफी अपरिचित हूं , विशेष रूप से इस बात पर विचार करते हुए कि आयाम असंबंधित नहीं हैं।

u_{n, k}

$u_{n, k}$

O

$O$

n, k

$n, k$

— orlp