Алгоритм, использующий стек
Получение обратной польской записи с использованием стека может осуществляться весьма просто на основе алгоритма, предложенного Дейкстрой, который ввел понятие стекового приоритета операций:
| Операция | Приоритет |
| ( | |
| + – | |
| * / |
Суть алгоритма в следующем. Просматривается исходная строка символов S слева направо, операнды переписываются в выходную строку В, а знаки операций заносятся в стек, который первоначально пуст, на основе следующих правил:
1) если в строке S встретился операнд, то помещаем его в строку В;
2) если в S встретилась открывающая скобка, то помещаем ее в стек;
3) если в S встретилась закрывающая скобка, то выталкиваем из стека в строку В все операции до открывающей скобки, саму отрывающую скобку также извлекаем из стека; обе скобки (открывающая и закрывающая) игнорируются;
4) если в S встретилась операция Х, то выталкиваем из стека все операции, приоритет которых не ниже Х, после чего операцию Х записываем в стек;
5) при достижении конца строки S, если стек не пуст, переписываем его элементы в выходную строку В.
Обратная польская запись обладает рядом замечательных свойств, которые превращают ее в идеальный промежуточный язык при трансляции.
Во-первых, вычисление выражения, записанного в обратной польской записи, может проводиться путем однократного просмотра, что является весьма удобным при генерации объектного кода программ.
Например, вычисление полученного выражения (15.1) может быть проведено следующим образом:
| Шаг | Анализируемая строка | Действие |
| AB+CD+*E– | R1=A+B | |
| R1CD+*E– | R2=C+D | |
| R1 R2*E– | R1=R1*R2 | |
| R1 E– | R1=R1–E | |
| R1 |
Здесь R1 и R2 – вспомогательные переменные.
Пример реализации
Пусть задано выражение a+b*c+(d*e+f)*g. Необходимо записать это выражение в постфиксной форме. Правильным ответом будет выражение abc*+de*f+g*+. Решаем эту задачу, используя стек.
Пусть исходная информация хранится в строке S=”a+b*c+(d*e+f)*g”. Результат будем получать в строке В.
Начинаем последовательно просматривать символы исходной строки, причем стек пуст и В – пустая строка.
Букву «a» помещается в строку В, а операцию «+» помещаем в стек. Букву «b» помещаем в строку В. На этот момент стек и строка В выглядят следующим образом:
| В = ”ab” | |
| + |
Операцию «*» помещаем в стек, т.к. элемент в вершине стека имеет более низкий приоритет. Букву «с» помещаем в строку В, после чего имеем
| В = ”abс” | |
| * | |
| + |
Следующий символ строки S «+». Анализируем стек и видим, что элемент в вершине стека «*» и следующий за ним «+» имеют приоритеты не ниже текущего, следовательно, обе операции извлекаем из стека и помещаем в строку В, а текущий элемент помещаем в стек. В итоге имеем
| В = ”abс*+” | |
| + |
Далее в строке S следует символ «(», его помещаем в стек, а букву «d» помещаем в строку В, в результате получается
| В = ”abс*+d” | |
| ( | |
| + |
Следующий в строке S символ «*». Так как открывающую скобку нельзя извлечь из стека до тех пор, пока не встретилась закрывающая, то «*» помещаем в стек. Букву «e» помещаем в строку В:
| В = ”abс*+de” | |
| * | |
| ( | |
| + |
Следующий прочитанный символ «+», и т.к. элемент стека «*» имеет более высокий приоритет, то извлекаем его из стека и помещаем в строку В, а текущий символ «+» помещаем в стек. Символ «f» помещаем в строку В:
| В = ”abс*+de*f” | |
| + | |
| ( | |
| + |
Далее в строке S идет закрывающая скобка, все элементы стека до символа «)» помещаем в строку В (это элемент «+»), а сам символ «(» извлекаем из стека. Обе скобки игнорируются:
| В = ”abс*+de*f+” | |
| + |
Операцию «*» помещаем в стек, а букву «g» – в строку В:
| В = ”abс*+de*f+g” | |
| * | |
| + |
Все символы строки S рассмотрены, следовательно, анализируем состояние стека, если он не пуст, то переписываем все его элементы в строку В:
| В = ”abс*+de*f+g*+” |
Таким образом, просмотрев исходную информацию только один раз, мы решили поставленную задачу.
Текст программы, реализующий рассмотренный алгоритм, может иметь следующий вид:
. . .
struct Stack {
char c; // Символ операции
Stack *Next;
} ;
int Prior (char);
Stack* InS( Stack*,char);
Stack* OutS( Stack*,char*);
void main ()
{
Stack *t, *Op = NULL; // Стек операций Op – пуст
char a, In[50], Out[50]; // Входная In и выходная Out строки
int k = 0, l = 0; // Текущие индексы для строк
puts(" Input formula : "); gets(In);
while ( In[k] != '\0') { // Анализируем символы строки In
// Если символ «)», выталкиваем из стека в выходную строку все операции
if ( In[k] == ')' ) {
while ( (Op -> c) != '(' ) { // до открывающей скобки
Op = OutS(Op,&a); // Считываем элемент из стека
if ( !Op ) a = '\0';
Out[l++] = a; // и записываем в строку Out.
}
t = Op; // Удаляем из стека открывающую скобку
Op = Op -> Next;
free(t);
}
// Если символ строки In – буква, заносим ее в строку Out
if ( In[k] >= 'a' && In[k] <= 'z' ) Out[l++] = In[k];
// Если символ – открывающая скобка, записываем ее в стек
if ( In[k] == '(' ) Op = InS(Op,In[k]);
/* Если символ – знак операции, переписываем из стека в строку Out все операции с большим или равным приоритетом */
if ( In[k] == '+' || In[k] == '–' || In[k] == '*' || In[k] == '/' ) {
while ( Op != NULL && Prior (Op -> c) >= Prior (In[k]) ) {
Op = OutS(Op,&a); // Извлекаем из стека символ Out[l++] = a; // и записываем в строку Out
}
Op = InS(Op,In[k]); // Текущий символ – в стек
}
k++;
} // Конец цикла анализа входной строки
// Если стек не пуст, переписываем все операции в выходную строку
while ( Op !=NULL) {
Op = OutS(Op,&a);
Out[l++] = a;
}
Out[l] = '\0’;
printf("\n Polish = %s", Out); // Выводим на экран результат
}
//======= Функция реализации приоритета операций =========
int Prior ( char a ) {
switch ( a ) {
case '*': case '/': return 3;
case '–': case '+': return 2;
case '(': return 1;
}
return 0;
}
// ============== Добавление элемента в стек =============
Stack* InS( Stack *t, char s) {
Stack *t1 = (Stack*) malloc(sizeof(Stack));
t1 -> c = s;
t1-> Next = t;
return t1;
}
// ============== Извлечение элемента из стека ===============
Stack* OutS( Stack *t, char *s ) {
Stack *t1 = t;
*s = t -> c;
t = t->Next;
free(t1);
return t;
}
Понятие хеширования
Для решения задачи поиска необходимого элемента среди данных большого объема был предложен алгоритм хеширования (hashing – перемешивание), при котором создаются ключи, определяющие данные массива и на их основании данные записываются в таблицу, названную хеш-таблицей. Ключи для записи определяются при помощи функции i = h(key), называемой хеш-функцией. Алгоритм хеширования определяет положение искомого элемента в хеш-таблице по значению его ключа, полученного хеш-функцией.
Понятие хеширования– это разбиение общего (базового) набора уникальных ключей элементов данных на непересекающиеся наборы с определенным свойством.
Возьмем, например, словарь или энциклопедию. В этом случае буквы алфавита могут быть приняты за ключи поиска, т.е. основным элементом алгоритма хеширования является ключ (key). В большинстве приложений ключ обеспечивает косвенную ссылку на данные.
Фактически хеширование – это специальный метод адресации данных для быстрого поиска нужной информации по ключам.
Если базовый набор содержит N элементов, то его можно разбить на 2N различных подмножеств.
Хеш-таблица и хеш-функции
Функция, отображающая ключи элементов данных во множество целых чисел (индексы в таблице – хеш-таблица), называется функцией хеширования, или хеш-функцией:
i = h(key);
где key – преобразуемый ключ, i – получаемый индекс таблицы, т.е. ключ отображается во множество целых чисел (хеш-адреса), которые впоследствии используются для доступа к данным.
Однако хеш-функция для нескольких значений ключа может давать одинаковое значение позиции i в таблице. Ситуация, при которой два или более ключа получают один и тот же индекс (хеш-адрес), называется коллизией при хешировании.
Хорошей хеш-функцией считается такая функция, которая минимизирует коллизии и распределяет данные равномерно по всей таблице, а совершенной хеш-функцией – функция, которая не порождает коллизий:
Разрешить коллизии при хешировании можно двумя методами:
– методом открытой адресации с линейным опробыванием;
– методом цепочек.
Хеш-таблица
Хеш-таблица представляет собой обычный массив с необычной адресацией, задаваемой хеш-функцией.
Хеш-структуру считают обобщением массива, который обеспечивает быстрый прямой доступ к данным по индексу.
Имеется множество схем хеширования, различающихся как выбором удачной функции h(key), так и алгоритма разрешения конфликтов. Эффективность решения реальной практической задачи будет существенно зависеть от выбираемой стратегии.
Примеры хеш-функций
Выбираемая хеш-функция должна легко вычисляться и создавать как можно меньше коллизий, т.е. должна равномерно распределять ключи на имеющиеся индексы в таблице. Конечно, нельзя определить, будет ли некоторая конкретная хеш-функция распределять ключи правильно, если эти ключи заранее не известны. Однако, хотя до выбора хеш-функции редко известны сами ключи, некоторые свойства этих ключей, которые влияют на их распределение, обычно известны. Рассмотрим наиболее распространенные методы задания хеш-функции.
Метод деления. Исходными данными являются – некоторый целый ключ key и размер таблицы m. Результатом данной функции является остаток от деления этого ключа на размер таблицы. Общий вид функции:
int h(int key, int m) {
return key % m; // Значения
}
Для m = 10 хеш-функция возвращает младшую цифру ключа.
Для m = 100 хеш-функция возвращает две младшие цифры ключа.
Аддитивный метод, в котором ключом является символьная строка. В хеш-функции строка преобразуется в целое суммированием всех символов и возвращается остаток от деления на m (обычно размер таблицы m = 256).
int h(char *key, int m) {
int s = 0;
while(*key)
s += *key++;
return s % m;
}
Коллизии возникают в строках, состоящих из одинакового набора символов, например, abc и cab.
Данный метод можно несколько модифицировать, получая результат, суммируя только первый и последний символы строки-ключа.
int h(char *key, int m) {
int len = strlen(key), s = 0;
if(len < 2) // Если длина ключа равна 0 или 1,
s = key[0]; // возвратить key[0]
else
s = key[0] + key[len–1];
return s % m;
}
В этом случае коллизии будут возникать только в строках, например, abc и amc.
Метод середины квадрата, в котором ключ возводится в квадрат (умножается сам на себя) и в качестве индекса используются несколько средних цифр полученного значения.
Например, ключом является целое 32-битное число, а хеш-функция возвращает средние 10 бит его квадрата:
int h(int key) {
key *= key;
key >>= 11; // Отбрасываем 11 младших бит
return key % 1024; // Возвращаем 10 младших бит
}
Метод исключающего ИЛИ для ключей-строк (обычно размер таблицы m=256). Этот метод аналогичен аддитивному, но в нем различаются схожие слова. Метод заключается в том, что к элементам строки последовательно применяется операция «исключающее ИЛИ».
В мультипликативном методе дополнительно используется случайное действительное число r из интервала [0,1), тогда дробная часть произведения r*key будет находиться в интервале [0,1]. Если это произведение умножить на размер таблицы m, то целая часть полученного произведения даст значение в диапазоне от 0 до m–1.
int h(int key, int m) {
double r = key * rnd();
r = r – (int)r; // Выделили дробную часть
return r * m;
}
В общем случае при больших значениях m индексы, формируемые хеш-функцией, имеют большой разброс. Более того, математическая теория утверждает, что распределение получается более равномерным, если m является простым числом.
В рассмотренных примерах хеш-функция i = h(key) только определяет позицию, начиная с которой нужно искать (или первоначально – поместить в таблицу) запись с ключом key. Поэтому схема хеширования должна включать алгоритм решения конфликтов, определяющий порядок действий, если позиция i = h(key) оказывается уже занятой записью с другим ключом.
Схемы хеширования
В большинстве задач два и более ключей хешируются одинаково, но они не могут занимать в хеш-таблице одну и ту же ячейку. Существуют два возможных варианта: либо найти для нового ключа другую позицию, либо создать для каждого индекса хеш-таблицы отдельный список, в который помещаются все ключи, преобразованные в этот индекс.
Эти варианты и представляют собой две классические схемы:
– хеширование методом цепочек (со списками), или так называемое многомерное хеширование – chaining with separate lists;
– хеширование методом открытой адресации с линейным опробыванием – linear probe open addressing.
Метод открытой адресации с линейным опробыванием.Изначально все ячейки хеш-таблицы, которая является обычным одномерным массивом, помечены как не занятые. Поэтому при добавлении нового ключа проверяется, занята ли данная ячейка. Если ячейка занята, то алгоритм осуществляет осмотр по кругу до тех пор, пока не найдется свободное место («открытый адрес»), т.е. либо элементы с однородными ключами размещают вблизи полученного индекса, либо осуществляют двойное хеширование, используя для этого разные, но взаимосвязанные хеш-функции.
В дальнейшем, осуществляя поиск, сначала находят по ключу позицию i в таблице, и, если ключ не совпадает, то последующий поиск осуществляется в соответствии с алгоритмом разрешения конфликтов, начиная с позиции i по списку.
Метод цепочек используется чаще предыдущего.В этом случае полученный хеш-функцией индекс i трактуется как индекс в хеш-таблице списков, т.е. ключ key очередной записи отображается на позицию i = h(key) таблицы. Если позиция свободна, то в нее помещается элемент с ключом key, если же она занята, то отрабатывается алгоритм разрешения конфликтов, в результате которого такие ключи добавляются в список, начинающийся в i-й ячейке хеш-таблицы. Например, обозачив N –NULL:
В итоге имеем таблицу массива связных списков или деревьев.
Процесс заполнения (считывания) хеш-таблицы прост, но доступ к элементам требует выполнения следующих операций:
– вычисление индекса i;
– поиск в соответствующей цепочке.
Для улучшения поиска при добавлении нового элемента можно использовать алгоритма вставки не в конец списка, а – с упорядочиванием, т.е. добавлять элемент в нужное место.
При решении задач на практике необходимо подобрать хеш-функцию i = h(key), которая по возможности равномерно отображает значения ключа key на интервал [0, m–1], m – размер хеш-таблицы. И чаще всего, если нет информации о вероятности распределения ключей по записям, используя метод деления, берут хеш-функцию i = h(key) = key%m.
При решении обратной задачи – доступ (поиск) к определенному подмножеству возможен из хеш-таблицы (хеш-структуры), которая обеспечивает по хеш-адресу (индексу) быстрый доступ к нужному элементу.