1. რეკურსიული პროგრამირება
Recursio ლათინურად “დაბრუნება”-ს ნიშნავს
რეკურსია წარმოადგენს მეთოდს, რომელსაც ზოგადი ამოცანა დაჰყავს უფრო მცირე ზომის, მარტივი ამოცანების ამოხსნაზე
რეკურსიული ალგორითმი მუშაობის პროცესში საკუთარ თავს მიმართავს.
რეკურსიის არსი იმაში მდგომარეობს, რომ ფუნქციის მიერ საკუთარი თავის ყოველი გამოძახებისას მეხსიერებაში იქმნება ფუნქციის ახალი ასლი შესაბამისი ლოკალური ცვლადებით, ხოლო მუშაობის დამთავრებისთანავე ეს მეხსიერება თავისუფლდება და შედეგები გადაეცემა გამოძახების წერტილს.

2. რეკურსია შეიძლება იყოს:
პირდაპირი, როცა ფუნქცია იძახებს თავის თავს.
ირიბი, როცა A ფუნქცია იძახებს B-ს, ხოლო B ფუნქცია A-ს.

3. რეკურსიის ლიტერატურულ მაგალითებად შეიძლება ჩაითვალოს “რწყილი და ჭიანჭველა”, “თხა და ვენახი”...
ორ სარკეს შორის მოთავსებული საგანი წარმოშობს რეკურსიულ გამოსახულებათა უსასრულო როდენობას.

4. ფაქტორიალის გამოთვლა რეკურსიულად
N! =
1, როცა N = 1
N * (N – 1)!, როცა N > 1
რეკურსიის დროს მნიშვნელოვანია ქვეპროგრამიდან (ფუქციიდან) გამოსვლის მომენტის მკაფიო განსაზღვრა, რათა ალგორითმი სასრული იყოს.
int factorial( int a) {
if (a == 1) return 1;
else {
a = a * factorial(a-1);
return a; }

5. ფუნქციის პირველი გამოძახება ძირითადი პროგრამიდან უნდა მოხდეს. მაგ
ფუნქციის პირველი გამოძახება ძირითადი პროგრამიდან უნდა მოხდეს. მაგ., α= fact(5)
გამოვთვალოთ 5!
1 გამოძახება (n=5)
Function fact {
fact= 5 * fact(4); }
2 გამოძახება (n=4)
fact(5) = 120
Function fact {
fact= 4* fact(3); }
5 *24
3 გამოძახება (n=3)
α= 120
Function fact {
fact= 3* fact(2); }
4 *6
4 გამოძახება (n=2)
Function fact {
fact= 2* fact(1); }
5 გამოძახება (n=1)
3 *2
Function fact {
fact= 1; }
2 *1

6. მაგალითი: ნატურალური რიცხვის გადაყვანა თვლის ათობითი სისტემიდან ორობითში.39 38 19 18 9 8 4 2 1
3910 =
rec(int n) {
if (n >1) rec(n/2);
cout<<n%2; }

7. int rec(int n) { cout<<n%2; } { cout<<n%2; } {
if (n>1) rec(n/2);
cout<<n%2; }
2 გამოძახება (n = 19)
int rec(int n) {
if (n>1) rec(n/2);
cout<<n%2; }
3 გამოძახება (n = 9)
int rec(int n) {
if (n>1) rec(n/2);
cout<<n%2; }
4 გამოძახება
(n = 4)
int rec(int n) {
if (n>1) rec(n/2);
cout<<n%2; }
5 გამოძახება (n = 2)
int rec(int n) {
if (n>1) rec(n/2);
cout<<n%2; }
6 გამოძახება (n = 1)
int rec(int n) {
cout<<n%2; }

8. ფიბონაჩის მიმდევრობა
ვიპოვოთ ფიბონაჩის მიმდევრობის საწყისი N წევრი. ცნობილია, რომ ამ მიმდევრობის პირეველი ორი წევრი 1-ის ტოლია, ხოლო ყოველი მომდევნო წევრი წინა ორი წევრის ჯამის ტოლია (1, 1, 2, 3, 5, 8, 13, 21, …).
ამოცანის რეკურსიული აღწერა:
Ф(n) =
1, თუ n = 1 ან n = 2;
Ф(n – 1) + Ф(n – 2), როცა n > 2

9. ფიბონაჩის მიმდევრობა
ეს პროგრამა ნათლად ამჟღავნებს რეკურსიის ნაკლოვან მხარეს. K>70 მნიშვნელობებისათვის პროგრამა ძალზე დიდ დროს ანდომებს. საქმე იმაშია, რომ FIB[70]-ის გამოთვლისთვის რეკურსიულმა ფუნქციამ უნდა გამოთვალოს FIB[69] და FIB[68]. მიუხედავად იმისა, რომ FIB[68] ფუნქციას უკვე გამოთვლილი ჰქონდა FIB[69]-ის გამოთვლის დროს, ის ამ მნიშვნელობას თავიდან ითვლის და ასე იქცევა მიმდევრობის ყველა სხვა წევრის მიმართაც. სწორედ ეს გახლავთ რეკურსიის ნელი მუშაობის მიზეზი – ის უამრავჯერ ითვლის ფუნქციის მნიშვნელობას ერთი და იგივე არგუმენტისათვის. მართალია, მასივის შემოღება და მიღებული შედეგების მასში შენახვა მკვეთრად გააუმჯობესებს რეკურსიის მუშაობის სიჩქარესაც.
ამ შემთხვევაში რეკურსიულ ვარიანტზე გაცილებით ეფექტურია იტერაციული ვარიანტი.
#include<iostream>
using namespace std;
int k,x;
int fibon(int n) {
if(n<=2) return 1;
return fibon(n-1)+fibon(n-2); }
main (){
cin>>k;
x=fibon(k);
cout<<x<<endl;

10. რეკურსიის ხე ფიბონაჩის მიმდევრობისათვის
35 - 8
36 - 5
37 - 3
38 - 2
39 - 1
40 - 1
ცხრილებში ნაჩვენებია გამოძახებათა რაოდენობა n=40-სათვის

11. პროგრამა, რომელიც ახდენს მთელი რიცხვის ჩანაწერის შებრუნებას
#include <iostream>
using namespace std;
int n;
int revers(int n1) {
cout<<n1%10;
if (n1/10!=0) revers(n1/10);
return 0; }
int main(){
cin>>n;
revers(n);

12. ორობითი ძებნა
ორობითი ძებნა პოულობს საძებნი ელემენტის მდებარეობას (ინდექსს) დალაგებულ მასივში (ან სიაში) ყოველ ბიჯზე საძებნი არის ორჯერ შემცირებით.
ორობითი ძებნა ახორციელებს O(log N) შედარებას.
მაგალითი: მოვძებნოთ მასივში რიცხვი 43.
index 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
value -7 -2 21 23 31 33 37 43 51 55 78 86 94
114
min
mid
max

13. ორობითი ძებნის კოდი #include <iostream> using namespace std;
int bsearch(int L[],int x, int first, int last) {
if (last >= first) {
int middle = (first + last) / 2;
if (x == L[middle]) return middle;
else if (x < L[middle]) return bsearch(L, x, first, middle-1);
else return bsearch(L, x, middle+1, last); }
return -(first + 1);
int main(){
int myList[] = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
int size, myfirst = 0, findthis;
int n = myList[size];
int mylast = n - 1;
cin >> findthis;
int result = binarySearch(myList, findthis, myfirst, mylast);