рефераты

Рефераты

рефераты   Главная
рефераты   Краткое содержание
      произведений
рефераты   Архитектура
рефераты   Астрономия
рефераты   Банковское дело
      и кредитование
рефераты   Безопасность
      жизнедеятельности
рефераты   Биографии
рефераты   Биология
рефераты   Биржевое дело
рефераты   Бухгалтерия и аудит
рефераты   Военное дело
рефераты   География
рефераты   Геодезия
рефераты   Геология
рефераты   Гражданская оборона
рефераты   Животные
рефераты   Здоровье
рефераты   Земельное право
рефераты   Иностранные языки
      лингвистика
рефераты   Искусство
рефераты   Историческая личность
рефераты   История
рефераты   История отечественного
      государства и права
рефераты   История политичиских
      учений
рефераты   История техники
рефераты   Компьютерные сети
рефераты   Компьютеры ЭВМ
рефераты   Криминалистика и
      криминология
рефераты   Культурология
рефераты   Литература
рефераты   Литература языковедение
рефераты   Маркетинг товароведение
      реклама
рефераты   Математика
рефераты   Материаловедение
рефераты   Медицина
рефераты   Медицина здоровье отдых
рефераты   Менеджмент (теория
      управления и организации)
рефераты   Металлургия
рефераты   Москвоведение
рефераты   Музыка
рефераты   Наука и техника
рефераты   Нотариат
рефераты   Общениеэтика семья брак
рефераты   Педагогика
рефераты   Право
рефераты   Программирование
      базы данных
рефераты   Программное обеспечение
рефераты   Промышленность
      сельское хозяйство
рефераты   Психология
рефераты   Радиоэлектроника
      компьютеры
      и перифирийные устройства
рефераты   Реклама
рефераты   Религия
рефераты   Сексология
рефераты   Социология
рефераты   Теория государства и права
рефераты   Технология
рефераты   Физика
рефераты   Физкультура и спорт
рефераты   Философия
рефераты   Финансовое право
рефераты   Химия - рефераты
рефераты   Хозяйственное право
рефераты   Ценный бумаги
рефераты   Экологическое право
рефераты   Экология
рефераты   Экономика
рефераты   Экономика
      предпринимательство
рефераты   Юридическая психология

 
 
 

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

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

// 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);}
© 2011 Рефераты