6

मान लीजिए कि हमारे पास एन तत्वों का बाइनरी ढेर है और अन्य तत्वों को शामिल करना चाहते हैं (जरूरी नहीं कि एक के बाद एक)। इसके लिए कुल समय क्या होगा?एक तत्व बाइनरी ढेर में एन तत्वों को सम्मिलित करने की असीमित समय जटिलता पहले से ही एन तत्व

मुझे लगता है कि यह theta (n logn) है क्योंकि एक प्रविष्टि लॉगऑन लेती है।

+0

जैसा लगता है कि मौजूदा ढेर का आकार किसी भी तरह परिणाम में प्रवेश करना चाहिए। –

उत्तर

3

मान लिया जाये कि हम दिए गए हैं:

  • प्राथमिकता कतार मानक द्विआधारी ढेर एच द्वारा कार्यान्वित (कार्यान्वित सरणी)
  • n ढेर

की वर्तमान आकार पर हम निम्नलिखित है प्रविष्टि गुण:

  • डब्ल्यू (एन) = worstcase (एन) = Θ (एलजी एन) (थीटा)। -> डब्ल्यू (एन) = Ω (एलजी एन) और डब्ल्यू (एन) = ओ (एलजी एन)
  • ए (एन) = औसत कैस (एन) = Θ (एलजी एन) (थेटा)। -> डब्ल्यू (एन) = Ω (एलजी एन) और डब्ल्यू (एन) = ओ (एलजी एन)
  • बी (एन) = बेस्टकेस (एन) = Θ (1) (थेटा)। -> डब्ल्यू (एन) = Ω (1) और डब्ल्यू (एन) = हे (1)
हर मामले, हम के लिए

तो

  • टी (एन) = Ω (1) और टी (एन) = ओ (एलजी एन)

वर्स्टकेस तब होता है जब हम नए न्यूनतम मूल्य डालते हैं, इसलिए अप-ढेर को पूरी शाखा यात्रा करना पड़ता है।

बेस्टकेस तब होता है जब न्यूनतम-ढेर (शीर्ष पर न्यूनतम के साथ ढेर) हम बिग (अद्यतन शाखा पर सबसे बड़ी) मूल्य डालते हैं (इसलिए अप-हीप तुरंत बंद हो जाता है)।

आप पहले से ही n तत्वों से युक्त ढेर पर n संचालन की श्रृंखला के बारे में पूछा है, यह आकार बढ़ेगा है

from n to 2*n 

क्या asymptotically है ...

n=Θ(n) 
2*n=Θ(n) 

क्या हमारे समीकरण सरल करता है। (हमें एन के विकास के बारे में चिंता करने की ज़रूरत नहीं है, क्योंकि इसकी वृद्धि लगातार कारक है)।

तो, हम आपरेशन के "n सम्मिलन के लिए" है:

  • क्सी (एन) = X_for_n_insertions (एन)
    • वाई (एन) = Θ (एन एलजी एन)
    • ऐ (एन) = Θ (एन एलजी एन)
    • बीआई (एन) = Θ (एन)
  • इसका अर्थ है, "सभी मामले" के लिए:
    • ती (एन) = Ω (एन) और ती (एन) = O (n एलजी n)

पी.एस. थेटा Θ, ओमेगा Ω प्रतीकों को प्रदर्शित करने के लिए, आपको यूटीएफ -8 स्थापित/संगत होना चाहिए।

0

अपने theeta (nlogn) नहीं ... अपने आदेश (nlogn) सम्मिलन से कुछ के बाद से कम तो सटीक logn समय लग सकता है ... इसलिए n सम्मिलन के लिए लगेगा समय < = nlogn

= > समय जटिलता = ओ (nlogn)

5

दिया गया: एन तत्वों का ढेर और एन तत्वों को सम्मिलित किया जाना चाहिए। तो अंत में 2 * एन तत्व होंगे। चूंकि ढेर 2 तरीकों से बनाया जा सकता है 1. लगातार सम्मिलन और 2. ढेर विधि बनाएं। Amoung इन बिल्ड ढेर विधि को हेप बनाने के लिए ओ (एन) समय लगता है जिसे How can building a heap be O(n) time complexity? में समझाया गया है। तो कुल समय आवश्यक ओ (2 * एन) है जो ओ (एन)

संबंधित मुद्दे