Chapter 4

Стек, опашка и рекурсия

Абстрактен тип данни (АТД) е абстракция на структура от данни.

За всеки АТД се посочва:
- съхраняваните данни;
- операциите върху данните;
- състоянията на грешки, свързани с тези операции.

Стек абстрактен тип данни (АТД)

Стекът АТД съхранява обекти от произволен тип.
Операциите добавяне и изтриване следват схемата "последен влязъл - пръв излязъл" - last-in first-out (LIFO).
Основни стекови операции:
- push(object o): добавяне (вмъкване) на елемента o в началото на стека;
- pop(): изтриване (премахване, изваждане) и връщане на последния добавен елемент.
Спомагателни стекови операции:
- top(): връща псевдоним към последния добавен елемент без да го изтрива;
- size(): връща броя на елементите в стека;
- isEmpty(): връща булева стойност, показваща дали има елементи в стека (или е празен).

Пример: push(3), push(4), pop()...

Изключения

Опит за изпълнение на операция на АТД понякога може да предизвиква състояние на грешка, наречена изключение.
Казва се, че изключение е "изхвърлено" (thrown) от операция, която не може да бъде изпълнена.
Стековите операции pop и top не могат да бъдат изпълнени, ако стекът е празен.
Опити за изпълнение на pop и top за празен стек изхвърлят изключение StackEmptyException.
html-4.9 (Stack)
html-4.10 (StackEmptyException)
Достъп до елементите (избягвайки копирането): html-4.11 (Stack2)

Проста реализация, базирана на масив

Един прост начин за реализация на стек АТД е с масив S:
- променливата t съхранява индекса на първия (top) елемент на стека.

Algorithm size()
return t + 1

Algorithm pop()
    if isEmpty() then
        throw EmptyStackException
    else
        t ← t − 1
        return S[t +1]

Algorithm push(o)
    if t = S.length − 1 then
        throw FullStackException
    else
        t ← t + 1
        S[t] ← o

Масивът с елементите на стека може да се напълни.

Тогава операцията push ще изхвърли изключение FullStackException.

Това изключение е от реализацията с масив и не е присъщо на стек АТД.
Всяка функция се изпълнява на константно време O(1) - не зависи от големината на стека.

html-4.13 (ArrayStack1) ; html-4.14 (ArrayStack2)
ArrayStack.cpp; StackExcept.cpp

Опашка АТД

Опашката съхранява обекти от произволен тип.
Операциите добавяне и изтриване следват схемата "пръв влязъл - пръв излязъл" - first-in first-out (FIFO).
Добавянето е в края на опашката, а изтриването - в началото на опашката.
Основни операции за опашка:

enqueue(Object o): добавяне на елемент o в края на опашката;
dequeue(): изтриване на елемент от началото на опашката.

Спомагателни функции за опашка:

front(): връща елементът в началото на опашката, без да го изтрива;
size(): връща броя на елементите в опашката;
isEmpty(): връща булева стойност, показваща дали има елементи в опашката (или е празна).

Изключения:

Опит за изпълнение на dequeue или front за празна опашка изхвърля изключение EmptyQueueException.

Пример: enqueue(5), enqueue(3), dequeue(), ...

Приложения на опашка:

Преки приложения:

списъци с чакащи, бюрокрация;
достъп до общи (споделени) ресурси, напр. принтер;
Multiprogramming.

Непреки приложения:

допълнителни структури от данни за алгоритми;
компоненти от други структури от данни.

Проста реализация с масив

html-4.16 (Queue)

Използва се кръгов масив с размер N.
Две променливи указват началото и края на опашката:

f е индексът на първия елемент;
r е индексът веднага след последния елемент, елементът с индекс r се държи празен.

Операции на опашка АТД:

Algorithm size()
return (N − f + r) mod N

Algorithm isEmpty()
return (f = r)

Algorithm enqueue(o)
    if size() = N − 1 then
        throw FullQueueException
    else
        Q[r] ← o
        r ← (r + 1) mod N

Algorithm dequeue()
    if isEmpty() then
        throw EmptyQueueException
    else
        o ← Q[f]
        f ← (f + 1) mod N
        return o

Използва се операция модул (остатък от целочислено деление).
Операция enqueue изхвърля изключение, ако масивът е пълен. Това изключение е зависимо от реализацията.
Операция dequeue изхвърля изключение, ако опашката е празна. Това изключение е присъщо за опашка АТД.
Всяка функция се изпълнява на константно време O(1) - не зависи от големината на опашката.

Едносвързан списък

Едносвързан списък е конкретна линейна структура от данни (не е АТД!), състояща се от редица от върхове (възли, nodes).
Всеки възел се състои от:

елемент (данна) и
връзка (указател) към следващия възел.

Реализация на стек АТД с едносвързан списък

html-4.18 (Node)
html-4.19 (LinkedStack1)
html-4.20 (LinkedStack2)
html-4.21 (LinkedStack3)
LinkedStack.cpp

Реализация на опашка АТД с едносвързан списък

html-4.22 (LinkedQueue)

Опашка с два края АТД (дек)

Поддържа добавяне и изваждане на елементи от двата края.

Основните функции на дек АТД са следните:

insertFirst(o), insertLast(o)
removeFirst(), removeLast()

В дек АТД с включват и поддържащите функции:

first(), last()
size(), isEmpty()

Пример: insertFirst(3), insertFirst(5), first(), removeFirst(), insertLast(7),...

Двусвързан списък

Двусвързан списък е конкретна линейна структура от данни (не е АТД!), състояща се от редица от върхове (възли, nodes).
Всеки възел се състои от:
- елемент (данна);
- връзка (указател) към предишния възел;
- връзка (указател) към следващия възел.
Добавени са два специални възли - trailer и header. Те опростяват кода за операциите вмъкване и изтриване на възел.

Реализация на дек АТД с двусвързан списък

Поставяне и изваждане на елементи в двата края на двойно свързан списък е лесно да се извършва за време O(1).
html-4.23 (Node)
html-4.24 (LinkedDeque1)
LinkedDeque.h; LinkedDeque.cpp

Шаблон за адаптивно проектиране (Adapter Design Pattern)

Шаблонът за адаптивно проектиране настройва функции от един клас, така, че те могат да бъдат използвани за реализацията на функциите на друг клас.
html-4.25 (DequeStack)
Адаптираме класа LinkedDeque, който реализира по-мощни функции на дек АТД така, че да могат да бъдат използвани като по-простите функции на стек АТД.

Рекурсия

В този пример, ние ще разгледаме триъгълни форми, като тази, показана тук:
```
[]
[][]
[][][]
```
n-то триъгълно число е лицето на триъгълник с ширина n, като се предполага, че всеки [] е с площ 1.
От по-горе, третото триъгълно число е 6.

Ето описание на класа, който ще разработим:

class Triangle {
public:
   Triangle(int w);
   int get_area() const;
private:
   int width;
};
Triangle::Triangle(int w)
{ width = w; }

Ако ширината на триъгълника е 1, тогава триъгълникът е с лице 1.
```
[]

int Triangle::get_area()
{ if (width == 1) return 1;
   . . .
}
```
За справяне с общия случай, помислете за тази картинка.
```
[]
[][]
[][][]
[][][][]
```
Мислим си за лицето на по-големия триъгълник като
```
smaller_area + width
```

За да намерим по-малкото лице правим по-малък триъгълник!

int Triangle::get_area()
{  if (width == 1) return 1;
   Triangle smaller_triangle(width - 1);
   int smaller_area = smaller_triangle.get_area();
   return smaller_area + width;
}

Here's how the area is computed for a triangle of width 4.
- The get_area function makes a smaller triangle of width 3.
  - It calls get_area on that triangle.
    - That function makes a smaller triangle of width 2.
      - It calls get_area on that triangle.
        
        That function make a smaller triangle of width 1.
        
        It calls get_area on that triangle.
      - That function returns 1.
    - The function returns smaller_area + width = 1 + 2 = 3.
  - The function returns smaller_area + width = 3 + 3 = 6.
- The function returns smaller_area + width = 6 + 4 = 10.

Техниката на изразяване на решение на даден проблем от гледна точка на решение по-малка версия на същия проблем се нарича рекурсия.
Има две основни изисквания, за да е успешна рекурсията:
- Всяко рекурсивно извикване трябва да опрости изчисляването по някакъв начин.
- Трябва да има специален случай, при който изчисленията да се извършат директно (без рекурсивно извикване).
Тук, get_area извиква себе си отново с по-малки и по-малки стойности на ширината, достигайки в крайна сметка широчина 1.

Какво се случва, когато се извика функцията с широчина -1? Бъдете внимателни!
Рекурсията не е наистина необходимо да се реши тази задача. Това може да бъде направено с помощта на:
- един прост цикъл:
```
double area = 0;
for (int i = 1; i <= width; i++) area = area + 1;
```
- или по формулата:
```
width * (width + 1) / 2.
```

(triangle.cpp)

Ефективност на рекурсията

Въпреки че рекурсия може да бъде мощен инструмент за реализацията на сложни алгоритми, тя може да доведе до програми, които функционират лошо.
Ще анализираме въпроса кога рекурсия е от полза и когато тя е неефективна.
За нашето изследване ще разгледаме редицата на Фибоначи, определена с равенствата:
- f₁ = 1
- f₂ = 1
- f_n = f_n_-1 + f_n_-2
Първите 10 члена от редицата на Фибоначи са:

1, 1, 2, 3, 5, 8, 13, 21, 34, 55, . . .
Човек може лесно да напише рекурсивни функции за пресмятане на числата на Фибоначи.
```
int fib(int n)
{  if (n <= 2) return 1;
   else return fib(n - 1) + fib(n - 2);
}
```

Функцията работи правилно, но за средно големи стойности на n отнема невероятно много време за изчисляване на стойността.
За да се види ефекта, опитайте тестовата програма (fibtest.cpp) с n между 30 и 50.

За определяне на проблема, вмъкваме трасиращи съобщения във функцията.

int fib(int n)
{  cout << "Entering fib: n = " << n << "\n";
   int f;
   if (n <= 2) f = 1;
   else f = fib(n - 1) + fib(n - 2);
   cout << "Exiting fib: n = " << n
      << " return value = " << f << "\n";
   return f;
}

Резултатът от изпълнението на функцията показва защо изчислението отнема толкова време (fibtrace.cpp).

Entering fib: n = 6
Entering fib: n = 5
Entering fib: n = 4
Entering fib: n = 3
Entering fib: n = 2
Exiting fib: n = 2 return value = 1
Entering fib: n = 1
Exiting fib: n = 1 return value = 1
Exiting fib: n = 3 return value = 2
Entering fib: n = 2
Exiting fib: n = 2 return value = 1
Exiting fib: n = 4 return value = 3
Entering fib: n = 3
Entering fib: n = 2
Exiting fib: n = 2 return value = 1
Entering fib: n = 1
Exiting fib: n = 1 return value = 1
Exiting fib: n = 3 return value = 2
Exiting fib: n = 5 return value = 5
Entering fib: n = 4
Entering fib: n = 3
Entering fib: n = 2
Exiting fib: n = 2 return value = 1
Entering fib: n = 1
Exiting fib: n = 1 return value = 1
Exiting fib: n = 3 return value = 2
Entering fib: n = 2
Exiting fib: n = 2 return value = 1
Exiting fib: n = 4 return value = 3
Exiting fib: n = 6 return value = 8

Дървото на извикванията илюстрира как функциите се извикват една друга.
Тъй като fib(4) се извиква два пъти и fib(3) се извиква 3 пъти, функциите губят много време за ненужно изчисляване на същите стойности отново и отново.

Човек просто би написал следващата стойност като събере предишните две, които вече са изчислени и никога няма да изчислява една стойност два пъти.

За да се имитира процеса с молив и хартия, може с един цикъл да се изчислят числата на Фибоначи (fibloop.cpp).

int fib(int n)
{  if (n <= 2) return 1;
   int fold = 1;
   int fold2 = 1;
   int fnew;
   for (int i = 3; i <= n; i++)
   {  fnew = fold + fold2;
      fold2 = fold;
      fold = fnew;
   }
   return fnew;
}

Може ли винаги да се ускори рекурсивното решение, като се смени с цикъл?
Често итеративното и рекурсивно решение по същество имат същата производителност.
Пример: Да се провери дали едно изречение е палиндром - низ, който е равен на себе си, когато се обърнат всички символи. (Дума, фраза, стих или изречение, което гласи същото назад или напред.)

rotor
A man, a plan, a canal - Panama!
Go hand a salami, I'm a lasagna hog
Madam, I'm Adam

Нашата цел е да се реализира рекурсивна предикатна функция.
```
bool is_palindrome(string s)
```
Премахваме на първия и последен знак:: "rotor" става "oto". Думата е палиндром, ако
- първата и последната букви съвпадат и
- думата, получен чрез отстраняване на първата и последната буква е палиндром.
Най-простите низове за теста за палиндром са:
- низове с два знака или
- низове с един символ или
- празен низ.

Рекурсивната функция е:

bool is_palindrome (string s)
{  if (s.length() <= 1) return true;
   char first = s[0];
   char last = s[s.length() - 1];
   if (first == last)
   {   string shorter = s.substr(1, s.length() - 2);
       return is_palindrome(shorter);
   }
   else return false;
}

Едно итеративно решение за палиндром е:

bool is_palindrome(string s)
{  int start = 0;
   int end = text.length() - 1;
   while (start < end)
   {  if (s[start] != s[end] return false;
      start++;
      end--;
   }
   return true;
}

Итеративното и рекурсивното решение на проблема палиндром се реализират приблизително с една и съща скорост.
Има доста проблеми, които са драстично по-лесно решими рекурсивно, отколкото итеративно.
Често рекурсивни решения са по-лесни за разбиране и прилагане правилно, отколкото са итеративните.
"To iterate is human, to recurse divine." L. Peter Deutsch.