nested loop

nested loop (tsz. nested loops)

1. (informatika) beágyazott ciklus

A beágyazott ciklusok (nested loops) egy fontos programozási technika a C++ nyelvben, amely lehetővé teszi, hogy egy cikluson belül egy másik ciklust futtassunk. Ez különösen hasznos lehet például kétdimenziós tömbök bejárásánál, kombinációk generálásánál vagy bonyolultabb algoritmusok megvalósításánál.

A beágyazott ciklus egy olyan ciklus, amely egy másik ciklus belsejében található. Működése úgy történik, hogy a belső ciklus minden egyes iterációja teljesen végrehajtódik a külső ciklus egy adott iterációján belül.

Például:

#include <iostream>

int main() {
    for (int i = 0; i < 3; i++) {  // Külső ciklus
        for (int j = 0; j < 2; j++) {  // Belső ciklus
            std::cout << "i: " << i << ", j: " << j << std::endl;
        }
    }
    return 0;
}

1. A külső ciklus (for (int i = 0; i < 3; i++)):
   • Háromszor fut le (i = 0, 1, 2).
2. A belső ciklus (for (int j = 0; j < 2; j++)):
   • Minden i értékhez kétszer fut le (j = 0, 1).

Kimenet:

i: 0, j: 0
i: 0, j: 1
i: 1, j: 0
i: 1, j: 1
i: 2, j: 0
i: 2, j: 1

A beágyazott ciklusokat különböző típusú ciklusokkal lehet kombinálni:

A for ciklusok beágyazása a leggyakoribb megoldás:

for (int i = 0; i < 5; i++) {
    for (int j = 0; j < 3; j++) {
        std::cout << "(" << i << ", " << j << ") ";
    }
    std::cout << std::endl;
}

Kimenet:

(0, 0) (0, 1) (0, 2)
(1, 0) (1, 1) (1, 2)
(2, 0) (2, 1) (2, 2)
(3, 0) (3, 1) (3, 2)
(4, 0) (4, 1) (4, 2)

Nemcsak for ciklusokat lehet beágyazni, hanem while ciklusokat is:

int i = 0;
while (i < 3) {
    int j = 0;
    while (j < 2) {
        std::cout << "i: " << i << ", j: " << j << std::endl;
        j++;
    }
    i++;
}

Ez akkor hasznos, ha legalább egyszer szeretnénk végrehajtani a ciklus magját:

int i = 0;
do {
    int j = 0;
    do {
        std::cout << "i: " << i << ", j: " << j << std::endl;
        j++;
    } while (j < 2);
    i++;
} while (i < 3);

Egy klasszikus példa a beágyazott ciklusokra a szorzótábla kiíratása:

#include <iostream>

int main() {
    for (int i = 1; i <= 10; i++) {
        for (int j = 1; j <= 10; j++) {
            std::cout << i * j << "\t";
        }
        std::cout << std::endl;
    }
    return 0;
}

Kimenet:

1  2  3  4  5  6  7  8  9  10
2  4  6  8 10 12 14 16 18  20
...
10 20 30 40 50 60 70 80 90 100

Ez a program egy háromszög alakú mintázatot ír ki:

#include <iostream>

int main() {
    int sorok = 5;

    for (int i = 1; i <= sorok; i++) {
        for (int j = 1; j <= i; j++) {
            std::cout << "* ";
        }
        std::cout << std::endl;
    }
    return 0;
}

Kimenet:

* 
* * 
* * * 
* * * * 
* * * * * 

A beágyazott ciklusok komoly teljesítményproblémákat okozhatnak, ha nem megfelelően használjuk őket. Például:

• Egy két szintű ciklus O(n²) időbeli komplexitást eredményez.
• Egy három szintű ciklus O(n³) időbeli komplexitással bír.
• Egy négy vagy több szintű ciklus szinte biztosan rossz megoldás, hacsak nem teljesen szükséges.

Ha nagy adatmennyiséggel dolgozunk, érdemes megvizsgálni az optimalizálási lehetőségeket, például: - Ciklusok csökkentése: Ha lehet, kerüljük a felesleges belső ciklusokat. - Hatékony adatszerkezetek használata: Például egy előre kiszámított tömb vagy hashmap használata. - Rekurzió alkalmazása: Bizonyos esetekben a rekurzió jobb lehet, mint a mélyen beágyazott ciklusok.

A beágyazott ciklusok nélkülözhetetlenek a programozásban, különösen akkor, ha mátrixokat, kombinációkat vagy bonyolult mintázatokat kell kezelnünk. Ugyanakkor ügyelni kell arra, hogy ne használjunk túl sok beágyazott ciklust, mivel ezek gyorsan rombolhatják a teljesítményt.

Ha egy algoritmusban több ciklus is szükséges, akkor mindig próbáljuk minimalizálni az iterációk számát és hatékonyabb megoldásokat keresni.

• nested loop - Szótár.net (en-hu)
• nested loop - Sztaki (en-hu)
• nested loop - Merriam–Webster
• nested loop - Cambridge
• nested loop - WordNet
• nested loop - Яндекс (en-ru)
• nested loop - Google (en-hu)
• nested loop - Wikidata
• nested loop - Wikipédia (angol)