Главная:
Рефераты
Главная
Метрология
Менеджмент
Международное право
Медицина физкультура здравоохранение
ИГП
Земельное право
Журналистика
Жилищное право
Экология и охрана природы
Транспорт
Религия и мифология
Педагогика
Маркетинг реклама и торговля
История и исторические личности
Бухгалтерский учет и аудит
Геополитика
Ботаника и сельское хозяйство
Архитектура
Новейшая история политология
Программирование базы данных
Наука и техника
Математика и физика
История политичиских учений
Законодательство и право
География и геология
Банковское право
Медицинский справочник
Карта сайта
Рефераты. Реферат: Шпоры по Си. Шаблоны стандартных структур данных
Реферат: Шпоры по Си. Шаблоны стандартных структур данных
//----------------------------------------------------------------------
------
// 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
{ 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
{ 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
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
{ 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
{ 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] минимального
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] //сравнение
{ 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
{ 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
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
{ 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] минимального
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] //сравнение
{ 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
{ 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
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
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
{ 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=??????????†††?????????†††???????
{ 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
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
{ 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. Односвязный список
// 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->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(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
{ 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
{ 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->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. Двусвязный циклический список
// 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
{ 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
{ 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
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]->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. Дерево с ограниченным числом потомков
// 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
if(r!=NULL) {tmp2=&r->Min(); if(*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&&keyFindBin(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
if(r!=NULL) {tmp2=&r->Min(); if(*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);}
Апрель (48)
Март (20)
Февраль (988)
Январь (720)
Январь (21)
2012 © Все права защищены
При использовании материалов активная
ссылка на источник
обязательна.
