2010-05-06 6 views
10

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

संपादित करें: मेरा वर्तमान समाधान एक ही लंबाई के बुलियन वेक्टर का उपयोग करना है जो सेट में हो सकता है, और सदस्यता तालिका के रूप में उपयोग कर रहा है।

+1

है वहाँ किसी भी मौका है कि आप सटीक कोड प्रदान है? आपके प्रश्न से मैं यह नहीं समझ सकता कि क्या आप सूची या वैक्टर का उपयोग कर रहे हैं, आप कैसे जोड़ते हैं या हटाते हैं (क्या फ़ंक्शन?) तत्व, आपका वर्तमान समाधान कैसे काम करता है (लॉजिकल वेक्टर को दोबारा शुरू करना/मूल में निकालना है?)? आपके द्वारा प्रदान की जाने वाली अधिक जानकारी, अधिक अनुकूलन किया जा सकता है। – Marek

+0

आर का नया संस्करण इस पर बेहतर होना चाहिए। क्या यह सच है? – userJT

+0

मुझे संदेह है कि वेक्टर को बार-बार बदलना क्योंकि तत्वों को जोड़ा या हटा दिया गया है, कभी भी तेज़ होगा। –

उत्तर

12

The R Inferno के अध्याय 2 इस पर कुछ दिलचस्प टिप्पणी, perdiodic बढ़ रही वस्तुओं फिर से शामिल है तुलना स्मृति विखंडन और आवंटन ओवरहेड duce।

यदि आप जानते हैं कि सेट का अंतिम आकार क्या है, तो आपके द्वारा सुझाई गई विधि शायद सबसे अच्छा है - यानी subset पूरे ब्रह्मांड से एक एप्रोपेट सदस्यता वेक्टर का उपयोग कर। यह जानने में मुश्किल है कि आप जो भी करने की कोशिश कर रहे हैं उसे देखे बिना सबसे अच्छा क्या है।

+0

+1 मैं सेट सदस्यता का प्रतिनिधित्व करने वाले बूलियन वेक्टर के साथ समाप्त हुआ। – Stedy

+0

संदर्भित करने के लिए –

+0

क्या आप लिंक अपडेट कर सकते हैं?'404 नहीं मिला' – Shreyans

11

यदि आप एक वेक्टर शुरू कर सकते हैं ताकि एल्गोरिदम के दौरान इसकी अधिकतम लंबाई के बराबर लंबाई हो।

उदा

vec <- rep(NA,10) 
vec[1:3] <- 1:3 
vec[4:5] <- 4:5 
vec[6:10] <- 6:10 

बजाय

vec <- 1:3 
vec <- c(vec,4:5) 
vec <- c(vec,6:10) 

> system.time({vec <- rep(NA,10^4); for (i in 1:(10^4)) vec[i] <- i }) 
    user system elapsed 
    0.043 0.001 0.044 

को
> system.time({vec <- NULL; for (i in 1:(10^4)) vec <- c(vec,i) }) 
    user system elapsed 
    0.249 0.089 0.335 
+0

लेकिन मैं संभवतः आखिरी न केवल वेक्टर में किसी भी आइटम को हटा सकता हूं। –

+1

निश्चित रूप से। लूप वेक्टर शुरू करने और बार-बार असाइनमेंट के साथ एक बनाने के बीच अंतर दिखाने के लिए उदाहरण हैं। मैंने स्पष्ट रूप से आपके एल्गोरिदम को नहीं देखा है, लेकिन इस विधि को अभी भी काम करना चाहिए, क्योंकि 'i' आपके एल्गोरिदम में किसी भी बिंदु पर कोई भी संख्या हो सकती है। यह केवल शुरुआत करने के लिए अपने वेक्टर की लंबाई जानने पर निर्भर करता है। इसके अलावा, इसे हटाने के बजाय आप उस तत्व को 'एनए' के ​​रूप में असाइन करेंगे और उसी लंबाई के वेक्टर को बनाए रखेंगे। – wkmor1

+0

आपको 'eval/parse' का उपयोग करने की आवश्यकता नहीं है, यह पर्याप्त है जब आप ब्रेसिज़ में अभिव्यक्ति लेते हैं, यानी: 'system.time ({vec <- rep (NA, 10^4); (i में 1 :(10^4)) vec [i] <- i}) ' – Marek

3

यह कहना मुश्किल है कि आप क्या चाहते हैं। शायद आप वास्तव में पुश और पॉप जैसे स्टैक कमांड चाहते हैं। निम्नलिखित नहीं है। लेकिन यह एक तेज समाधान है।

आपको आवश्यक प्रकार के सभी आइटम रखने के लिए पर्याप्त वेक्टर आवंटित करें। प्रत्येक मान को NA पर सेट करें। आइटम जोड़ना आसान है। आइटम को हटाने से उन्हें फिर से NA पर सेट किया जा रहा है। वेक्टर का उपयोग सिर्फ na.omit(myVec)

myVec <- numeric (maxLength) # a vector of maximum length 

is.na(myVec) <- 1:maxLength # set every item in myVec to NA 

myVec[c(2,6,20)] <- 5   # add some values 

na.omit(myVec) 

#This will also work if you can initialize all of your values to something that you know you won't need. 
+0

एन आर स्टैक: http://rosettacode.org/wiki/Stack#R –

+1

@ जॉन: 'myVec <- rep (NA, maxLength) 'आपकी पहली दो पंक्तियों को अधिक स्पष्ट रूप से बदल देता है। इसके अलावा, बड़े लेखन के साथ क्या है? –

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