रीवर्सन में लूप के लिए जावा कैसे चालू करें? [बंद] - जावा, loops

मेरे पास लूप के लिए तीन हैं, और मैं उन्हें चालू करना चाहता हूंरिकर्सिव विधि में क्योंकि मैं इसे किसी भी लूप के लिए करना चाहता हूं। मैंने ऑनलाइन खोज की, लेकिन मुझे लगता है कि मुझे बिल्कुल वही चीज़ नहीं है, उदाहरण के लिए यह लड़का लूप के लिए रिकर्सन बदल जाता है लूप के लिए एक रिकर्सिव फ़ंक्शन को चालू करना? कोड:

    int x = 3;
for (int i = 0; i < x; i++) {
for (int j = 0; j < x; j++) {
for (int k = 0; k < x; k++){
list.add(array[i] + array[j] + array[k]);
}
}
}

उत्तर:

जवाब के लिए 2 № 1

ए के बारे में सोचो for लूप एक छोटे से अज्ञात समारोह के रूप में लेता हैएक पैरामीटर के रूप में लूप सूचकांक मान। लूप के अगले पुनरावृत्ति को शुरू करने के लिए, फ़ंक्शन लूप इंडेक्स पैरामीटर के लिए एक नए मान के साथ स्वयं को कॉल कर सकता है।

इस कदर:

Object loop(int i, Object data) {
if (i > 0) {
return loop(i - 1, evolve(data));
} else {
return data;
}
}

यह वही है:

for ( ; i > 0; i--) {
data = evolve(data);
}

कुछ भाषाओं में, विशेष रूप से योजना, और जो जावा 8 या 9 को जानता है, संकलक को एक रिकर्सिव फ़ंक्शन जैसे फ़ंक्शन को संकलित करने की गारंटी है loop जैसा कि यह संकलित करता है उतना ही ऊपर for ऊपर लूप

वर्तमान और सहित अन्य भाषाओं मेंजावा के पिछले संस्करण, लगभग सभी कंपाइलर्स एक निष्पादन योग्य बना देंगे जो एक बड़ा कॉल स्टैक बनाता है। जब कॉल स्टैक बड़ा होता है तो यह अनुमति आकार को ओवरफ़्लो भी कर सकता है और प्रोग्राम को क्रैश कर सकता है।


जवाब के लिए 2 № 2

Haters एक तरफ, चलो यह करते हैं! [1]

दिया हुआ:

int x = 3;
for (int i = 0; i < x; i++) {
for (int j = 0; j < x; j++) {
for (int k = 0; k < x; k++){
list.add(array[i] + array[j] + array[k]);
}
}
}

चलो उस पर विचार करें प्रत्येक पाश क्या यह स्वयं का रिकर्सिव फ़ंक्शन है - जैसा कि यह बनाता हैपुनरावृत्ति के मामले बहुत आसान है! यह एकमात्र "गैर-सोच" विधि है जिसे मैं लूप को रिकर्सन में बदलने के बारे में जानता हूं। रिकर्सिव गहराई तक ही सीमित होगी 3*x => i+j+k तो यह एक छोटे से के लिए "काफी सुरक्षित" है[2] x

जावा में इस ढांचे को एन्कोड करने के लिए प्रत्येक लूप के लिए एक अलग विधि की आवश्यकता होती है। (उच्च-आदेश कार्यों वाली भाषा में इन तीन कार्यों को संक्षेप में संयुक्त किया जा सकता है .. लेकिन जावा में नहीं [7]।)

void loopI(int i) {
if (i < x) {
loopJ(0);   // "start j loop"
loopI(i++); // "next i loop" / recurrence case
}
// "end loop" / base case
}

void loopJ(int j) {
if (j < x) {
loopK(0);
loopJ(j++);
}
}

void loopK(int k) {
if (k < x) {
list.add(array[i] + array[j] + array[k]);
loopK(k++);
}
}

// do it!
loopI(0);

ये सभी सकता है एक एकल पुनरावर्ती समारोह में संयुक्त हो, लेकिनजो पुनरावृत्ति मामलों को "सोच" और अतिरिक्त सशर्त (या सामान्य अभिव्यक्तियों, शायद) के रूप में थोड़ा कठिन बनाने के लिए राज्य को आगे बढ़ाने की आवश्यकता है।

यहां एक उदाहरण है संयुक्त रिकर्सिव फ़ंक्शन (यह गलत है जब x 0 है)। ऊपर तीन विधि दृष्टिकोण के विपरीत, ढेर गहराई बढ़ेगी x^3 => i*j*k। इस आसानी से जावा की रिकर्सन सीमा को मार देगा - यहां तक ​​कि छोटे मूल्यों के लिए भी x- जावा के रूप में [7] नहीं करता है "टी है पूंछ कॉल अनुकूलन

void loop(int i, int j, int k) {
list.add(array[i] + array[j] + array[k]);

// advance states
k++;
if (k == x) { k = 0; j++; }
if (j == x) { j = 0; i++; }
if (i == x) { i = 0; }

// terminate on all wrap-around
if (i == 0 && j == 0 && k == 0) { return; }

// recurse
loop(i, j, k);
}

[1] वाईएमएमवी, केवल सैद्धांतिक उद्देश्यों के लिए - मुझे रिकर्सन पसंद है, लेकिन यह इसके लिए उपयुक्त नहीं है ये मामला जावा में

[2] "छोटे" के कुछ मूल्य के लिए। देखें कि आपका ढेर कितना गहरा हो सकता है!


संबंधित सवाल
सबसे लोकप्रिय