уря, я сдала двунаправленный список бинарных деревьев стеков студентов!!!!!!
да здрявствует КЮ!!!!


// студент /*минимальная неделимая единица */

# include
class student
{
private:
char * name;
int value;
public:
student (const char * iname = 0, int ivalue = 0);
student (const student & init);
~student ();

student & operator = (const student & rhs);
int operator < (const student & rhs) const;
int operator == (const student & rhs) const;

int init (const char * iname, int ivalue);
int read (FILE * fp);
int get_value () {return value;};
const char * get_name () {return ((const char *) name);}
void change_name (const char * name_);
void change_value (int value_);
void print (FILE * fp) const;

void menu ();
};

class stack_node_student : public student
{
// заготовка для стеков студентов
// к каждому студенту приделана ссылка на правого студент

private:
stack_node_student * next;

public:
stack_node_student (const char * iname = 0, int ivalue = 0): student (iname, ivalue)
{next = 0;}
stack_node_student (const stack_node_student & rhs): student (rhs) { next = 0;}
~stack_node_student () { next = 0;}
stack_node_student & operator = (const stack_node_student & rhs)
{*((student *) this) = rhs; next = 0; return * this;}

stack_node_student * get_next () const {return next;}
void set_next (stack_node_student * next_) {next = next_;}
};













//студент. неделимая элементарная частица
/* 0-ой уровень*/


# include
//#define DEBUG
# define BUF_LEN 665


int student :: init (const char * iname, int ivalue)
{
if (iname)
{ name = new char [strlen (iname) + 1];
if (! name) return -1;
strcpy (name, iname); }
else name = 0;
value = ivalue;
return 0;
}

student :: student (const char * iname, int ivalue)
{
# ifdef DEBUG
printf ("student :: student (%s, %d)\n", (iname ? iname : "no name"), ivalue);
# endif
name = 0; value = 0;
init (iname, ivalue);
}

student :: ~student ()
{
# ifdef DEBUG
printf ("student :: ~student (%s, %d)\n", (name ? name : "no name"), value);
# endif
if (name) delete [] name;
name = 0; value = 0;
}

student :: student (const student & rhs)
{ init (rhs.name, rhs.value);}

student & student :: operator = (const student & rhs)
{ this->student :: ~student ();
init (rhs.name, rhs.value);
return * this;}

int student :: operator < (const student & b) const
{
int res;
res = strcmp (name, b.name);
if (res < 0) return 1;
if (res > 0) return 0;
if (value < b.value) return 1;
return 0;
}

int student :: operator == (const student & b) const
{
if (! (value == b.value)) return 0;
return (! strcmp (name, b.name));
}

void student :: change_name (const char * name_)
{
if (name) delete [] name;
if (name_)
{
name = new char [strlen (name_) + 1];
if (! name)
return;
strcpy (name, name_);
}
}

void student :: change_value (int value_) { value = value_; }

int student :: read (FILE * fp)
{
char buf [BUF_LEN];
int v;

if (fscanf (fp, "%s%d", buf, & v) != 2)
return -1;
if (init (buf, v)) return -2;
return 0;
}

void student :: print (FILE * fp) const
{
fprintf (fp, "%s %d\n", this->name, this->value);
}

void student :: menu ()
{
int wish;
printf ("\nYOU'RE EDITING STUDENT\n");
printf ("0 - go to stack\n");
printf ("1 - print student\n");
printf ("2 - change name\n");
printf ("3 - change value :)\n");
printf ("-1 - print menu\n");
printf ("?: ");

for (;;)
{
if (fscanf (stdin, "%d", &wish)!= 1) {printf ("read error!\n"); break;}
switch (wish)
{ case 0: { return;}
case 1: { print (stdout); break; }
case 2: { char buf [BUF_LEN];
printf ("new name of our student is:\n");
if (fscanf (stdin, "%s", buf) != 1)
{ printf ("Error!\n"); break;}
change_name ((const char *) buf); break; }
case 3: { int v;
printf ("new value of our student is:\n");
if (fscanf (stdin, "%d", & v) != 1)
{printf ("Error!\n"); break;}
change_value (v);
break; }
case -1: {
printf ("0 - go to stack\n");
printf ("1 - print student\n");
printf ("2 - change name\n");
printf ("3 - change value :)\n");
printf ("-1 - print menu\n"); }
default:
printf ("unknown command!\n");
}
printf ("?: ");
}
}







// СТЕК СТУДЕНТОВ


class stack
{
// стек студентов
private:
stack_node_student * top;
stack_node_student * curr;
public:
stack (); ~stack ();

void add (stack_node_student * q);
void del ();

void print (FILE * fp, int) const;
void print_top (FILE * fp) const;

int init (int n, FILE * fp);
void clean ();
int empty ();

int load(int n, FILE *fp);

int get_c () { if (! top) return 0; return (*top).get_value(); }

void menu ();
};

// заготовка стека студентов для бинарного дерева стеков студентов

class tree_node_stack : public stack
{
private:
tree_node_stack * r, // правый потомок
* l, // левый потомок
* p; // родитель
public:
tree_node_stack (): stack ()
{p = l = r = 0;}
tree_node_stack (const tree_node_stack & rhs): stack (rhs)
{p = l = r = 0;}
~tree_node_stack ()
{p = l = r = 0;}

tree_node_stack & operator = (const tree_node_stack & rhs)
{*((stack *) this) = rhs; p = l = r = 0; return * this;}

tree_node_stack * get_right () const {return r;}
tree_node_stack * get_left () const {return l;}
tree_node_stack * get_parent () const {return p;}
void set_right (tree_node_stack * rs) {r = rs;}
void set_left (tree_node_stack * ls) {l = ls;}
void set_parent (tree_node_stack * ps){p = ps;}


};












// Стек студентов.срр


# define MAX_STACK_PRINT 9

stack :: stack () { top = curr = 0;}
stack :: ~stack () { clean (); top = curr = 0;}

void stack :: clean () {for (; top;) del ();}

void stack :: add (stack_node_student * t)
{ t->set_next (top); top = t; if (! curr) curr = t; }

void stack :: del ()
{
stack_node_student * t;
if (curr == top) { delete top; top = curr = 0; }
else { t = top->get_next (); delete top; top = t; }
}

void stack :: print (FILE * fp, int max) const
{
stack_node_student * t;
int i;
t = top;
for (i = 0;
(i < MAX_STACK_PRINT) && t && (i < max);
i++, t = t->get_next ())
{t->print (fp); printf ("\n");}
}

void stack :: print_top (FILE * fp) const
{ if (top) top->print (fp); }

int stack :: load (int n, FILE * fp)
{
int i, b;
stack_node_student * t;
/*
первая итерация добавления студентов
*/
t = new stack_node_student ();
if (! t) { clean (); top = curr = 0; }
b = t->read (fp);
if (b < 0) { delete t; clean (); top = curr = 0; return -4; }
top = curr = t;
/*
последующие итерации повторения студентов
*/
for (i = 1; i < n; i++)
{
t = new stack_node_student ();
if (! t) { clean (); top = curr = 0; return -1;}
b = t->read(fp);
if (b < 0) { delete t; clean (); top = curr = 0; return -2; }
add (t);
}
return 0;
}

int stack :: empty () { if (! top) return 1; return 0;}

void stack :: menu ()
{
int wish;
printf ("\nYOU'RE IN STACK\n");
printf ("0 - student menu\n");
printf ("1 - back to tree menu\n");
printf ("2 - add student to stack\n");
printf ("3 - delete student from stack\n");
printf ("4 - print students in stack\n");
printf ("5 - print top\n");
printf ("-1 - print command list\n");
printf ("?: ");

for (;;)
{
if (fscanf (stdin, "%d", & wish) != 1)
{ printf ("read error!\n"); break; }
switch (wish)
{
case 0: {if (top) top->menu (); printf("\nYou're int\n"); break;}
case 1: {return;}
case 2: {
stack_node_student * t;
t = new stack_node_student;
if (! t) {printf ("not enought memory!\n"); break;}
add (t);
break; }
case 3: {if (top) del (); break; }
case 4: {print (stdout, MAX_STACK_PRINT); break; }
case 5: {print_top (stdout); break; }
case -1: {
printf ("0 - student menu\n");
printf ("1 - back to tree menu\n");
printf ("2 - add student to stack\n");
printf ("3 - delete student from stack\n");
printf ("4 - print students in stack\n");
printf ("5 - print top\n");
printf ("-1 - print command list\n");
break; }
default: printf ("unknown command!\n");
}
printf ("?: ");
}
};








/* Дерево стеков студентов */


# ifndef _T_H_
# define _T_H_

class tree
{
private:
tree_node_stack * root;
tree_node_stack * curr;

public:
tree (); ~tree ();

void add_left (tree_node_stack *); void del_left ();
void add_right (tree_node_stack *); void del_right ();
void add_first (tree_node_stack *);

void go_left (); void go_right (); void go_root ();

void print (FILE * fp) const;
void print_tree (FILE *, tree_node_stack *, int &) const;
void print_elem (FILE *) const;
void print_root (FILE *fp) { if (root) root -> print(fp, 1);}

int load (int, int, FILE *);
void ins (tree_node_stack *, tree_node_stack *);

void clean (tree_node_stack *);
//удаление поддерева, начиная с указателя как с вершины, включая поддерево

int empty ();
void menu ();
};





/* заготовка

дерева стеков студентов
под список дерева стеков студентов

к каждому дереву стеков студентов присоединяется указатели на
левый и правый элемент */

class list_node_tree : public tree
{
private:
list_node_tree * next, *prev;

public:
list_node_tree (): tree () {next = prev = 0;}
~list_node_tree () {next = prev = 0;}

list_node_tree * get_next () const {return (this->next);}
list_node_tree * get_prev () const {return (this->prev);}
void set_next (list_node_tree * n_) {this->next = n_;}
void set_prev (list_node_tree * p_) {this->prev = p_;}
list_node_tree & operator = (const list_node_tree & rhs)
{*((tree *) this) = rhs; prev = next = 0; return * this;}

};

# endif

/* Дерево стеков студентов */


# define MAX_PRINTING_TREE 6
# include

tree :: tree () {root = curr = 0;}
tree :: ~tree (){if (root) clean (root); root = curr = 0;}

// удаление поддерева, начиная с текущего указателя, вместе с указателем
void tree :: clean (tree_node_stack * r)
{ if (r->get_left ()) {clean (r->get_left ());}
if (r->get_right ()) {clean (r->get_right ());}
delete r;}


void tree :: add_left (tree_node_stack * s_)
{ if (curr->get_left ())
{ (curr->get_left ())->set_parent (s_); s_->set_left (curr->get_left ());}
curr->set_left (s_); s_->set_parent (curr);}
void tree :: add_right (tree_node_stack * s_)
{ if (curr->get_right ())
{ (curr->get_right ())->set_parent (s_); s_->set_right (curr->get_right ());}
curr->set_right (s_); s_->set_parent (curr);}


void tree :: del_left () {clean (curr->get_left ()); curr->set_left (0); }
void tree :: del_right (){clean (curr->get_right ()); curr->set_right (0);}

void tree :: add_first (tree_node_stack * s_)
{ s_->set_left (root);
if (root) root->set_parent (s_);
root = s_;
if (! curr) curr = s_;}

void tree :: go_left () { curr = curr->get_left ();}
void tree :: go_right (){ curr = curr->get_right ();}
void tree :: go_root () { curr = root;}

void tree :: print (FILE * fp) const
{ int level = 0;
if (root) print_tree (fp, root, level); else printf("Tree to print is empty\n");}

void tree :: print_tree (FILE * fp, tree_node_stack * r, int & level) const
{
const char *temp;
if (level > MAX_PRINTING_TREE) return;
if (r)
{ int i;
for (i = 0; i < level * 2; i++) fprintf (fp, " ");
r -> print(fp, 1);
}
if (r->get_left ())
{this -> print_tree (fp, r->get_left (), ++level);
level--;}
if (r->get_right ())
{this -> print_tree (fp, r->get_right (), ++level);
level--;}
}

void tree :: print_elem (FILE * fp) const
{ curr->print (fp, MAX_STACK_PRINT);}

int tree :: load (int n, int k, FILE * fp)
{
int i, b;
tree_node_stack * t;

/* Чтение первого дерева*/
t = new tree_node_stack ();
if (! t) { curr = root = 0; }
b = t -> load (k, fp);
if (b < 0) { delete t; curr = root = 0; return -12; }
curr = root = t;
/*Последующие чтения дерева*/
for (i = 1; i < n; i++)
{ t = new tree_node_stack ();
if (! t) { curr = root = 0; return -311; }
b = t -> load (k, fp);
if (b < 0) {delete t; curr = root = 0; return -245; }
ins (root, t);
}
return 0;

}

void tree :: ins (tree_node_stack * r, tree_node_stack * next)
{
if ( (r -> get_c() ) < (next -> get_c()) )
{
if (r->get_right ()) ins (r->get_right (), next);
else {curr = r; add_right (next);}
}
else
{
if (r->get_left ()) ins (r->get_left (), next);
else {curr = r; add_left (next);}
}
}

int tree :: empty () {if (root) return 0; return 1;}

void tree :: menu ()
{
int wish;
printf ("WELCOME TO THE TREE EDITING\n");
printf ("0 - current stack menu\n");
printf ("1 - return to list menu\n");
printf ("2 - add stack to the left subtree\n");
printf ("3 - add stack to the right subtree\n");
printf ("4 - add first stack\n");
printf ("5 - delete left subtree\n");
printf ("6 - delete right subtree\n");
printf ("7 - move curr to the left\n");
printf ("8 - move curr to the right\n");
printf ("9 - move current pointer to the root\n");
printf ("10 - print tree\n");
printf ("11 - print current stack\n");
printf ("-1 - print wishlist\n");
printf ("?: ");

for (;;)
{
if (scanf ("%d", & wish) != 1) { printf ("read error!\n"); break;}
switch (wish)
{
case 0: {if (curr) curr->menu ();
printf("You're in TREE EDITING MENU AGAIN\n"); break; }
case 1: {return;}
case 2: {tree_node_stack * s_;
s_ = new tree_node_stack ();
if (! s_) {printf ("memory's not enough\n"); break;}
if (empty ()) add_first (s_); else add_left (s_);
break; }
case 3: {tree_node_stack * s_;
s_ = new tree_node_stack ();
if (! s_) {printf ("memory's not enough\n");break;}
if (empty ()) add_first (s_); else add_right (s_);
break; }
case 4: {tree_node_stack * s_;
s_ = new tree_node_stack ();
if (! s_) {printf ("not enought memory!\n");break;}
add_first (s_); break;}
case 5: { if (curr && curr->get_left ()) del_left (); break;}
case 6: { if (curr && curr->get_right ())del_right ();break;}
case 7: { if (curr) go_left ();
if (! curr) go_root (); break; }
case 8: { if (curr)go_right ();
if (! curr) go_root (); break; }
case 9: { go_root (); break; }
case 10: { print (stdout); break; }
case 11: { if (curr) print_elem (stdout); break; }
case -1: {
printf ("0 - current stack menu\n");
printf ("1 - return to list menu\n");
printf ("2 - add stack to the left subtree\n");
printf ("3 - add stack to the right subtree\n");
printf ("4 - add first stack\n");
printf ("5 - delete left subtree\n");
printf ("6 - delete right subtree\n");
printf ("7 - move curr to the left\n");
printf ("8 - move curr to the right\n");
printf ("9 - move current pointer to the root\n");
printf ("10 - print tree\n");
printf ("11 - print current stack\n");
printf ("-1 - print wishlist\n");
printf ("?: "); break; }
default:
printf ("unknown wish!\n");
}
printf ("?: ");
}
};






/* Двунаправленный список
деревьев
стеков
студентов */







class list {
private:
list_node_tree *before, *after;
list_node_tree base;
public:
list ();
~list();
void InsBefore (list_node_tree *);
void InsAfter (list_node_tree *);
void DelBefore ();
void DelAfter ();
void GetBefore (list_node_tree *);
int GetAfter (list_node_tree *);

void forward(); void backward();

void print_before (FILE *fp) { if ( before != &base) before -> print_root (fp); else fprintf(fp, "none\n"); }
void print_after (FILE *fp) { if ( after != &base ) after -> print_root (fp); else fprintf(fp, "none\n"); }

void go_beg();
int load (int, int, int, FILE*);
void print (FILE*);
void menu();
};


list :: list ()
{
before = after = &base; base.set_next(&base); base.set_prev(&base);
}

void list :: InsBefore (list_node_tree* n_)
{
/*Ксюшенька, любимая моя, напишешь ты эту прогу --- не расстраивайся!
Все будет хорошо, моя расчетверяющаяся личность.....*/
n_ -> set_prev( before);
after -> set_prev (n_);
before -> set_next (n_);
before = n_;
before -> set_next(after);
printf("After = base, %d\n", after == &base);
}


void list :: InsAfter (list_node_tree* n_)
{
n_ -> set_next (after);
before -> set_next(n_);
after -> set_prev (n_);
after = n_;
after -> set_prev(before);
}

list::~list() { for(;;)
{ DelBefore();
if ((before == &base) && (after == &base)) break; } }



void list :: DelBefore ()
{
list_node_tree *pos;
if (before == &base || (before -> get_prev()) == NULL) return;
pos = before;
before = pos -> get_prev();
delete pos;
before -> set_next (after);
after -> set_prev (before);
}

void list :: DelAfter ()
{
list_node_tree *pos;
if (after == &base || (after -> get_next() == NULL) ) return;
pos = after;
after = pos -> get_next ();
delete after;
after -> set_prev (before);
before -> set_next (after);
}



void list :: go_beg ()
{
before = &base;
after = (base.get_next());
}

void list :: forward ()
{
if (after -> get_next() == &base) return;
before = after; after = after -> get_next();
}
void list :: backward()
{
if (before -> get_prev() == &base) return;
after = before; before = before -> get_prev();
}



void list :: print(FILE *fp)
{
list_node_tree * curr;
//go_beg();
for(curr = base.get_next();;)
{
//printf("i try to print smth!!!");
if ((curr == & base) || (!curr)) break;
curr -> print_root(fp);
curr = curr -> get_next();
}
}

int list :: load (int n, int m, int k, FILE * fp)
{
int i, b;
list_node_tree * t;
t = new list_node_tree ();
b = t->load (m, k, fp);
if (b < 0) { delete t;return -3; }
InsBefore(t);


for (i = 1; i < n; i++)
{
t = new list_node_tree (); if (! t) return -1;
b = t->load (m, k, fp);
if (b < 0)
{ delete t; return -1; }
InsBefore (t);
printf("d");
}
return 0;
}





void list :: menu ()
{
int wish;
printf ("\n");
printf ("LIST. YOU'RE EDITING LIST\n");

printf ("0 - go to the tree menu for left\n");
printf ("13 - go to the tree menu for right\n");

printf ("1 - print_left\n");
printf ("2 - print_right\n");
printf ("3 - add to right\n");
printf ("4 - add to left\n");
printf ("5 - print curr\n");
printf ("6 - forward\n");
printf ("7 - backward\n");
printf ("8 - del from left\n");
printf ("9 - del from right\n");
printf ("6 - \n");
printf ("-1 - print wish list\n");
printf ("?: ");

for (;;)
{
if (fscanf (stdin, "%d", & wish) != 1) {printf ("read error!\n"); break; }
switch (wish)
{
case 0: {if (before != & base) before -> menu(); break;}
case 13: {if (after != & base) after -> menu(); break;}
case 1: {if (before != & base) before -> print_root(stdout); break;}
case 2: {if (after != & base) after -> print_root(stdout); break;}
case 4: {list_node_tree * t;
t = new list_node_tree;
if (! t) {printf (" not enought memory!\n"); break;}
InsBefore(t); break;}
case 3: {list_node_tree * t;
t = new list_node_tree;
if (! t) {printf (" not enought memory!\n"); break;}
InsAfter(t); break;}

case 6: {forward(); break;}
case 7: {backward(); break;}
case 8: {DelBefore(); break;}
case 9: {DelAfter(); break;}

case 5: print(stdout); break;
case -1:
printf ("0 - go to the tree menu for left\n");
printf ("13 - go to the tree menu for right\n");
printf ("1 - print_left\n");
printf ("2 - print_right\n");
printf ("3 - add to right\n");
printf ("4 - add to left\n");
printf ("5 - print curr\n");
printf ("6 - forward\n");
printf ("7 - backward\n");
printf ("8 - del from left\n");
printf ("9 - del from right\n");
printf ("6 - \n");
printf ("-1 - print wish list\n");
printf ("?: ");


}
printf("?: ");
}
}









int main (void)
{
list SAMPLE;

FILE * fp;
fp = fopen ("a.txt", "r"); if (! fp) {printf ("Read error!\n"); return -1;}

SAMPLE.load (5, 3, 5, fp);
SAMPLE.menu ();

scanf("%d", &k);
return 0;
}