Обнинский институт атомной энергетики

Национальный исследовательский ядерный университет «МИФИ»

Кафедра Компьютерных систем, сетей и технологий

Лабораторная работа №1

Динамическая структура данных типа «Стек»

Выполнил: студент

Группы ВТ2-С10

Сергеев А.Н.

Проверил:

Тельнов В.П.

Обнинск, 2012

Постановка задачи. Разработайте в MS Visual Studio программное решение на языке Си, которое реализует динамическую структуру данных (контейнер) типа «Стек». Каждый элемент контейнера содержит строки символов произвольной длины.

В программном решении следует реализовать следующие операции над контейнером:

· создание и уничтожение контейнера;

· добавление и извлечение элементов контейнера;

· обход всех элементов контейнера (итератор);

· удаление из контейнера дублирующих элементов;

· вычисление количества элементов в контейнере;

· реверс контейнера (первый элемент контейнера становится последним, второй

элемент становится предпоследним и т.д.);

· объединение, пересечение и вычитание контейнеров;

· сохранение контейнера в дисковом файле и восстановление контейнера из файла.

Рисунок, изображающий структуру данных:

Стек — структура данных, в которой доступ к элементам организован по принципу LIFO (last in — first out, «последним пришёл — первым вышел»). Добавление элемента, называемое также проталкиванием (push), возможно только в вершину стека (добавленный элемент становится первым сверху). Удаление элемента, называемое также выталкиванием (pop), тоже возможно только из вершины стека, при этом второй сверху элемент становится верхним.

Стеки широко применяются в вычислительной технике. Например, для отслеживания точек возврата из подпрограмм используется стек вызовов, который является неотъемлемой частью архитектуры большинства современных процессоров. Языки программирования высокого уровня также используют стек вызовов для передачи параметров при вызове процедур.

Достоинства стека:

· размер структуры ограничивается только размером памяти машины;

· при изменении логической последовательности элементов структуры требуется не перемещение данных в памяти, а только коррекция указателей.

Однако существуют и недостатки:

· работа с указателями требует, как правило, более высокой квалификации от программиста;

· на поля связок расходуется дополнительная память;

· доступ к элементам может быть менее эффективным по времени.

· нельзя напрямую обратиться к элементу, не лежащему на вершине стека

В данной лабораторной работе над структурой данных типа «Стек» можно выполнить следующие операции:

1. Начальное формирование стека.

2. Добавление элемента в стек.

3. Выборка из стека.

4. Итератор (проход всех элементов стека)

5. Удаление из стека дублирующих элементов.

6. Реверс стека.

7. Объединение стеков.

8. Пересечение стеков.

9. Вычитание стеков.

10. Сохранение стека в дисковый файл.

11. Считывание стека из дискового файла.

12. Удаление стека.

13. Подсчёт количества элементов в стеке.

Сам элемент динамической структуры представляет собой структуру с тремя полями: данные, указатель на следующий элемент, номер элемента (последнее поле необязательно, но в данном случае оно необходимо для реализации итератора (см. далее)):

//элемент стека

struct Node

{

char* Data; //данные

struct Node* Next; //указатель на след. эл-т

int sp; //номер элемента стека

};

Описание каждого из вышеприведённых алгоритмов:

1. Начальное формирование стека: struct Node* First(struct Node** top, char* data);

Выделяется память под новый элемент стека, после чего полю Data присваивается введённая строка data, а полю Next – значение нуль, т.к. элемент стека на данный момент первый и перед ним ничего нет. Указатель на вершину top меняется на указатель на данный элемент, т.е. первый элемент на данный момент является вершиной стека; нумеруем элемент как нулевой.

2. Добавление элемента в стек: void Push(struct Node** top, char* data);

Выделяется память под новый элемент, в него записывается введённая строка, указателю на следующий элемент присваивается значение указателя на вершину, данный элемент теперь является вершиной стека; элемент нумеруется.

3. Выборка из стека: char* Pop(struct Node** top);

Выделяем дополнительную память, в которую запишем данные, которые хранит элемент, лежащий на вершине; выделяем ещё одну доп. память, которой присваиваем элемент, лежащий на вершине. Адрес вершины меняем на адрес следующего элемента и освобождаем память, которую занимает данный элемент.

4. Итератор: char* Iter(struct Node** top, int num);

Выделяем дополнительную память, которая будет являться копией нашего стека. После чего поочерёдно вынимаем элементы до тех пор, пока значение num не совпадёт с номером искомого элемента.

5. Удаление из стека дублирующих элементов: void DelSimilar(struct Node** top);

Выделяем память под дополнительный стек, в котором будет храниться первоначальный стек, но уже без дублирующих элементов. Первым элементом дополнительного стека будет элемент, лежащий на вершине первоначального стека. После чего начинаем вынимать элементы из первоначального стека и сравнивать их с элементами, лежащими в дополнительном стеке. Если среди них попадаются равные, то эти элементы в стек не добавляются. Если же похожих элементов нет, то на последней итерации этот элемент будет добавлен в дополнительный стек. В конце реверсируем стек (см. далее), чтобы он выглядел как первоначальный.

6. Реверс стека: void Rev(struct Node** top);

Выделяем дополнительный стек, который и будет реверсивным. Первым элементом реверсивного стека будет верхний элемент первоначального стека. Далее просто вынимаем поочерёдно элементы из исходного стека и помещаем их также поочерёдно в дополнительный стек.

7. Объединение стеков: void Union(struct Node** top1, struct Node** top2);

Выделяем память под дополнительный стек, в котором будет храниться результат. В данной функции участвуют два исходных стека top1 и top2. Первым элементом дополнительного стека будет элемент, лежащий на вершине первого исходного стека. Далее просто начинаем заполнять дополнительный стек элементами из обоих исходных стеков. После чего удаляем дублирующие элементы функцией удаления дублирующих элементов (см.выше).

8. Пересечение стеков: void Intersection(struct Node** top1, struct Node** top2);

Выделяем память под дополнительный стек, в котором будет храниться результат. В данной функции участвуют два исходных стека top1 и top2. Вводим флаг для проверки первого элемента результата, который изначально равен нулю. Подсчитываем количество элементов во втором стеке. Далее, вынимаем поочерёдно каждый из элементов первого стека и сравниваем их с элементами второго стека. Если попадается равный, и флаг при этом всё ещё равен нулю, то записываем элемент в результат как первый элемент и меняем значение флага. Если флаг не равен нулю, то помещаем элемент в результат функцией Push. После прохода всех элементов удаляются дублирующие элементы. Если же по проходу все элементов обоих стеков равных не обнаружилось, выдаётся соответствующее сообщение.

9. Вычитание стеков: void Substraction(struct Node** top1, struct Node** top2);

Выделяем память под дополнительный стек, в котором будет храниться результат. В данной функции участвуют два исходных стека top1 и top2. Вводим флаг для проверки первого элемента результата, который изначально равен нулю. Подсчитываем количество элементов во втором стеке. Далее начинаем поочерёдно вынимать каждый из элементов первого стека и сравнивать их с элементами второго стека. Если попадаются равные, то эти элементы в результат не записываем. Если похожих элементов нет, и флаг при этом остаётся равным нулю, то на последней итерации добавляем этот элемент в результат в качестве первого элемента, меняя при этом флаг. Если же флаг не был равным нулю, то добавляем этот элемент в результат функцией Push. Если все элементы были одинаковыми, то результат вычитания должен быть равным нулю, в этом случае выводится соответствующее сообщение.

10. Сохранение стека в дисковый файл: void Write(FILE *fout, struct Node** top);

Открываем файл. После чего с помощью функции Pop поочерёдно вынимаем элементы из стека и записываем в файл.

11. Считывание стека из дискового файла: void Read(FILE *fin, struct Node** top);

Открываем файл. Выделяем память под строку, в которую будем записывать каждый элемент стека. Если при считывании первой строки не был достигнут конец файла, то эту строку записываем как первый элемент стека. После чего выписываем остальные элементы, пока не будет достигнут конец файла, не забывая при это выделять память под дополнительную строку.

12. Удаление стека: void Delete(struct Node** top);

Здесь всё просто – вынимаем элементы из стека функцией Pop, память освобождается автоматически при вызове этой функции.

13. Подсчёт количества элементов в стеке: int Num(Node** top);

Вводим счётчик элементов. Выделяем дополнительную память, которая будет являться копией исходного стека. Пока указатель на вершину не будет равен нулю, инкрементируем счётчик.

Руководство пользователя:

Прежде, чем приступить к запуску программы, нужно обратить внимание на несколько важных нюансов:

1. Для работы с файлами требуется создать два файла на диске C с расширением .txt, которые будут называться input и output. То есть, адреса этих файлов должны выглядеть так: C:\\input.txt и C:\\output.txt. В output вы, при вызове функции void Write(FILE *fout, struct Node** top), будете записывать стек, который вы предварительно должны создать и заполнить уже по ходу работы программы. Из input вы будете, используя функцию void Read(FILE *fin, struct Node** top) считывать стек, каждый элемент которого должен быть записан в отдельной строке файла, т.е. сначала в этот файл нужно записать данные, например:

(1-я строка) abc

(2-я строка) bcd

и так далее.

2. Программа выделяет память только под два стека. То есть вы не можете работать с тремя и более стеками, так как выделение память под стеки происходит независимо от вас.

После того, как вы убедитесь в том, что эти нюансы учтены, можете запускать программу. После запуска на экране появляется меню программы и предложение выбрать режим работы (Choose the mode of work: ). Обратите внимание на меню – здесь вы видите пронумерованные операции, которые можно проделать со стеком (Operations what you can do with stack:):

Operations what you can do with stack:

1. Create the stack by pushing the first element.

2. Push the element to the stack.

3. Pop the element from the top of stack.

4. Show the element of stack with number... (write the number of element).

5. Delete from the stack duplicate elements.

6. Reverse the stack.

7. Unite two stacks.

8. Intersect two stacks.

9. Substract from the stack A a stack B.

10. Save the stack into file.

11. Read the stack from file.

12. Delete the stack.

13. Calculate the number of elements.

14. Quit the program.

Соответственно:

1. Создать стек посредством добавления первого элемента.

2. Добавить элемент в стек.

3. Достать элемент из стека.

4. Показать элемент стека под номером… (напишите номер элемента)

5. Удалить из стека дублирующие элементы.

6. Реверсировать стек.

7. Объединить два стека.

8. Пересечь два стека.

9. Вычесть из стека А стек В.

10. Сохранить стек в файл.

11. Считать стек из файла.

12. Удалить стек.

13. Подсчитать количество элементов.

14. Выйти из программы.

После того, как вы выберите нужную вам операцию, введите её номер в командной строке и нажмите Enter. Теперь вам будет предложено выбрать стек, с которым вы хотите продолжить работу (первый или второй). Заметим, что этого не произойдёт, если вы выберите операцию под номером 14, так как эта операция завершит работу программы. После того, как вы выберите стек, введите в командную строку его номер (1 или 2) и нажмите Enter. Кроме цифр 1 или 2 больше ничего вводить нельзя! Если ваш стек ещё не заполнен, но вы хотите начать его заполнять, то обязательно воспользуйтесь командой под номером 1. Если вы начнёте заполнять стек командой 2 без использования команды 1, то в дальнейшем обработка такого стека приведёт к ошибке программы. После выбора стека на экране высветится сообщение, соответствующее действию команды (например, команда 1 выдаст следующее сообщение: «Write the value of first element: », что означает «Напишите значение первого элемента: »). Теперь вам остаётся только записать в командную строку значение (например, abc) и нажать Enter. Программа возвратит вас в меню. Далее вы можете продолжать операции со стеками по вышеупомянутой схеме. Если вы хотите выйти из программы, то во вновь появившемся меню введите 14.

Структурная схема программы:

Листинг авторского кода на языке Си:

#include "stdio.h"

#include "string.h"

#include "stdlib.h"

//элемент стека

struct Node

{

char* Data; //данные

struct Node* Next; //указатель на след. эл-т

int sp; //номер элемента стека (для удобства)

};

//меню программы

void menu(void)

{

printf(

"\n"

"*****************************************\n"

"Operations what you can do with stack:\n"

"1. Create the stack by pushing the first element.\n"

"2. Push the element to the stack.\n"

"3. Pop the element from the top of stack.\n"

"4. Show the element of stack with number... (write the number of element).\n"

"5. Delete from the stack duplicate elements.\n"

"6. Reverse the stack.\n"

"7. Unite two stacks.\n"

"8. Intersect two stacks.\n"

"9. Substract from the stack A a stack B.\n"

"10. Save the stack into file.\n"

"11. Read the stack from file.\n"

"12. Delete the stack.\n"

"13. Calculate the number of elements.\n"

"14. Quit the program.\n\n"

);

}

//инициализация стека

void Init(struct Node** top)

{

*top = (struct Node*)malloc(sizeof(struct Node));

(*top)->sp = NULL;

(*top)->Data = NULL;

(*top)->Next = NULL;

}

//начальное формирование стека

struct Node* First(struct Node** top, char* data)

{

struct Node* t = (struct Node*)malloc(sizeof(struct Node));

t->Data = data;

t->Next = 0; //т.к. эл-т первый, то перед ним ничего нет

*top = t;

(*top)->sp = 0; //даём элементу номер 0

return t;

}

//функция помещения элемента в стек

void Push(struct Node** top, char* data)

{

struct Node* t = (struct Node*)malloc(sizeof(struct Node)); //выделяем память под новый эл-т

t->Data = data; //записываем в поле Data введённую строку

t->Next = *top; //указываем на след. эл-т

*top = t; //меняем указатель вершины на данный эл-т, который теперь сам становится вершиной

(*top)->sp = (((*top)->Next)->sp) + 1; //нумеруем элемент

}

//итератор

char* Iter(struct Node** top, int num)

{

struct Node** temp = (struct Node**)malloc(sizeof(struct Node));

*temp = (*top);

while((*temp)!=NULL)

{

if((*temp)->sp == num)

return((*temp)->Data);

*temp = (*temp)->Next;

}

return("There is no such element");

}

//функция выборки из стека

char* Pop(struct Node** top)

{

char* temp = (char*)malloc(sizeof(char*));

temp = (*top)->Data; //записываем в temp строку, которая лежит на вершине стека

struct Node* t = *top; //t теперь есть элемент, лежащий на вершине

*top = (*top)->Next; //меняем адрес вершины на адрес следующего эл-та стека

free(t);

return temp;

}

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

void Rev(struct Node** top)

{

struct Node* ExtraSt = (struct Node*)malloc(sizeof(struct Node)); //выделяем память под доп. стек, который будет реверсным

struct Node** extop = (struct Node**)malloc(sizeof(struct Node));

ExtraSt = First(*(&extop), Pop(*(&top)));

while((*top)!=0)

Push(&ExtraSt, Pop(*(&top)));

while(ExtraSt!=0)

printf("%s\n", Pop(&ExtraSt));

}

//подсчёт количества элементов в стеке

int Num(Node** top)

{

int count = 0;

struct Node** temp = (struct Node**)malloc(sizeof(struct Node));

*temp = (*top);

while ((*temp)!=0)

{

count++;

*temp = (*temp)->Next;

}

return count;

}

//удаление из стека дублирующихся эл-тов

void DelSimilar(struct Node** top)

{

int k=1; //кол-во эл-тов в будущем доп. стеке

struct Node* Extra = (struct Node*)malloc(sizeof(struct Node)); //объявляем доп. стек, в котором

struct Node** extop = (struct Node**)malloc(sizeof(struct Node));//будет храниться первоначальный,

Extra = First(*(&extop), Pop(*(&top))); //но без дублирующих эл-тов

while((*top)!=0)

{

char* s = Pop(*(&top)); //вынимаем строку с вершины

for(int i=0; i<k; ++i) //сравниваем s с каждым эл-том доп, стека

{

if(strcmp(s, Iter(&Extra, i)) == 0) //если они равны, то этот эл-т в стек не добавляем

break;

else if(i == (k-1)) //если похожих эл-тов нет, то на последней итерации добавляем его в стек

{

k++;

Push(&Extra, s);

break;

}

}

}

Rev(&Extra);//для эстетики реверсируем

}

//пересечение стеков

void Intersection(struct Node** top1, struct Node** top2)

{

struct Node* Extra = (struct Node*)malloc(sizeof(struct Node)); //здесь будет храниться результат

struct Node** extop = (struct Node**)malloc(sizeof(struct Node));

Init(&Extra);

int k = Num(*(&top2)); //кол-во эл-тов во втором стеке

int f = 0; //флаг для проверки первого эл-та результата

while((*top1)!=0)

{

char* fs = Pop(*(&top1));

for(int i=0; i<k; ++i)

{

if(strcmp(fs, Iter(*(&top2), i)) == 0 && f == 0) //если флаг =0, то эл-т первый

{

First(&Extra, fs); //кладём в результат первый эл-т

f++; //меняем значение флага

break;

}

else if(strcmp(fs, Iter(*(&top2), i)) == 0 && f != 0)

{

Push(&Extra, fs);

break;

}

}

}

if(Extra->Data == 0)

{

printf("Result of intersection equals zero\n");

return;

}

DelSimilar(&Extra); //удаляем повторяющиеся эл-ты из результата

}

//объединение стеков

void Union(struct Node** top1, struct Node** top2)

{

struct Node* Extra = (struct Node*)malloc(sizeof(struct Node)); //здесь будет храниться результат

struct Node** extop = (struct Node**)malloc(sizeof(struct Node));

Extra = First(*(&extop), Pop(*(&top1))); //начинаем просто заполнять стек результата

while((*top1)!=0) //эл-тами из обоих стеков

Push(&Extra, Pop(*(&top1)));

while((*top2)!=0)

Push(&Extra, Pop(*(&top2)));

DelSimilar(&Extra); //удаляем дублирующиеся эл-ты

}

//вычитание стеков

void Substraction(struct Node** top1, struct Node** top2)

{

struct Node* Extra = (struct Node*)malloc(sizeof(struct Node)); //здесь будет храниться результат

struct Node** extop = (struct Node**)malloc(sizeof(struct Node));

Init(&Extra);

int k = Num(*(&top2)); //кол-во эл-тов во втором стеке

int f = 0; //флаг для проверки первого эл-та результата

while((*top1)!=0)

{

char* fs = Pop(*(&top1));

for(int i=0; i<k; ++i)

{

if(strcmp(fs, Iter(*(&top2), i)) == 0)

break;

else if(i == (k-1) && f == 0)

{

First(&Extra, fs);

f++;

break;

}

else if(i == (k-1) && f != 0)

{

Push(&Extra, fs);

break;

}

}

}

if(Extra->Data == 0)

{

printf("Substraction equals zero\n");

return;

}

Rev(&Extra);

}

//удаление стека

void Delete(struct Node** top)

{

while((*top)!=0)

Pop((*&top));//просто вынимаем все элементы, память освобождается в функции Pop

}

//сохранение стека в файл

void Write(FILE *fout, struct Node** top)

{

if((fout = fopen("c:\\output.txt", "wt")) == 0)

{

printf("File opening error!\n");

return;

}

while((*top)!=0)

fprintf(fout, "%s\n", Pop(*(&top)));

}

//восстановление стека из файла

void Read(FILE *fin, struct Node** top)

{

if((fin = fopen("c:\\input.txt", "rt")) == 0)

{

printf("File opening error!\n");

return;

}

char* s = (char*)malloc(sizeof(char*));

if(!feof(fin))

{

fscanf(fin, "%s", s);//выписываем первый элемент

First(*(&top), s);

}

while(!feof(fin))

{

char* s = (char*)malloc(sizeof(char*));

fscanf(fin, "%s", s);//выписываем следующие элементы

Push(*(&top), s);

}

}

int main()

{

FILE *fin, *fout;

menu();

int c;

struct Node* Stack1;

struct Node* Stack2;

Init(&Stack1);

Init(&Stack2);

while(true)

{

printf("Choose the mode of work: ");

scanf("%d", &c);

switch(c)

{

case 1:

{

int i;

printf("\nWhat stack would you like to fill? (write 1 or 2) ");

scanf("%d", &i);

switch(i)

{

case 1:

{

char temp[81];

printf("\nWrite the value of first element: ");

scanf("%s", &temp);

First(&Stack1, temp);

menu();

break;

}

case 2:

{

char temp[81];

printf("\nWrite the value of first element: ");

scanf("%s", &temp);

First(&Stack2, temp);

menu();

break;

}

}

}

case 2:

{

int i;

printf("\nWhat stack would you like to fill? (write 1 or 2) ");

scanf("%d", &i);

switch(i)

{

case 1:

{

char temp[81];

printf("\nWrite the value of first element: ");

scanf("%s", &temp);

Push(&Stack1, temp);

menu();

break;

}

case 2:

{

char temp[81];

printf("\nWrite the value of first element: ");

scanf("%s", &temp);

Push(&Stack2, temp);

menu();

break;

}

}

}

case 3:

{

int i;

printf("\nFrom which stack would you like to pop? (write 1 or 2) ");

scanf("%d", &i);

switch(i)

{

case 1:

{

if(!Stack1)

{

printf("\nFill the stack!\n\n");

menu();

break;

}

printf("%s\n",Pop(&Stack1));

menu();

break;

}

case 2:

{

if(!Stack2)

{

printf("\nFill the stack!\n\n");

menu();

break;

}

printf("%s\n",Pop(&Stack2));

menu();

break;

}

}

case 4:

{

int d;

printf("\nWhich stack would you like ti use? (write 1 or 2) ");

scanf("%d", &d);

switch(d)

{

case 1:

{

if(!Stack1)

{

printf("\nFill the stack!\n\n");

menu();

break;

}

int i;

printf("\nWrite the number of element: ");

scanf("%d", &i);

printf("\nElement is %s", Iter(&Stack1, i));

menu();

break;

}

case 2:

{

if(!Stack2)

{

printf("\nFill the stack!\n\n");

menu();

break;

}

int i;

printf("\nWrite the number of element: ");

scanf("%d", &i);

printf("\nElement is %s", Iter(&Stack2, i));

menu();

break;

}

}

}

case 5:

{

int i;

printf("\nFrom which stack would you like to delete similar elements? (write 1 or 2) ");

scanf("%d", &i);

switch(i)

{

case 1:

{

if(!Stack1)

{

printf("\nFill the stack!\n\n");

menu();

break;

}

printf("\n");

DelSimilar(&Stack1);

menu();

break;

}

case 2:

{

if(!Stack2)

{

printf("\nFill the stack!\n\n");

menu();

break;

}

printf("\n");

DelSimilar(&Stack2);

menu();

break;

}

}

}

case 6:

{

int i;

printf("\nWhich stack would you like to reverse? (write 1 or 2)");

scanf("%d", &i);

switch(i)

{

case 1:

{

if(!Stack1)

{

printf("\nFill the stack!\n\n");

menu();

break;

}

Rev(&Stack1);

menu();

break;

}

case 2:

{

if(!Stack2)

{

printf("\nFill the stack!\n\n");

menu();

break;

}

Rev(&Stack2);

menu();

break;

}

}

}

case 7:

{

printf("\n");

Union(&Stack1, &Stack2);

menu();

break;

}

case 8:

{

printf("\n");

Intersection(&Stack1, &Stack2);

menu();

break;

}

case 9:

{

printf("\n");

Substraction(&Stack1, &Stack2);

menu();

break;

}

case 10:

{

int i;

printf("\nWhich stack would you like to write? (write 1 or 2) ");

scanf("%d", &i);

switch(i)

{

case 1:

{

if(!Stack1)

{

printf("\nFill the stack!\n\n");

menu();

break;

}

Write(fout, &Stack1);

menu();

break;

}

case 2:

{

if(!Stack2)

{

printf("\nFill the stack!\n\n");

menu();

break;

}

Write(fout, &Stack2);

menu();

break;

}

}

}

case 11:

{

int i;

printf("\nIn which stack would you like to read the data? (write 1 or 2) ");

scanf("%d", &i);

switch(i)

{

case 1:

{

Read(fin, &Stack1);

menu();

break;

}

case 2:

{

Read(fin, &Stack2);

menu();

break;

}

}

}

case 12:

{

int i;

printf("\nWhich stack would you like to delete? (write 1 or 2) ");

scanf("%d", &i);

switch(i)

{

case 1:

{

if(!Stack1)

{

printf("\nStack is already empty!");

menu();

break;

}

Delete(&Stack1);

menu();

break;

}

case 2:

{

if(!Stack2)

{

printf("\nStack is already empty!");

menu();

break;

}

Delete(&Stack2);

menu();

break;

}

}

}

case 13:

{

int i;

printf("\nWhere would you like to calculate the number of elements? (write 1 or 2)");

scanf("%d", &i);

switch(i)

{

case 1:

{

if(!Stack1)

{

printf("\nNothing to calculate because stack is empty!\n");

menu();

break;

}

printf("%d\n", Num(&Stack1));

menu();

break;

}

case 2:

{

if(!Stack2)

{

printf("\nNothing to calculate because stack is empty!\n");

menu();

break;

}

printf("%d\n", Num(&Stack2));

menu();

break;

}

}

}

case 14: return 0;

}

}

}

}