छोटे विंडो आकारों पर, n log n
छँटाई काम कर सकती है। क्या इसे प्राप्त करने के लिए कोई बेहतर एल्गोरिदम है?
छोटे विंडो आकारों पर, n log n
छँटाई काम कर सकती है। क्या इसे प्राप्त करने के लिए कोई बेहतर एल्गोरिदम है?
जवाबों:
यहां एक संभव एल्गोरिथ्म का वर्णन करने वाला एक लेख है। स्रोत कोड में शामिल है और एक काफी गंभीर अनुप्रयोग (लेजर इंटरफेरोमेट्री पर आधारित गुरुत्वाकर्षण तरंग का पता लगाना) है, इसलिए आप इसे अच्छी तरह से जांचने की उम्मीद कर सकते हैं।
यदि आप एक सन्निकटन को सहन करने के लिए तैयार हैं, तो अन्य विधियाँ हैं। उदाहरण के लिए, एक सन्निकटन एक मान है जिसका रैंक सच्चे माध्यिका से कुछ (उपयोगकर्ता द्वारा निर्दिष्ट) दूरी के भीतर है। उदाहरण के लिए, मंझला (सामान्यीकृत) रैंक 0.5 है, और यदि आप 10% की त्रुटि अवधि निर्दिष्ट करते हैं, तो आप एक जवाब चाहते हैं, जिसमें 0.45 और 0.55 के बीच रैंक है।
यदि ऐसा उत्तर उचित है, तो कई समाधान हैं जो डेटा की खिड़कियों को स्लाइड करने पर काम कर सकते हैं। मूल विचार एक निश्चित आकार (लगभग 1 / त्रुटि शब्द) के डेटा का एक नमूना बनाए रखने और इस नमूने पर माध्य की गणना करना है। यह दिखाया जा सकता है कि उच्च संभावना के साथ, इनपुट की प्रकृति पर ध्यान दिए बिना, परिणामी माध्यक मेरे द्वारा उल्लिखित गुणों को संतुष्ट करता है।
इस प्रकार, मुख्य सवाल यह है कि एक निश्चित आकार के डेटा के चल रहे नमूने को कैसे बनाए रखा जाए, और इसके लिए कई दृष्टिकोण हैं, जिसमें जलाशय के नमूने के रूप में ज्ञात तकनीक भी शामिल है। उदाहरण के लिए, यह पत्र: http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.24.7136
यदि आप डेटा की लंबाई-के विंडो को एक क्रमबद्ध रूप से दोगुनी लिंक की गई सूची के रूप में बनाए रखते हैं, तो एक द्विआधारी खोज के माध्यम से (प्रत्येक नए तत्व को सम्मिलित करने के लिए जैसा कि यह विंडो में स्थानांतरित हो जाता है) और पॉइंटर्स का एक गोलाकार सरणी (तुरंत तत्वों का पता लगाने के लिए) हटाए जाने की आवश्यकता है), खिड़की की प्रत्येक पारी में एक तत्व डालने के लिए ओ (लॉग (के)) प्रयास की आवश्यकता होती है, खिड़की से बाहर स्थानांतरित तत्व को हटाने के लिए केवल ओ (1) प्रयास, और खोजने के लिए केवल ओ (1) प्रयास। माध्यिका (क्योंकि हर बार जब कोई तत्व सूची में डाला जाता है या हटाया जाता है, तो आप ओ (1 वर्ष) के समय के मध्य में एक सूचक को अपडेट कर सकते हैं)। लंबाई N की एक सरणी के प्रसंस्करण के लिए कुल प्रयास इसलिए O ((nk) log (k)) <= O (n log (k)) है। यह अब तक प्रस्तावित किसी भी अन्य तरीकों से बेहतर है और यह एक अनुमान नहीं है, यह सटीक है।
जैसा कि आपने बताया कि छंटाई O(n·log n)
लंबाई की एक खिड़की के लिए होगी n
। इस गति को l=vectorlength
करने से कुल लागत में एक और इजाफा होता है O(l·n·log n)
।
इसे धकेलने का सबसे सरल तरीका स्मृति में अंतिम n तत्वों की एक क्रमबद्ध सूची को रखते हुए है, जब एक खिड़की से अगले एक तक चलती है। आदेश सूची में से एक तत्व को हटाने / सम्मिलित करने के रूप में O(n)
यह दोनों लागतों का परिणाम होगा O(l·n)
।
स्यूडोकोड:
l = length(input)
aidvector = sort(input(1:n))
output(i) = aid(n/2)
for i = n+1:l
remove input(i-n) from aidvector
sort aid(n) into aidvector
output(i) = aid(n/2)
वर्तमान माध्यिका खोजने के लिए यहाँ एक समाधान O (1) है, और एक नया नंबर जोड़ने के लिए O (log n) http://www.dsalgo.com/RunningMedian.php
यदि आप सच्चे मंझले के बजाय एक अनुमान के साथ रह सकते हैं, तो रेमेडियन एल्गोरिथ्म (पीडीएफ) कम भंडारण आवश्यकताओं और अच्छी तरह से परिभाषित सटीकता के साथ एक-पास है।
बेस बी के साथ रेमेडियन बी अवलोकनों के समूहों के मध्यस्थों की गणना करके आगे बढ़ता है, और तब इन मध्यस्थों का ध्यान रखता है, जब तक कि केवल एक अनुमान नहीं रहता है। इस विधि को केवल आकार बी (जहां n = b ^ k) के k सरणियों की आवश्यकता है ...
मैं एक एम्बेडेड अनुप्रयोग में इस RunStats C ++ लाइब्रेरी का उपयोग करता था। यह सबसे सरल चलने वाली आँकड़े लाइब्रेरी है जिसे मैंने अभी तक पाया है।
लिंक से:
कोड डेटा के माध्यम से एक पास में मानक विचलन की गणना के लिए नूथ और वेलफ़ोर्ड की विधि का विस्तार है। यह तिरछापन और कुर्तोसिस और साथ ही समान इंटरफ़ेस के साथ गणना करता है। डेटा के माध्यम से केवल एक पास की आवश्यकता के अलावा, एल्गोरिदम संख्यात्मक रूप से स्थिर और सटीक है।