2010-09-06 19 views
6

में शिफ्ट मैं कैसे अगले तत्वसरणी अगले तत्व

eg: x[5] = { 5, 4, 3, 2, 1 }; // initial values 
    x[0] = 6; // new values to be shifted 
    x[5] = { 6, 5, 4, 3, 2 }; // shifted array, it need to be shifted, 
           // not just increment the values. 

यह मैं अब तक क्या किया है के लिए एक सरणी में तत्वों को स्थानांतरित कर सकते हैं। यह गलत है, यही कारण है कि मुझे यहां मदद की ज़रूरत है। अग्रिम में धन्यवाद।

सभी की
#include <iostream> 

using namespace std; 

int main() 
{ 
    int x[5] = { 5, 4, 3, 2, 1 }; 

    int array_size = sizeof(x)/sizeof(x[0]); 

    x[0] = 6; 

    int m = 1; 

    for(int j = 0; j < array_size; j++) { 
    x[m+j] = x[j]; 
    cout << x[j] << endl; 
    } 

    return 0; 
} 
+0

प्रारंभ सरणी के अंत सूचकांक से सरणी में इस नकल नहीं बल्कि उसके बाद शुरू आप अगले तत्व खो देंगे जब आप शुरू से ही तत्व को कॉपी शुरू क्योंकि से। तो लूप –

+0

के लिए बदलें कृपया "एक से बंद" नोट करें: x [m + j] = x [j]; इंडेक्स "array_size" के साथ तत्व को ओवरराइट करने का प्रयास करेगा जो सरणी को बहिष्कृत करता है - यह अपरिभाषित व्यवहार है। – sharptooth

उत्तर

8
#include <iostream> 

int main() { 

    int x[5] = { 5, 4, 3, 2, 1 }; 

    int array_size = sizeof (x)/sizeof (x[0]); 

    for (int j = array_size - 1; j > 0; j--) { 

     x[j] = x[j - 1]; 
    } 

    x[0] = 6; 

    for (int j = 0; j < array_size; j++) { 

     std::cout << x[j]; 
    } 

    return 0; 
} 
+0

आपको बहुत बहुत धन्यवाद। – Azam

+0

क्या यह जानबूझकर सेगमेंटेशन गलती का खतरा नहीं है? – imkendal

4

सबसे पहले, आप से पहले सरणी में पुराने मूल्यों को शिफ्ट करना चाहिए आप नया मान लिखें। लेकिन एक लूप के बजाय, आप memmove() का उपयोग करने के बेहतर हैं। या किसी भी सरणी के बजाय std::vector के साथ भी बेहतर - यह आपके लिए इन सभी निम्न-स्तरीय मुद्दों को संभालता है, जिसमें आवश्यकता होने पर स्वचालित रूप से सरणी का आकार बदलना शामिल है।

+0

+1 'memmove' –

+0

के लिए +1 लेकिन मुझे लगता है कि यह होमवर्क है, इसलिए मुझे लगता है कि लूप और इंडेक्स हेरफेर की आवश्यकता है। –

8

"दाये ले जाने के" करने के लिए आप सरणी के अंत से पुनरावृति करने के लिए है:

for(int j = array_size - 2; j >= 0; j--) { 
    x[m+j] = x[j]; 
    cout << x[j] << endl; 
} 

अन्यथा तुम सिर्फ 0 तत्व के साथ सभी तत्वों के ऊपर लिख।

कृपया array_size - 2 पर ध्यान दें - अन्यथा आपके पास "एक से एक" है जो सरणी के अंत से परे तत्व तक पहुंचने का प्रयास कर रहा है और यह अपरिभाषित व्यवहार है।

+1

+1 अच्छा पकड़, हर किसी के द्वारा याद किया गया (स्वयं सहित :-) –

+0

काम नहीं करता है। उत्पादन 2,3,4,6 – Azam

+1

@azam बन गया: मैंने केवल आपके कोड में बड़ी समस्या को इंगित किया।आपको अभी भी मान को [0] तत्व में रखना होगा और आउटपुट प्राप्त करने के लिए आपको दूसरी बार सरणी पर फिर से चलना होगा। – sharptooth

1

सामान्य मामले में जहां आपको m तत्वों को स्थानांतरित करने की आवश्यकता है (जहां 0 <= m <n): सरणी के अंत से प्रारंभ करें। यदि आप शुरुआत (इंडेक्स 0) से शुरू करते हैं तो आप ओवरराइट करते हैं और फिर उस ओवरराइड वैल्यू को ले जाते हैं।

std::memmove के स्रोत कोड का अध्ययन भी निर्देशक हो सकता है।

+0

मुझे लगता है कि यह समाधान है, और घुमाव का उपयोग करने वाले एक लूप के लिए उपयोग करने वालों की तुलना में बेहतर हैं। लाइब्रेरी दिनचर्या का उपयोग करना हमेशा अपना कोड लिखने से बेहतर होता है। –

0

आप सरणी के अंत से शुरू कर सकते हैं। आप पहले की स्थिति में अंतिम स्थिति के लिए 2 अंतिम स्थिति में

  • तत्व, 2 अंतिम स्थिति के लिए 3 अंतिम स्थिति में
  • तत्व,
  • ....
  • तत्व कॉपी (सूचकांक 0) दूसरे स्थिति और अंत में
  • पहले स्थिति में नया नंबर कॉपी करें। ।

for(j = array_size-1; j >0; j--) { 
x[j] = x[j-1]; 
} 
x[0] = 6; 
14
#include<algorithm> 

// ... 
std::rotate(x, x+4, x+5); 
x[0] = 6; 
+0

क्षमा करें। मैं अहंकार का उपयोग नहीं करना चाहता। वास्तव में एक सी ++ समाधान प्रदान करने के लिए – Azam

+5

+1। – fredoverflow

0
#include <iostream> 

    using namespace std; 

    int main() 
    { 
     int x[5] = { 5, 4, 3, 2, 1 }; 

     int array_size = sizeof(x)/sizeof(x[0]); 

     int m = 1; 

     for(int j = array_size-1; j > 0; j--) { 
      x[j] = x[j-m]; 
      cout << x[j] << endl; 
     } 

     x[0] = 6; 
     return 0; 
    } 
+0

आपका आउटपुट 2,3,4,5 है – Azam

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