किसी दिए गए बुलबुलों के एल्गोरिथ्म के औसत समय की जटिलता का मूल्यांकन।

11

एक बुलबुले के इस छद्म कोड को ध्यान में रखते हुए:

FOR i := 0 TO arraylength(list) STEP 1  
    switched := false
    FOR j := 0 TO arraylength(list)-(i+1) STEP 1
        IF list[j] > list[j + 1] THEN
            switch(list,j,j+1)
            switched := true
        ENDIF
    NEXT
    IF switched = false THEN
        break
    ENDIF
NEXT

औसत समय-जटिलता का मूल्यांकन करने के लिए मुझे किन मूल विचारों को ध्यान में रखना होगा? मैंने पहले से ही सबसे खराब और सबसे अच्छे मामलों की गणना करने का काम पूरा किया है, लेकिन मैं जानबूझकर फंस गया हूं कि समीकरण बनाने के लिए आंतरिक लूप की औसत जटिलता का मूल्यांकन कैसे किया जाए।

सबसे खराब स्थिति समीकरण है:

\sum_{i = 0}^{n} (\sum_{j = 0}^{n - (i + 1)} O (1) + O (1)) = O (\frac{n^{2}}{2} + \frac{n}{2}) = O (n^{2})

$\sum_{i=0}^n \left(\sum_{j=0}^{n -(i+1)}O(1) + O(1)\right) = O(\frac{n^2}{2} + \frac{n}{2}) = O(n^2)$

जिसमें आंतरिक सिग्मा आंतरिक लूप का प्रतिनिधित्व करता है, और बाहरी सिग्मा बाहरी लूप का प्रतिनिधित्व करता है। मुझे लगता है कि मुझे "अगर-तब-ब्रेक" के कारण दोनों सिग्मा को बदलने की आवश्यकता है, -काउंस, जो बाहरी सिग्मा को प्रभावित कर सकता है, लेकिन आंतरिक लूप में इफ-क्लॉज के कारण भी, जो लूप के दौरान किए गए कार्यों को प्रभावित करेगा (4 क्रियाएं + 1 तुलना अगर सही है, तो सिर्फ 1 तुलना)।

औसत-समय शब्द पर स्पष्टीकरण के लिए: इस छँटाई एल्गोरिथ्म को अलग-अलग सूचियों (समान लंबाई) पर अलग-अलग समय की आवश्यकता होगी, क्योंकि एल्गोरिथ्म को छोरों के माध्यम से / भीतर कम या ज्यादा चरणों की आवश्यकता हो सकती है जब तक कि सूची पूरी तरह से क्रम में न हो। मैं उन दौरों के औसत का मूल्यांकन करने के लिए एक गणितीय (गैर सांख्यिकीय तरीका) खोजने की कोशिश करता हूं।

इसके लिए मैं किसी भी आदेश की उसी संभावना की अपेक्षा करता हूं।

— सिम
स्रोत

6

आपको पहले यह परिभाषित करने की आवश्यकता है कि औसत का क्या अर्थ है। चूंकि एल्गोरिथ्म नियतात्मक है, इसलिए आपको इनपुट पर किसी प्रकार का वितरण मान लेना होगा।

— सुरेश

@ क्या आप दिखा सकते हैं कि आपने सबसे खराब स्थिति वाले समय की जटिलता की गणना कैसे की? फिर, हमें इस बात का अंदाजा हो सकता है कि आपके मामले में औसत जटिलता का क्या मतलब है।

— 0x0

मेरा मतलब है कि औसत-समय के लिए सबसे अधिक संभावना समय की जरूरत है (या दूसरे शब्दों में 'शुद्ध' गणितीय संस्करण का: सभी समय का मतलब सांख्यिकीय विश्लेषण करते हुए देखा गया)। उदाहरण के लिए एस्कॉर्ट के पास औसतन नॉग्न होता है भले ही इसका सबसे खराब मामला n ^ 2 हो।

— सिम

1

बबल सॉर्ट एवरेज केस = सबसे खराब केस टाइम जटिलता, अर्थ के मामले में, औसत केस टाइम जटिलता भी

n^{2}

$n^2$

— 0x0

3

एक अंतर है। quicksort को "एक पिवट का चयन करते समय सिक्का tosses की पसंद पर" औसत दिया जाता है, जिसका डेटा के साथ कोई लेना-देना नहीं है। जबकि आप यह अनुमान लगा रहे हैं कि आप "सभी इनपुट पर औसत" करना चाहते हैं, जो मानता है (उदाहरण के लिए) कि आप इनपुट के प्रत्येक आदेश की उसी संभाव्यता के साथ होने की उम्मीद करते हैं। यह उचित है, लेकिन इसे स्पष्ट रूप से कहा जाना चाहिए।

— सुरेश

9

लंबाई की सूची के लिए , औसत का मतलब है कि आपको सभी पर एक समान वितरण के साथ शुरुआत करनी होगी[ , .., ] के क्रमपरिवर्तन : वे सभी सूचियाँ होंगी जिन पर आपको विचार करना है। $n$ $n!$ $1$ $n$

तब आपकी औसत जटिलता द्वारा विभाजित सभी सूचियों के लिए कदम की संख्या का योग होगी। $n!$

$(x_i)_i$ $nd$ $d$ $x_i$ $i$ $\max_i(\max(1,i-x_i))$

फिर आप गणित करते हैं: प्रत्येक लिए इस विशेष अधिकतम दूरी के साथ सूचियों की संख्या पाते हैं , फिर का अपेक्षित मान : $d$ $c_d$ $d$

\frac{1}{n!} Σ_{घ = 0}^{n} घ {सी}_{घ}

$\frac1{n!}\ \sum_{d=0}^n{\ dc_d}$

और वह मूल विचार सबसे कठिन भाग के बिना है जो पा । शायद वहाँ एक सरल समाधान है। $c_d$

संपादित करें: 'अपेक्षित' जोड़ा गया

— jmad
स्रोत

यदि आप एक सामान्य वितरण पर विचार करते हैं, तो क्या लगभग अनुमानित है ?

c_{d}

$c_d$

— सिम

आप कह सकते हैंक्योंकि आप [ , .., ] के सभी क्रमों को कहीं भी मसल सकते हैं और अंत में जोड़ सकते हैं , लेकिन औसत में small साबित करने के लिए यह छोटा है ।

c_{d} \geq (n + 1 - d) (d - 1)!

$c_d≥(n+1-d)(d-1)!$

2

$2$

d

$d$

1

$1$

n ²

$n²$

— जम्द

19

याद रखें कि एक जोड़ी (resp। ) यदि और तो उल्टा है । $(A[i], A[j])$ $(i,j)$ $i < j$ $A[i] > A[j]$

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

एक समान यादृच्छिक क्रमचय में व्युत्क्रमों की अपेक्षित संख्या की गणना करना आसान है:

चलो एक क्रमचय हो, और के विपरीत हो । उदाहरण के लिए, यदि तो । $P$ $R(P)$ $P$ $P = 2,1,3,4$ $R(P) = 4,3,1,2$

सूचकांकों के प्रत्येक जोड़े के लिए या से किसी एक में उलटा है । $(i,j)$ $P$ $R(P)$

चूंकि जोड़े की कुल संख्या , और कुल संख्या और प्रत्येक जोड़ी क्रमपरिवर्तन के बिल्कुल आधे में उलटी है, सभी क्रमपरिवर्तन समान रूप से होने की संभावना है, व्युत्क्रमों की अपेक्षित संख्या है: $n(n-1)/2$

\frac{n (n - 1)}{4}

$\frac{n(n-1)}{4}$

— जो
स्रोत

यह व्युत्क्रमों की मात्रा का मूल्यांकन करता है। लेकिन ब्रेक-क्लॉज के समय की तुलना पर निर्भर करता है कि तुलना की मात्रा के बारे में क्या है

— सिम

आप स्वैप द्वारा एक तुलना प्राप्त करते हैं और सबसे महत्वपूर्ण बात यह है कि एक स्वैप अधिकतम एक पर आक्रमणों की संख्या को कम कर सकता है।

— जम्द

हर तुलना एक स्वैप में नहीं होती है, अगर क्लॉज झूठा है, तो कोई उलटा नहीं किया जाता है।

— सिम

@rgrig यदि आप एक प्रति-उदाहरण प्रदान करते हैं, तो मैं अपना उत्तर सही करूंगा।

— जो

@ जो: मैंने अपनी टिप्पणी हटा दी। यह गलत था।

— रिगिग

2

स्वैप की संख्या <पुनरावृत्तियों की संख्या (दोनों अनुकूलित और साथ ही सरल बबल केस परिदृश्य में)

व्युत्क्रम संख्या = स्वैप की संख्या।

इसलिए, Iterations की संख्या> $\frac{n(n-1)}{4}$

इस प्रकार, औसत स्थिति जटिलता । लेकिन, चूंकि औसत केस सबसे खराब स्थिति से अधिक होता है, इसलिए हम यह पाते हैं कि यह , $\omega(n^2)$ $O(n^2)$

यह हमें देता है: औसत समय = $\theta(n^2)$

(समय जटिलता = पुनरावृत्तियों की संख्या नं। स्वैप की संख्या)

— kushj
स्रोत

0

इस दस्तावेज़ में, बुलबुला प्रकार की औसत समय जटिलता O (nlog (n)) तक पहुँच गई! http://algo.inria.fr/flajolet/Publications/ViFl90.pdf

— user84630
स्रोत

1

n^{2} / 2

$n^2/2$