Algoritm iterativ

Această intrare sau secțiune despre programare nu citează sursele necesare sau cei prezenți sunt insuficienți . Puteți îmbunătăți această intrare adăugând citări din surse de încredere în conformitate cu liniile directoare privind utilizarea surselor .

Un algoritm iterativ este un tip de algoritm constând dintr-o secvență de acțiuni care se repetă, până când repetarea însăși (un ciclu) este necesară. Toate operațiile care necesită repetarea aceleiași acțiuni de mai multe ori, dar într-un număr finit se numesc proceduri iterative. La fiecare iterație , interpretul execută o sarcină. La final, verificați dacă această sarcină trebuie repetată prin intermediul unei condiții de repetare .

Exemplu de linie de asamblare

Pentru a explica mai bine conceptul de algoritm iterativ, luați în considerare munca unui lucrător de linie de asamblare : el trebuie să efectueze aceleași acțiuni în mod repetat până când există piese de asamblat. Algoritmul iterativ al liniei de asamblare poate fi descris după cum urmează:

 1. Ridicați componentele
2. Asamblați componentele
3. Treceți componentele colegului
4. Dacă există alte componente de asamblat, reveniți la pasul 1

Utilizarea iterațiilor în limbaje de programare

Pentru a face mai ușoară implementarea procedurilor iterative în limbaje de programare la nivel înalt, există două construcții de bază: for și while . Primul se pretează ciclurilor enumerative (adică acelea în care numărul de iterații este predeterminat sau depinde de o valoare numerică calculată înainte de iterație), în timp ce al doilea permite aplicarea gratuită a condiției de iterație.

În acest sens, trebuie făcute câteva distincții sintactice importante între limbajele familiei C (cu adăugarea Java ) și limbajul Visual Basic . Ne ocupăm separat de sintaxa constructelor menționate mai sus în cele două cazuri

Familia C

În ceea ce privește constructul pentru, sintaxa este următoarea:

 for (declarație inițială; condiție de iterație; instrucțiune de sfârșit de buclă) {
    [instrucțiuni de iterație]
}

sau

 for (declarație inițială; condiție de iterație; instrucțiune de sfârșit de buclă) [instrucțiune de iterație];

în funcție de faptul dacă o iterație are una sau mai multe instrucțiuni. Funcționarea este după cum urmează:

1. Instrucțiunea inițială este executată
2. Blocul iterativ este executat
3. Instrucțiunea de sfârșit de ciclu este executată
4. Dacă condiția de iterație este adevărată , bucla se repetă, apoi revine la verificarea condiției
5. Dacă condiția de iterație este falsă, bucla este închisă

Definiția de mai sus vă permite să utilizați o buclă for cu orice tip de condiție. Cu toate acestea, acest ciclu este potrivit pentru algoritmi enumerativi. De exemplu, următorul cod C ++ scrie pe ecran, element cu element, elementele unui tablou :

 for (i = 0; i <count (arr); i ++) cout «arr [i]« endl;

În ceea ce privește construcția while, aceasta specifică doar condiția de iterație, lăsând celelalte două operații în sarcina codului. Există o variantă, do ... while . Să examinăm sintaxa:

 while (condiție) {
    [instrucțiuni]
}
afirmație while (condiție);

face {
   [instrucțiuni]
} while (condiție);
do [statement] while (condition);

Diferența dintre construcții este la fel de simplă, pe atât de substanțială:

• În timp ce verifică condiția: dacă este adevărată, execută bucla până când condiția devine falsă
• Faceți ... În timp ce efectuează prima iterație și apoi se comportă ca cea precedentă

Do ... While este, prin urmare, deosebit de potrivit atunci când este vorba de structuri de date din care datele care trebuie verificate trebuie mai întâi extrase printr-un apel funcțional.

De exemplu, presupunând că avem o clasă de tip Stack MyStack , care conține obiecte de tip MyObj , vrem să scriem conținutul obiectelor pe ecran până când găsim un anumit element terminator, cu condiția ca stiva să nu fie niciodată goală (de exemplu, constructorul inițializează stiva cu terminatorul și pop-ul nu o șterge oricum). Următorul cod necesită bucla do ... while

 char TERMINATOR = '\ 0';
MyStack Stk;
MyObj Obj;
șir Objstr
face {
   Obj = Stk.pop ();
   Objstr = Obj.content ();
   cout «Objstr« endl;
} while (Objstr! = TERMINATOR);

În limbajele C este posibil să se controleze secvența dinamică a buclelor iterative prin intermediul a două instrucțiuni care pot sări la următoarea iterație sau să întrerupă bucla cu totul. Aceste instrucțiuni sunt continue și se rup . De exemplu, următorul cod prezintă primele 5 fișiere executabile ale unui director, stocate ca o matrice de șiruri . În exemplu, nu sunt luate în considerare mai multe extensii (de exemplu .exe.bak )

 k = 0;
for (i = 0; 0 <count (dir); i ++) {
    if (! strpos (". exe", dir [i])) continue;
    if (k == 5) pauză;
    cout «dir [i]« endl;
    k ++;
}

Visual Basic

În limbajul Visual Basic , cu o referire specială la versiunea .NET , este posibil să creați bucle iterative într-un mod foarte simplu datorită construcțiilor For ... Next și Do ... Loop .

Bucla For VB este destinată strict buclelor de enumerare. Dacă în C parametrii pentru sunt liberi, în VB bucla trebuie să fie numerică. Iată sintaxa specifică (<> indicați opționalitatea):

 Pentru [contor] = [valoare inițială] La [valoare finală] <Pas [salt]>
    [instrucțiuni]
Următorul

Variabila contorului trebuie să fie numerică, valorile inițiale și finale pot fi și funcții care returnează un număr întreg. Pasul este o valoare opțională care indică cantitatea de creștere / scădere, care în mod implicit este 1 (sau -1). Executorul recunoaște dinamic, în timpul rulării , dacă bucla ar trebui să fie incrementală sau descrescătoare prin compararea valorilor de început și de sfârșit.

În mod similar cu limbajele C, este posibil să utilizați un Do ... Loop în patru versiuni diferite

 În timp ce [condiție] Do
    [instrucțiuni]
Buclă

Do
    [instrucțiuni]
În timp ce [condiție]

Celelalte două sunt obținute prin înlocuirea While cu termenul Până

• Prima sintaxă verifică dacă condiția este adevărată înainte de a continua
• Al doilea efectuează prima iterație și apoi verifică dacă condiția este adevărată
• Al treilea și al patrulea, în mod similar cu cele precedente, continuă numai dacă condiția este falsă

Iterări în limbaje de asamblare

În limbajele de asamblare tradiționale nu există construcții iterative, deoarece primitivele disponibile la nivel de mașină nu le prevăd; iterațiile sunt de fapt reprezentate prin instrucțiuni explicite pentru a trece la o instrucțiune anterioară. Pentru a crea o buclă for cu instrucțiuni de asamblare, pornim de la exemplul liniei de asamblare și creăm codul structurându-l după cum urmează:

1. Punctul de pornire al ciclului ( START ) și prima instrucțiune după ciclu ( END ) sunt etichetate
2. Orice instrucțiuni de pre-iterație merg înainte de eticheta START
3. Declarațiile de pauză corespund unui salt necondiționat (JMP) la END
4. Afirmațiile continue corespund unui salt necondiționat (JMP) la START
5. Condiția de iterație este implementată pe START , implementând un algoritm de comparație astfel încât, dacă condiția este falsă, aceasta sare imediat la END
6. Este implementat întregul algoritm de iterație
7. Faceți un salt necondiționat la START

Elemente conexe

• Algoritm recursiv

Portal IT : accesați intrările Wikipedia care se ocupă cu IT