Коллекции представляют собой организацию данных и определяют методы доступа к этим данным. Коллекции подразделяются на две категории: линейные и нелинейные. Линейная коллекция содержит список элементов, упорядоченных по положению. В этом списке имеется первый элемент, второй и т.д. Массив с индексом, отражающим порядок элементов является основным примером линейной коллекции. Нелинейная коллекция определяет элементы без позиционного упорядочивания. С помощью прямого доступа мы можем выбрать элемент непосредственно, не обращаясь к предыдущим. Примером такой коллекции служит уже хорошо знакомый нам массив, для доступа к элементам которого мы можем использовать индексы. В коллекциях, называемых последовательными списками прямой доступ невозможен. Нужно сперва обратиться к первому элементу, затем через него ко второму и т.д. до нужного.

Коллекции с индексным доступом

К данному виду относят словари и хеш-таблицы.

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

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

Коллекции с прямым доступом

Массив – совокупность однотипных элементов, расположенных в смежных ячейках памяти. Для доступа к элементам используют числовой индекс – порядковый номер в наборе.

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

Коллекции с последовательным доступом

Более общей коллекцией является список, сохраняющий элементы в определенном порядке. Структура, называемая линейным списком содержит произвольное число элементов. Размер списка изменяется, после удаления и добавления к нему новых элементов. Первый элемент находится в начале или голове списка, а последний – в хвосте списка. Каждый элемент списка имеет связь с последующим, таким образом можно передвигаться от одного элемента к другому. Для доступа к элементам списка необходимо выполнять прохождение от головы до нужной позиции. Если движение по списку можно осуществлять только в одном направлении, то список называется однонаправленным, если в двух направлениях – двунаправленный. Если элемент списка хранит информацию об одном “соседе”, то список называется односвязным, если о двух – двусвязным.

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

Очередь – это список с доступом в начало и конец. Элементы вставляются в конец, а извлекаются из начала списка. Иногда используются очереди приоритетов. В них добавление новых элементов происходит в конец, а удаление – из произвольного места согласно приоритету.

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

Нелинейные коллекции

Иерархическая коллекция – набор элементов, разделенных на уровни. Элементны на текущем уровне могут иметь несколько связанных элементов на нижнем уровне. Особой иерархической коллекцией является дерево, в которой на верхнем уровне имеется один эелемент – корень. Элементы в дереве называют узлами, каждый из которых указывает на нисходящие узлы, называемыми потомками. Каждый элемент, за исключением корня имеет одного потомка. Дерево является идеальной структурой для описания файловой системы с каталогами и подкаталогами.

Группа – представляет те коллекции, которые содержат элементы без упорядочивания. Набор переменных в программе – яркий пример группы. Сюда можно отнести граф – структуру, задающую набор вершин и набор связей, соединяющих вершины. Графы широко используются в планировании, транспортных задачах и в задачах проектирования. Сеть – особая форма графа, которая приписывает вес каждой связи. Вес указывает стоимость использования связи при прохождения графа. Так в задаче коммивояжера используется сеть для представления городов и стоимостей проезда из города в город.

Программная реализация списков

Рассмотрев классификацию коллекций приступим к практической их реализации. Начнем с общих вопросов. Список может храниться в памяти двумя способами. Во-первых, это традиционное последовательное расположение элементов с смежных областях памяти, а во-вторых, в произвольных областях с динамическими связями между собой. Основным преимуществом динамически связанных списков является простота изменения порядка следования элементов. В массиве для изменения порядка мы вынуждены делать перестановку элементов, что отнимает время и приводит к массе ненужных операций. С ростом размера элемента и их числа эти факторы сильно влияют на выполнение программы. В динамическом списке нет необходимости перемещать элементы, важно только изменить адресные связи. Для организации списка нам необходимы динамические объекты, расположенные в любых областях памяти и связанных между собой через адреса. Элемент списка должен содержать информационные поля для хранения данных и служебные поля для хранения адресов связанных с ним элементов. В языках программирования используются составные типы, которые могут включать несколько полей с данными. Для хранения адресов используются специальные переменные указатели. Таким образом, для реализации элемента списка нам потребуются составной тип и указатели.

struct Item
{
		char *text;     // информационные поля
		Item *next;    // служебные поля
};

Рассмотрим программные реализации общих для односвязного списка операций:
СОЗДАНИЕ ПЕРВОГО ЭЛЕМЕНТА

Item *unit(char *str)
{
	Item *head=new Item;
	head->text=new char[strlen(str)+1];
	strcpy(head->text,str);
	head->next=NULL;
	return head;
}

ДОБАВЛЕНИЕ ЭЛЕМЕНТА (в голову n = 0)

Item *addItemNOM(Item *head,char *buf,int n)
{
	Item *temp=head;
	Item *item=new Item;
	item->text=new char[strlen(buf)+1];
	strcpy(item->text,buf);
	if(n==0)
	{
		item->next=head;
		return item;
	}
	else
	{
		for(int i=1;i<(n-1) && head->next;i++)
			head=head->next;
		item->next=head->next;
		head->next=item;
		return temp;
	};
}

УДАЛЕНИЕ ЭЛЕМЕНТА

Item *removeItemNOM(Item *head,int n)
{
	Item *temp=head,*item=0;
	if(n==0)
	{
		head=head->next;
		delete temp;
		return head;
	}
	else
	{
		for(int i=1;inext->next;i++)
			head=head->next;
		item=head->next;
		head->next=head->next->next;
		delete item;
		return temp;
	};
}

УДАЛЕНИЕ СПИСКА

bool removeALL(Item *head)
{
	if(!head) return false;
	Item *temp;
	while (head)
	{
		temp=head->next;
		delete head;
		head=temp;
	}
	return true;
}

СОХРАНЕНИЕ СПИСКА

void saveall(Item *head,FILE *fp)
{
while(1)
{
fwrite(head,sizeof(Item),1,fp);
if(head->next)
head=head->next;
else
return;
}
}

ЗАГРУЗКА СПИСКА ИЗ ФАЙЛА

Item  * loadall(Item *head,FILE *fp)
{
fseek(fp,0L,0);
head=new Item; int a;
BOOK *old_head=head,*temp;
while((a=fread(head,sizeof(Item),1,fp)))
{
head->next=new Item;
temp=head;
head=head->next;
}
head=temp;
head->next=NULL;
return old_head;
}

КОПИРОВАНИЕ СПИСКА

Item  * copy(Item  * head1, Item  * head2)
{
head2=new Item;
Item  * old_head2=head2;
while(1)
{
memcpy(head2,head1,sizeof(Item));
if(head1->next)
{
head2->next=new Item;
head1=head1->next;
head2=head2->next;
}
else
break;
}
head2->next=NULL;
return old_head2;
}
ПОИСК ПО ПОЛЮ
Item *search_title(Item  * head,char  * text)
{
while(head->next)
{
if(!strcmp(head-> text, text)) return head;
head=head->next;
}
if(!strcmp(head-> text, text))
return head;
else
return NULL;
}

Процедура LZW-сжатия:

СТРОКА = очередной символ из входного потока

WHILE входной поток не пуст DO

СИМВОЛ = очередной символ из входного потока

IF СТРОКА+СИМВОЛ в таблице строк THEN

СТРОКА = СТРОКА+СИМВОЛ

ELSE

вывести в выходной поток код для СТРОКА

добавить в таблицу строк СТРОКА+СИМВОЛ

СТРОКА = СИМВОЛ

END of IF

END of WHILE

вывести в выходной поток код для СТРОКА

Рассмотрим работу алгоритма на примере обработки входной строки /WED/WE/WEE/WEB/WET , которая является кратким списком английских слов, разделенных символом “/”. Как вы можете заметить, анализируя алгоритм, его работа начинается с того, что на первом шаге цикла он выполняет проверку на наличие строки “/W” в таблице. Когда он не находит эту строку, то генерирует код для “/” и добавляет в таблицу строку “/W”. Т.к. 256 символов уже определены для кодов 0 – 255, то первой определенной строке может быть поставлен в соответствие код 256. После этого система читает следующую букву (”E”), добавляет вторую подстроку (”WE”) в таблицу и выводит код для буквы “W”. Этот процесс повторяется до тех пор, пока вторая подстрока, состоящая из прочитанных символов “/” и “W”, не сопоставится со строковым номером 256. В этом случае система выводит код 256 и добавляет трехсимвольную подстроку в таблицу. Этот процесс продолжается до тех пор, пока не исчерпается входной поток и все коды не будут выведены.

Входная строка : /WED/WE/WEE/WEB/WET

Вход(символы)         Выход(коды)            Новые коды (таблица строк)

/W                               /                                 256 = /W

E                                 W                                257 = WE

D                                E                                258 = ED

/                                  D                                259 = D/

WE                             256                             260 = /WE

/                                  E                                 261 = E/

WEE                           260                             262 = /WEE

/W                               261                             263 = E/W

EB                              257                             264 = WEB

/                                  B                                 265 = B/

WET                           260                            266 = /WET

<EOF>                       T

Как можно заметить, таблица строк быстро заполняется, т.к. новая строка добавляется в таблицу каждый раз, когда генерируется код. В этом явно вырожденном примере было выведено пять закодированных подстрок и семь символов. Если использовать 9-битные коды для вывода, то 19-символьная входная строка будет преобразована в 13.5-символьная выходную строку. Конечно, этот пример был выбран только для демонстрации. В действительности сжатие обычно не начинается до тех пор, пока не будет построена достаточно большая таблица, обычно после прочтения порядка 100 входных байт. Алгоритму сжатия соответствует свой алгоритм распаковки. Он получает выходной поток кодов от алгоритма сжатия и использует его для точного восстановления входного потока. Одной из причин эф- фективности LZW-алгоритма является то, что он не нуждается в хранении таблицы строк, полученной при сжатии. Таблица может быть точно восстановлена при распаковке на основе выходного потока алго- ритма сжатия. Это возможно потому, что алгоритм сжатия выводит СТРОКОВУЮ и СИМВОЛЬНУЮ компоненты кода прежде чем он поместит этот код в выходной поток. Это означает, что сжатые данные не обременены необходимостью тянуть за собой большую таблицу перевода. Алгоритм распаковки представлен ниже. В соответствии с алгоритмом сжатия, он добавляет новую строку в таблицу строк каждый раз, когда читает из входного потока новый код. Все, что ему необходимо сделать в добавок – это перевести каждый входной код в строку и переслать ее в выходной поток.

Процедура LZW-распаковки:

читать СТАРЫЙ_КОД

вывести СТАРЫЙ_КОД

СИМВОЛ = СТАРЫЙ_КОД

WHILE входной поток не пуст DO

читать НОВЫЙ_КОД

IF NOT в таблице перевода НОВЫЙ_КОД THEN

СТРОКА = перевести СТАРЫЙ_КОД

СТРОКА = СТРОКА+СИМВОЛ

ELSE

СТРОКА = перевести НОВЫЙ_КОД

END of IF

вывести СТРОКУ

СИМВОЛ = первый символ СТРОКИ

добавить в таблицу перевода СТАРЫЙ_КОД+СИМВОЛ

СТАРЫЙ_КОД = НОВЫЙ_КОД

END of WHILE

Входные коды : / W E D 256 E 260 261 257 B 260 T

НОВЫЙ КОД           СТАРЫЙ КОД         СТРОКА        СИМВОЛ      Таблица

/                                  /                             /

W                                /                            W               W                    256 = /W

E                                 W                          E               E                     257 = WE

D                                E                           D               D                     258 = ED

256                             D                           /W             /                      259 = D/

E                                 256                         E              E                     260 = /WE

260                             E                          /WE           /                       261 = E/

261                             260                         E/                         E                     262 = /WEE

257                             261                       WE            W                    263 = E/W

B                                 257                          B                         B                     264 = WEB

260                             B                        /WE             /                       265 = B/

T                                 260                         T              T                     266 = /WET

Концепции, использованные в алгоритме сжатия, настолько просты, что весь алгоритм может быть записан в несколько строк. Но так как управление построением таблицы требует некоторых специальных действий, реализация несколько более сложна. В демонстрационной программе, приведенной ниже, использовались коды длиной 12, 13 и 14 бит. При длине кода 12 бит потенциально возможно хранить до 4096 строк в таблице. Каждый раз, когда читается новый символ, таблица строк должна просматриваться для сопоставления. Если сопоставление не найдено, новая строка должна быть добавлена в таблицу.

Здесь возникают две проблемы. Во-первых, таблица строк может достаточно быстро стать очень большой. Даже если длина строк в среднем ограничивается 3 или 4 символами каждая, верхний предел длин строк может легко превысить 7 или 8 байт на код. К тому же количество памяти, необходимой для хранения строк, заранее не известно, так как оно зависит от общей длины строк. Вторая проблема заключается в организации поиска строк. Каждый раз, когда читается новый символ, необходимо организовать поиск для новой строки вида СТРОКА+СИМВОЛ. Это означает поддержку отсортированного списка строк. В этом случае поиск для каждой строки включает число сравнений порядка log2 от общего числа строк.

Использование 12-битных слов потенциально позволяет выполнять не более 12 сравнений для каждого кода. Первая проблема может быть решена хранением строк как комбинаций код/символ. Так как каждая строка в действительности является представлением комбинации уже существующего кода и добавочного символа, можно хранить каждую строку как отдельный код плюс символ. Например в разобранном выше примере строка “/WEE” хранится как код 260 и символ “E”. Это позволяет использовать для хранения только 3 байта вместо 5 (включающих дополнительный байт для конца строки). Идя назад, можно определить, что код 260 хранится как код 256 плюс добавочный символ “E”. Наконец, код 256 хранится как “/” плюс “W”.

Выполнение сравнения строк является немного более трудным. Новый метод хранения увеличивает время, необходимое для сравнения строк, но он не влияет на число сравнений. Эта проблема решается использованием алгоритма хэширования для хранения строк. Это означает, что код 256 не хранится в каком-либо массиве по адресу 256, а хранится в массиве по адресу, сформированному на основе самой строки. При определении места хранения данной строки можно использовать тестовую строку для генерации хэшадреса и затем найти целевую строку однократным сравнением. Так как код для любой данной строки нельзя узнать в дальнейшем иначе как по его позиции в массиве, необходимо хранить код для данной строки совместно с данными строки.

Символ          Веpоятность             Интеpвал

a                          .2                         [0.0; 0.2)

e                          .3                        [0.2; 0.5)

i                           .1                        [0.5; 0.6)

o                           .2                        [0.6; 0.8)

u                           .1                        [0.8; 0.9)

!                           .1                        [0.9; 1.0)

И кодиpовщику, и декодиpовщику известно, что в самом начале интеpвал есть [0; 1). После пpосмо- тpа пеpвого символа “e”, кодиpовщик сужает интеpвал до [0.2; 0.5), котоpый модель выделяет этому символу. Втоpой символ “a” сузит этот новый интеpвал до пеpвой его пятой части, поскольку для “a”

выделен фиксиpованный интеpвал [0.0; 0.2). В pезультате получим pабочий интеpвал [0.2; 0.26), т.к. пpедыдущий интеpвал имел шиpину в 0.3 единицы и одна пятая от него есть 0.06. Следующему символу “i” соответствует фиксиpованный интеpвал [0.5; 0.6), что пpименительно к pабочему интеpвалу [0.2; 0.26) суживает его до интеpвала [0.23, 0.236). Пpодолжая в том же духе, имеем:

В начале                    [0.0; 1.0)

После пpосмотpа      “e” [0.2; 0.5 )

-”-”-”-                          “a” [0.2; 0.26 )

-”-”-”-                          “i” [0.23; 0.236 )

-”-”-”-                          “i” [0.233; 0.2336)

-”-”-”-                          “!” [0.23354; 0.2336)

Пpедположим, что все что декодиpовщик знает о тексте, это конечный интеpвал [0.23354; 0.2336). Он сpазу же понимает, что пеpвый закодиpованный символ есть “e”, т.к. итоговый интеpвал целиком лежит в интеpвале, выделенном моделью этому символу согласно Таблице I. Тепеpь повтоpим действия кодиpовщика:

Сначала                     [0.0; 1.0)

После пpосмотpа      “e” [0.2; 0.5)

Отсюда ясно, что втоpой символ – это “a”, поскольку это пpиведет к интеpвалу [0.2; 0.26), котоpый полностью вмещает итоговый интеpвал [0.23354; 0.2336). Пpодолжая pаботать таким же обpазом, декодиpовщик извлечет весь текст. Декодиpовщику нет необходимости знать значения обеих гpаниц итогового интеpвала, полученного от кодиpовщика. Даже единственного значения, лежащего внутpи него, напpимеp 0.23355, уже достаточ- но. (Дpугие числа – 0.23354,0.23357 или даже 0.23354321 – вполне годятся). Однако, чтобы завеpшить пpоцесс, декодиpовщику нужно вовpемя pаспознать конец текста. Кpоме того, одно и то же число 0.0 можно пpедставить и как “a”, и как “aa”, “aaa” и т.д. Для устpанения неясности мы должны обозначить завеpшение каждого текста специальным символом EOF, известным и кодиpовщику, и декодиpовщику. Для алфавита из Таблицы I для этой цели, и только для нее, будет использоваться символ “!”. Когда декодиpовщик встpечает этот символ, он пpекpащает свой пpоцесс.

Кодирование проводим в несколько этапов.

1. Строим таблицу встречаемости символов, делим каждое значение на общее число символов и располагаем символы в порядке уменьшения вероятностей:

A – 5               5/10 = 0.5

B – 2                2/10 = 0.2

C – 2                2/10 = 0.2

D – 1               1/10 = 0.1

2. После этого стpоим кодовые комбинации пpостым методом. Делим столбик с веpоятностями таким обpазмо, чтобы сyмма веpоятностей веpхней части pавнялась пpиблизительно сyмме веpоятностей нижней части

0.5 – пеpвая часть = 0.5

—–

0.2 \

0.2 | – втоpая часть = 0.5

0.1 /

3. Hапpитив веpоятностей веpхней части пpоставляем нyли, напpотив нижней – единицы. В нашем пpимеpе полyчим:

0.5       0

0.2        1

0.2       1

0.1       1

4. Пpоделываем потом то же с pазделенными частями.В конце-концов пpидем к томy, что делить больше нечего.

А         0.5       0

B         0.2       10

C         0.2       110

D         0.1       111

В итоге сообщение, занимавшее 70 бит – AABCDAABC займет только 17 бит: 00101101110010110. Пpичем закодиpованное сообщение (это видно) не может быть pаскодиpовано несколькими способами, хотя длина кодов символов отличается. Чтобы пpочитать закодиpованное сообщение стpоится бинаpное деpево. В нашем слyчае оно бyдет такое:

()

/ \

0(A)    1

/ \

0(B)    1

/ \

0(C)  1(D)

Недостатки метода Шеннона-Фано:

1. Низкая скорость, поскольку требуется предварительная обработка файла.

2. Эффективность кодирования не всегда гарантирована.

В качестве примера равномерного кода можно назвать ASCII-таблицу, где каждому из 256 символов сопоставлено двоичное значение от 00000000 до 11111111. Независимо от вероятности появления символа на его представление отводится 1 байт, или 8 бит. Как известно, национальные языки обладают большой избыточностью, то есть разницей между энтропией источника и максимально возможной энтропией, обусловленной равной вероятностью появления любого символа из алфавита. Например, избыточность русского языка составляет 70%, а английского – 50%. Это в частности означает, что некоторые буквы появляются в тексте гораздо чаще других и поэтому использовать равномерное кодирование нерационально.

При неравномерном кодировании часто встречающимся символам сопоставляются более короткие кодовые последовательности, редко встречающимся – более длинные. За счет этого удается значительно сократить объем файла без потерь информации. Существует несколько методов неравномерного кодирования, важнейших из которых является метод Шеннона-Фано.

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

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

Измерение информации в быту (информация как новизна). Вы получили какое-то сообщение (например, прочитали статью в любимом журнале). В этом сообщении содержится какое-то количество информации. Как оценить, сколько информации вы получили? Другими словами, как измерить информацию? Можно ли сказать, что чем больше статья, тем больше информации она содержит? Разные люди, получившие одно и то же сообщение, по-разному оценивают количество информации, содержащееся в нем. Это происходит оттого, что знания людей об этих событиях, явлениях до получения сообщения были различными. Поэтому те, кто знал об этом мало, сочтут, что получили много информации, те же, кто знал больше, чем написано в статье, скажут, что информации не получили вовсе. Таким образом, количество информации в сообщении зависит от того, насколько ново это сообщение для получателя. При таком подходе непонятно, по каким критериям можно ввести единицу измерения информации. Следовательно, с точки зрения информации как новизны мы не можем оценить количество информации, содержащейся в научном открытии, новом музыкальном стиле, новой теории общественного развития.

Измерение информации в технике. В технике часто используют простой и грубый способ определения количества информации, который может быть назван объемным. Он основан на подсчете числа символов в сообщении, т.е. связан с его длиной и не учитывает содержания. Длина сообщения зависит от числа различных символов, употребляемых для записи сообщения. Например, слово “мир“ в русском алфавите записывается тремя знаками, в английском – пятью (реасе), а в КОИ-8 – двадцатью четырьмя битами (111011011110100111110010). В вычислительной технике применяются две стандартные единицы измерения: бит (binary digit) и байт (byte). Конечно, будет правильно, если вы скажете: “В слове “Рим” содержится 24 бита информации, а в сообщении “миру мир!” – 72 бита”. Однако, прежде чем измерить информацию в битах, вы определяете количество символов в этом сообщении.

Нам привычнее работать с символами, машине – с кодами. Каждый символ не случайно кодируется 8-битным кодом. Мы уже обсуждали, почему это так. Поэтому для удобства была введена более “крупная” единица информации в технике (преимущественно в вычислительной) – байт. Теперь вам легче подсчитать количество информации в техническом сообщении – оно совпадает с количеством символов в нем.

Измерение информации в теории информации (информация как снятая неопределенность). Пусть имеется колода из 32 игральных карт (от семерок до тузов). Задумывается одна из карт. Необходимо, задавая вопросы, на которые будут даны ответы “да” или “нет”, угадать задуманную карту. Первый вопрос: “Задумана карта черной масти?” Ответ: “Нет”. Ответ уменьшает неопределенность вдвое и приносит отгадывающему 1 бит информации. Второй вопрос: “Задумана карта бубновой масти?” Ответ: “Да”. Это еще один бит информации, исходная неопределенность уменьшилась в 4 раза. Третий вопрос: “Задумана карта – картинка?” Ответ: “Нет”. Третий бит информации, первоначальная неопределенность уменьшилась в 8 раз. Четвертый вопрос: “Задуманная карта младше девятки?” Ответ: “Да”. Еще один бит информации, первоначальная неопределенность уменьшилась в 16 раз. Пятый вопрос: “Задумана восьмерка бубновая?” Ответ: “Нет”. Отгадывающий получил пятый бит информации, исходная неопределенность уменьшилась в 32 раза. Последний ответ позволяет с уверенностью сказать, что была задумана бубновая семерка. Неопределенности не осталось. Очень приближенно можно считать, что количество информации в сообщении о каком-то событии совпадает с количеством вопросов, которые необходимо задать. Чтобы получить ту же информацию, ответ на эти вопросы может быть лишь “да” или “нет”. Причем событие, о котором идет речь, должно иметь равновероятные исходы (монета может упасть только “орлом” или “решкой” – два равновероятных исхода, задуманной может оказаться любая из 32 карт – 32 равновероятных исхода и т. п.).

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

В 100 Мб можно уместить:

Страниц текста – 50 000 или 150 романов

Цветных слайдов высочайшего качества – 150

Аудиозапись речи видного политического деятеля – 1.5 часа

Музыкальный фрагмент качества СD-стерео – 10 минут

Фильм высокого качества записи – 15 секунд

Протоколы операций с банковским счетом – за 1000 лет

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

H(U) = M {-logP(u_i)} = М{}=

Энтропия характеризует среднее количество информации, которое может быть получено от источника.

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

Множества – одно из основных понятий вычислительной математики и программирования. Почти каждая математическая модель, описывающая объекты реального мира содержит множества. Под простыми множествами мы будем понимать последовательность простых данных, то есть символов и чисел.

Основными структурами данных для хранения простых множеств являются массивы. Массивы могут быть одномерными и многомерными (наиболее распространены двумерные, или матрицы). Последовательность элементов одномерного массива имеет вид: A={1,2,3,4}. Произвольную последовательность элементов массива можно записать как (1, 2, 3). Для операций над элементами множеств могут привлекаться вспомогательные переменные. Часто используются указатели массива: l – левая граница, r – правая граница. В процессе работы алгоритма значение l увеличивается, а r – уменьшается.

Обмен значений двух переменных

Эта задача является наиболее распространенной и используется во многих, более сложных алгоритмов. Наиболее общее ее решение гласит – необходима третья переменная.

Алгоритм 1. Обмен значений двух переменных

SWAP(A,B)

t ←A

A←B

B←t

Однако, для числовых A и В можно использовать алгоритм без дополнительной переменной.

Алгоритм 2. Обмен значений двух переменных-2

SWAP(A,B)

А← A + B

B ←A – B

A←A – B

Если начальные значения А и В обозначим А0, В0, то в каждой строке алгоритма А и В принимают следующие значения:

А = А0 + В0,             В = В0

А = А0 + В0,             В = А0

А = В0,           В = А0

Нахождение минимального и максимального элемента

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

Алгоритм 3. Нахождение мин/макс значений элементов

A[] ← (A₁,A₂, …A_N)

MINMAX(A[])

Min←A[1]

max ←A[1]

for I←2 to N do

if A[I] < min then min←A[I] fi

if A[I] > max then max←A[I] fi

od

Группировка элементов массива

Дан массив А и число В. Переставить элементы в массиве А таким образом, чтобы слева от некоторой границы стояли числа меньше В, а справа – больше В.

Алгоритм 4. Группировка элементов массива

A[] ← (A₁,A₂, …A_N)

GROUPING1(A[],N,B)

l ←0

r ←N

while l ≠ r do

if A[l + 1]≤B then l←l + 1

elsif A[r] ≥ B then r←r + 1

else SWAP(A[l + 1],A[r])

l ←l + 1, r←r – 1

fi

od

Та же задача, но требуется, чтобы сначала шли элементы, меньшие B, затем равные B, а лишь затем большие B.

Решение. Теперь потребуются три границы: до первой будут идти элементы, меньшие B, от первой до второй – равные B, затем неизвестно какие до третьей, а после третьей – большие B. (Более симметричное решение использовало бы четыре границы, но вряд ли игра стоит свеч.) В качестве очередного рассматриваемого элемента берем элемент справа от средней границы.

Алгоритм 5. Группировка элементов массива-2

A[]← (A₁,A₂, …A_N)

GROUPING2(A[],N,B)

l← 0

m← 0

r← N

while m ≠ r do

if A[m + 1] = B then

m ← m + 1

elsif A[m + 1] > B then

SWAP(A[m + 1],A[r])

r← r – 1

else

SWAP(A[m + 1],A[l + 1])

l ← l + 1,m←m + 1

fi

od

Генерирование перестановок

Рассматривая задачу комивояжера мы столкнулись с необходимостью генерировать перестановки в массиве целых чисел, означающих номера городов. Под перестановкой мы будем понимать возможную последовательность элементов массива. Например, для массива из трех элементов A={1,2,3} можно указать 6 различных последовательностей: (1, 2, 3), (2, 1, 3), (2, 3, 1), (3, 2, 1), (3, 1, 2), (1, 3, 2). Число перестановок для множества из N элементов равно (N!). А вот пример программы, которая генерирует перестановки, используя антилексографический порядок (описать алгоритм самостоятельно) для перебора всех маршрутов в задаче комивояжера:

#include <stdio.h>
#include <conio.h>
int N=4;
void reverse(int *tours,int N)
{
int i=1,j=N,t;
while(i<j)
{
t=tours[i];
tours[i]=tours[j];
tours[j]=t;
i++;j--;
}
}
void antilex(int *tours,int m)
{
int t;
if(m==1)
{
for(int k=1;k<=N;k++)
printf("%d ",tours[k]);
printf("\n");
}
else
for(int i=1;i<=m;i++)
{
antilex(tours,m-1);
if(i<m)
{
t=tours[i];
tours[i]=tours[m];
tours[m]=t;
reverse(tours,m-1);
}
}
}
void main(void)
{
int tours[4];
for(int i=1;i<=N;i++)
tours[i]=i;
clrscr();
antilex(tours,N);
}

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

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

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

Вот некоторые из трудных задач:

• Задача комивояжера. Комивояжер должен объехать N городов с целью осуществления продажи своих товаров. Все N городов соединены дорогами по принципу “каждый с каждым”. Известна стоимость проезда между двумя любыми городами. Найти оптимальный маршур движения так, чтобы побывать во всех городах и при этом иметь минимальные затраты на дорогу.

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

• Тройная выполнимость. Есть список n логических выражений, каждое с тремя переменными.

Например: если (x и y) то z, (x и y) или не z и т.д. Существуют ли такие значения всех переменных, чтобы все утверждения были истинными?

Пример 1. Рассмотрим проблему вскрытия алгоритма шифрования по ключу. Временная сложность такого вскрытия пропорциональна числу возможных ключей, которое экспоненциально зависит от длины ключа. Если n – длина ключа, то сложность вскрытия грубой силой равна O(2n). При n бит сложность равна 256 и в этом случае вскрытие возможно за приемлимое время. При n = 112 бит сложность равна 2112 вскрытие становится невозможным.

Пример 2. Рассмотрим в качестве примера задачу комивояжера. Комивояжер должен объехать N городов с целью осуществления продажи своих товаров. Все N городов соединены дорогами по принципу “каждый с каждым”. Известна стоимость проезда между двумя любыми городами. Найти оптимальный маршур движения так, чтобы побывать во всех городах и при этом иметь минимальные затраты на дорогу. Исходная информация задана в виде перечня городов и соответствующей матрицы стоимостей, то есть двумерного массива с элементами C_ij , равными стоимости проезда из города i в город j. В данном случае матрица имеет N строк и N столбцов. Следует также уточнить, что маршрут начинается и заканчивается в одном (базовом) городе и не может дважды проходить через один и тот же город.

Решение (метод грубого перебора).

Произвольно пронумеруем N городов целыми числами от 1 до N, причем базовый город имеет номер N. Каждый тур (один из возможных маршрутов) однозначно соответствует перестановке целых чисел 1, 2, ..N – 1. Для каждой перестановки строим тур и определяем его стоимость. Обрабатывая все перестановки запоминаем маршрут, который имеет на текущий момент самую низкую стоимость. Если находится маршрут с меньшей стоимостью, то все дальнейшие сравнения осуществляем с ним.

Алгоритм 1. Задача комивояжера

TOUR ←1

MIN ← 1

for I ←1 to (N – 1)! do

P ← get P          (получение I-ой перестановки целых чисел 1,2,..N-1)

T(p),COST(T(p))    Строим тур T(P) and Вычисляем стоимость COST(T(P))

if COST(T(P)) < MIN then

TOUR←T(p),

MIN←COST(T(P))

fi

od

Попробуем оценить сложность данного алгоритма. Алгоритм является факториальным, с оценкой O(n!). В задаче требуется найти (N – 1)! перестановок целых чисел. Если даже требуется только один шаг для каждой перестановки, то эта часть алгоритма потребует O[(n - 1)!] шагов, поэтому любая верхняя граница для общего времени работы должна быть O(n!). Построим таблицу, иллюстрирующую вычислительную сложность алгоритма, предполагая, что производительность компьютера 1GFLOPS (1000000000 op/s).

Кол-во городов, N               Кол-во туров                        T,с                   T,дн                T,лет

2                                             2                      2e-08               << 1               << 1

3                                             6                      6e-08               << 1               <<1

4                                             24                    2e-07               << 1               << 1

10                                           4e+06              4e-02               << 1               << 1

15                                           13e+12            1e+04              0.15                << 1

18                                           6e+15              6e+07              740                 20

19                                           1e+17              1e+09              14000              390

20                                           2e+18              2e+10              280000            770

1. Постоянный – сложность оценивается как O(1).

2. Линейный – оценка равна O(n).

3. Квадратный – O(n²)

4. Кубический, полиноминальный – O(n³),O(n^m).

5. Экспоненциальный – O(t^p(n)), t- константа, p(n) – некоторая полиномиальная функция.

6. Факториальный - O(n!). Обладает наибольшей временной сложностью среди всех известных типов.

С ростом n временная сложность может стать настолько огромной, что это повлияет на практическую реализуемость алгоритма. Рассмотрим таблицу, в которой сравнивается время выполнения алгоритмов разных типов при n = 10⁶, при условии, что единицей времени для компьютера является микросекунда.

Тип                 Сложность                Кол-во операций      Время при 106 операций в сек.

Постоянные              O(1)                            1                                 1мкс

Линейные                 O(n)                            10⁶ 1 с

Квадратичные          O(n²)                           10¹² 11.6 дн.

Кубические               O(n³)                           10¹⁸ 32000 лет

Экспоненциальные O(2ⁿ)                          10³⁰¹⁰³⁰ в 10³⁰¹⁰⁰⁶ раз больше времени существования Вселенной