Разработка шаблонов структуры данных в памяти, страница 2

                                               else r->ins(q);

                                   }

                        }

                        /*-----------------------------------------------------------------------------------------*/

                        node* srch(T k)                     //получение указателя на объект по ключу (типа Т)

                        {

                                   if (k==dat) return this;

                                   if (k<dat)

                                   {

                                               if (l==NULL) return NULL;

                                               return l->srch(k);

                                   }

                                   else

                                   {

                                               if (r==NULL) return NULL;

                                               return r->srch(k);

                                   }

                        }

                        /*-----------------------------------------------------------------------------------------*/

                        node* get(int n)         //получение указателя на объект по Логическому Номеру

                        {

                                   if (n>=cnt) return NULL;

                                   if (l!=NULL)

                                   {

                                               if (n<l->cnt) return l->get(n);

                                               n=n-l->cnt;

                                   }

                                   if (n==0) return this;

                                   n--;

                                   if (r!=NULL) return r->get(n);

                                   return NULL;

                        }

                        friend ostream &operator<<(ostream &o, node &n)     //вывод в поток

                                   //при вызове метода слева должен стаять какой либо поток,

                                   //а справа указатель типа node

                        {

                                   if (n.l!=NULL) o<<*n.l;//если левая ветка не равна нулю то мы выводим ее

                                   o<<n.dat<<endl;

                                   if (n.r!=NULL) o<<*n.r;

                                   return o;

                        }

                        friend istream &operator>>(istream &i, node &n)    //загрузка из потока

                                   //тоже самое только для операции чтения из потока

                        {

                                   T a;

                                   i>>a;

                                   n.ins(a);

                                   return i;

                        }

            };

            node *root;     //корень

public:

            btree() {root=NULL;}    //конструктор

            ~btree() {if (root!=NULL) delete root;}                  //деструктор

            void scn(int n) {if (root!=NULL) root->scn(n);}    //полный обход с нумерацией вершин

            void shw(int num) {if (root!=NULL) root->shw(num);}     //просмотр двоичного дерева

            void ins(T idat)                                        //включение с сохранением порядка

            {

                        if (root==NULL) root=new node(idat);

                        else root->ins(idat);

                        this->scn(1);

            }

            int srch(T k)                                                              //поиск по ключу

            {

                        if (root==NULL) return NULL;

                        node *q=root->srch(k);

                        if (q==NULL) return NULL;

                        return q->lnum;

            }

            T get(int n)                                                                //поиск по логическому номеру

            {

                        if (root==NULL) return NULL;

                        node *q=root->get(n);

                        if (q==NULL) return NULL;

                        return q->dat;

            }

            friend ostream &operator<<(ostream &o, btree &t)        //вывод в поток

            {

                        //t- дерево которое передается в метод

                        //t.root- корневая вешина дерева которое передается в метод

                        if (t.root!=NULL) o<<*t.root;//передаем в метод адрес(указатель) в метод вывода в поток

                        return o;

            }

            friend istream &operator>>(istream &i, btree &t)       //загрузка из потока

            {

                        if (t.root!=NULL) i>>*t.root;

                        return i;

            }

};