- •1. Типы структур данных
- •2. Стек
- •Void stack::Push(int NewElement){
- •Int stack::Pop(){
- •If(!Empty){
- •2.1. Применения стека
- •2.1.1. Программный стек
- •Void main(void){
- •2.1.2.1. Обход шахматной доски ходом коня
- •Int I,j; // координаты клетки
- •Int move; // номер хода, которым покидаем клетку
- •Int I,j; // текущие координаты клетки
- •Int V; // указатель стека
- •Int BegMove,k,i2,j2;
- •2.1.2. Реализация рекурсии
- •If(Move(n,I,j,k,&i2,&j2) && !Board[i2][j2]){
- •If(Good){
- •2.1.2.1. Вычисление определенного интеграла
- •Interval Stack[maxstack];
- •2.1.3. Польская инверсная запись (полиз)
- •If(isalpha(z)) return 'б'; // буква – операнд
- •Int Poliz(char *in,char *out){
- •2.1.4. Вычисление выражения, представленного в полиз
- •Контрольные вопросы
- •3. Очередь
- •Контрольные вопросы
- •4. Массивы
- •4.1. Размещение прямоугольных массивов в последовательной памяти
- •4.2. Метод Айлиффа
- •Контрольные вопросы
- •5. Списочные структуры
- •5.1. Односвязный линейный список
- •5.1.1. Представление односвязного списка
- •5.1.2. Операции над односвязным списком
- •!!!!!!5.1.3. Голова списка
- •5.1.4 Циклический список
- •5.1.5. Пример. Сложение многочленов
- •Int px,py,pz; // степени X,y,z
- •Int PowerCmp(node *p, node *q){
- •Void PoliAdd(node *p, node *q){
- •5.2. Двусвязный линейный список
- •Void DeleteUzel(uzel *p){
- •5.3. Ортогональные списки
- •Int Row,Col; // строка и столбец элемента
- •5.4. Списки общего вида
- •5.4.1. Пример. Топологическая сортировка.
- •Int count; // счетчик числа элементов, предшествующих
- •Void TopSort(pair *p, int n_pair, file *result){
- •Void AddToTail(mains *head, mains *V){
- •5.5. Стек свободного пространства
- •Void DeleteNode(node *p, node *s){
- •5.6. Обслуживание свободного пространства
- •5.6.1. Счетчик ссылок
- •5.6.2. Сбор мусора
- •Контрольные вопросы
- •6. Множества
- •Int nElem; // число элементов в множестве
- •Int Elem[maxsize]; // элементы множества
- •Int Element; // номер элемента множества
- •Void Delete(node *p); // удаление узла вслед за p
- •Void setinlist::Delete(node *p){
- •Контрольные вопросы
- •7. Деревья
- •7.1. Бинарные деревья
- •7.2. Обход бинарного дерева
- •Void DirectByPass(node *Root){
- •Void InverseByPass(node *Root){
- •Int Tag; // может принимать значения operation или number
- •7.3. Прошитые деревья
- •Void InverseBypass(node *Root){
- •7.4. Другие представления бинарных деревьев
- •7.5. Представление деревьев общего вида
- •Int nSon; // действительное число сыновей узла
- •7.5.1. Представление деревьев общего вида бинарными деревьями
- •Контрольные вопросы
- •8. Конечный автомат
- •Int State; // текущее состояние
- •Int Class;
- •If(!Found){
- •Контрольные вопросы
- •9. Таблицы
- •9.1. Последовательные таблицы
- •Контрольные вопросы
- •9.2. Сортированные таблицы
- •9.2.1. Алгоритмы поиска в сортированной таблице
- •9.2.1.1. Бинарный поиск (дихотомия)
- •Int BinSearch(int Key, int n, int t[]){
- •Void *bsearch(const void *key, const void *base, size_t nelem, size_t width, int (*fcmp)(const void *a, const void *b ));
- •9.2.2. Вставка и удаление в сортированной таблице
- •9.2.3. Оценка трудоемкости сортировки !!!!!
- •9.2.4. Внутренняя сортировка
- •9.2.4.1. Сортировка подсчетом
- •Void CountSort(int n, int t[]){
- •9.2.4.2. Сортировка простым выбором
- •Void SimpleChoice(int n, int t[]){
- •9.2.4.3. Квадратичный выбор
- •9.2.4.6. Сортировка методом "пузырька"
- •Void BubbleSort(int n, int t[]){
- •9.2.4.7. Сортировка слиянием
- •9.2.4.4. Выбор из дерева
- •9.2.4.5. Сортировка простыми вставками
- •Void InsertSort(int n, int t[]){
- •Void Merge(int n, int *t, int m, int *V, int *r){
- •9.2.4.8. Сортировка фон Неймана
- •Void Join(int a[], int b[], int *left, int *right,
- •Int *kl, int *kr, int Step){
- •9.2.4.9. Сортировка Хоара (1962 г.) !!!!!
- •Int Partition(int m, int n, int t[]){
- •Void Hoar(int m, int n, int t[]){
- •Void qsort(void *base, size_t nelem, size_t width,
- •Int (*fcmp)(const void *, const void *));
- •9.2.4.10. Двоичная поразрядная сортировка
- •Int BitPart(unsigned int Left, unsigned int Right,
- •Void BitSort(unsigned int Left, unsigned int Right,
- •Void BinarySort(int n,unsigned Tab[], unsigned int keylen){
- •9.2.4.11. Цифровая поразрядная сортировка
- •Void DigitalSort(byte *t, int n, int KeyLen){
- •Int *Count;
- •Int *Pos; // позиции расстановки
- •9.2.1. Внешняя сортировка
- •9.2.1.1. Многопутевое слияние и выбор с замещением
- •9.2.1.2. Многофазное слияние
- •9.2.1.3. Фибоначчиево слияние
- •9.2.1.4. Каскадное слияние
- •9.2.1.5. Сортировка в одном файле
- •Контрольные вопросы
- •9.3. Древовидные таблицы
- •Void *Record; // указатель на запись таблицы
- •Int WhatSon; // каким сыном устанавливать новую запись –
- •Int CmpKeys; // результат сравнения ключей
- •Int Info;
- •Int Rank; // для доступа по индексу
- •9.3.1. Оценка трудоемкости поиска в случайном дереве
- •9.3.2. Оптимальные деревья
- •Int Info;
- •9.3.3. Сбалансированные деревья
- •9.3.4.1. Поддержание балансировки
- •9.3.5. Представление линейных списков деревьями
- •Int Info;
- •Int Rank;
- •Контрольные вопросы
- •9.4. Таблицы с прямым доступом
- •9.5. Рассеянные таблицы (Hash)
- •9.5.1. Анализ трудоемкости операций над рассеянной таблицей
- •Контрольные вопросы
- •Литература
- •454091, Г.Челябинск, ул.Свободы, 155/1
Int Info;
struct NODE *Left;
struct NODE *Right;
};
NODE *CreateOptimalTree(int KeyArray[], int m, int n){
//создать оптимальное дерево из ключей отрезка от m до n
// сортированного массива ключей KeyArrayint k;
NODE *Root;
if(n<m) return NULL;
Root=new NODE;
k=(n+m)/2;
Root->Info=KeyArray[k];
if(n==m){
Root->Left=NULL;
Root->Right=NULL;
} else {
Root->Left=CreateOptimalTree(KeyArray,m,k-1);
Root->Right=CreateOptimalTree(KeyArray,k+1,n);
}
return Root;
}
Построение оптимальных деревьев имеет смысл для статических деревьев, то есть для таких, для которых операции вставки и удаления отсутствуют. Восстановление оптимальности после вставки или удаления требует полного перестроения дерева.
9.3.3. Сбалансированные деревья
Сбалансированные деревья представляют собой компромисс между оптимальными и случайными деревьями. Авторы идеи сбалансированного дерева - Адельсон-Вельский и Ландис (1962 г.), поэтому такие деревья называют также AVL-деревьями. AVL-деревья используют дополнительно 2 бита на узел и позволяют за время ~log2N, выполнять операции вставки, поиска и удаления.
Определим высоту дерева как максимальную
длину пути от корня до л
иста.
Будем называть дерево сбалансированным,
если в каждом узле высота правого и
левого поддеревьев различаются не более
чем на 1. На рис. 43
Рис.43 Пример сбалансированного дерева
изображен пример сбалансированного дерева. Оценим максимальную высоту сбалансированного дерева. Обозначим минимальное число узлов в AVL-дереве высоты h через N(h). В таком дереве с минимальным числом узлов одна из ветвей, исходящих из корня, должна содержать N(h-1) узлов, а другая - N(h-2) узлов. Таким образом,
(6)
Очевидно, что N(0)=1, N(1)=2. Далее по формуле (6) находим , что N(2)=4. Для h=3 и h=4 можно непосредственно проверить, а затем по индукции доказать, что при h3 справедливо неравенство
(7)
где
-положительный корень уравнения
,
которое является характеристическим
для разностного уравнения (6). Действительно,
допустим, что неравенство (7) выполняется
для всех k<N.
Тогда, подставив в правую часть равенства
(6) нижние границы N(h-1),
N(h-2)
в соответствии с неравенством (7), получим:
(8)
Подставим в левую часть неравенства (7) нижнюю грань для N(h) из неравенства (8). В результате будет получено более сильное неравенство:
(9)
Очевидно, что если (9) справедливо, то тем более справедливо (7). Преобразуем неравенство (9) к виду:
Трехчлен
в скобках тождественно равен нулю, так
как - его корень.
Остается –1<0. Таким образом, неравенство
(7) доказано. Следовательно, если
сбалансированное дерево содержит ветвь
длины h>3, то число
его вершин n удовлетворяет
неравенству
,
откуда
(10)
Величина
h+1 – это число
сравнений ключей при поиске записи,
расположенной в конце пути длиной h,
исходящем из корня. Окончательный вывод:
число сравнений ключей при поиске в
сбалансированном дереве из n
узлов не превышает
.
9.3.4.1. Поддержание балансировки
Для работы алгоритма поддержания балансировки требуется в каждом узле хранить показатель сбалансированности, принимающий значения –1, 0, 1,
Рис 44. Два случая нарушения балансировки
и равный разности высот правого и левого поддеревьев узла. В принципе возможны только два случая нарушения балансировки, изображенные на рис 44. Другие "плохие" случаи можно получить вращением вокруг вертикальных осей, проходящих через узлы A и B.
Первый
случай имеет место, когда вставка
увеличивает высоту правого поддерева
узла В с h до h+1.
Во втором случае либо h=0
и X – новый узел, либо узел
X имеет поддеревья с
высотами h, h+1.
Преобразования, изображенные на р
ис.45
восстанавливают балансировку, сохраняя
правильность построения дерева.
Рис. 45 Восстановление балансировки
В обоих случаях в дереве нужно изменить лишь несколько связей. Преобразованные деревья имеют высоту h+2, как до включения нового узла. Следовательно, часть дерева, расположенная над узлам А не изменится. Обратите внимание на тот факт, что порядок следования узлов в обратном порядке до и после преобразования не изменился.
