If(Move(n,I,j,k,&i2,&j2) && !Board[i2][j2]){

Good=true;

break;

}

}

If(Good){

// текущую клетку и номер хода помещаем в стек

v++; stack[v].i=i; stack[v].j=j; stack[v].move=k;

// пометить клетку, как посещенную

Board[i][j]=true;

BegMove=0;

i=i2; j=j2;

// может обошли все ?

if(v==n*n-2){

// последнюю клетку - в стек

v++; stack[v].i=i2; stack[v].j=j2;

goto finish;

}

goto M; // все повторить для очередной клетки

} else { // ход не найден

// взять из стека, если он не пуст

if(v<0){ // стек пуст - задача не имеет решения

out=false;

goto finish;

}

// взять из стека

i=stack[v].i; j=stack[v].j; BegMove=stack[v].move+1; v--;

Board[i][j]=false;

goto M;

}

finish:

// освободим память

for(i=0;i<n;i++){

delete [] Board[i];

}

delete [] Board;

return out;

}

2.1.2.1. Вычисление определенного интеграла

Следующий пример иллюстрирует применение стека для реше­ния задачи, в которой часть работы выполняется по тому же алгоритму, что и вся работа. Каждое значение интеграла будем вычислять по формуле прямоугольников (хотя применяемый метод безразличен и можно было бы использовать любой).

Вычисляем два очередных приближения интеграла –

• как площадь одного прямоугольника:

- как площадь двух прямоугольников:

Если два приближения отличаются друг от друга более чем на назна­чен­ную меру погрешности eps, делим интервал интегри­рования (a,b) пополам, и левую половину сразу обра­ботаем тем же алгоритмом, а обработку правой отложим на потом – в стек. В против­ном случае , I2 – окончательный ответ. Прибавим его к уже вычисленной части результата и поинтересуемся, не осталось ли отложенной на потом работы в стеке. Если ДА, то возьмемся за ее выполнение, если НЕТ – решение получено.

Текст функции, использу­ющей ручное ведение стека для реали­зации рекурсии, приведен ниже:

#include <math.h>

#include <values.h>

struct INTERVAL{

double a,b;

};

const int MAXSTACK=100;

//----------------------------------------

double Integral(double a, double b, double (*f)(double),

double eps){

// вычисление определенного интеграла от a до b с точн. eps

// от ф-ии f по формуле прямоугольников

double I1,I2; // два последовательных приближения

double d;

double Result=0;

int v=-1; // указатель стека

Interval Stack[maxstack];

Again:

d=b-a;

I1=(*f)(a)*d; // счет на одном интервале

d=(b-a)/2; // ширина интервала

I2=((*f)(a)+(*f)((a+b)/2))*d; // счет на 2х интервалах

if(fabs(I1-I2)<eps){

Result+=I2;

if(v>=0){ // если стек не пуст - взять из стека

a=Stack[v].a;

b=Stack[v].b;

v--;

goto Again;

} else {

// стек пуст - решение получено

return Result;

}

} else {

// правую часть - в стек

// а левой займемся немедленно

v++;

if(v>=MAXSTACK){

MessageBox(0,"Переполнение стека","Ошибка",MB_OK);

return MAXDOUBLE; // см. values.h

} else {

Stack[v].a=(a+b)/2;

Stack[v].b=b;

// a остается без изменений

b=(a+b)/2;

goto Again;

}

}

}

2.1.3. Польская инверсная запись (полиз)

ПОЛИЗ, или, как её еще называют, обратная польская запись, это способ бесско­боч­ного представления выражений (не только арифметических), в которых операнды пред­шествуют операции. Например, выражение

в обратной польской записи буде выглядеть следующим образом:

Выражение, представленное в ПОЛИЗ, замечательно тем, что оно может быть вычислено за один проход слева направо без возвратов и забеганий вперед. Вычисление выражения в ПОЛИЗ выполняется следующим образом. Двигаясь слева направо по строке, операнды помещаем в стек. Когда встретится операция, то она выполняется над операндами, находящимися на вершине стека. Результат операции помещается в вершину стека вместо использованных операндов. Таблица, приведенная ниже, иллюстрирует процесс вычисления. В столбце "Входная строка" подчеркнута обработанная часть строки. Промежуточные результаты обозначены R₀,R₁,R₂. Окончательный результат вычисления – единственный элемент на вершине стека операндов.

Входная строка	Стек	Пояснение
4 A * 2 X / - 3 B * 2 Y * + *	4
4 A * 2 X / - 3 B * 2 Y * + *	A4
4 A * 2 X / - 3 B * 2 Y * + *	R0	R0=4*A
4 A * 2 X / - 3 B * 2 Y * + *	2R0
4 A * 2 X / - 3 B * 2 Y * + *	X2R0
4 A * 2 X / - 3 B * 2 Y * + *	R1R0	R1=2/X
4 A * 2 X / - 3 B * 2 Y * + *	R0	R0=R0-R1
4 A * 2 X / - 3 B * 2 Y * + *	3R0
4 A * 2 X / - 3 B * 2 Y * + *	B3R0
4 A * 2 X / - 3 B * 2 Y * + *	R1R0	R=3*B
4 A * 2 X / - 3 B * 2 Y * + *	2R1R0
4 A * 2 X / - 3 B * 2 Y * + *	Y2R1R0
4 A * 2 X / - 3 B * 2 Y * + *	R2R1R0	R2=2*Y
4 A * 2 X / - 3 B * 2 Y * + *	R1R0	R2=R1+R2
4 A * 2 X / - 3 B * 2 Y * + *	R0	R0=R0*R1

Таблица 2. Вычисление значения выражения, заданного польской записью.

Отметим, что в обратную польскую запись может быть преобра­зована любая компью­тер­ная программа. В области архитектуры ЭВМ в своё время это привело к созданию безадрес­ных ЭВМ, в области программного обеспечения – к созданию так называемых "прямых" методов трансляции. Весьма популярным в течение некоторого времени был язык ФОРТ, полностью базирующийся на ПОЛИЗ.

Рассмотрим алгоритм преобразования скобочного выражения в ПОЛИЗ. Для простоты ограничимся арифметическими выра­жениями, использующими четыре действия арифметики. Предположим также, что операнды только переменные с однобуквенными идентификаторами. Преобразование выполняется за один проход. Строка просматри­ва­ется слева направо.

Операнды сразу помещаются в выходную строку.

Знаки операций сначала помещаются в стек. Прежде чем быть поме­щенным в стек, знак операции выталкивает из стека все опера­ции, которые имеют приоритет больше или равный приоритета вход­ной операции.

Открывающая скобка просто помещается в стек как операция с самим низким приоритетом.

Закрывающая скобка выталкивает из стека в выходную строку все операции вплоть до ближайшей открывающей скобки, которая удаляется из стека, но в выходную строку не помещается. Закрывающая скобка в стек не помещается.

После того как входная строка закончилась, остаток стека выталкивается в выходную строку.

Текст алгоритма преобразования приведен ниже.

struct opri{ // знаки операций и их приоритеты

char oper; // операция

unsigned char prior; // приоритет

};

//---------------------------------------------

static opri tpri[]={ // таблица приоритетов

{'+',1},

{'-',1},

{'*',2},

{'/',2}

};

// Приоритет операции из входной строки

static unsigned char vhpri;

//----------------------------------------------

static char Class(char z){

// Классификация символов из входной строки

// Символ может быть отнесен к одному из классов:

// - 'б' – буква (операнд)

// - 'о' – операция

// - '('

// - ')'

// - 'н' – недопустимый символ

int i;

if(z=='(' || z==')') return z;