Контрольные вопросы

1. Чем отличается связанное распределение памяти под данные от последовательного?

2. Какие преимущества даёт представление строки линейным списком по сравнению с представлением её как массива символов?

3. Какие операции могут быть выполнены над линейным списком?

4. Что такое голова списка и зачем она нужна?

5. Чем отличается кольцевой список от обычного и какие дополнительные возможности он имеет?

6. Какие дополнительные возможности предоставляет двусвязный список по сравнению с односвязным ?

7. В каких случаях целесообразно применять ортогональные списки вместо многомерных массивов?

8. Чем отличается список общего вида от обычного линейного списка?

9. Дайте определение понятия "топологическая сортировка"

10. Что такое стек свободного пространства?

11. Каковы недостатки метода счетчика ссылок при обслуживании свободного пространства для списочных структур?

12. Аналогичный вопрос для метода "сбора мусора"

6. Множества

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

При использовании битовых строк, каждое множество представляется последовательностью битов, длина которой равна числу элементов в универсальном множестве, то есть в множестве всех возможных элементов. Равенство единице j-го бита строки означает, что элемент с номером j входит в множество. Теоретико-множественные операции над множествами, представ­ленными последовательностями битов, выполняются как побитовые булевы операции. Так, пересечению множеств соответствует конъюнкция, объедине­нию – дизъюнкция, разности x-y, где x,y – множества, соответствует побитовая операция .

Структура данных для множества, хранящегося в массиве, может быть следующей:

const int MAXSIZE=100;

struct SETINARRAY {

Int nElem; // число элементов в множестве

Int Elem[maxsize]; // элементы множества

};

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

• в первом случае фиксируется объем универсального множества

• во втором – максимально возможное количество элементов в множестве.

Кроме того, если количество элементов в множестве в среднем невелико, то память используется нерационально. От этих недостатков свободно представ­ление множества линейным списком. Ниже приведено определение класса SETINLIST.

#ifndef _SETINLIST_H

#define _SETINLIST_H

//--------------------------------------

struct NODE{ // узел списка

Int Element; // номер элемента множества

NODE *Next; // указатель на следующий элемент множества

};

//--------------------------------------

class SETINLIST{

private:

NODE *Head;

NODE *Insert(NODE *p); // вставка узла после p

Void Delete(node *p); // удаление узла вслед за p

public:

SETINLIST(); // конструктор пустого списка

SETINLIST(const int *m, int n); // конструктор создающий

// множество по массиву m длиной n

SETINLIST(const SETINLIST &a); //конструктор копирования

~SETINLIST();

SETINLIST operator *(const SETINLIST &x); // пересечение

// множеств

SETINLIST operator -(const SETINLIST &x); // вычитание

// множеств

SETINLIST operator +(const SETINLIST &x); // объединение

// множеств

SETINLIST & operator=(const SETINLIST &x);// оператор

// присваивания

};

#endif

Далее приводится реализация методов класса. При этом предполагается, что элементы множества расположены в списке в порядке возрастания. Голова списка вместо номера элемента содержит значение INT_MAX (см. файл limits.h).

#include "SETINLIST.h"

#include "limits.h"

//-------------------------------------

SETINLIST::SETINLIST(){

this->Head=new NODE;

this->Head->El=INT_MAX;

this->Head->Next=this->Head;

}

//--------------------------------------

SETINLIST::SETINLIST(const int *m, int n){

int i;

NODE *p,*x;

this->Head=new NODE;

this->Head->Next=this->Head;

this->Head->El=INT_MAX;

for(i=0,p=this->Head;i<n;i++,p=p->Next){

x=Insert(p);

x->El=m[i];

}

}

//--------------------------------------

SETINLIST::~SETINLIST(){

NODE *x,*y;

x=this->Head;

do {

y=x->Next;

delete x;

x=y;

} while (x!=Head);

}

//--------------------------------

NODE *SETINLIST::Insert(NODE *p){

NODE *x=new NODE;

x->Next=p->Next;

p->Next=x;

return x;

}

//----------------------------------