Реферат: Шпоры по Си. Шаблоны стандартных структур данных Реферат: Шпоры по Си. Шаблоны стандартных структур данных
Реферат: Шпоры по Си. Шаблоны стандартных структур данных РЕФЕРАТЫ РЕКОМЕНДУЕМ  
 
Тема
 • Главная
 • Авиация
 • Астрономия
 • Безопасность жизнедеятельности
 • Биографии
 • Бухгалтерия и аудит
 • География
 • Геология
 • Животные
 • Иностранный язык
 • Искусство
 • История
 • Кулинария
 • Культурология
 • Лингвистика
 • Литература
 • Логистика
 • Математика
 • Машиностроение
 • Медицина
 • Менеджмент
 • Металлургия
 • Музыка
 • Педагогика
 • Политология
 • Право
 • Программирование
 • Психология
 • Реклама
 • Социология
 • Страноведение
 • Транспорт
 • Физика
 • Философия
 • Химия
 • Ценные бумаги
 • Экономика
 • Естествознание



Реферат: Шпоры по Си. Шаблоны стандартных структур данных

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

// 1. стек представлен динамическим массивом

// 1. хранение указателей на объекты

// 1. включение элемента с сохранением упорядоченности

template class StackDA

{ private:

T **data; //динамический МУ на данные

int size,sp; //размер стека,кол-во элементов

public:

StackDA(int _size);

int Push(T &element); //результат:если стек полный то [-1]

//иначе, количество
элементов

T *Pop(void); //результат:если стек пустой то [NULL]

~StackDA(void); };

template StackDA::StackDA(int _size)

{ size=_size;

data=(T**)new char[size*sizeof(T*)]; //выделение памяти под
МУ

sp=0; }

template int StackDA::Push(T &element)

{ if(sp==size) return -1; //стек полный

for(int k=0;k
for(int p=++sp;p>k;p--) data[p]=data[p-1];

data[k]=&element;

return sp; }

template T *StackDA::Pop(void)

{ if(sp==0) return NULL; //стек пустой

return data[--sp]; }

template StackDA::~StackDA(void)

{ delete data; }

void main()

{ StackDA s(20); //стек из 20-ти указателей на int

int a=13,b=5,c=7;

s.Push(a); s.Push(b); s.Push(c); //укладываем данные

int *pa=s.Pop(),*pb=s.Pop(),*pc=s.Pop();}//вытаскиваем упорядоченные

//по возрастанию эл-ты

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

// 1. стек представлен динамическим массивом

// 1. хранение указателей на объекты

// 2. поиск и возвращение минимального объекта

template class StackDA

{ private:

T **data; //динамический МУ на данные

int size,sp; //размер стека,кол-во элементов

public:

StackDA(int _size);

int Push(T &element); //результат:если стек полный то [-1]

//иначе, количество
элементов

T *Pop(void); //результат:если стек пустой то [NULL]

T *FindMin(void);

~StackDA(void); };

template StackDA::StackDA(int _size)

{ size=_size;

data=(T**)new char[size*sizeof(T*)]; //выделение памяти под
МУ

sp=0; }

template int StackDA::Push(T &element)

{ if(sp==size) return -1; //стек полный

data[sp]=&element;

return sp++; }

template T *StackDA::Pop(void)

{ if(sp==0) return NULL; //стек пустой

return data[--sp]; }

template StackDA::~StackDA(void)

{ delete data; }

template T *StackDA::FindMin(void)

{ if(sp==0) return NULL; //стек пустой

T *min=data[0];

for(int k=1;k
return min; }

void main()

{ StackDA s(20); //стек из 20-ти указателей на int

int a=13,b=5,c=7;

s.Push(a); s.Push(b); s.Push(c); //укладываем данные

int *m=s.FindMin(); } // поиск мин.

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

// 1. стек представлен динамическим массивом

// 1. хранение указателей на объекты

// 3. сортировка(любым методом)

template class StackDA

{ private:

T **data; //динамический МУ на данные

int size,sp; //размер стека,кол-во элементов

public:

StackDA(int _size);

int Push(T &element); //результат:если стек полный то [-1]

//иначе, количество
элементов

T *Pop(void); //результат:если стек пустой то [NULL]

void Sort(void);

~StackDA(void); };

template StackDA::StackDA(int _size)

{ size=_size;

data=(T**)new char[size*sizeof(T*)]; //выделение памяти под
МУ

sp=0; }

template int StackDA::Push(T &element)

{ if(sp==size) return -1; //стек полный

data[sp]=&element;

return sp++; }

template T *StackDA::Pop(void)

{ if(sp==0) return NULL; //стек пустой

return data[--sp]; }

template void StackDA::Sort(void)

{ for(int i=0;i
for(int j=i+1;j
if(*data[j]>*data[i])

{ T *temp=data[j];data[j]=data[i];data[i]=temp; } } //
обмен

template StackDA::~StackDA(void)

{ delete data; }

void main()

{ StackDA s(20); //стек из 20-ти указателей на int

int a=13,b=5,c=7;

s.Push(a); s.Push(b); s.Push(c); //укладываем данные

s.Sort();

int *pa=s.Pop(),*pb=s.Pop(),*pc=s.Pop();}//вытаскиваем упорядоченные

//по возрастанию эл-ты

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

// 1. стек представлен динамическим массивом

// 1. хранение указателей на объекты

// 4. двоичный поиск по ключу

template class StackDA

{ private:

T **data; //динамический МУ на данные

int size,sp; //размер стека,кол-во элементов

public:

StackDA(int _size);

int Push(T &element); //результат:если стек полный то [-1]

//иначе, количество
элементов

T *Pop(void); //результат:если стек пустой то [NULL]

void Sort(void);

T *FindBin(T &key); //двоичный поиск

~StackDA(void); };

template StackDA::StackDA(int _size)

{ size=_size;

data=(T**)new char[size*sizeof(T*)]; //выделение памяти под
МУ

sp=0; }

template int StackDA::Push(T &element)

{ if(sp==size) return -1; //стек полный

data[sp]=&element;

return sp++; }

template T *StackDA::Pop(void)

{ if(sp==0) return NULL; //стек пустой

return data[--sp]; }

template void StackDA::Sort(void)

{ for(int i=0;i
for(int j=i+1;j
if(*data[j]>*data[i])

{ T *temp=data[j];data[j]=data[i];data[i]=temp; } } //
обмен

template T *StackDA::FindBin(T &key)

{ int a=0,b=sp-1; //начало,конец отрезка

while(a<=b)

{ int m=(a+b)/2; //середина

if(*data[m]==key) return data[m]; //совпало с ключом

if(*data[m]>key) a=m+1; //правая часть

else b=m-1; }//левая
часть

return NULL; } //не найден

template StackDA::~StackDA(void)

{ delete data; }

void main()

{ StackDA s(20); //стек из 20-ти указателей на int

int a=13,b=5,c=7,d=13;

s.Push(a); s.Push(b); s.Push(c); //укладываем данные

s.Sort(); int *k=s.FindBin(d); } //поиск

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

// 1. стек представлен динамическим массивом

// 1. хранение указателей на объекты

// 5. включение элемента по номеру

template class StackDA

{ private:

T **data; //динамический МУ на данные

int size,sp; //размер стека,кол-во элементов

public:

StackDA(int _size);

int Push(T &element); //результат:если стек полный то [-1]

//иначе, количество
элементов

T *Pop(void); //результат:если стек пустой то [NULL]

int Insert(T &element,int num); //включение по номеру

//результат:если нельзя то [-1]

//иначе, количество
элементов

~StackDA(void); };

template StackDA::StackDA(int _size)

{ size=_size;

data=(T**)new char[size*sizeof(T*)]; //выделение памяти под
МУ

sp=0; }

template int StackDA::Push(T &element)

{ if(sp==size) return -1; //стек полный

data[sp]=&element;

return sp++; }

template T *StackDA::Pop(void)

{ if(sp==0) return NULL; //стек пустой

return data[--sp]; }

template int StackDA::Insert(T &element,int num)

return sp;

template StackDA::~StackDA(void)

{ delete data; }

void main()

{ StackDA s(20); //стек из 20-ти указателей на int

int a=13,b=5,c=7;

s.Push(a); s.Push(b); //укладываем данные

s.Insert(c,1); //вставляем элемент

int *pa=s.Pop(),*pb=s.Pop(),*pc=s.Pop();}//вытаскиваем эл-ты

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

// 1. стек представлен динамическим массивом

// 1. хранение указателей на объекты

// 6. исключение элемента по номеру

template class StackDA

{ private:

T **data; //динамический МУ на данные

int size,sp; //размер стека,кол-во элементов

public:

StackDA(int _size);

int Push(T &element); //результат:если стек полный то [-1]

//иначе, количество
элементов

T *Pop(void); //результат:если стек пустой то [NULL]

T *Exclude(int num); //исключение по номеру

//результат:если нельзя то [NULL]

~StackDA(void); };

template StackDA::StackDA(int _size)

{ size=_size;

data=(T**)new char[size*sizeof(T*)]; //выделение памяти под
МУ

sp=0; }

template int StackDA::Push(T &element)

{ if(sp==size) return -1; //стек полный

data[sp]=&element;

return sp++; }

template T *StackDA::Pop(void)

{ if(sp==0) return NULL; //стек пустой

return data[--sp]; }

template T *StackDA::Exclude(int num)



template StackDA::~StackDA(void)

{ delete data; }

void main()

{ StackDA s(20); //стек из 20-ти указателей на int

int a=13,b=5,c=7;

s.Push(a); s.Push(b); s.Push(c); //укладываем данные

int *k=s.Exclude(1); //вытаскиваем элемент

int *pa=s.Pop(),*pb=s.Pop(),*pc=s.Pop();}//вытаскиваем эл-ты

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

// 1. стек представлен динамическим массивом

// 1. хранение указателей на объекты

// 7. поиск и возвращение элемента по номеру

template class StackDA

{ private:

T **data; //динамический МУ на данные

int size,sp; //размер стека,кол-во элементов

public:

StackDA(int _size);

int Push(T &element); //результат:если стек полный то [-1]

//иначе, количество
элементов

T *Pop(void); //результат:если стек пустой то [NULL]

T *operator[](int num); //взятие по номеру

//результат:если нельзя то [NULL]

~StackDA(void); };

template StackDA::StackDA(int _size)

{ size=_size;

data=(T**)new char[size*sizeof(T*)]; //выделение памяти под
МУ

sp=0; }

template int StackDA::Push(T &element)

{ if(sp==size) return -1; //стек полный

data[sp]=&element;

return sp++; }

template T *StackDA::Pop(void)

{ if(sp==0) return NULL; //стек пустой

return data[--sp]; }

template T *StackDA::operator[](int num)

большой


template StackDA::~StackDA(void)

{ delete data; }

void main()

{ StackDA s(20); //стек из 20-ти указателей на int

int a=13,b=5,c=7;

s.Push(a); s.Push(b); s.Push(c); //укладываем данные

int *k=s[1]; //берем элемент

int *pa=s.Pop(),*pb=s.Pop(),*pc=s.Pop();}//вытаскиваем эл-ты

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

// 1. стек представлен динамическим массивом

// 2. хранение объектов

// 1. включение элемента с сохранением упорядоченности

template class StackDA

{ private:

T *data;

int size,sp; //размер стека,кол-во элементов

public:

StackDA(int _size);

int Push(T element); //результат:если стек полный то [-1]

//иначе, количество
элементов

T *Pop(void); //результат:если стек пустой то [NULL]

~StackDA(void); };

template StackDA::StackDA(int _size)

{ size=_size;

data=(T*)new T[size]; //выделение памяти

sp=0; }

template int StackDA::Push(T element)

{ if(sp==size) return -1; //стек полный

for(int k=0;k
for(int p=++sp;p>k;p--) data[p]=data[p-1];

data[k]=element;

return sp; }

template T *StackDA::Pop(void)

{ if(sp==0) return NULL; //стек пустой

return &data[--sp]; }

template StackDA::~StackDA(void)

{ delete [] data; }

void main()

{ StackDA s(20); //стек из 20-ти int

s.Push(27); s.Push(13); s.Push(19); //укладываем данные

int *pa=s.Pop(),*pb=s.Pop(),*pc=s.Pop();

}//вытаскиваем упорядоченные

//по возрастанию эл-ты

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

// 1. стек представлен динамическим массивом

// 2. хранение объектов

// 2. поиск и возвращение минимального объекта

template class StackDA

{ private:

T *data;

int size,sp; //размер стека,кол-во элементов

public:

StackDA(int _size);

int Push(T element); //результат:если стек полный то [-1]

//иначе, количество
элементов

T *Pop(void); //результат:если стек пустой то [NULL]

T *FindMin(void);

~StackDA(void); };

template StackDA::StackDA(int _size)

{ size=_size;

data=(T*)new T[size]; //выделение памяти

sp=0; }

template int StackDA::Push(T element)

{ if(sp==size) return -1; //стек полный

data[sp]=element;

return sp++; }

template T *StackDA::Pop(void)

{ if(sp==0) return NULL; //стек пустой

return &data[--sp]; }

template StackDA::~StackDA(void)

{ delete [] data; }

template T *StackDA::FindMin(void)

{ if(sp==0) return NULL; //стек пустой

int min=data[0];

for(int k=1;k
return &data[min]; }

void main()

{ StackDA s(20); //стек из 20-ти int

s.Push(55); s.Push(11); s.Push(33); //укладываем данные

int *m=s.FindMin(); } // поиск мин.

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

// 1. стек представлен динамическим массивом

// 2. хранение объектов

// 3. сортировка(любым методом)

template class StackDA

{ private:

T *data;

int size,sp; //размер стека,кол-во элементов

public:

StackDA(int _size);

int Push(T element); //результат:если стек полный то [-1]

//иначе, количество
элементов

T *Pop(void); //результат:если стек пустой то [NULL]

void Sort(void);

~StackDA(void); };

template StackDA::StackDA(int _size)

{ size=_size;

data=(T*)new T[size]; //выделение памяти

sp=0; }

template int StackDA::Push(T element)

{ if(sp==size) return -1; //стек полный

data[sp]=element;

return sp++; }

template T *StackDA::Pop(void)

{ if(sp==0) return NULL; //стек пустой

return &data[--sp]; }

template void StackDA::Sort(void)

{ for(int i=0;i
for(int j=i+1;j
if(data[j]>data[i])

{ T temp=data[j];data[j]=data[i];data[i]=temp; } } //
обмен

template StackDA::~StackDA(void)

{ delete [] data; }

void main()

{ StackDA s(20); //стек из 20-ти int

s.Push(35); s.Push(17); s.Push(29); //укладываем данные

s.Sort();

int *pa=s.Pop(),*pb=s.Pop(),*pc=s.Pop();}//вытаскиваем упорядоченные

//по возрастанию эл-ты

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

// 1. стек представлен динамическим массивом

// 2. хранение объектов

// 4. двоичный поиск по ключу

template class StackDA

{ private:

T *data;

int size,sp; //размер стека,кол-во элементов

public:

StackDA(int _size);

int Push(T element); //результат:если стек полный то [-1]

//иначе, количество
элементов

T *Pop(void); //результат:если стек пустой то [NULL]

void Sort(void);

T *FindBin(T key); //двоичный поиск

~StackDA(void); };

template StackDA::StackDA(int _size)

{ size=_size;

data=(T*)new T[size]; //выделение памяти

sp=0; }

template int StackDA::Push(T element)

{ if(sp==size) return -1; //стек полный

data[sp]=element;

return sp++; }

template T *StackDA::Pop(void)

{ if(sp==0) return NULL; //стек пустой

return &data[--sp]; }

template void StackDA::Sort(void)

{ for(int i=0;i
for(int j=i+1;j
if(data[j]>data[i])

{ T temp=data[j];data[j]=data[i];data[i]=temp; } } //
обмен

template T *StackDA::FindBin(T key)

{ int a=0,b=sp-1; //начало,конец отрезка

while(a<=b)

{ int m=(a+b)/2; //середина

if(data[m]==key) return &data[m]; //совпало с ключом

if(data[m]>key) a=m+1; //правая часть

else b=m-1; }//левая часть

return NULL; } //не найден

template StackDA::~StackDA(void)

{ delete [] data; }

void main()

{ StackDA s(20); //стек из 20-ти int

s.Push(78); s.Push(10); s.Push(5); //укладываем данные

s.Sort(); int *k=s.FindBin(78); } //поиск

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

// 1. стек представлен динамическим массивом

// 2. хранение объектов

// 5. включение элемента по номеру

template class StackDA

{ private:

T *data;

int size,sp; //размер стека,кол-во элементов

public:

StackDA(int _size);

int Push(T element); //результат:если стек полный то [-1]

//иначе, количество
элементов

T *Pop(void); //результат:если стек пустой то [NULL]

int Insert(T element,int num); //включение по номеру

//результат:если нельзя то [-1]

//иначе, количество
элементов

~StackDA(void); };

template StackDA::StackDA(int _size)

{ size=_size;

data=(T*)new T[size]; //выделение памяти

sp=0; }

template int StackDA::Push(T element)

{ if(sp==size) return -1; //стек полный

data[sp]=element;

return sp++; }

template T *StackDA::Pop(void)

{ if(sp==0) return NULL; //стек пустой

return &data[--sp]; }

template int StackDA::Insert(T element,int num)




template StackDA::~StackDA(void)

{ delete []data; }

void main()

{ StackDA s(20); //стек из 20-ти int

s.Push(99); s.Push(45); //укладываем данные

s.Insert(33,1); //вставляем элемент

int *pa=s.Pop(),*pb=s.Pop(),*pc=s.Pop();}//вытаскиваем эл-ты

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

// 1. стек представлен динамическим массивом

// 2. хранение объектов

// 6. исключение элемента по номеру

template class StackDA

{ private:

T *data;

int size,sp; //размер стека,кол-во элементов

public:

StackDA(int _size);

int Push(T element); //результат:если стек полный то [-1]

//иначе, количество
элементов

T *Pop(void); //результат:если стек пустой то [NULL]

void Exclude(int num); //исключение по номеру

//результат:если нельзя то [NULL]

~StackDA(void); };

template StackDA::StackDA(int _size)

{ size=_size;

data=(T*)new T[size]; //выделение памяти

sp=0; }

template int StackDA::Push(T element)

{ if(sp==size) return -1; //стек полный

data[sp]=element;

return sp++; }

template T *StackDA::Pop(void)

{ if(sp==0) return NULL; //стек пустой

return &data[--sp]; }

template void StackDA::Exclude(int num)

num<0)return;//стек пустой или номер слишком


template StackDA::~StackDA(void)

{ delete [] data; }

void main()

{ StackDA s(20); //стек из 20-ти int

s.Push(35); s.Push(11); s.Push(89); //укладываем данные

s.Exclude(1); //вытаскиваем элемент

int *pa=s.Pop(),*pb=s.Pop(),*pc=s.Pop(); }//вытаскиваем эл-ты

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

// 1. стек представлен динамическим массивом

// 2. хранение объектов

// 7. поиск и возвращение элемента по номеру

template class StackDA

{ private:

T *data;

int size,sp; //размер стека,кол-во элементов

public:

StackDA(int _size);

int Push(T element); //результат:если стек полный то [-1]

//иначе, количество
элементов

T *Pop(void); //результат:если стек пустой то [NULL]

T *operator[](int num); //взятие по номеру

//результат:если нельзя то [NULL]

~StackDA(void); };

template StackDA::StackDA(int _size)

{ size=_size;

data=(T*)new T[size]; //выделение памяти

sp=0; }

template int StackDA::Push(T element)

{ if(sp==size) return -1; //стек полный

data[sp]=element;

return sp++; }

template T *StackDA::Pop(void)

{ if(sp==0) return NULL; //стек пустой

return &data[--sp]; }

template T *StackDA::operator[](int num)

return &data[num];

template StackDA::~StackDA(void)

{ delete []data; }

void main()

{ StackDA s(20); //стек из 20-ти int

s.Push(54); s.Push(23); s.Push(87); //укладываем данные

int *k=s[1]; //берем элемент

int *pa=s.Pop(),*pb=s.Pop(),*pc=s.Pop();}//вытаскиваем эл-ты

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

// 2. стек представлен статическим массивом

// 1. хранение указателей на объекты

// 1. включение элемента с сохранением упорядоченности

template class StackSA

{ private:

T *data [size]; //cтатический МУ на
данные

int sp; //кол-во элементов

public:

StackSA();

int Push(T &element); //результат:если стек полный то [-1]

//иначе, количество
элементов

T *Pop(void);}; //результат:если стек пустой то [NULL]

template StackSA::StackSA()

{ sp=0; }

template int StackSA::Push(T &element)

{ if(sp==size) return -1; //стек полный

for(int k=0;k
for(int p=++sp;p>k;p--) data[p]=data[p-1];

data[k]=&element;

return sp; }

template T *StackSA::Pop(void)

{ if(sp==0) return NULL; //стек пустой

return data[--sp]; }

void main()

{ StackSA s; //стек из 20-ти указателей на int

int a=13,b=5,c=7;

s.Push(a); s.Push(b); s.Push(c); //укладываем данные

int *pa=s.Pop(),*pb=s.Pop(),*pc=s.Pop();}//вытаскиваем упорядоченные

//по возрастанию эл-ты

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

// 2. стек представлен cтатическим массивом

// 1. хранение указателей на объекты

// 2. поиск и возвращение минимального объекта

template class StackSA

{ private:

T *data[size]; //cтатический МУ на
данные

int sp; //кол-во элементов

public:

StackSA();

int Push(T &element); //результат:если стек полный то [-1]

//иначе, количество
элементов

T *Pop(void); //результат:если стек пустой то [NULL]

T *FindMin(void);};

template StackSA::StackSA()

{ sp=0; }

template int StackSA::Push(T &element)

{ if(sp==size) return -1; //стек полный

data[sp]=&element;

return sp++; }

template T *StackSA::Pop(void)

{ if(sp==0) return NULL; //стек пустой

return data[--sp]; }

template T *StackSA::FindMin(void)

{ if(sp==0) return NULL; //стек пустой

T *min=data[0];

for(int k=1;k
return min; }

void main()

{ StackSA s; //стек из 20-ти указателей на int

int a=13,b=5,c=7;

s.Push(a); s.Push(b); s.Push(c); //укладываем данные

int *m=s.FindMin();} // поиск мин.

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

// 2. стек представлен cтатическим массивом

// 1. хранение указателей на объекты

// 3. сортировка(любым методом)

template class StackSA

{ private:

T *data[size]; //статический МУ на
данные

int sp; //размер стека,кол-во элементов

public:

StackSA();

int Push(T &element); //результат:если стек полный то [-1]

//иначе, количество
элементов

T *Pop(void); //результат:если стек пустой то [NULL]

void Sort(void);};

template StackSA::StackSA()

{ sp=0; }

template int StackSA::Push(T &element)

{ if(sp==size) return -1; //стек полный

data[sp]=&element;

return sp++; }

template T *StackSA::Pop(void)

{ if(sp==0) return NULL; //стек пустой

return data[--sp]; }

template void StackSA::Sort(void)

{ for(int i=0;i
for(int j=i+1;j
if(*data[j]>*data[i])

{ T *temp=data[j];data[j]=data[i];data[i]=temp; } } //
обмен

void main()

{ StackSA s; //стек из 20-ти указателей на int

int a=13,b=5,c=7;

s.Push(a); s.Push(b); s.Push(c); //укладываем данные

s.Sort();

int *pa=s.Pop(),*pb=s.Pop(),*pc=s.Pop();

}//вытаскиваем упорядоченные

//по возрастанию эл-ты

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

// 2. стек представлен статическим массивом

// 1. хранение указателей на объекты

// 4. двоичный поиск по ключу

template class StackSA

{ private:

T *data[size]; //статический МУ на
данные

int sp; //кол-во элементов

public:

StackSA();

int Push(T &element); //результат:если стек полный то [-1]

//иначе, количество
элементов

T *Pop(void); //результат:если стек пустой то [NULL]

void Sort(void);

T *FindBin(T &key);}; //двоичный поиск

template StackSA::StackSA()

{ sp=0; }

template int StackSA::Push(T &element)

{ if(sp==size) return -1; //стек полный

data[sp]=&element;

return sp++; }

template T *StackSA::Pop(void)

{ if(sp==0) return NULL; //стек пустой

return data[--sp]; }

template void StackSA::Sort(void)

{ for(int i=0;i
for(int j=i+1;j
if(*data[j]>*data[i])

{ T *temp=data[j];data[j]=data[i];data[i]=temp; } } //
обмен

template T *StackSA::FindBin(T &key)

{ int a=0,b=sp-1; //начало,конец отрезка

while(a<=b)

{ int m=(a+b)/2; //середина

if(*data[m]==key) return data[m]; //совпало с ключом

if(*data[m]>key) a=m+1; //правая часть

else b=m-1; }//левая
часть

return NULL; } //не найден

void main()

{ StackSA s; //стек из 20-ти указателей на int

int a=13,b=5,c=7,d=13;

s.Push(a); s.Push(b); s.Push(c); //укладываем данные

s.Sort(); int *k=s.FindBin(d);} //поиск

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

// 2. стек представлен статическим массивом

// 1. хранение указателей на объекты

// 5. включение элемента по номеру

template class StackSA

{ private:

T *data[size]; //статический МУ на
данные

int sp; //кол-во элементов

public:

StackSA();

int Push(T &element); //результат:если стек полный то [-1]

//иначе, количество
элементов

T *Pop(void); //результат:если стек пустой то [NULL]

int Insert(T &element,int num); //включение по номеру

//результат:если нельзя то [-1]

}; //иначе, количество
элементов

template StackSA::StackSA()

{ sp=0; }

template int StackSA::Push(T &element)

{ if(sp==size) return -1; //стек полный

data[sp]=&element;

return sp++; }

template T *StackSA::Pop(void)

{ if(sp==0) return NULL; //стек пустой

return data[--sp]; }

template int StackSA::Insert(T &element,int
num)




void main()

{ StackSA s; //стек из 20-ти указателей на int

int a=13,b=5,c=7;

s.Push(a); s.Push(b); //укладываем данные

s.Insert(c,1); //вставляем элемент

int *pa=s.Pop(),*pb=s.Pop(),*pc=s.Pop();

}//вытаскиваем эл-ты

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

// 2. стек представлен ссстатическим массивом

// 1. хранение указателей на объекты

// 6. исключение элемента по номеру

template class StackSA

{ private:

T *data[size]; //статический МУ на
данные

int sp; //кол-во элементов

public:

StackSA();

int Push(T &element); //результат:если стек полный то [-1]

//иначе, количество
элементов

T *Pop(void); //результат:если стек пустой то [NULL]

T *Exclude(int num); //исключение по номеру

}; //результат:если нельзя то [NULL]

template StackSA::StackSA()

{ sp=0; }

template int StackSA::Push(T &element)

{ if(sp==size) return -1; //стек полный

data[sp]=&element;

return sp++; }

template T *StackSA::Pop(void)

{ if(sp==0) return NULL; //стек пустой

return data[--sp]; }

template T *StackSA::Exclude(int num)

num>=sp

void main()

{ StackSA s; //стек из 20-ти указателей на int

int a=13,b=5,c=7;

s.Push(a); s.Push(b); s.Push(c); //укладываем данные

int *k=s.Exclude(1); //вытаскиваем элемент

int *pa=s.Pop(),*pb=s.Pop(),*pc=s.Pop();

}//вытаскиваем эл-ты

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

// 2. стек представлен статическим массивом

// 1. хранение указателей на объекты

// 7. поиск и возвращение элемента по номеру

template class StackSA

{ private:

T *data; //статический МУ на данные

int sp; //кол-во элементов

public:

StackSA();

int Push(T &element); //результат:если стек полный то [-1]

//иначе, количество
элементов

T *Pop(void); //результат:если стек пустой то [NULL]

T *operator[](int num); //взятие по номеру

}; //результат:если нельзя то [NULL]

template StackSA::StackSA()

{ sp=0; }

template int StackSA::Push(T &element)

{ if(sp==size) return -1; //стек полный

data[sp]=element;

return sp++; }

template T *StackSA::Pop(void)

{ if(sp==0) return NULL; //стек пустой

return &data[--sp]; }

template T *StackSA::operator[](int num)

return NULL;//стек пустой или номер слишком


void main()

{ StackSA s; //стек из 20-ти указателей на int

int a=13,b=5,c=7;

s.Push(a); s.Push(b); s.Push(c); //укладываем данные

int *k=s[1]; //берем элемент

int *pa=s.Pop(),*pb=s.Pop(),*pc=s.Pop(); }//вытаскиваем эл-ты

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

// 2. стек представлен статическим массивом

// 2. хранение объектов

// 1. включение элемента с сохранением упорядоченности

template class StackSA

{ private:

T data[size];

int sp; //размер стека,кол-во элементов

public:

StackSA();

int Push(T element); //результат:если стек полный то [-1]

//иначе, количество элементов

T *Pop(void);}; //результат:если стек пустой то [NULL]

template StackSA::StackSA()

{ sp=0; }

template int StackSA::Push(T element)

{ if(sp==size) return -1; //стек полный

for(int k=0;k
for(int p=++sp;p>k;p--) data[p]=data[p-1];

data[k]=element;

return sp; }

template T *StackSA::Pop(void)

{ if(sp==0) return NULL; //стек пустой

return &data[--sp]; }

void main()

{ StackSA s; //стек из 25-ти int

s.Push(27); s.Push(13); s.Push(19); //укладываем данные

int *pa=s.Pop(),*pb=s.Pop(),*pc=s.Pop();}//вытаскиваем упорядоченные

//по возрастанию эл-ты

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

// 2. стек представлен статическим массивом

// 2. хранение объектов

// 2. поиск и возвращение минимального объекта

template class StackSA

{ private:

T data[size];

int sp; //размер стека,кол-во элементов

public:

StackSA();

int Push(T element); //результат:если стек полный то [-1]

//иначе, количество
элементов

T *Pop(void); //результат:если стек пустой то [NULL]

T *FindMin(void); };

template StackSA::StackSA()

{ sp=0; }

template int StackSA::Push(T element)

{ if(sp==size) return -1; //стек полный

data[sp]=element;

return sp++; }

template T *StackSA::Pop(void)

{ if(sp==0) return NULL; //стек пустой

return &data[--sp]; }

template T *StackSA::FindMin(void)

{ if(sp==0) return NULL; //стек пустой

int min=data[0];

for(int k=1;k
return &data[min]; }

void main()

{ StackSA s; //стек из 30-ти int

s.Push(55); s.Push(11); s.Push(33); //укладываем данные

int *m=s.FindMin(); } // поиск мин.

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

// 2. стек представлен статическим массивом

// 2. хранение объектов

// 3. сортировка(любым методом)

template class StackSA

{ private:

T data[size];

int sp; //размер стека,кол-во элементов

public:

StackSA();

int Push(T element); //результат:если стек полный то [-1]

//иначе, количество
элементов

T *Pop(void); //результат:если стек пустой то [NULL]

void Sort(void); };

template StackSA::StackSA()

{ sp=0; }

template int StackSA::Push(T element)

{ if(sp==size) return -1; //стек полный

data[sp]=element;

return sp++; }

template T *StackSA::Pop(void)

{ if(sp==0) return NULL; //стек пустой

return &data[--sp]; }

template void StackSA::Sort(void)

{ for(int i=0;i
for(int j=i+1;j
if(data[j]>data[i])

{ T temp=data[j];data[j]=data[i];data[i]=temp; } } //
обмен

void main()

{ StackSA s; //стек из 10-ти int

s.Push(35); s.Push(17); s.Push(29); //укладываем данные

s.Sort();

int *pa=s.Pop(),*pb=s.Pop(),*pc=s.Pop(); }//вытаскиваем
упорядоченные

//по возрастанию эл-ты

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

// 2. стек представлен статическим массивом

// 2. хранение объектов

// 4. двоичный поиск по ключу

template class StackSA

{ private:

T data[size];

int sp; //кол-во элементов

public:

StackSA();

int Push(T element); //результат:если стек полный то [-1]

//иначе, количество
элементов

T *Pop(void); //результат:если стек пустой то [NULL]

void Sort(void);

T *FindBin(T key); }; //двоичный поиск

template StackSA::StackSA()

{ sp=0; }

template int StackSA::Push(T element)

{ if(sp==size) return -1; //стек полный

data[sp]=element;

return sp++; }

template T *StackSA::Pop(void)

{ if(sp==0) return NULL; //стек пустой

return &data[--sp]; }

template void StackSA::Sort(void)

{ for(int i=0;i
for(int j=i+1;j
if(data[j]>data[i])

{ T temp=data[j];data[j]=data[i];data[i]=temp; } } //
обмен

template T *StackSA::FindBin(T key)

{ int a=0,b=sp-1; //начало,конец отрезка

while(a<=b)

{ int m=(a+b)/2; //середина

if(data[m]==key) return &data[m]; //совпало с ключом

if(data[m]>key) a=m+1; //правая часть

else b=m-1; }//левая часть

return NULL; } //не найден

void main()

{ StackSA s; //стек из 20-ти int

s.Push(78); s.Push(10); s.Push(5); //укладываем данные

s.Sort(); int *k=s.FindBin(78); } //поиск

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

// 2. стек представлен статическим массивом

// 2. хранение объектов

// 5. включение элемента по номеру

template class StackSA

{ private:

T data[size];

int sp; //размер стека,кол-во элементов

public:

StackSA();

int Push(T element); //результат:если стек полный то [-1]

//иначе, количество
элементов

T *Pop(void); //результат:если стек пустой то [NULL]

int Insert(T element,int num); //включение по номеру

//результат:если нельзя то [-1]

//иначе, количество элементов

};

template StackSA::StackSA()

{ sp=0; }

template int StackSA::Push(T element)

{ if(sp==size) return -1; //стек полный

data[sp]=element;

return sp++; }

template T *StackSA::Pop(void)

{ if(sp==0) return NULL; //стек пустой

return &data[--sp]; }

template int StackSA::Insert(T element,int
num)

num>sp

void main()

{ StackSA s; //стек из 20-ти int

s.Push(99); s.Push(45); //укладываем данные

s.Insert(33,1); //вставляем элемент

int *pa=s.Pop(),*pb=s.Pop(),*pc=s.Pop();}//вытаскиваем эл-ты

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

// 2. стек представлен статическим массивом

// 2. хранение объектов

// 6. исключение элемента по номеру

template class StackSA

{ private:

T data[size];

int sp; //размер стека,кол-во элементов

public:

StackSA();

int Push(T element); //результат:если стек полный то [-1]

//иначе, количество
элементов

T *Pop(void); //результат:если стек пустой то [NULL]

void Exclude(int num); }; //исключение по номеру

//результат:если нельзя то [NULL]

template StackSA::StackSA()

{ sp=0; }

template int StackSA::Push(T element)

{ if(sp==size) return -1; //стек полный

data[sp]=element;

return sp++; }

template T *StackSA::Pop(void)

{ if(sp==0) return NULL; //стек пустой

return &data[--sp]; }

template void StackSA::Exclude(int num)

большой


void main()

{ StackSA s; //стек из 20-ти int

s.Push(35); s.Push(11); s.Push(89); //укладываем данные

s.Exclude(1); //вытаскиваем элемент

int *pa=s.Pop(),*pb=s.Pop(),*pc=s.Pop(); }//вытаскиваем эл-ты

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

// 2. стек представлен статическим массивом

// 2. хранение объектов

// 7. поиск и возвращение элемента по номеру

template class StackSA

{ private:

T data[size];

int sp; //размер стека,кол-во элементов

public:

StackSA();

int Push(T element); //результат:если стек полный то [-1]

//иначе, количество
элементов

T *Pop(void); //результат:если стек пустой то [NULL]

T *operator[](int num);}; //взятие по номеру

//результат:если нельзя то [NULL]

template StackSA::StackSA()

{ sp=0; }

template int StackSA::Push(T element)

{ if(sp==size) return -1; //стек полный

data[sp]=element;

return sp++; }

template T *StackSA::Pop(void)

{ if(sp==0) return NULL; //стек пустой

return &data[--sp]; }

template T *StackSA::operator[](int num)



void main()

{ StackSA s; //стек из 20-ти int

s.Push(54); s.Push(23); s.Push(87); //укладываем данные

int *k=s[1]; //берем элемент

int *pa=s.Pop(),*pb=s.Pop(),*pc=s.Pop();}//вытаскиваем эл-ты

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

//3. статический массив

//1. хранение указателей на обьекты

//1. Включение элемента с сохранением упорядочености.

template class SArray

{ private:

T *data[size];

public:

SArray();

~SArray();

void operator+(T *q);

T* operator[](int i);};

template SArray::SArray()

{ for(int k=0;k
template SArray::~SArray()

{ for(int k=0;k
template void
SArray::ope???????†††????????????????????

if(k==size) return; //нет места в массиве

for(;k>0&&*data[k-1]>*q;k--) data[k]=data[k-1]; //раздвигаем элементы

data[k]=q; } //вставляем элемент

template T* SArray::operator[](int i)



void main()

{ SArray a; //заводим массив указателей на int

a+new int(5); a+new int(25); a+new int(15); //заносим
значения

int k=*a[1]; } // получаем значение 15

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

//3. статический массив

//1. хранение указателей на обьекты

//2. Поиск и возвращение минимального об"екта.

template class SArray

{ private:

T *data[size];

public:

SArray();

~SArray();

T* Min();

T* operator[](int i);};

template SArray::SArray()

{ for(int k=0;k
template SArray::~SArray()

{ for(int k=0;k
template T* SArray::Min()

{ for(int k=0;k элемента

int tmp=k++; //в tmp

for(;k
if(data[k]!=NULL&&*data[k]<*data[tmp]) tmp=k; //поиск
минимального

return data[tmp]; }

template T* SArray::operator[](int i)




void main()

{ SArray a; //заводим массив указателей на int

*a[1]=5; *a[4]=3; *a[3]=7; //заносим значения

int k=*a.Min(); } // получаем значение 3

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

//3. статический массив

//1. хранение указателей на обьекты

//3. Сортировка (любым методом).

template class SArray

{ private:

T *data[size];

public:

SArray();

~SArray();

void Sort();

T* operator[](int i); };

template SArray::SArray()

{ for(int k=0;k
template SArray::~SArray()

{ for(int k=0;k
template void SArray::Sort()

{ for(int i=0;i
for(int j=i+1;j
if(data[i]==NULL||(data[j]!=NULL&&*data[j]<*data[i]))
//сравнение

{ T* tmp=data[j]; data[j]=data[i]; data[i]=tmp; } } //обмен

template T* SArray::operator[](int i)




void main()

{ SArray a; //заводим массив указателей на int

*a[1]=15; *a[4]=9; *a[3]=17; //заносим значения

a.Sort(); //сортируем

int i=*a[0],j=*a[1],k=*a[2]; } //достаем отсортированнные по
возрастанию

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

//3. статический массив

//1. хранение указателей на обьекты

//4. Двоичный поиск на основе сравнения с внешним об"ектом-ключом

template class SArray

{ private:

T *data[size];

public:

SArray();

~SArray();

T* FindBin(T &key);

T* operator[](int i);};

template SArray::SArray()

{ for(int k=0;k
template SArray::~SArray()

{ for(int k=0;k
template T* SArray::FindBin(T& key)

{ int a=0,b=size-1; //начало,конец отрезка

while(a<=b)

{ int m=(a+b)/2; //середина

while(data[m]==NULL&&m>a) m--;

{ if(*data[m]==key) return data[m]; //совпало с ключом

if(*data[m]>key) a=m+1; //правая часть

else b=m-1; } }
//левая часть

return NULL; } //не найден

template T* SArray::operator[](int i)

i>=size) return NULL;


void main()

{ SArray a; //заводим массив указателей на int

*a[0]=5; *a[1]=9; *a[2]=17; //заносим значения

int i=*a.FindBin(17); } //двоичный поиск

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

//3. статический массив

//1. хранение указателей на обьекты

//5. Включение элемента по номеру.

template class SArray

{ private:

T *data[size];

public:

SArray();

~SArray();

T* operator[](int i);};

template SArray::SArray()

{ for(int k=0;k
template SArray::~SArray()

{ for(int k=0;k
template T* SArray::operator[](int i)



void main()

{ SArray a; //заводим массив указателей на int

*a[4]=6; *a[6]=7; *a[1]=2; //заносим значения

int i=*a[4]; i=*a[6]; i=*a[1];} //получаем значения

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

//3. статический массив

//1. хранение указателей на обьекты

//6. Исключение (удаление) элемента по номеру.

template class SArray

{ private:

T *data[size];

public:

SArray();

~SArray();

T* operator[](int i);

void Del(int i); };

template SArray::SArray()

{ for(int k=0;k
template SArray::~SArray()

{ for(int k=0;k
template T* SArray::operator[](int i)



template void SArray::Del(int i)

if(data[i]==NULL) return;


void main()

{ SArray a; //заводим массив указателей на int

*a[0]=500; *a[1]=98; *a[2]=17; //заносим значения

a.Del(0); a.Del(1); a.Del(2); } //удаляем

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

//3. статический массив

//1. хранение указателей на обьекты

//7. Поиск и возвращение элемента по номеру.

template class SArray

{ private:

T *data[size];

public:

SArray();

~SArray();

T* operator[](int i); };

template SArray::SArray()

{ for(int k=0;k
template SArray::~SArray()

{ for(int k=0;k
template T* SArray::operator[](int i)




void main()

{ SArray a; //заводим массив указателей на int

*a[4]=6; *a[6]=7; *a[1]=2; //заносим значения

int i=*a[4]; i=*a[6]; i=*a[1]; } //получаем значения

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

//3. статический массив

//2. хранение обьектов

//1. Включение элемента с сохранением упорядочености.

template class SArray

{ private:

T data[size];

public:

SArray();

void operator+(T &q);

T& operator[](int i);};

template SArray::SArray()

{ for(int k=0;k
template void SArray::operator+(T &q)

{ for(int k=0;k
if(k==size) return; //нет места в массиве

for(;k>0&&data[k-1]>q;k--) data[k]=data[k-1]; //раздвигаем элементы

data[k]=q; } //вставляем элемент

template T& SArray::operator[](int i)



void main()

{ SArray a; //заводим массив указателей на int

a+5; a+25; a+15; //заносим значения

int k=a[1]; } // получаем значение 15

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

//3. статический массив

//2. хранение обьектов

//2. Поиск и возвращение минимального об"екта.

template class SArray

{ private:

T data[size];

public:

SArray();

T& Min();

T& operator[](int i);};

template SArray::SArray()

{ for(int k=0;k
template T& SArray::Min()

{ int tmp=0;

for(int k=1;k
//поиск минимального

return data[tmp]; }

template T& SArray::operator[](int i)

if(i<0

void main()

{ SArray a; //заводим массив указателей на int

a[0]=5; a[1]=3; a[2]=7; //заносим значения

int k=a.Min(); } // получаем значение 3

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

//3. статический массив

//2. хранение обьектов

//3. Сортировка (любым методом).

template class SArray

{ private:

T data[size];

public:

SArray();

void Sort();

T& operator[](int i); };

template SArray::SArray()

{ for(int k=0;k
template void SArray::Sort()

{ for(int i=0;i
for(int j=i+1;j
if(data[j]
{ T tmp=data[j]; data[j]=data[i]; data[i]=tmp; } } //обмен

template T& SArray::operator[](int i)

i>=size) return data[0]; //если выходит за границы то


void main()

{ SArray a; //заводим массив указателей на int

a[1]=15; a[4]=9; a[3]=17; //заносим значения

a.Sort(); //сортируем

int i=a[0],j=a[1],k=a[2]; } //достаем отсортированнные по
возрастанию

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

//3. статический массив

//2. хранение обьектов

//4. Двоичный поиск на основе сравнения с внешним об"ектом-ключом

template class SArray

{ private:

T data[size];

public:

SArray();

T& FindBin(T &key);

T& operator[](int i);};

template SArray::SArray()

{ for(int k=0;k data???†††?????????????????????????????…??

{ int a=0,b=size-1,m; //начало,конец отрезка,середина

while(a<=b)

{ m=(a+b)/2; //середина

if(data[m]==key) return data[m]; //совпало с ключом

if(data[m]>key) a=m+1; //правая часть

else b=m-1; } //левая часть

return data[m]; } //не найден возвращаем ближайший

template T& SArray::operator[](int i)



void main()

{ SArray a; //заводим массив указателей на int

a[0]=5; a[1]=9; a[2]=17; //заносим значения

int i=a.FindBin(17); } //двоичный поиск

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

//3. статический массив

//2. хранение обьектов

//5. Включение элемента по номеру.

template class SArray

{ private:

T data[size];

public:

SArray();

T& operator[](int i);};

template SArray::SArray()

{ for(int k=0;k
template T& SArray::operator[](int i)



void main()

{ SArray a; //заводим массив указателей на int

a[4]=6; a[6]=7; a[1]=2; //заносим значения

int i=a[4]; i=a[6]; i=a[1]; } //получаем значения

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

//3. статический массив

//2. хранение обьектов

//6. Исключение (удаление) элемента по номеру.

template class SArray

{ private:

T data[size];

public:

SArray();

T& operator[](int i);

void Del(int i); };

template SArray::SArray()

{ for(int k=0;k
template T& SArray::operator[](int i)




template void SArray::Del(int i)

i>=size) return;


void main()

{ SArray a; //заводим массив указателей на int

a[0]=500; a[1]=98; a[2]=17; //заносим значения

a.Del(0); a.Del(1); a.Del(2); } //"удаляем"

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

//3. статический массив

//2. хранение обьектов

//7. Поиск и возвращение элемента по номеру.

template class SArray

{ private:

T data[size];

public:

SArray();

T& operator[](int i); };

template SArray::SArray()

{ for(int k=0;k
template T& SArray::operator[](int i)



void main()

{ SArray a; //заводим массив указателей на int

a[4]=6; a[6]=7; a[1]=2; //заносим значения

int i=a[4]; i=a[6]; i=a[1]; } //получаем значения

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

//4. динамический массив

//1. хранение указателей на обьекты

//1. Включение элемента с сохранением упорядочености.

template class DArray

{ private:

T **data;

int size;

public:

DArray(int _size);

~DArray();

void operator+(T *q);

T* operator[](int i);};

template DArray::DArray(int _size)

{ size=_size;

data=(T**) new
char[sizeof(T*)*s???††††?????????????????????????????????????????†††????
??????????????????????????????†††????????????????????

if(k==size) return; //нет места в массиве

for(;k>0&&*data[k-1]>*q;k--) data[k]=data[k-1]; //раздвигаем элементы

data[k]=q; } //вставляем элемент

template T* DArray::operator[](int i)




void main()

{ DArray a(10); //заводим массив указателей на int

int x=5,y=99,z=7;

a+&x; a+&y; a+&z; //заносим значения

int k=*a[1];} // получаем значение 7

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

//4. динамический массив

//1. хранение указателей на обьекты

//2. Поиск и возвращение минимального об"екта.

template class DArray

{ private:

T **data;

int size;

public:

DArray(int _size);

~DArray();

T* Min();

T* operator[](int i);};

template DArray::DArray(int _size)

{ size=_size;

data=(T**) new char[sizeof(T*)*size];

for(int
i=0;i
{ for(int k=0;k элемента

int tmp=k++; //в tmp

for(;k
if(data[k]!=NULL&&*data[k]<*data[tmp]) tmp=k; //поиск
минимального

return data[tmp]; }

template T* DArray::operator[](int i)

if(data[i]==NULL) data[i]=new T;


void main()

{ DArray a(20); //заводим массив указателей на int

*a[1]=5; *a[4]=3; *a[3]=7; //заносим значения

int k=*a.Min(); } // получаем значение 3

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

//4. динамический массив

//1. хранение указателей на обьекты

//3. Сортировка (любым методом).

template class DArray

{ private:

int size;

T **data;

public:

DArray(int _size);

~DArray();

void Sort();

T* operator[](int i); };

template DArray::DArray(int _size)

{ size=_size;

data=(T**) new char[sizeof(T*)*size];

for(int i=0;i
template DArray::~DArray()

{ delete data; }

template void DArray::Sort()

{ for(int i=0;i
for(int j=i+1;j
if(data[i]==NULL||(data[j]!=NULL&&*data[j]<*data[i]))
//сравнение

{ T* tmp=data[j]; data[j]=data[i]; data[i]=tmp; } } //обмен

template T* DArray::operator[](int i)

i>=size) return NULL;


void main()

{ DArray a(5); //заводим массив указателей на int

*a[1]=15; *a[4]=9; *a[3]=17; //заносим значения

a.Sort(); //сортируем

int i=*a[0],j=*a[1],k=*a[2]; } //достаем отсортированнные по
возрастанию

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

//4. динамический массив

//1. хранение указателей на обьекты

//4. Двоичный поиск на основе сравнения с внешним об"ектом-ключом

template class DArray

{ private:

int size;

T **data;

public:

DArray(int _size);

~DArray();

T* FindBin(T &key);

T* operator[](int i);};

template DArray::DArray(int _size)

{
size=_si??††††???????????????????††††???????????????????????????????????
??????†††?????????????????????????????…??

{ int a=0,b=size-1; //начало,конец отрезка

while(a<=b)

{ int m=(a+b)/2; //середина

while(data[m]==NULL&&m>a) m--;

{ if(*data[m]==key) return data[m]; //совпало с ключом

if(*data[m]>key) a=m+1; //правая часть

else b=m-1; } }
//левая часть

return NULL; } //не найден

template T* DArray::operator[](int i)

if(i<0

void main()

{ DArray a(15); //заводим массив указателей на int

*a[0]=5; *a[1]=9; *a[2]=17; //заносим значения

int i=*a.FindBin(17); } //двоичный поиск

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

//4. динамический массив

//1. хранение указателей на обьекты

//5. Включение элемента по номеру.

template class DArray

{ private:

int size;

T **data;

public:

DArray(int _size);

~DArray();

T* operator[](int i);};

template DArray::DArray(int _size)

{ size=_size;

data=(T**) new char[sizeof(T*)*size];

for(int i=0;i
template DArray::~DArray()

{ delete data;
}???????????????????????????????????????????†?????????????????†††???????
????????

{ DArray a(30); //заводим массив указателей на int

*a[4]=6; *a[6]=7; *a[1]=2; //заносим значения

int i=*a[4]; i=*a[6]; i=*a[1]; } //получаем
значения

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

//4. динамический массив

//1. хранение указателей на обьекты

//6. Исключение (удаление) элемента по номеру.

template class DArray

{ private:

int size;

T **data;

public:

DArray(int _size);

~DArray();

T* operator[](int i);

void Del(int i); };

template DArray::DArray(int _size)

{ size=_size;

data=(T**) new char[sizeof(T*)*size];

for(int i=0;i
template DArray::~DArray()

{ delete data; }

template T* DArray::operator[](int i)

if(data[i]==NULL) data[i]=new T;


template void DArray::Del(int i)



void main()

{ DArray a(30); //заводим массив указателей на int

*a[0]=500; *a[1]=98; *a[2]=17; //заносим значения

a.Del(0); a.Del(1); a.Del(2); } //удаляем

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

//4. динамический массив

//1. хранение указателей на обьекты

//7. Поиск и возвращение элемента по номеру.

template class DArray

{ private:

int size;

T **data;

public:

DArray(int _size);

~DArray();

T* operator[](int i); };

template DArray::DArray(int _size)

{ size=_size;

data=(T**) new char[sizeof(T*)*size];

for(int i=0;i
template DArray::~DArray()

{ delete data; }

template T* DArray::operator[](int i)

if(i<0

void main()

{ DArray a(20); //заводим массив указателей на int

*a[4]=6; *a[6]=7; *a[1]=2; //заносим значения

int i=*a[4]; i=*a[6]; i=*a[1]; } //получаем
значения

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

//4. динамический массив

//2. хранение обьектов

//1. Включение элемента с сохранением упорядочености.

template class DArray

{ private:

T *data;

int size,sp;

public:

DArray(int _size);

~DArray();

void operator+(T q);

T* operator[](int i);};

template DArray::DArray(int _size)

{ size=_size; sp=0;

data=(T*) new T[size];

for(int i=0;i
template DArray::~DArray()

{ de??????????????????????????????????†††??????????

for(int k=sp++;k>0&&data[k-1]>q;k--) data[k]=data[k-1]; //раздвигаем
элементы

data[k]=q; } //вставляем элемент

template T* DArray::operator[](int i)



void main()

{ DArray a(10); //заводим массив указателей на int

int x=5,y=99,z=7;

a+x; a+y; a+z; //заносим значения

int k=*a[1]; } // получаем значение 7

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

//4. динамический массив

//2. хранение обьектов

//2. Поиск и возвращение минимального об"екта.

template class DArray

{ private:

T *data;

int size;

public:

DArray(int _size);

~DArray();

T* Min();

T* operator[](int i);};

template DArray::DArray(int _size)

{ size=_size;

data=(T*) new T[size];

for(int i=0;i
template DArray::~DArray()

{ delete [] data; }

template T* DArray::Min()

{ int tmp=0;

for(int k=1;k
if(data[k]
return &data[tmp]; }

template T* DArray::operator[](int i)

i>=size) return NULL;


void main()

{ DArray a(3); //заводим массив указателей на int

*a[0]=5; *a[1]=3; *a[2]=7; //заносим значения

int k=*a.Min(); } // получаем значение 3

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

//4. динамический массив

//2. хранение обьектов

//3. Сортировка (любым методом).

template class DArray

{ private:

int size;

T *data;

public:

DArray(int _size);

~DArray();

void Sort();

T* operator[](int i); };

template DArray::DArray(int _size)

{ size=_size;

data=(T*) new T[size];

for(int i=0;i
template DArray::~DArray()

{ delete [] data; }

template void DArray::Sort()

{ for(int i=0????????†††?????????????

if(data[j]
{ T tmp=data[j]; data[j]=data[i]; data[i]=tmp; } } //обмен

template T* DArray::operator[](int i)




void main()

{ DArray a(5); //заводим массив указателей на int

*a[1]=15; *a[4]=9; *a[3]=17; //заносим значения

a.Sort(); //сортируем

int i=*a[0],j=*a[1],k=*a[2]; } //достаем отсортированнные по
возрастанию

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

//4. динамический массив

//2. хранение обьектов

//4. Двоичный поиск на основе сравнения с внешним об"ектом-ключом

template class DArray

{ private:

int size;

T *data;

public:

DArray(int _size);

~DArray();

T* FindBin(T &key);

T* operator[](int i);};

template DArray::DArray(int _size)

{ size=_size;

data=(T*) new T[size];

for(int i=0;i ??????????????????????†††??????????????????????????????…??

{ int a=0,b=size-1; //начало,конец отрезка

while(a<=b)

{ int m=(a+b)/2; //середина

while(data[m]==NULL&&m>a) m--;

{ if(data[m]==key) return &data[m]; //совпало с ключом

if(data[m]>key) a=m+1; //правая часть

else b=m-1; } }
//левая часть

return NULL; } //не найден

template T* DArray::operator[](int i)




void main()

{ DArray a(15); //заводим массив указателей на int

*a[0]=5; *a[1]=9; *a[2]=17; //заносим значения

int i=*a.FindBin(17); } //двоичный поиск

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

//4. динамический массив

//2. хранение обьектов

//5. Включение элемента по номеру.

template class DArray

{ private:

int size;

T *data;

public:

DArray(int _size);

~DArray();

T* operator[](int i);};

template DArray::DArray(int _size)

{ size=_size;

data=(T*) new T[size];

for(int i=0;i
template DArray::~DArray()

{ delete [] data; }

template T* DArray::operator[](int i)

{ if(i<0||i>=??????????†††?????????†††???????

{ DArray a(30); //заводим массив указателей на int

*a[4]=6; *a[6]=7; *a[1]=2; //заносим значения

int i=*a[4]; i=*a[6]; i=*a[1];
} //получаем значения

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

//4. динамический массив

//2. хранение обьектов

//6. Исключение (удаление) элемента по номеру.

template class DArray

{ private:

int size;

T *data;

public:

DArray(int _size);

~DArray();

T* operator[](int i);

void Del(int i); };

template DArray::DArray(int _size)

{ size=_size;

data=(T*) new T[size];

for(int i=0;i
template DArray::~DArray()

{ delete [] data; }

template T* DArray::operator[](int i)




template void DArray::Del(int i)

if(i<0

void main()

{ DArray a(30); //заводим массив указателей на int

*a[0]=500; *a[1]=98; *a[2]=17; //заносим значения

a.Del(0); a.Del(1); a.Del(2); } //удаляем

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

//4. динамический массив

//2. хранение обьектов

//7. Поиск и возвращение элемента по номеру.

template class DArray

{ private:

int size;

T *data;

public:

DArray(int _size);

~DArray();

T* operator[](int i); };

template DArray::DArray(int _size)

{ size=_size;

data=(T*) new T[size];

for(int i=0;i
template DArray::~DArray()

{ delete [] data; }

template
{ DArray a(20); //заводим массив указателей на int

*a[4]=6; *a[6]=7; *a[1]=2; //заносим значения

int i=*a[4]; i=*a[6]; i=*a[1]; } //получаем
значения

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

// 5. Односвязный список

// 1. Хранение указателей на объекты

// 1. Включение элемента с сохранением упорядочености.

template class List

{ private:

List *next;

T *data;

public:

List(T a);

~List();

void Add(T a); }; //добавление элемента

template List::List(T a)

{ next=NULL; data=new T; *data=a; }//выделение памяти и
копирование

template List::~List()

{ delete data; if(next!=NULL) delete next; }//удаление элемента
и списка

template void List::Add(T a) //добавление элемента

{ if(next==NULL) //если последний

{ if(a>*data) next=new List(a); else

{ next=new List(*data);

*data=a; } } else

{ if(a<*data) //если вставляемый меньше текущего

{ next->Add(*data); //раздвигаем (рекурсия)

*data=a; } else

if(a>*data&&a<*next->data) //если вставляемый должен
быть следующим

{ List *p=next;

next=new List(a); //создаем новый элемент

next->next=p; } else

next->Add(a); } } //если вставляемый больше текущего
(рекурсия)

void main()

{ List a(10); //создание списка

a.Add(5); a.Add(11); a.Add(3); } //вставка элементов

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

// 5. Односвязный список

// 1. Хранение указателей на объекты

// 2. Поиск и возвращение минимального обьекта.

template class List

{ private:

List *next;

T *data;

public:

List(T a);

~List();

T *FindMin(); //поиск минимального

void Insert(T a,int pos); }; //вставка элемента

template List::List(T a)

{ next=NULL; data=new T; *data=a; }//выделение памяти и
копирование

template List::~List()

{ delete data; if(next!=NULL) delete next; }//удаление элемента
и списка

template T* List::FindMin()

{ T* tmp=data; //принимаем начальный за минимальный

List *p=this->next;

while(p!=NULL) //проходим список

{ if(*p->data<*tmp) tmp=p->data; //если есть меньший -
запоминаем

p=p->next; }

return tmp; } //возвращаем минимальный

template void List::Insert(T a,int pos)

{ List *p=this,*q;

while(pos-->0&&p->next!=NULL) p=p->next; //ищем место в списке

q=p->next;

p->next=new List(*p->data); //создаем новый элемент

*p->data=a; //записываем данные

p->next->next=q; } //восстанавливаем последовательность
элементов

void main()

{ List a(10); //создание списка

a.Insert(15,1); a.Insert(4,2); a.Insert(7,3);//вставка
элементов

int k=*a.FindMin(); } // поиск минимального

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

// 5. Односвязный список

// 1. Хранение указателей на объекты

// 3. Сортировка (любым методом).

template class List

{ private:

List *next;

T *data;

public:

List(T a);

~List();

void Sort(); //сортировка

void Insert(T a,int pos); }; //вставка элемента

template List::List(T a)

{ next=NULL; data=new T; *data=a; }//выделение памяти и
копирование

template List::~List()

{ delete data; if(next!=NULL) delete next; }//удаление элемента
и списка

template void List::Sort()

{ for(List *p=this;p->next!=NULL;p=p->next)

for(List *q=p->next;q!=NULL;q=q->next)

if(*p->data>*q->data) //если слева больший элемент

{ T* tmp=p->data; p->data=q->data; q->data=tmp; }
} //производим обмен

template void List::Insert(T a,int pos)

{ List *p=this,*q;

while(pos-->0&&p->next!=NULL) p=p->next; //ищем место в списке

q=p->next;

p->next=new List(*p->data); //создаем новый элемент

*p->data=a; //записываем данные

p->next->next=q; } //восстанавливаем последовательность
элементов

void main()

{ List a(10); //создание списка

a.Insert(15,1); a.Insert(4,2); a.Insert(7,3);//вставка
элементов

a.Sort(); } //сортировка элементов

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

// 5. Односвязный список

// 1. Хранение указателей на объекты

// 4. Двоичный поиск на основе сравнения с внешним обьектом-ключом

template class List

{ private:

List *next;

T *data;

public:

List(T a);

~List();

List*Search(int num);

T* FindBin(T key);

void Insert(T a,int pos);}; //вставка элемента

template List::List(T a)

{ next=NULL; data=new T; *data=a; }//выделение памяти и
копирование

template List::~List()

{ delete data; if(next!=NULL) delete next; }//удаление элемента
и списка

template List* List::Search(int num)

{ List *p=this;

while(num-->0&&p->next!=NULL) { p=p->next; }//ищем в списке

return p; }

template T* List::FindBin(T key)

{ int a=0,b=1; //начало,конец отрезка

List *p=this;

while(p->next!=NULL) { b++; p=p->next; } //подсчет элементов

while(a<=b)

{ int m=(a+b)/2; //середина

if(*Search(m)->data==key) return Search(m)->data; //совпало с
ключом

if(*Search(m)->data
else b=m-1;
}//левая часть

return NULL; } //не найден

template void List::Insert(T a,int pos)

{ List *p=this,*q;

while(pos-->0&&p->next!=NULL) p=p->next; //ищем место в списке

q=p->next;

p->next=new List(*p->data); //создаем новый элемент

*p->data=a; //записываем данные

p->next->next=q; } //восстанавливаем последовательность
элементов

void main()

{ List a(3); //создание списка

a.Insert(6,1); a.Insert(9,2); a.Insert(17,3);//вставка
элементов

int j=*a.FindBin(11);}

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

// 5. Односвязный список

// 1. Хранение указателей на объекты

// 5. Включение элемента по номеру.

template class List

{ private:

List *next;

T *data;

public:

List(T a);

~List();

void Insert(T a,int pos); }; //вставка элемента

template List::List(T a)

{ next=NULL; data=new T; *data=a; }//выделение памяти и
копирование

template List::~List()

{ delete data; if(next!=NULL) delete next; }//удаление элемента
и списка

template void List::Insert(T a,int pos)

{ List *p=this,*q;

while(pos-->0&&p->next!=NULL) p=p->next; //ищем место в списке

q=p->next;

p->next=new List(*p->data); //создаем новый элемент

*p->data=a; //записываем данные

p->next->next=q; } //восстанавливаем последовательность
элементов

void main()

{ List a(10); //создание списка

a.Insert(55,1); } //вставка элемента на первую позицию

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

// 5. Односвязный список

// 1. Хранение указателей на объекты

// 6. Исключение (удаление) элемента по номеру.

template class List

{ private:

List *next;

T *data;

public:

List(T a);

~List();

void Insert(T a,int pos); //вставка элемента

void Delete(int pos);}; //удаление элемента

template List::List(T a)

{ next=NULL; data=new T; *data=a; }//выделение памяти и
копирование

template List::~List()

{ delete data; if(next!=NULL) delete next; }//удаление элемента
и списка

template void List::Insert(T a,int pos)

{ List *p=this,*q;

while(pos-->0&&p->next!=NULL) p=p->next; //ищем место в списке

q=p->next;

p->next=new List(*p->data); //создаем новый элемент

*p->data=a; //записываем данные

p->next->next=q; } //восстанавливаем последовательность
элементов

template void List::Delete(int pos)

{ if(pos==0||next==NULL)return;//первый или единственный элемент не
удаляется

List *p=this,*q=next;

while(pos-->1&&q->next!=NULL){ p=p->next;q=q->next; }//ищем
место в списке

p->next=q->next;

q->next=NULL;

delete q; }

void main()

{ List a(10); //создание списка

a.Insert(55,1); a.Insert(5,2); a.Insert(17,3);//вставка
элементов

a.Delete(1); }//удаление элемента

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

// 5. Односвязный список

// 1. Хранение указателей на объекты

// 7. Поиск и возвращение элемента по номеру.

template class List

{ private:

List *next;

T *data;

public:

List(T a);

~List();

void Insert(T a,int pos); //вставка элемента

T* Get(int num); };//получить элемент по номеру

template List::List(T a)

{ next=NULL; data=new T; *data=a; }//выделение памяти и
копирование

template List::~List()

{ delete data; if(next!=NULL) delete next; }//удаление элемента
и списка

template void List::Insert(T a,int pos)

{ List *p=this,*q;

while(pos-->0&&p->next!=NULL) p=p->next; //ищем место в списке

q=p->next;

p->next=new List(*p->data); //создаем новый элемент

*p->data=a; //записываем данные

p->next->next=q; } //восстанавливаем последовательность
элементов

template T* List::Get(int num)

{ List *p=this;

while(num-->0&&p->next!=NULL) { p=p->next; }//ищем в списке

return p->data; }

void main()

{ List a(10); //создание списка

a.Insert(13,1);a.Insert(33,2); //вставка элементов

int i=*a.Get(1); } //взять элемент по номеру

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

// 5. Односвязный список

// 2. Хранение объектов

// 1. Включение элемента с сохранением упорядочености.

template class List

{ private:

List *next;

T data;

public:

List(T a);

~List();

void Add(T a); }; //добавление элемента

template List::List(T a)

{ next=NULL; data=a; }//выделение памяти и копирование

template List::~List()

{ if(next!=NULL) delete next; }//удаление элемента и списка

template void List::Add(T a) //добавление элемента

{ if(next==NULL) //если последний

{ if(a>data) next=new List(a); else

{ next=new List(data);

data=a; } } else

{ if(a
{ next->Add(data); //раздвигаем

data=a; } else

if(a>data&&adata) //если вставляемый должен быть
следующим

{ List *p=next;

next=new List(a); //создаем новый элемент

next->next=p; } else

next->Add(a); } } //если вставляемый больше текущего

void main()

{ List a(10); //создание списка

a.Add(5); a.Add(11); a.Add(3); }; //вставка элементов

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

// 5. Односвязный список

// 2. Хранение объектов

// 2. Поиск и возвращение минимального обьекта.

template class List

{ private:

List *next;

T data;

public:

List(T a);

~List();

T FindMin(); //поиск минимального

void Insert(T a,int pos); }; //вставка элемента

template List::List(T a)

{ next=NULL; data=a; }//выделение памяти и копирование

template List::~List()

{ if(next!=NULL) delete next; }//удаление элемента и списка

template T List::FindMin()

{ T tmp=data; //принимаем начальный за минимальный

List *p=this->next;

while(p!=NULL) //проходим список

{ if(p->datadata; //если есть меньший -
запоминаем

p=p->next; }

return tmp; } //возвращаем минимальный

template void List::Insert(T a,int pos)

{ List *p=this,*q;

while(pos-->0&&p->next!=NULL) p=p->next; //ищем место в списке

q=p->next;

p->next=new List(p->data); //создаем новый элемент

p->data=a; //записываем данные

p->next->next=q; } //восстанавливаем последовательность
элементов

void main()

{ List a(10); //создание списка

a.Insert(3,1); a.Insert(9,2); //вставка элементов

int k=a.FindMin(); }; // поиск минимального

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

// 5. Односвязный список

// 2. Хранение объектов

// 3. Сортировка (любым методом).

template class List

{ private:

List *next;

T data;

public:

List(T a);

~List();

void Sort(); //сортировка

void Insert(T a,int pos);}; //вставка элемента

template List::List(T a)

{ next=NULL; data=a; }//выделение памяти и копирование

template List::~List()

{ if(next!=NULL) delete next; }//удаление элемента и списка

template void List::Sort()

{ for(List *p=this;p->next!=NULL;p=p->next)

for(List *q=p->next;q!=NULL;q=q->next)

if(p->data>q->data) //если слева больший элемент

{ T tmp=p->data; p->data=q->data; q->data=tmp; } }
//производим обмен

template void List::Insert(T a,int pos)

{ List *p=this,*q;

while(pos-->0&&p->next!=NULL) p=p->next; //ищем место в списке

q=p->next;

p->next=new List(p->data); //создаем новый элемент

p->data=a; //записываем данные

p->next->next=q; } //восстанавливаем последовательность
элементов

void main()

{ List a(10); //создание списка

a.Insert(155,1);a.Insert(77,2); //вставка элементов

a.Sort(); } //сортировка элементов

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

// 5. Односвязный список

// 2. Хранение объектов

// 4. Двоичный поиск на основе сравнения с внешним обьектом-ключом

template class List

{ private:

List *next;

T data;

public:

List(T a);

~List();

List*Search(int num);

T FindBin(T key);

void Insert(T a,int pos); }; //вставка элемента

template List::List(T a)

{ next=NULL; data=a; }//выделение памяти и копирование

template List::~List()

{ if(next!=NULL) delete next; }//удаление элемента и списка

template List* List::Search(int num)

{ List *p=this;

while(num-->0&&p->next!=NULL) { p=p->next; }//ищем в списке

return p; }

template T List::FindBin(T key)

{ int a=0,b=1; //начало,конец отрезка

List *p=this;

while(p->next!=NULL) { b++; p=p->next; } //подсчет элементов

while(a<=b)

{ int m=(a+b)/2; //середина

if(Search(m)->data==key) return Search(m)->data; //совпало с
ключом

if(Search(m)->data
else b=m-1;
}//левая часть

return 0; } //не найден

template void List::Insert(T a,int pos)

{ List *p=this,*q;

while(pos-->0&&p->next!=NULL) p=p->next; //ищем место в списке

q=p->next;

p->next=new List(p->data); //создаем новый элемент

p->data=a; //записываем данные

p->next->next=q; } //восстанавливаем последовательность
элементов

void main()

{ List a(10); //создание списка

a.Insert(12,1); a.Insert(15,2); a.Insert(95,3); //вставка
элементов

int j=a.FindBin(11); }

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

// 5. Односвязный список

// 2. Хранение объектов

// 5. Включение элемента по номеру.

template class List

{ private:

List *next;

T data;

public:

List(T a);

~List();

void Insert(T a,int pos); }; //вставка элемента

template List::List(T a)

{ next=NULL; data=a; }//выделение памяти и копирование

template List::~List()

{ if(next!=NULL) delete next; }//удаление элемента и списка

template void List::Insert(T a,int pos)

{ List *p=this,*q;

while(pos-->0&&p->next!=NULL) p=p->next; //ищем место в списке

q=p->next;

p->next=new List(p->data); //создаем новый элемент

p->data=a; //записываем данные

p->next->next=q; } //восстанавливаем последовательность
элементов

void main()

{ List a(10); //создание списка

a.Insert(15,1); } //вставка элемента на первую позицию

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

// 5. Односвязный список

// 2. Хранение объектов

// 6. Исключение (удаление) элемента по номеру.

template class List

{ private:

List *next;

T data;

public:

List(T a);

~List();

void Insert(T a,int pos); //вставка элемента

void Delete(int pos); };//удаление элемента

template List::List(T a)

{ next=NULL; data=a; }//выделение памяти и копирование

template List::~List()

{ if(next!=NULL) delete next; }//удаление элемента и списка

template void List::Insert(T a,int pos)

{ List *p=this,*q;

while(pos-->0&&p->next!=NULL) p=p->next; //ищем место в списке

q=p->next;

p->next=new List(p->data); //создаем новый элемент

p->data=a; //записываем данные

p->next->next=q; } //восстанавливаем последовательность
элементов

template void List::Delete(int pos)

{ if(pos==0||next==NULL)return;//первый или единственный элемент не
удаляется

List *p=this,*q=next;

while(pos-->1&&q->next!=NULL){ p=p->next;q=q->next; }//ищем
место в списке

p->next=q->next;

q->next=NULL;

delete q; }

void main()

{ List a(10); //создание списка

a.Insert(55,1); //вставка элемента на первую позицию

a.Delete(1); } //удаление элемента

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

// 5. Односвязный список

// 2. Хранение объектов

// 7. Поиск и возвращение элемента по номеру.

template class List

{ private:

List *next;

T data;

public:

List(T a);

~List();

void Insert(T a,int pos); //вставка элемента

T Get(int num); };//получить элемент по номеру

template List::List(T a)

{ next=NULL; data=a; }//выделение памяти и копирование

template List::~List()

{ if(next!=NULL) delete next; }//удаление элемента и списка

template void List::Insert(T a,int pos)

{ List *p=this,*q;

while(pos-->0&&p->next!=NULL) p=p->next; //ищем место в списке

q=p->next;

p->next=new List(p->data); //создаем новый элемент

p->data=a; //записываем данные

p->next->next=q; } //восстанавливаем последовательность
элементов

template T List::Get(int num)

{ List *p=this;

while(num-->0&&p->next!=NULL) { p=p->next; }//ищем в списке

return p->data; }

void main()

{ List a(10); //создание списка

a.Insert(55,1); //вставка элемента на первую позицию

int i=a.Get(0); } //взять элемент по номеру

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

// 6. Двусвязный циклический список

// 1. Хранение указателей на объекты

// 1. Включение элемента с сохранением упорядочености.

template class List

{ private:

List *next,*prev;

T *data;

public:

List(T a);

~List();

void Add(T a); }; //добавление элемента

template List::List(T a)

{ next=this; prev=this;

data=new T; *data=a; }//выделение памяти и копирование

template List::~List()

{ delete data; //удаление элемента

data=NULL;

if(next!=NULL&&next->data!=NULL) //проверка на зацикливание

delete next; }//удаление списка

template void List::Add(T a) //добавление элемента

{ List *p=this,*q=next;

while(*p->datanext; q=q->next; } //поиск
места

if(*p->datanext=new List(a); else // вставка после

{ p->next=new List(*p->data); // -//- до

*p->data=a; }

p->next->next=q; p->next->prev=p; } //расстановка
связей

void main()

{ List a(10); //создание списка

a.Add(5); a.Add(11); a.Add(3); }; //вставка элементов

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

// 6. Двусвязный циклический список

// 1. Хранение указателей на объекты

// 2. Поиск и возвращение минимального обьекта.

template class List

{ private:

List *next,*prev;

T *data;

public:

List(T a);

~List();

T *FindMin(); //поиск минимального

void Insert(T a,int pos); }; //вставка элемента

template List::List(T a)

{ next=this; prev=this;

data=new T; *data=a; }//выделение памяти и копирование

template List::~List()

{ delete data; //удаление элемента

data=NULL;

if(next!=NULL&&next->data!=NULL) //проверка на зацикливание

delete next; }//удаление списка

template T* List::FindMin()

{ T* tmp=data; //принимаем начальный за минимальный

List *p=this->next;

while(p!=this) //проходим список

{ if(*p->data<*tmp) tmp=p->data; //если есть меньший -
запоминаем

p=p->next; }

return tmp; } //возвращаем минимальный

template void List::Insert(T a,int pos)

{ List *p=this,*q;

while(pos-->0&&p->next!=this) p=p->next; //ищем место в списке

q=p->next;

p->next=new List(*p->data); //создаем новый элемент

*p->data=a; //записываем данные

p->next->next=q;

p->next->prev=p; } //восстанавливаем последовательность
элементов

void main()

{ List a(10); //создание списка

a.Insert(15,1); a.Insert(6,1); a.Insert(7,1); //вставка
элементов

int k=*a.FindMin(); }; // поиск минимального

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

// 6. Двусвязный циклический список

// 1. Хранение указателей на объекты

// 3. Сортировка (любым методом).

template class List

{ private:

List *next,*prev;

T *data;

public:

List(T a);

~List();

void Sort(); //сортировка

void Insert(T a,int pos); }; //вставка элемента

template List::List(T a)

{ next=this; prev=this;

data=new T; *data=a; }//выделение памяти и копирование

template List::~List()

{ delete data; //удаление элемента

data=NULL;

if(next!=NULL&&next->data!=NULL) //проверка на зацикливание

delete next; }//удаление списка

template void List::Sort()

{ for(List *p=this;p->next!=this;p=p->next)

for(List *q=p->next;q!=this;q=q->next)

if(*p->data>*q->data) //если слева больший элемент

{ T* tmp=p->data; p->data=q->data; q->data=tmp; }
} //производим обмен

template void List::Insert(T a,int pos)

{ List *p=this,*q;

while(pos-->0&&p->next!=this) p=p->next; //ищем место в списке

q=p->next;

p->next=new List(*p->data); //создаем новый элемент

*p->data=a; //записываем данные

p->next->next=q;

p->next->prev=p; } //восстанавливаем последовательность
элементов

void main()

{ List a(10); //создание списка

a.Insert(15,1); a.Insert(6,1); a.Insert(7,1); //вставка
элементов

a.Sort(); }; //сортировка элементов

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

// 6. Двусвязный циклический список

// 1. Хранение указателей на объекты

// 4. Двоичный поиск на основе сравнения с внешним обьектом-ключом

template class List

{ private:

List *next,*prev;

T *data;

public:

List(T a);

~List();

List*Search(int num);

T* FindBin(T key);

void Insert(T a,int pos); }; //вставка элемента

template List::List(T a)

{ next=this; prev=this;

data=new T; *data=a; }//выделение памяти и копирование

template List::~List()

{ delete data; //удаление элемента

data=NULL;

if(next!=NULL&&next->data!=NULL) //проверка на зацикливание

delete next; }//удаление списка

template List* List::Search(int num)

{ List *p=this;

while(num-->0&&p->next!=this) { p=p->next; }//ищем в списке

return p; }

template T* List::FindBin(T key)

{ int a=0,b=1; //начало,конец отрезка

List *p=this;

while(p->next!=this) { b++; p=p->next; } //подсчет элементов

while(a<=b)

{ int m=(a+b)/2; //середина

if(*Search(m)->data==key) return Search(m)->data; //совпало с
ключом

if(*Search(m)->data
else b=m-1;
}//левая часть

return NULL; } //не найден

template void List::Insert(T a,int pos)

{ List *p=this,*q;

while(pos-->0&&p->next!=this) p=p->next; //ищем место в списке

q=p->next;

p->next=new List(*p->data); //создаем новый элемент

*p->data=a; //записываем данные

p->next->next=q;

p->next->prev=p; } //восстанавливаем последовательность
элементов

void main()

{ List a(10); //создание списка

a.Insert(15,1); a.Insert(6,1); a.Insert(7,1); //вставка
элементов

int j=*a.FindBin(11); };

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

// 6. Двусвязный циклический список

// 1. Хранение указателей на объекты

// 5. Включение элемента по номеру.

template class List

{ private:

List *next,*prev;

T *data;

public:

List(T a);

~List();

void Insert(T a,int pos); }; //вставка элемента

template List::List(T a)

{ next=this; prev=this;

data=new T; *data=a; }//выделение памяти и копирование

template List::~List()

{ delete data; //удаление элемента

data=NULL;

if(next!=NULL&&next->data!=NULL) //проверка на зацикливание

delete next; }//удаление списка

template void List::Insert(T a,int pos)

{ List *p=this,*q;

while(pos-->0&&p->next!=this) p=p->next; //ищем место в списке

q=p->next;

p->next=new List(*p->data); //создаем новый элемент

*p->data=a; //записываем данные

p->next->next=q;

p->next->prev=p; } //восстанавливаем последовательность
элементов

void main()

{ List a(10); //создание списка

a.Insert(55,1); }; //вставка элемента на первую позицию

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

// 6. Двусвязный циклический список

// 1. Хранение указателей на объекты

// 6. Исключение (удаление) элемента по номеру.

template class List

{ private:

List *next,*prev;

T *data;

public:

List(T a);

~List();

void Insert(T a,int pos); //вставка элемента

void Delete(int pos); };//удаление элемента

template List::List(T a)

{ next=this; prev=this;

data=new T; *data=a; }//выделение памяти и копирование

template List::~List()

{ delete data; //удаление элемента

data=NULL;

if(next!=NULL&&next->data!=NULL) //проверка на зацикливание

delete next; }//удаление списка

template void List::Insert(T a,int pos)

{ List *p=this,*q;

while(pos-->0&&p->next!=this) p=p->next; //ищем место в списке

q=p->next;

p->next=new List(*p->data); //создаем новый элемент

*p->data=a; //записываем данные

p->next->next=q;

p->next->prev=p; } //восстанавливаем последовательность
элементов

template void List::Delete(int pos)

{ if(pos==0||next==this)return;//первый или единственный элемент не
удаляется

List *p=this,*q=next;

while(pos-->1&&q->next!=this){ p=p->next;q=q->next; }//ищем
место в списке

p->next=q->next;

q->next->prev=p;

q->next=NULL;

delete q; }

void main()

{ List a(10); //создание списка

a.Insert(55,1); //вставка элемента на первую позицию

a.Delete(1);} //удаление элемента

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

// 6. Двусвязный циклический список

// 1. Хранение указателей на объекты

// 7. Поиск и возвращение элемента по номеру.

template class List

{ private:

List *next,*prev;

T *data;

public:

List(T a);

~List();

void Insert(T a,int pos); //вставка элемента

T* Get(int num); };//получить элемент по номеру

template List::List(T a)

{ next=this; prev=this;

data=new T; *data=a; }//выделение памяти и копирование

template List::~List()

{ delete data; //удаление элемента

data=NULL;

if(next!=NULL&&next->data!=NULL) //проверка на зацикливание

delete next; }//удаление списка

template void List::Insert(T a,int pos)

{ List *p=this,*q;

while(pos-->0&&p->next!=this) p=p->next; //ищем место в списке

q=p->next;

p->next=new List(*p->data); //создаем новый элемент

*p->data=a; //записываем данные

p->next->next=q;

p->next->prev=p; } //восстанавливаем последовательность
элементов

template T* List::Get(int num)

{ List *p=this;

while(num-->0&&p->next!=this) { p=p->next; }//ищем в списке

return p->data; }

void main()

{ List a(10); //создание списка

a.Insert(15,1); a.Insert(6,1); a.Insert(7,1); //вставка
элементов

int i=*a.Get(2); }; //взять элемент по номеру

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

// 6. Двусвязный циклический список

// 2. Хранение объектов

// 1. Включение элемента с сохранением упорядочености.

template class List

{ private:

List *next,*prev;

T data;

public:

List(T a);

~List();

void Add(T a); }; //добавление элемента

template List::List(T a)

{ next=this; prev=this; data=a; }

template List::~List()

{ data=-1; if(next!=NULL&&next->data!=-1) //проверка на
зацикливание

delete next; }//удаление списка

template void List::Add(T a) //добавление элемента

{ List *p=this,*q=next;

while(p->datanext; q=q->next; } //поиск
места

if(p->datanext=new List(a); else // вставка после

{ p->next=new List(p->data); // -//- до

p->data=a; }

p->next->next=q; p->next->prev=p; } //расстановка
связей

void main()

{ List a(10); //создание списка

a.Add(5); a.Add(11); a.Add(3); }; //вставка элементов

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

// 6. Двусвязный циклический список

// 2. Хранение объектов

// 2. Поиск и возвращение минимального обьекта.

template class List

{ private:

List *next,*prev;

T data;

public:

List(T a);

~List();

T FindMin(); //поиск минимального

void Insert(T a,int pos); }; //вставка элемента

template List::List(T a)

{ next=this; prev=this; data=a; }

template List::~List()

{ data=-1; if(next!=NULL&&next->data!=-1) //проверка на
зацикливание

delete next; }//удаление списка

template T List::FindMin()

{ T tmp=data; //принимаем начальный за минимальный

List *p=this->next;

while(p!=this) //проходим список

{ if(p->datadata; //если есть меньший -
запоминаем

p=p->next; }

return tmp; } //возвращаем минимальный

template void List::Insert(T a,int pos)

{ List *p=this,*q;

while(pos-->0&&p->next!=this) p=p->next; //ищем место в списке

q=p->next;

p->next=new List(p->data); //создаем новый элемент

p->data=a; //записываем данные

p->next->next=q;

p->next->prev=p; } //восстанавливаем последовательность
элементов

void main()

{ List a(10); //создание списка

a.Insert(15,1); a.Insert(6,1); a.Insert(7,1); //вставка
элементов

int k=a.FindMin(); } // поиск минимального

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

// 6. Двусвязный циклический список

// 2. Хранение объектов

// 3. Сортировка (любым методом).

template class List

{ private:

List *next,*prev;

T data;

public:

List(T a);

~List();

void Sort(); //сортировка

void Insert(T a,int pos); }; //вставка элемента

template List::List(T a)

{ next=this; prev=this; data=a; }

template List::~List()

{ data=-1; if(next!=NULL&&next->data!=-1) //проверка на
зацикливание

delete next; }//удаление списка

template void List::Sort()

{ for(List *p=this;p->next!=this;p=p->next)

for(List *q=p->next;q!=this;q=q->next)

if(p->data>q->data) //если слева больший элемент

{ T tmp=p->data; p->data=q->data; q->data=tmp; } }
//производим обмен

template void List::Insert(T a,int pos)

{ List *p=this,*q;

while(pos-->0&&p->next!=this) p=p->next; //ищем место в списке

q=p->next;

p->next=new List(p->data); //создаем новый элемент

p->data=a; //записываем данные

p->next->next=q;

p->next->prev=p; } //восстанавливаем последовательность
элементов

void main()

{ List a(10); //создание списка

a.Insert(15,1); a.Insert(6,1); a.Insert(7,1); //вставка
элементов

a.Sort(); } //сортировка элементов

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

// 6. Двусвязный циклический список

// 1. Хранение объектов

// 4. Двоичный поиск на основе сравнения с внешним обьектом-ключом

template class List

{ private:

List *next,*prev;

T data;

public:

List(T a);

~List();

List*Search(int num);

T FindBin(T key);

void Insert(T a,int pos); }; //вставка элемента

template List::List(T a)

{ next=this; prev=this; data=a; }

template List::~List()

{ data=-1; if(next!=NULL&&next->data!=-1) //проверка на
зацикливание

delete next; }//удаление списка

template List* List::Search(int num)

{ List *p=this;

while(num-->0&&p->next!=this) { p=p->next; }//ищем в списке

return p; }

template T List::FindBin(T key)

{ int a=0,b=1; //начало,конец отрезка

List *p=this;

while(p->next!=this) { b++; p=p->next; } //подсчет элементов

while(a<=b)

{ int m=(a+b)/2; //середина

if(Search(m)->data==key) return Search(m)->data; //совпало с
ключом

if(Search(m)->data
else b=m-1;
}//левая часть

return 0; } //не найден

template void List::Insert(T a,int pos)

{ List *p=this,*q;

while(pos-->0&&p->next!=this) p=p->next; //ищем место в списке

q=p->next;

p->next=new List(p->data); //создаем новый элемент

p->data=a; //записываем данные

p->next->next=q;

p->next->prev=p; } //восстанавливаем последовательность
элементов

void main()

{ List a(10); //создание списка

a.Insert(15,1); a.Insert(6,1); a.Insert(7,1); //вставка
элементов

int j=a.FindBin(11);};

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

// 6. Двусвязный циклический список

// 1. Хранение объектов

// 5. Включение элемента по номеру.

template class List

{ private:

List *next,*prev;

T data;

public:

List(T a);

~List();

void Insert(T a,int pos);}; //вставка элемента

template List::List(T a)

{ next=this; prev=this; data=a; }

template List::~List()

{ data=-1; if(next!=NULL&&next->data!=-1) //проверка на
зацикливание

delete next; }//удаление списка

template void List::Insert(T a,int pos)

{ List *p=this,*q;

while(pos-->0&&p->next!=this) p=p->next; //ищем место в списке

q=p->next;

p->next=new List(p->data); //создаем новый элемент

p->data=a; //записываем данные

p->next->next=q;

p->next->prev=p; } //восстанавливаем последовательность
элементов

void main()

{ List a(10); //создание списка

a.Insert(55,1);} //вставка элемента на первую позицию

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

// 6. Двусвязный циклический список

// 1. Хранение объектов

// 6. Исключение (удаление) элемента по номеру.

template class List

{ private:

List *next,*prev;

T data;

public:

List(T a);

~List();

void Insert(T a,int pos); //вставка элемента

void Delete(int pos); }; //удаление элемента

template List::List(T a)

{ next=this; prev=this; data=a; }

template List::~List()

{ data=-1; if(next!=NULL&&next->data!=-1) //проверка на
зацикливание

delete next; }//удаление списка

template void List::Insert(T a,int pos)

{ List *p=this,*q;

while(pos-->0&&p->next!=this) p=p->next; //ищем место в списке

q=p->next;

p->next=new List(p->data); //создаем новый элемент

p->data=a; //записываем данные

p->next->next=q;

p->next->prev=p; } //восстанавливаем последовательность
элементов

template void List::Delete(int pos)

{ if(pos==0||next==this)return;//первый или единственный элемент не
удаляется

List *p=this,*q=next;

while(pos-->1&&q->next!=this){ p=p->next;q=q->next; }//ищем
место в списке

p->next=q->next;

q->next->prev=p;

q->next=NULL;

delete q; }

void main()

{ List a(10); //создание списка

a.Insert(55,1); //вставка элемента на первую позицию

a.Delete(1);} //удаление элемента

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

// 6. Двусвязный циклический список

// 1. Хранение объектов

// 7. Поиск и возвращение элемента по номеру.

template class List

{ private:

List *next,*prev;

T data;

public:

List(T a);

~List();

void Insert(T a,int pos); //вставка элемента

T Get(int num); };//получить элемент по номеру

template List::List(T a)

{ next=this; prev=this; data=a; }

template List::~List()

{ data=-1; if(next!=NULL&&next->data!=-1) //проверка на
зацикливание

delete next; }//удаление списка

template void List::Insert(T a,int pos)

{ List *p=this,*q;

while(pos-->0&&p->next!=this) p=p->next; //ищем место в списке

q=p->next;

p->next=new List(p->data); //создаем новый элемент

p->data=a; //записываем данные

p->next->next=q;

p->next->prev=p; } //восстанавливаем последовательность
элементов

template T List::Get(int num)

{ List *p=this;

while(num-->0&&p->next!=this) { p=p->next; }//ищем в списке

return p->data; }

void main()

{ List a(10); //создание списка

a.Insert(15,1); a.Insert(6,1); a.Insert(7,1); //вставка
элементов

int i=a.Get(2); }; //взять элемент по номеру

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

// 7. Дерево с ограниченным числом потомков

// 1. Хранение указателей на объекты

// 1. Включение элемента с сохранением упорядочености.

template class Tree

{ private:

Tree *child[size];

T *data;

public:

Tree();

~Tree();

void Add(T a);} //добавление элемента

template Tree::Tree()

{ for(int i=0;i
template Tree::~Tree()

{ if(data!=NULL) delete data; //удаление элемента

for(int i=0;i
if(child[i]!=NULL) delete child[i]; }//удаление поддеревьев

template void Tree::Add(T a) //добавление
элемента

{ if(data==NULL) { data=new T; *data=a; return; }

for(int i=0;i*child[i]->data;i++);

if(child[i]==NULL) child[i]=new Tree;

child[i]->Add(a); }

void main()

{ Tree a; //создание дерева с пятью потомками в вершине

a.Add(5); a.Add(11); a.Add(3); a.Add(15);} //вставка элементов

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

// 7. Дерево с ограниченным числом потомков

// 1. Хранение указателей на объекты

// 2. Поиск и возвращение минимального обьекта.

template class Tree

{ private:

Tree *child[size];

T *data;

public:

Tree();

~Tree();

void Add(T a); //добавление элемента

T *FindMin(); }//поиск минимального

template Tree::Tree()

{ for(int i=0;i
template Tree::~Tree()

{ if(data!=NULL) delete data; //удаление элемента

for(int i=0;i
if(child[i]!=NULL) delete child[i]; }//удаление поддеревьев

template void Tree::Add(T a) //добавление
элемента

{ if(data==NULL) { data=new T; *data=a; return; }

for(int i=0;i*child[i]->data;i++);

if(child[i]==NULL) child[i]=new Tree;

child[i]->Add(a); }

template T* Tree::FindMin()

{ T* tmp=data; //принимаем начальный за минимальный

for(int i=0;i
if(child[i]!=NULL)

{ T* tmp2=child[i]->FindMin(); //ищем в поддереве

if(*tmp2<*tmp) tmp=tmp2; }

return tmp; } //возвращаем минимальный

void main()

{ Tree a; //создание дерева с пятью потомками в вершине

a.Add(5); a.Add(11); a.Add(3); a.Add(15); //вставка элементов

int k=*a.FindMin(); } // поиск минимального

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

// 7. Дерево с ограниченным числом потомков

// 1. Хранение указателей на объекты

// 3. Сортировка (любым методом).

template class Tree

{ private:

Tree *child[size];

T *data;

public:

Tree();

~Tree();

void Add(T a); //добавление элемента

void Sort(); }//сортировка

template Tree::Tree()

{ for(int i=0;i
template Tree::~Tree()

{ if(data!=NULL) delete data; //удаление элемента

for(int i=0;i
if(child[i]!=NULL) delete child[i]; }//удаление поддеревьев

template void Tree::Add(T a) //добавление
элемента

{ if(data==NULL) { data=new T; *data=a; return; }

for(int i=0;i*child[i]->data;i++);

if(child[i]==NULL) child[i]=new Tree;

child[i]->Add(a); }

template void Tree::Sort()

{ for(int i=0;i
if(child[i]!=NULL) child[i]->Sort(); //сортируем
поддерево

for(i=0;i
for(int j=i+1;j
if(child[i]!=NULL&&child[j]!=NULL)

if(*child[j]->data<*child[i]->data) //поиск
наибольшего

{ T*
t=child[j]->data;child[j]->data=child[i]->data;

child[i]->data=t; } } //обмен

void main()

{ Tree a; //создание дерева с пятью потомками в вершине

a.Add(5); a.Add(11); a.Add(3); a.Add(15); //вставка элементов

a.Sort(); } //сортировка элементов

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

// 7. Дерево с ограниченным числом потомков

// 1. Хранение указателей на объекты

// 4. Двоичный поиск на основе сравнения с внешним обьектом-ключом

template class Tree

{ private:

Tree *child[size];

T *data;

public:

Tree();

~Tree();

void Add(T a); //добавление элемента

T* FindBin(T key); }

template Tree::Tree()

{ for(int i=0;i
template Tree::~Tree()

{ if(data!=NULL) delete data; //удаление элемента

for(int i=0;i
if(child[i]!=NULL) delete child[i]; }//удаление поддеревьев

template void Tree::Add(T a) //добавление
элемента

{ if(data==NULL) { data=new T; *data=a; return; }

for(int i=0;i*child[i]->data;i++);

if(child[i]==NULL) child[i]=new Tree;

child[i]->Add(a); }

template T* Tree::FindBin(T key)

{ T* p;

if (*data==key) return data;//совпадение

for(int i=0;i
{ p=child[i]->FindBin(key);

if(p!=NULL) return p; } //найден

return NULL; } //не найден

void main()

{ Tree a; //создание дерева с пятью потомками в вершине

a.Add(5); a.Add(11); a.Add(3); a.Add(15); //вставка элементов

int j=*a.FindBin(11);}

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

// 7. Дерево с ограниченным числом потомков

// 1. Хранение указателей на объекты

// 5. Включение элемента по номеру.

template class Tree

{ private:

Tree *child[size];

T *data;

public:

Tree();

~Tree();

void Add(T a); //добавление элемента

void Insert(T a,int pos); }; //вставка элемента

template Tree::Tree()

{ for(int i=0;i
template Tree::~Tree()

{ if(data!=NULL) delete data; //удаление элемента

for(int i=0;i
if(child[i]!=NULL) delete child[i]; }//удаление поддеревьев

template void Tree::Add(T a) //добавление
элемента

{ if(data==NULL) { data=new T; *data=a; return; }

for(int i=0;i*child[i]->data;i++);

if(child[i]==NULL) child[i]=new Tree;

child[i]->Add(a); }

template void Tree::Insert(T a,int pos)

{ if(pos==0) //позиция найдена

{ if(data==NULL) { data=new T; *data=a; return; }
//вставка

if(child[0]==NULL) child[0]=new Tree;

child[0]->Insert(*data,0); *data=a; return; }
//вставка в поддерево

for(int i=0;i
if(child[i]!=NULL)

if(--pos==0) { child[i]->Insert(a,pos); return;
}

if(i; child[i]->Insert(a,0);
return; }

for(i=0;i
if(child[i]!=NULL)

{ child[i]->Insert(a,pos); } }

void main()

{ Tree a; //создание дерева с пятью потомками в вершине

a.Add(5); a.Add(11); a.Add(3); a.Add(15); //вставка элементов

a.Insert(55,1); } //вставка элемента на первую позицию

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

// 7. Дерево с ограниченным числом потомков

// 1. Хранение указателей на объекты

// 6. Исключение (удаление) элемента по номеру.

template class Tree

{ private:

Tree *child[size];

T *data;

public:

Tree();

~Tree();

void Add(T a); //добавление элемента

void Delete(int pos);}; //удаление элемента

template Tree::Tree()

{ for(int i=0;i
template Tree::~Tree()

{ if(data!=NULL) delete data; //удаление элемента

for(int i=0;i
if(child[i]!=NULL) delete child[i]; }//удаление поддеревьев

template void Tree::Add(T a) //добавление
элемента

{ if(data==NULL) { data=new T; *data=a; return; }

for(int i=0;i*child[i]->data;i++);

if(child[i]==NULL) child[i]=new Tree;

child[i]->Add(a); }

template void Tree::Delete(int pos)

{ for(int i=0;i
if(child[i]!=NULL)

if(--pos==0) { delete child[i]->data;
child[i]->data=NULL; return; }

for(i=0;i
if(child[i]!=NULL)

{ child[i]->Delete(pos); } }

void main()

{ Tree a; //создание дерева с пятью потомками в вершине

a.Add(5); a.Add(11); a.Add(3); a.Add(15); //вставка элементов

a.Delete(1); }//удаление элемента

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

// 7. Дерево с ограниченным числом потомков

// 1. Хранение указателей на объекты

// 7. Поиск и возвращение элемента по номеру.

template class Tree

{ private:

Tree *child[size];

T *data;

public:

Tree();

~Tree();

void Add(T a); //добавление элемента

T* Get(int pos);}; //получить элемент по номеру

template Tree::Tree()

{ for(int i=0;i
template Tree::~Tree()

{ if(data!=NULL) delete data; //удаление элемента

for(int i=0;i
if(child[i]!=NULL) delete child[i]; }//удаление поддеревьев

template void Tree::Add(T a) //добавление
элемента

{ if(data==NULL) { data=new T; *data=a; return; }

for(int i=0;i*child[i]->data;i++);

if(child[i]==NULL) child[i]=new Tree;

child[i]->Add(a); }

template T* Tree::Get(int pos)

{ if(pos==0) return data;

for(int i=0;i
if(child[i]!=NULL)

if(--pos==0) { return child[i]->data; }

T* p;

for(i=0;i
if(child[i]!=NULL)

{ p=child[i]->Get(pos);

if(p!=NULL) return p; }

return NULL; }

void main()

{ Tree a; //создание дерева с пятью потомками в вершине

a.Add(5); a.Add(11); a.Add(3); a.Add(15); //вставка элементов

int i=*a.Get(2); } //взять элемент по номеру

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

// 7. Дерево с ограниченным числом потомков

// 2. Хранение объектов

// 1. Включение элемента с сохранением упорядочености.

template class Tree

{ private:

Tree *child[size];

T data;

public:

Tree();

~Tree();

void Add(T a); }; //добавление элемента

template Tree::Tree()

{ for(int i=0;i
template Tree::~Tree()

{ for(int i=0;i
if(child[i]!=NULL) delete child[i]; }//удаление поддеревьев

template void Tree::Add(T a) //добавление
элемента

{ if(data==0) { data=a; return; }

for(int i=0;ichild[i]->data;i++);

if(child[i]==NULL) child[i]=new Tree;

child[i]->Add(a); }

void main()

{ Tree a; //создание дерева с пятью потомками в вершине

a.Add(5); a.Add(11); a.Add(3); a.Add(15);} //вставка элементов

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

// 7. Дерево с ограниченным числом потомков

// 2. Хранение объектов

// 2. Поиск и возвращение минимального обьекта.

template class Tree

{ private:

Tree *child[size];

T data;

public:

Tree();

~Tree();

void Add(T a); //добавление элемента

T FindMin(); }//поиск минимального

template Tree::Tree()

{ for(int i=0;i
template Tree::~Tree()

{ for(int i=0;i
if(child[i]!=NULL) delete child[i]; }//удаление поддеревьев

template void Tree::Add(T a) //добавление
элемента

{ if(data==0) { data=a; return; }

for(int i=0;ichild[i]->data;i++);

if(child[i]==NULL) child[i]=new Tree;

child[i]->Add(a); }

template T Tree::FindMin()

{ T tmp=data; //принимаем начальный за минимальный

for(int i=0;i
if(child[i]!=NULL)

{ T tmp2=child[i]->FindMin(); //ищем в поддереве

if(tmp2
return tmp; } //возвращаем минимальный

void main()

{ Tree a; //создание дерева с пятью потомками в вершине

a.Add(5); a.Add(11); a.Add(3); a.Add(15); //вставка элементов

int k=a.FindMin(); } // поиск минимального

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

// 7. Дерево с ограниченным числом потомков

// 2. Хранение объектов

// 3. Сортировка (любым методом).

template class Tree

{ private:

Tree *child[size];

T data;

public:

Tree();

~Tree();

void Add(T a); //добавление элемента

void Sort(); };//сортировка

template Tree::Tree()

{ for(int i=0;i
template Tree::~Tree()

{ for(int i=0;i
if(child[i]!=NULL) delete child[i]; }//удаление поддеревьев

template void Tree::Add(T a) //добавление
элемента

{ if(data==0) { data=a; return; }

for(int i=0;ichild[i]->data;i++);

if(child[i]==NULL) child[i]=new Tree;

child[i]->Add(a); }

template void Tree::Sort()

{ for(int i=0;i
if(child[i]!=NULL) child[i]->Sort(); //сортируем
поддерево

for(i=0;i
for(int j=i+1;j
if(child[i]!=NULL&&child[j]!=NULL)

if(child[j]->datadata) //поиск
наибольшего

{ T
t=child[j]->data;child[j]->data=child[i]->data;

child[i]->data=t; } } //обмен

void main()

{ Tree a; //создание дерева с пятью потомками в вершине

a.Add(5); a.Add(11); a.Add(3); a.Add(15); //вставка элементов

a.Sort(); } //сортировка элементов

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

// 7. Дерево с ограниченным числом потомков

// 2. Хранение объектов

// 4. Двоичный поиск на основе сравнения с внешним обьектом-ключом

template class Tree

{ private:

Tree *child[size];

T data;

public:

Tree();

~Tree();

void Add(T a); //добавление элемента

T FindBin(T key);};

template Tree::Tree()

{ for(int i=0;i
template Tree::~Tree()

{ for(int i=0;i
if(child[i]!=NULL) delete child[i]; }//удаление поддеревьев

template void Tree::Add(T a) //добавление
элемента

{ if(data==0) { data=a; return; }

for(int i=0;ichild[i]->data;i++);

if(child[i]==NULL) child[i]=new Tree;

child[i]->Add(a); }

template T Tree::FindBin(T key)

{ T p;

if (data==key) return data;//совпадение

for(int i=0;i
{ p=child[i]->FindBin(key);

if(p!=NULL) return p; } //найден

return NULL; } //не найден

void main()

{ Tree a; //создание дерева с пятью потомками в вершине

a.Add(5); a.Add(11); a.Add(3); a.Add(15); //вставка элементов

int j=a.FindBin(11); }

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

// 7. Дерево с ограниченным числом потомков

// 2. Хранение объектов

// 5. Включение элемента по номеру.

template class Tree

{ private:

Tree *child[size];

T data;

public:

Tree();

~Tree();

void Add(T a); //добавление элемента

void Insert(T a,int pos); }; //вставка элемента

template Tree::Tree()

{ for(int i=0;i
template Tree::~Tree()

{ for(int i=0;i
if(child[i]!=NULL) delete child[i]; }//удаление поддеревьев

template void Tree::Add(T a) //добавление
элемента

{ if(data==0) { data=a; return; }

for(int i=0;ichild[i]->data;i++);

if(child[i]==NULL) child[i]=new Tree;

child[i]->Add(a); }

template void Tree::Insert(T a,int pos)

{ if(pos==0) //позиция найдена

{ if(data==NULL) { data=a; return; } //вставка

if(child[0]==NULL) child[0]=new Tree;

child[0]->Insert(data,0); data=a; return; }
//вставка в поддерево

for(int i=0;i
if(child[i]!=NULL)

if(--pos==0) { child[i]->Insert(a,pos); return;
}

if(i; child[i]->Insert(a,0);
return; }

for(i=0;i
if(child[i]!=NULL)

{ child[i]->Insert(a,pos); } }

void main()

{ Tree a; //создание дерева с пятью потомками в вершине

a.Add(5); a.Add(11); a.Add(3); a.Add(15); //вставка элементов

a.Insert(55,1);} //вставка элемента на первую позицию

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

// 7. Дерево с ограниченным числом потомков

// 2. Хранение объектов

// 6. Исключение (удаление) элемента по номеру.

template class Tree

{ private:

Tree *child[size];

T data;

public:

Tree();

~Tree();

void Add(T a); //добавление элемента

void Delete(int pos); };//удаление элемента

template Tree::Tree()

{ for(int i=0;i
template Tree::~Tree()

{ for(int i=0;i
if(child[i]!=NULL) delete child[i]; }//удаление поддеревьев

template void Tree::Add(T a) //добавление
элемента

{ if(data==0) { data=a; return; }

for(int i=0;ichild[i]->data;i++);

if(child[i]==NULL) child[i]=new Tree;

child[i]->Add(a); }

template void Tree::Delete(int pos)

{ if(pos==0) data=0;

for(int i=0;i
if(child[i]!=NULL)

if(--pos==0) { child[i]->data=0; return; }

for(i=0;i
if(child[i]!=NULL)

{ child[i]->Delete(pos); } }

void main()

{ Tree a; //создание дерева с пятью потомками в вершине

a.Add(5); a.Add(11); a.Add(3); a.Add(15); //вставка элементов

a.Delete(1); }//удаление элемента

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

// 7. Дерево с ограниченным числом потомков

// 2. Хранение объектов

// 7. Поиск и возвращение элемента по номеру.

template class Tree

{ private:

Tree *child[size];

T data;

public:

Tree();

~Tree();

void Add(T a); //добавление элемента

T Get(int pos); };//получить элемент по номеру

template Tree::Tree()

{ for(int i=0;i
template Tree::~Tree()

{ for(int i=0;i
if(child[i]!=NULL) delete child[i]; }//удаление поддеревьев

template void Tree::Add(T a) //добавление
элемента

{ if(data==0) { data=a; return; }

for(int i=0;ichild[i]->data;i++);

if(child[i]==NULL) child[i]=new Tree;

child[i]->Add(a); }

template T Tree::Get(int pos)

{ if(pos==0) return data;

for(int i=0;i
if(child[i]!=NULL)

if(--pos==0) { return child[i]->data; }

T p;

for(i=0;i
if(child[i]!=NULL)

{ p=child[i]->Get(pos);

if(p!=NULL) return p; }

return 0; }

void main()

{ Tree a; //создание дерева с пятью потомками в вершине

a.Add(5); a.Add(11); a.Add(3); a.Add(15); //вставка элементов

int i=a.Get(2); } //взять элемент по номеру

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

// 8. Двоичное дерево

// 1. Хранение указателей на обьекты

// 1. Включение элемента с сохранением упорядочености.

template class BTree

{ private:

BTree *l,*r; //указатели на левое и правое
поддеревья

T* data;

public:

void Add(T &a);

BTree();

~BTree(); };

template void BTree::Add(T &a)

{ if(data==NULL) { data=new T; *data=a; return; } //вставка в
текущий

if(a>*data)

{ if(r==NULL) r=new BTree; r->Add(a); } else //в правый

{ if(l==NULL) l=new BTree; l->Add(a); } } //в левый

template BTree::BTree()

{ l=NULL; r=NULL; data=NULL; }//инициализация

template BTree::~BTree()

{ if(data!=NULL) delete data; //удаление данных

if(l!=NULL) delete l; // -//- левого поддерева

if(r!=NULL) delete r; } // -//- правого поддерева

void main()

{ BTree a; //двоичное дерево из long-ов

a.Add(10); a.Add(3); a.Add(210); a.Add(70); }

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

// 8. Двоичное дерево

// 1. Хранение указателей на обьекты

// 2. Поиск и возвращение минимального об"екта.

template class BTree

{ private:

BTree *l,*r; //указатели на левое и правое
поддеревья

T* data;

public:

void Add(T &a);

T& Min();

BTree();

~BTree(); };

template void BTree::Add(T &a)

{ if(data==NULL) { data=new T; *data=a; return; } //вставка в
текущий

if(a>*data)

{ if(r==NULL) r=new BTree; r->Add(a); } else //в правый

{ if(l==NULL) l=new BTree; l->Add(a); } } //в левый

template T& BTree::Min()

{ T* tmp=data,*tmp2;

if(l!=NULL) {tmp2=&l->Min(); if(*tmp2<*tmp) tmp=tmp2;} //поиск слева

if(r!=NULL) {tmp2=&r->Min(); if(*tmp2<*tmp) tmp=tmp2;} //поиск справа

return *tmp; }

template BTree::BTree()

{ l=NULL; r=NULL; data=NULL; }//инициализация

template BTree::~BTree()

{ if(data!=NULL) delete data; //удаление данных

if(l!=NULL) delete l; // -//- левого поддерева

if(r!=NULL) delete r; } // -//- правого поддерева

void main()

{ BTree a; //двоичное дерево из long-ов

a.Add(10); a.Add(3); a.Add(210); a.Add(70);

long k=a.Min(); }

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

// 8. Двоичное дерево

// 1. Хранение указателей на обьекты

// 3. Сортировка (любым методом).

template class BTree

{ private:

BTree *l,*r; //указатели на левое и правое
поддеревья

T* data;

public:

void Add(T &a);

void Sort();

BTree();

~BTree(); };

template void BTree::Add(T &a)

{ if(data==NULL) { data=new T; *data=a; return; } //вставка в
текущий

if(a>*data)

{ if(r==NULL) r=new BTree; r->Add(a); } else //в правый

{ if(l==NULL) l=new BTree; l->Add(a); } } //в левый

template void BTree::Sort()

{ if(l!=NULL) l->Sort(); //сортировка левого поддерева

if(r!=NULL) r->Sort(); //сортировка правого поддерева

if(l!=NULL&&r!=NULL)

if(*l->data>*r->data){ BTree *t=l; l=r; r=t; } }// обмен

template BTree::BTree()

{ l=NULL; r=NULL; data=NULL; }//инициализация

template BTree::~BTree()

{ if(data!=NULL) delete data; //удаление данных

if(l!=NULL) delete l; // -//- левого поддерева

if(r!=NULL) delete r; } // -//- правого поддерева

void main()

{ BTree a; //двоичное дерево из long-ов

a.Add(10); a.Add(3); a.Add(210); a.Add(70);

a.Sort();}

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

// 8. Двоичное дерево

// 1. Хранение указателей на обьекты

// 4. Двоичный поиск на основе сравнения с внешним об"ектом-ключом

template class BTree

{ private:

BTree *l,*r; //указатели на левое и правое
поддеревья

T* data;

public:

void Add(T &a);

T* FindBin(T &key);

BTree();

~BTree(); };

template void BTree::Add(T &a)

{ if(data==NULL) { data=new T; *data=a; return; } //вставка в
текущий

if(a>*data)

{ if(r==NULL) r=new BTree; r->Add(a); } else //в правый

{ if(l==NULL) l=new BTree; l->Add(a); } } //в левый

template T* BTree::FindBin(T &key)

{ if(key==*data) return data; T* s=NULL;

if(l!=NULL&&key<*data) s=l->FindBin(key);

if(s!=NULL) return s;

if(r!=NULL&&key>*data) s=r->FindBin(key);

if(s!=NULL) return s;

return NULL; }

template BTree::BTree()

{ l=NULL; r=NULL; data=NULL; }//инициализация

template BTree::~BTree()

{ if(data!=NULL) delete data; //удаление данных

if(l!=NULL) delete l; // -//- левого поддерева

if(r!=NULL) delete r; } // -//- правого поддерева

void main()

{ BTree a; //двоичное дерево из long-ов

a.Add(10); a.Add(3); a.Add(210); a.Add(70);

long j=*a.FindBin(210);}

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

// 8. Двоичное дерево

// 1. Хранение указателей на обьекты

// 5. Включение элемента по номеру.

template class BTree

{ private:

BTree *l,*r; //указатели на левое и правое
поддеревья

T* data;

public:

void Add(T &a);

int Insert(T &a,int k);

BTree();

~BTree(); };

template void BTree::Add(T &a)

{ if(data==NULL) { data=new T; *data=a; return; } //вставка в
текущий

if(a>*data)

{ if(r==NULL) r=new BTree; r->Add(a); } else //в правый

{ if(l==NULL) l=new BTree; l->Add(a); } } //в левый

template int BTree::Insert(T &a,int k)

{ if(k==0)

{ if(data==NULL) { data=new T; *data=a; return 0; }

if(l!=NULL&&r==NULL)

{ r=new BTree; r->data=new T;

*r->data=*data; *data=a; return 0; }

if(l==NULL)

{ l=new BTree; l->data=new T;

*l->data=*data; *data=a; return 0; }

l->Insert(*data,0);

*data=a; return 0; }

if(k==1&&l!=NULL) return l->Insert(a,0);

if(k==2&&r!=NULL) return r->Insert(a,0);

if(l!=NULL) { k-=l->Insert(a,k); if(k==0) return 0; }

if(r!=NULL) { k-=r->Insert(a,k); if(k==0) return 0; }

return k; }

template BTree::BTree()

{ l=NULL; r=NULL; data=NULL; }//инициализация

template BTree::~BTree()

{ if(data!=NULL) delete data; //удаление данных

if(l!=NULL) delete l; // -//- левого поддерева

if(r!=NULL) delete r; } // -//- правого поддерева

void main()

{ BTree a; //двоичное дерево из long-ов

a.Add(10); a.Add(3); a.Add(210); a.Add(70);

a.Insert(111,0);}

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

// 8. Двоичное дерево

// 1. Хранение указателей на обьекты

// 6. Исключение (удаление) элемента по номеру.

template class BTree

{ private:

BTree *l,*r; //указатели на левое и правое
поддеревья

T* data;

public:

void Add(T &a);

int Delete(int k);

BTree();

~BTree(); };

template void BTree::Add(T &a)

{ if(data==NULL) { data=new T; *data=a; return; } //вставка в
текущий

if(a>*data)

{ if(r==NULL) r=new BTree; r->Add(a); } else //в правый

{ if(l==NULL) l=new BTree; l->Add(a); } } //в левый

template int BTree::Delete(int k)

{ if(k==0) if(data!=NULL) { delete data; data=NULL; return
0; }

if(k==1&&l!=NULL) return l->Delete(0);

if(k==2&&r!=NULL) return r->Delete(0);

if(l!=NULL) {k-=l->Delete(k); if(k==0) return 0; }

if(r!=NULL) {k-=r->Delete(k); if(k==0) return 0; }

return k; }

template BTree::BTree()

{ l=NULL; r=NULL; data=NULL; }//инициализация

template BTree::~BTree()

{ if(data!=NULL) delete data; //удаление данных

if(l!=NULL) delete l; // -//- левого поддерева

if(r!=NULL) delete r; } // -//- правого поддерева

void main()

{ BTree a; //двоичное дерево из long-ов

a.Add(10); a.Add(3); a.Add(210); a.Add(70);

a.Delete(1); }

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

// 8. Двоичное дерево

// 1. Хранение указателей на обьекты

// 7. Поиск и возвращение элемента по номеру.

template class BTree

{ private:

BTree *l,*r; //указатели на левое и правое
поддеревья

T* data;

public:

void Add(T &a);

T* Find(int &k);

BTree();

~BTree(); };

template void BTree::Add(T &a)

{ if(data==NULL) { data=new T; *data=a; return; } //вставка в
текущий

if(a>*data)

{ if(r==NULL) r=new BTree; r->Add(a); } else //в правый

{ if(l==NULL) l=new BTree; l->Add(a); } } //в левый

template T* BTree::Find(int &k)

{ if(k==0) return data;

T* tmp=NULL; k--;

if(l!=NULL) {tmp=l->Find(k); if(tmp!=NULL) return tmp; }

if(r!=NULL) {tmp=r->Find(k); if(tmp!=NULL) return tmp; }

return NULL; }

template BTree::BTree()

{ l=NULL; r=NULL; data=NULL; }//инициализация

template BTree::~BTree()

{ if(data!=NULL) delete data; //удаление данных

if(l!=NULL) delete l; // -//- левого поддерева

if(r!=NULL) delete r; } // -//- правого поддерева

void main()

{ BTree a; //двоичное дерево из long-ов

a.Add(10); a.Add(3); a.Add(210); a.Add(70);

long m=*a.Find(1);}

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

// 8. Двоичное дерево

// 2. Хранение обьектов

// 1. Включение элемента с сохранением упорядочености.

template class BTree

{ private:

BTree *l,*r; //указатели на левое и правое
поддеревья

T data;

public:

void Add(T &a);

BTree();

~BTree(); };

template void BTree::Add(T &a)

{ if(data==NULL) { data=a; return; } //вставка в текущий

if(a>data)

{ if(r==NULL) r=new BTree; r->Add(a); } else //в правый

{ if(l==NULL) l=new BTree; l->Add(a); } } //в левый

template BTree::BTree()

{ l=NULL; r=NULL; data=0; }//инициализация

template BTree::~BTree()

{ data=0; //удаление данных

if(l!=NULL) delete l; // -//- левого поддерева

if(r!=NULL) delete r; } // -//- правого поддерева

void main()

{ BTree a; //двоичное дерево из long-ов

a.Add(10); a.Add(3); a.Add(210); a.Add(70); }//заполнение

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

// 8. Двоичное дерево

// 2. Хранение обьектов

// 2. Поиск и возвращение минимального об"екта.

template class BTree

{ private:

BTree *l,*r; //указатели на левое и правое
поддеревья

T data;

public:

void Add(T &a);

T& Min();

BTree();

~BTree(); };

template void BTree::Add(T &a)

{ if(data==NULL) { data=a; return; } //вставка в текущий

if(a>data)

{ if(r==NULL) r=new BTree; r->Add(a); } else //в правый

{ if(l==NULL) l=new BTree; l->Add(a); } } //в левый

template T& BTree::Min()

{ T* tmp=&data,*tmp2;

if(l!=NULL) {tmp2=&l->Min(); if(*tmp2<*tmp) tmp=tmp2;} //поиск слева

if(r!=NULL) {tmp2=&r->Min(); if(*tmp2<*tmp) tmp=tmp2;} //поиск справа

return *tmp; }

template BTree::BTree()

{ l=NULL; r=NULL; data=0; }//инициализация

template BTree::~BTree()

{ data=0; //удаление данных

if(l!=NULL) delete l; // -//- левого поддерева

if(r!=NULL) delete r; } // -//- правого поддерева

void main()

{ BTree a; //двоичное дерево из long-ов

a.Add(10); a.Add(3); a.Add(210); a.Add(70);//заполнение

long k=a.Min(); }

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

// 8. Двоичное дерево

// 2. Хранение обьектов

// 3. Сортировка (любым методом).

template class BTree

{ private:

BTree *l,*r; //указатели на левое и правое
поддеревья

T data;

public:

void Add(T &a);

void Sort();

BTree();

~BTree(); };

template void BTree::Add(T &a)

{ if(data==NULL) { data=a; return; } //вставка в текущий

if(a>data)

{ if(r==NULL) r=new BTree; r->Add(a); } else //в правый

{ if(l==NULL) l=new BTree; l->Add(a); } } //в левый

template void BTree::Sort()

{ if(l!=NULL) l->Sort(); //сортировка левого поддерева

if(r!=NULL) r->Sort(); //сортировка правого поддерева

if(l!=NULL&&r!=NULL)

if(l->data>r->data){ BTree *t=l; l=r; r=t; } }// обмен

template BTree::BTree()

{ l=NULL; r=NULL; data=0; }//инициализация

template BTree::~BTree()

{ data=0; //удаление данных

if(l!=NULL) delete l; // -//- левого поддерева

if(r!=NULL) delete r; } // -//- правого поддерева

void main()

{ BTree a; //двоичное дерево из long-ов

a.Add(10); a.Add(3); a.Add(210); a.Add(70);//заполнение

a.Sort();}

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

// 8. Двоичное дерево

// 2. Хранение обьектов

// 4. Двоичный поиск на основе сравнения с внешним об"ектом-ключом

template class BTree

{ private:

BTree *l,*r; //указатели на левое и правое
поддеревья

T data;

public:

void Add(T &a);

T* FindBin(T &key);

BTree();

~BTree(); };

template void BTree::Add(T &a)

{ if(data==NULL) { data=a; return; } //вставка в текущий

if(a>data)

{ if(r==NULL) r=new BTree; r->Add(a); } else //в правый

{ if(l==NULL) l=new BTree; l->Add(a); } } //в левый

template T* BTree::FindBin(T &key)

{ if(key==data) return &data; T* s=NULL;

if(l!=NULL&&keyFindBin(key);

if(s!=NULL) return s;

if(r!=NULL&&key>data) s=r->FindBin(key);

if(s!=NULL) return s;

return NULL; }

template BTr???????

{ l=NULL; r=NULL; data=0; }//инициализация

template BTree::~BTree()

{ data=0; //удаление данных

if(l!=NULL) delete l; // -//- левого поддерева

if(r!=NULL) delete r; } // -//- правого поддерева

void main()

{ BTree a; //двоичное дерево из long-ов

a.Add(10); a.Add(3); a.Add(210); a.Add(70);//заполнение

long j=*a.FindBin(210);}

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

// 8. Двоичное дерево

// 2. Хранение обьектов

// 5. Включение элемента по номеру.

template class BTree

{ private:

BTree *l,*r; //указатели на левое и правое
поддеревья

T data;

public:

void Add(T &a);

int Insert(T &a,int k);

BTree();

~BTree(); };

template void BTree::Add(T &a)

{ if(data==NULL) { data=a; return; } //вставка в текущий

if(a>data)

{ if(r==NULL) r=new BTree; r->Add(a); } else //в правый

{ if(l==NULL) l=new BTree; l->Add(a); } } //в левый

template int BTree::Insert(T &a,int k)

{ if(k==0)

{ if(data==0) { data=a; return 0; }

if(l!=NULL&&r==NULL)

{ r=new BTree; r->data=data; data=a; return 0; }

if(l==NULL)

{ l=new BTree; l->data=data; data=a; return 0; }

l->Insert(data,0);

data=a; return 0; }

if(k==1&&l!=NULL) return l->Insert(a,0);

if(k==2&&r!=NULL) return r->Insert(a,0);

if(l!=NULL) { k-=l->Insert(a,k); if(k==0) return 0; }

if(r!=NULL) { k-=r->Insert(a,k); if(k==0) return 0; }

return k; }

template BTree::BTree()

{ l=NULL; r=NULL; data=0; }//инициализация

template BTree::~BTree()

{ data=0; //удаление данных

if(l!=NULL) delete l; // -//- левого поддерева

if(r!=NULL) delete r; } // -//- правого поддерева

void main()

{ BTree a; //двоичное дерево из long-ов

a.Add(10); a.Add(3); a.Add(210); a.Add(70);//заполнение

a.Insert(111,0);}

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

// 8. Двоичное дерево

// 2. Хранение обьектов

// 6. Исключение (удаление) элемента по номеру.

template class BTree

{ private:

BTree *l,*r; //указатели на левое и правое
поддеревья

T data;

public:

void Add(T &a);

int Delete(int k);

BTree();

~BTree(); };

template void BTree::Add(T &a)

{ if(data==NULL) { data=a; return; } //вставка в текущий

if(a>data)

{ if(r==NULL) r=new BTree; r->Add(a); } else //в правый

{ if(l==NULL) l=new BTree; l->Add(a); } } //в левый

template int BTree::Delete(int k)

{ if(k==0) { data=0; return 0; }

if(k==1&&l!=NULL) return l->Delete(0);

if(k==2&&r!=NULL) return r->Delete(0);

if(l!=NULL) {k-=l->Delete(k); if(k==0) return 0; }

if(r!=NULL) {k-=r->Delete(k); if(k==0) return 0; }

return k; }

template BTree::BTree()

{ l=NULL; r=NULL; data=0; }//инициализация

template BTree::~BTree()

{ data=0; //удаление данных

if(l!=NULL) delete l; // -//- левого поддерева

if(r!=NULL) delete r; } // -//- правого поддерева

void main()

{ BTree a; //двоичное дерево из long-ов

a.Add(10); a.Add(3); a.Add(210); a.Add(70);//заполнение

a.Delete(1);}

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

// 8. Двоичное дерево

// 2. Хранение обьектов

// 7. Поиск и возвращение элемента по номеру.

template class BTree

{ private:

BTree *l,*r; //указатели на левое и правое
поддеревья

T data;

public:

void Add(T &a);

T* Find(int &k);

BTree();

~BTree(); };

template void BTree::Add(T &a)

{ if(data==NULL) { data=a; return; } //вставка в текущий

if(a>data)

{ if(r==NULL) r=new BTree; r->Add(a); } else //в правый

{ if(l==NULL) l=new BTree; l->Add(a); } } //в левый

template T* BTree::Find(int &k)

{ if(k==0) return &data;

T* tmp=NULL; k--;

if(l!=NULL) {tmp=l->Find(k); if(tmp!=NULL) return tmp; }

if(r!=NULL) {tmp=r->Find(k); if(tmp!=NULL) return tmp; }

return NULL; }

l=NULL; r=NULL; data=0; }//инициализация

template BTree::~BTree()

{ data=0; //удаление данных

if(l!=NULL) delete l; // -//- левого поддерева

if(r!=NULL) delete r; } // -//- правого поддерева

void main()

{ BTree a; //двоичное дерево из long-ов

a.Add(10); a.Add(3); a.Add(210); a.Add(70);//заполнение

long m=*a.Find(1);}

      ©2010