- •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;
NODE *Left;
NODE *Right;
Int Rank; // для доступа по индексу
};
bool DeleteKey(NODE *Head, int Key){
// удалить Key из дерева с головой Head
NODE *Cur, *Next=NULL,*father=NULL;
// ищем узел, запоминая каждый раз отца
for(Cur=Head; Cur->Info!=Key && Cur!=NULL; Cur=Next){
if(Key<=Cur->Info){
Next=Cur->Left;
} else {
Next=Cur->Right;
}
father=Cur;
}
if(Cur==NULL){ // не нашли Key
return false;
}
// узел сur надо удалить
// может у Cur пуста правая связь ?
if(Cur->Right==NULL){
if(father->Left==Cur){
// он левый сын своего отца
father->Left=Cur->Left;
} else {
// он правый сын своего отца
father->Right=Cur->Left;
}
delete Cur;
return true;
}
// поищем последователя с пустой левой связью
// шаг вправо и вниз до упора по левым связям
Next=Cur->Right;
father=Cur;
while(Next->Left!=NULL){
father=Next;
Next=Next->Left;
}
// Next - удаляемый узел
if(father->Left==Next){
// удаляемый узел - левый сын своего отца
father->Left=Next->Right;
} else {
// удаляемый узел - правый сын своего отца
father->Right=Next->Right;
}
Cur->Info=Next->Info;
delete Next;
return true;
}
9.3.1. Оценка трудоемкости поиска в случайном дереве
Обозначим
значения ключей, следующих в порядке
возрастания k1,k2,…,kn.
Вероятность того, что в корень попадет
ключ ki,
равна 1/n.
Тогда в левом поддереве будет i-1
узлов, а в правом n-i
узлов. Пусть an
– средний у
ровень
узла в дереве, содержащем n
узлов. Тогда при условии, что ключ ki
находится в корне,
Выражение в правой части содержит три слагаемых:
искомый узел находится в левом поддереве с вероятностью (i-1)/n и средний уровень его равен ai-1+1
с вероятностью 1/n это корень и его уровень 1.
с вероятностью (n-i)/n искомый узел находится в правом поддереве и средний уровень его an-i+1
И
скомая
величина an
представляет собой среднее по i
для всех
(1)
Отсюда
следует:
(2)
а
из (1) можно получить:
(3)
Из
(3) можно найти
,
и, подставив это в (2), получим:
(4)
an
можно представить в виде:
(5),где
.
Справедливость (5) можно проверить
непосредственной подстановкой (5) в (4).
По
формуле Эйлера
,
где
-
постоянная Эйлера, равная 0.571… Для
больших n
получим:
В
заключение отметим, что, хотя среднее
время поиска в случайном дереве
пропорционально логарифму числа узлов,
тем не менее, существует досадная
в
озможность
получения вырожденного дерева, время
поиска в котором пропорционально числу
узлов. Примеры таких деревьев приведены
на рис.42.
Рис.42 Примеры вырожденных деревьев
9.3.2. Оптимальные деревья
Оптимальным назовем дерево, высота которого минимальна. Это означает, что у него заполнены все уровни, кроме, быть может, последнего. Алгоритм построения оптимального дерева заключается в следующем:
отсортируем ключи и средний из них поместим в корень
левым сыном сделаем ключ, являющийся средним среди ключей слева от корня
правым сыном сделаем ключ, являющийся средним среди ключей справа от корня
точно также поступим при выборе сыновей каждого из узлов.
Ниже представлен текст функции, формирующей оптимальное дерево.
const int LEFT=0;
const int RIGHT=1;
struct NODE {
