Int k; free(item)

for (int i = 0; i < getSize()-1; i++)

for (int j = i; j < getSize()-1; j++)

if (item[j] < item[j+1]){

k = item[j];

item[j] = item[i];

item[i] = k; }

4.5.Объекты и классы. Структура класса: поля, методы, свойства. Разработка классов пользователей с динамическими структурами данных типа объект-таблица. Пример описания класса.

Первая часть во 2 и 3 билетах!

Разработка классов пользователей с динамическими структурами данных типа объект-таблица.

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

Для объявления класса можно воспользоваться определением двумерного массива или массива из указателей на списки любого типа.

Таблицу можно реализовать как массив массивов/списков/очередей. Ниже приведен пример реализации таблицы в качестве массива списков.

struct CListNode

{

int x;

CListNode* next;

};

class CTable

{…

CListNode* head[];

CTable(int size) {mallooc(head, size*sizeof(CListNode));};

…}

обращение к первому элементу списка i-той строки внутри класса:

CListNode* h = head[i];

cout<<h->x;

остальные элементы списка адресуются последовательным перебором.

while (h->next != null)

h = h->next;

Класс должен включать в себя методы:

1. выделение памяти для новой строки таблицы

2. вставку элемента в произвольное место i-той строки (с выделением памяти из кучи)

3. удаление произвольного элемента i-той строки (с освобождением памяти)

4. поиск элемента таблицы

5. сортировка строк таблицы по первом столбцу (по возрастанию)

6. удаление таблицы (с освобождением памяти)

Примерная реализация

1. realloc(head, msize(head) + sizeof(CListNode))

2. вставить число newX в i-тую строку на позицию N

int j = 0;

CListNode* newL = new CListNode;

newL->x = newX;

CListNode* l = head[i];

while (l->next != null && j++ < N)

l = l->next;

newL->next = l->next;

l->next = newL;

3. int j = 0;

CListNode* l = head[i];

while (l->next != null && j++ < N)

l = l->next;

CListNode* tmp = l->next;

l->next = l->next->next;

delete tmp;

4. CListNode* l ;

for (int i = 0; i< msize(head); i++)

{ l = head[i];

while (l->next != null)

{ if (l->x == findX) return l;

l = l->next; } }

return null;

5. { CListNode* tmp;

for (int i = 0; i < msize(head)-1; i++)

for (int j = i; j < msize(head)-1; j++)

if (head[j]->x < head[j+1]->x)

{

tmp = head[j];

head[j] = head[i];

head [i] = tmp; } }

6. CListNode* l;

for (int i = 0; i< msize(head); i++) {

while (head[i] != null) {

l = head[i]->next;

delete head[i];

head[i] = l; } }

free(head);

4.6.Структура данных типа списков. Варианты организации списков. Операции над списками. Примеры программирования операций над списками разных типов.

Динамические структуры данных любого типа – вектор, список, таблица – объявляются без описания их размерности. В процессе решения задач размерности этих структур могут изменяться. Использование динамической памяти для организации хранения массивов в памяти позволяет задавать только адрес массива в памяти, а его размерность определять при решении задачи. При этом место для данных выделяется из свободной области ОП – из «кучи», а обращение к выделенным областям происходит по указателям на них. Выделенную память необходимо освобождать по окончанию работы с ней (delete).

Существует несколько вариантов организации списков.

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

Стек - это конечная последовательность некоторых однотипных элементов - скалярных переменных, массивов, структур или объединений, среди которых могут быть и одинаковые. Стек представляет динамическую структуру данных; ее количество элементов заранее не указывается и в процессе работы, как правило, изменяется. Если в стеке элементов нет, то он называется пустым и обозначается S=< >.

Допустимыми операциями над стеком являются:

- проверка стека на пустоту S=< >,

- добавление нового элемента Sn+1 в конец стека – преобразование

< S1,...,Sn> в < S1,...,Sn+1>;

- изъятие последнего элемента из стека – преобразование

< S1,...,Sn-1,Sn> в < S1,...,Sn-1>;

- доступ к его последнему элементу Sn, если стек не пуст.

Операции добавления, удаления, доступа к элементу только в конце списка

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

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

struct CListNode {

int x;

CListNode* next;//указатель};

Данные

class CList {

Данные

CListNode* head; …}

Класс должен включать в себя методы:

1. вставку элемента в произвольное место списка (с выделением памяти из кучи)

2. удаление произвольного элемента списка (с освобождением памяти)

3. поиск элемента списка

4. удаление списка (с освобождением памяти)

сортировка не является оптимальной операцией, т.к. доступ строго последовательный, хотя можно и реализовать – процедура обмена соседними элементами + «пузырек».

Так же в операции над списками включаются:

• Создать список

• Сохранить данные из списка в файле / Прочитать данные из файла в список

• Найти в списке требуемое значение

• Сортировать список

Примерная реализация

1. вставить число newX в список на позицию N

int i = 0;

CListNode* newL = new CListNode;

newL->x = newX;

CListNode* l = head;

while (l->next != null && i++ < N)

l = l->next;

newL->next = l->next;

l->next = newL;

2. int i = 0;

CListNode* l = head;

while (l->next != null && i++ < N)

l = l->next;

CListNode* tmp = l->next;

l->next = l->next->next;

3. CListNode* l = head;

while (l->next != null)

{

if (l->x == findX)

return l;

l = l->next;}

return null;

4. CListNode* l;

while (head != null)

{

l = head->next;

delete head;

head = l;

На основе указателей строятся такие динамические структуры данных, как: динамический вектор, список, таблица, дерево и т.п..

Есть кольцевые двусвязные списки, n - связные списки, деревья, сетевые структуры. Структура списка определяется количеством полей ссылок на структуру данных этого же типа.

Двусвязные списки

Кольцевой список – это обычный односвязный список, но последний элемент всегда ссылается на начало списка.

Выводы по работе со списочными структурами данных:

1. Алгоритмы сложнее, чем для обработки массивов

2. Дополнительный расход памяти на указатели

3. Размещение списочных структур только в динамической памяти

4. Размер требуемой памяти надо контролировать:

{$ M A, B, C} – A – максимальный размер статической памяти,

B - нижняя граница Heap, C – верхняя граница Heap.

Стандартные размеры: {$M 16384,0,65536}

5. Реализация алгоритмов со списками использует столько памяти, сколько нужно для хранения текущего списка

6. Удаление, вставка, сортировка элементов требуют меньших затрат времени

Реализует дисциплину FIFO (очередь), если добавляем новые элементы в конец, т.к. читаем элементы всегда с головы. LIFO (стек), если добавляем в голову, и читаем оттуда же.

+ и – основных операций над списками

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

«--» доступ к элементам последовательный, через проход элементов один за другим от головы

«+» легко вставить новый элемент в любое место списка, легко поменять элементы местами (просто изменить указатели)