Reja: kirish: I. Bob. Takrorlanuvchi jarayonlani tashkil etish

Ichma-ich joylashgan siklik algoritmga doir blok-sxema
Rekurrent algoritmlar. Hisoblash jarayonida ba’zi bir algoritmlarning o‘ziga qayta murojaat qilishga to‘g‘ri keladi. O‘ziga–o‘zi murojaat qiladigan algoritmlarga rekkurent algoritmlar yoki rekursiya deb ataladi.
Bunday algoritmga misol sifatida Fibonachchi sonlarini keltirish mumkin. Ma’lumki, Fibonachchi sonlari quyidagicha aniqlangan.
a0qa1q1, aiqai-1+ai-2 iq2,3,4,…. Bu rekkurent ifoda algoritmiga mos keluvchi blok-sxema 2.15-rasmda keltirilgan. Eslatib o‘tamiz formuladagi i-indeksga hojat yo‘q, agar Fibonachchi sonining nomerini ham aniqlash zarur bo‘lsa, birorta parametr-kalit kiritish kerak bo‘ladi.


Fibonachchi sonlarining n- hadini hisoblash algoritmi.

Massivlarni qayta ishlashda siklik algoritmlardan foydalanish
C++ tilida siklik algoritmlarni amalga oshirishni ko'rib chiqing, unda tsikl operatorlarining uch turi mavjud:
– sikl operatori;
– while old sharti bilan sikl operatori;
do ... while postshartli sikl operatori.
Barcha tsikl bayonotlari quyidagi komponentlarni o'z ichiga olishi shart:
- boshlang'ich qiymatlarni belgilash (insializatsiya);
– tsiklni davom ettirish sharti;
- tsikl tanasi;
– sikl parametrini o‘zgartirish (hisoblagich).
For iborasi odatda takrorlar soni oldindan aniqlanganda yoki siklning bajarilishini davom ettirish sharti qisqa ifodada yozilganda ishlatiladi. Berilgan sonli hadlar yig‘indisini hisoblash, sonlar ketma-ketligining minimal (maksimal) elementini topish, massiv elementlarini o‘sish (kamayish) tartibida tartiblash va hokazolar bu operatordan foydalanishga misol bo‘la oladi. [7]
Operator sintaksisi quyidagicha:
uchun (; ; )
{
;
}
Ushbu bayonotning konstruktsiyasi qavs ichida joylashtirilgan va bir-biridan nuqta-vergul (;) va ko'p marta takrorlanishi mumkin bo'lgan buyruqlar (sikl tanasi) bilan ajratilgan uchta asosiy blokdan iborat. Loop operatorining bajarilishining boshida, bir marta, ishga tushirish blokida, tsiklni boshqaradigan o'zgaruvchilarning boshlang'ich qiymatlari o'rnatiladi. Keyin shart tekshiriladi va agar u to'g'ri bo'lsa, u holda boshqaruv tsikl tanasining bajarilishiga o'tadi. O'zgartirish bloki sikl parametrlarini o'zgartiradi va agar shart rost bo'lsa, tsiklning bajarilishi davom etadi. Agar shart bajarilmasa (nolga teng yoki noto'g'ri), u holda sikl uziladi va boshqaruv for operatoridan keyingi operatorga o'tkaziladi. Eng muhimi, shartni tekshirish tsiklning boshida amalga oshiriladi. Bu shuni anglatadiki, agar shart dastlab noto'g'ri bo'lsa, tsiklning tanasi bir marta ham bajarilmasligi mumkin.
Yig'indini hisoblashning oddiy misoli for bayonotidan foydalanishni ko'rsatadi:
int s = 0;
for(int i=1;i<=10;i++)
s+=i;
Ushbu tsikl bayonotini quyidagicha o'qilishi mumkin: "s + = i buyrug'ini 10 marta bajaring (1 dan 10 gacha bo'lgan i qiymatlari uchun, har bir iteratsiyada i 1 ga ortadi)". Ushbu misolda ikkita boshlang'ich qiymat tayinlanishi mavjud: s = 0 va i = 1, tsiklni davom ettirish sharti: (i <= 10) va parametr o'zgarishi: i ++. Loopning tanasi s + = i buyrug'idir.
Kompyuterning ushbu tsiklni bajarish tartibi quyidagicha:
1) boshlang'ich qiymatlar tayinlanadi (s = 0, i = 1);
2) shart tekshiriladi (i <= 10);
3) agar shart rost (to'g'ri) bo'lsa, tsikl tanasining buyrug'i (yoki buyruqlari) bajariladi: oldingi takrorlashda olingan yig'indiga yangi raqam qo'shiladi;
4) sikl parametri 1 ga oshiriladi.
Keyin biz 2-bandga qaytamiz. Agar 2-banddagi shart bajarilmasa (noto'g'ri), tsikl chiqadi. [5]
Operatorda u yoki bu blok yo'q bo'lganda mumkin bo'lgan konstruktsiyalar mavjud: agar dastlabki qiymat oldindan o'rnatilgan bo'lsa, ishga tushirish bo'lmasligi mumkin; shart - agar shart har doim to'g'ri deb faraz qilinsa, ya'ni tsikl tanasi uzluksiz ravishda break operatori duch kelmaguncha bajarilishi kerak; va o'zgartirishlar - agar parametr o'sishi tsikl tanasida amalga oshirilsa. Bunday hollarda blok ifodasining o'zi qoldiriladi, lekin nuqta-vergul (;) qoldirish kerak.
Shuni ta'kidlash kerakki, for operatori tsikl tanasini to'g'ridan-to'g'ri uning parametrlarida yozishga imkon beradi. Masalan, raqamlar yig'indisini quyidagicha hisoblash mumkin:
for(int s=0, i=1; i<=10; s+=i++)
Ushbu misolda tsikl tanasi yo'q va ishga tushirish blokida ikkita bayonot mavjud bo'lib, ular "vergul" operatsiyasi bilan ajratiladi va s va i o'zgaruvchilarning boshlang'ich qiymatlarini o'rnatadi.
Keling, for sikl operatoridan foydalanishning oddiy misollarini ko'rib chiqaylik. [6]
1) 1 dan 10 gacha raqamlarni kvadratlari bilan ko'rsatish:
for(int i=1;i<11;i++)
cout << i <<" " << i * i;
Loop i = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 qiymatlari bilan bajariladi. Shundan so‘ng i 11 qiymatini qabul qilaman va shart (11<11) bajarilmaydi. bajariladi (noto'g'ri) - tsikl chiqadi.
2) 1 dan 100 gacha musbat toq sonlarni kvadratlari bilan chiqarish. Loop avvalgisiga o'xshash tarzda yoziladi, lekin parametr 2 ga oshadi, ya'ni tsikl i = 1, 3, 5, 7, ..., 97, 99 qiymatlari uchun bajariladi.
for(int i=1; i<100; i+=2)
cout << i <<" " << i * i;
3) faktorial hisoblash F = n! (esda tuting, faktorial n formulasi bilan hisoblanadi! = 1 * 2 * 3 * ... * (n-2) * (n-1) * n, masalan: 4! = 1 * 2 * 3 * 4 = 24) . Mana, amalda o'xshash bo'lgan for bayonotini yozishning uchta shakli:
1) int F = 1, n = 5,
for(int i = 1; i <= n; i++)
F*=i;
2) int F, i, n = 5,
uchun(F=1, i=1; i<=n; F*=i++)
3) int F = 1, i = 1, n = 5,
for(; i <= n;)
F*=i++;
Loopning keyingi iteratsiyasini erta boshlash uchun siz keyingi iteratsiya davomiga o'tish operatoridan foydalanishingiz mumkin, masalan:
uchun(i=0;i<20;i++)
{
agar (massiv [i] == 0) davom etsa;
massiv [i] = 1 / massiv [i];
}
Loopdan erta chiqish uchun break (qurilishdan chiqish) yoki qaytish (joriy funktsiyadan chiqish) iboralari qo'llaniladi. [19]
For iborasidan ba'zi foydalanishlar bir nechta tsikl parametrlaridan foydalanishga ruxsat berish orqali uning moslashuvchanligini oshiradi.
Masalan:
int top, bot;
charstring[100], temp;
uchun (top = 0, bot = 98; tepa {
temp = string [yuqori];
string[yuqori] = string[bot];
string[bot] = temp;
}
Ushbu misolda, belgilar qatorini teskari tartibda yozishni amalga oshirish uchun tsikl parametrlari ikkita o'zgaruvchidan iborat yuqori va bot, ularning qiymatlari bir-biriga qarab harakatlanadi. E'tibor bering, for operatorining ishga tushirish blokida ikkita o'zgaruvchining boshlang'ich qiymatlari vergul bilan ajratilgan. Shartli ifodadan keyin bu o'zgaruvchilarning o'zgartirishlari ham vergul bilan ajratilgan holda yoziladi.
For iborasi uchun yana bir qiziqarli foydalanish holati cheksiz tsikldir. Bunday siklni tashkil qilish uchun bo'sh shartli ifoda yozish mumkin, sikldan chiqish uchun esa if ko'rsatmasi break operatori bilan birga ishlatiladi. [20]
Masalan:
uchun ( ; ; )
{
agar () sindirish;
}
Looplar bir-birining ichiga joylashtirilishi mumkin. Ichki halqalardan foydalanilganda dasturni shunday tuzish kerakki, ichki halqa tashqi halqa tanasiga to'liq mos tushadi, ya'ni ilmoqlar kesishmasligi kerak. O'z navbatida, ichki pastadir o'z ichiga o'rnatilgan halqalarni o'z ichiga olishi mumkin. Tashqi va ichki pastadirlarning parametr nomlari boshqacha bo'lishi kerak. Quyidagi tuzilmalarga ruxsat beriladi:
tuman (k = 1; k <= 10; k++)
{
tuman (i = 1; i <= 10; i++)
{
tuman (t = 1; t <= 10; t++)
{
...
}
}
}
Masalan, "yulduzchalar" uchburchagini ko'rsatish uchun o'rnatilgan halqalardan foydalaniladi:
*
**
***
****
Bitta qatorni ko'rsatish uchun alohida halqa hosil qilish kerak va bir nechta shunday qatorlarni ko'rsatish uchun birinchi halqani keyingi qatorga o'tishni tashkil etadigan tsiklga joylashtirish kerak. Birinchi qatorda faqat bitta "yulduzcha", ikkinchisida - ikkita, uchinchisida - uchta va hokazo bo'lishi kerak. Ya'ni, i raqami bo'lgan qator i "yulduzcha" dan iborat bo'lishi kerak, shuning uchun ichki tsikl i marta bajariladi. [18]
int i, j, m;
cout << "Qatorlar sonini kiriting m:";
cin >> m;
uchun(i=1;i<=m;i++)
{
uchun (j = 1; j <= i; j++) cout << "*";
cout << endl;
}
Old shartli va keyingi shartli operatorlar sikllarni tashkil qilish uchun ishlatiladi va for bayonotiga muqobildir. Odatda, agar takrorlashlar soni oldindan ma'lum bo'lmasa va tsikl tanasining bir necha marta takrorlanishi uchun shart ma'lum bo'lsa, shartli halqa qo'llaniladi, bu haqiqat ostida tsikl bajarilishini davom ettiradi. Bu holat har safar keyingi iteratsiyadan oldin tekshirilishi kerak. Masalan, fayldan ma'lumotlarni o'qishda sikl sharti ma'lumotlarning to'g'ridan-to'g'ri faylda mavjudligi hisoblanadi, ya'ni ma'lumotlarni o'qish ko'rsatgich faylning oxiriga ishora qilguncha takrorlanishi kerak.
Old shartli sikl sintaksisi quyidagicha:
esa ()
{

};
Ko'rsatmalar ketma-ketligi (sikl tanasi) shart rost bo'lganda bajariladi va shart noto'g'ri bo'lganda tsikl chiqadi. Agar tsiklga kirishda shart noto'g'ri bo'lsa, u holda operatorlar ketma-ketligi hech qachon bajarilmaydi va boshqaruv keyingi dastur operatoriga o'tadi.
Keyingi iteratsiyadan keyin har safar shartning haqiqatini tekshirish zarurati tug'ilsa, keyingi shartli sikl ishlatiladi. Yuqorida ta'kidlab o'tilganidek, oldingi shartli sikl va keyingi shartli sikl o'rtasidagi farq birinchi iteratsiyada yotadi: shartdan qat'iy nazar, keyingi shart tsikli har doim kamida bir marta bajariladi. [17]
Postshartli sikl sintaksisi quyidagicha:
qil
{

}
while();
Ko'rsatmalar ketma-ketligi (loop tanasi) shart noto'g'ri bo'lgunga qadar bir yoki bir necha marta bajariladi. Do ... while sikl operatori hech bo‘lmaganda bir marta sikl tanasini bajarish zarurati tug‘ilganda qo‘llaniladi, chunki shart ko‘rsatmalar bajarilgandan so‘ng tekshiriladi.
Agar tsiklning tanasi bitta gapdan iborat bo'lsa, u holda {} bayon qavslari ixtiyoriy.
while va do ... while operatorlari tsikl tanasi ichida break va return operatorlarini bajarishda muddatidan oldin tugashi mumkin.
10 dan 100 gacha bo'lgan barcha toq sonlar yig'indisini hisoblash misolidan foydalanib, turli xil tsikl operatorlari ishidagi farqni ko'rib chiqing:
1) for bayonotidan foydalanish:
int i, s = 0;
uchun(i=11;i<100;i+=2)
s+=i;
2) while iborasidan foydalanish:
int s = 0, i = 11;
while(i<100)
{
s+=i;
i+=2;
}
3) do ... while iborasidan foydalanish:
int s = 0, i = 11;
qil
{
s+=i;
i+=2;
}
while(i<100);