Архив3 / kursach(7) / курсач / tree

#include <cstdio>
#include <cstdlib>
#include <stack>
#include <iostream>

using namespace std;

struct tree_node{
	
	int key;
	double value;
	
	struct tree_node *left;
	struct tree_node *right;
};

struct sctree{
		
	int size;
	int max_size;
	
	struct tree_node* head;
};



/*void avltree_free(struct avltree *tree)
{
	if (tree == NULL)
		return;
	avltree_free(tree->left);
	avltree_free(tree->right);
	free(tree);
}*/

/*struct sctree *sctree_lookup(struct sctree *tree, int key)
{
	while (tree != NULL) {
		if (key == tree->key) {
			return tree;
		} else if (key < tree->key) {
			tree = tree->left;
		} else {
			tree = tree->right;
		}
	}
return tree;
}*/


struct sctree *sctree_create()
{
	struct sctree *node;
	node = new sctree;
	if (node != NULL) {
		
		node->size=0;
		node->max_size=0;
		node->head=NULL;
	}
return node;
}

struct tree_node* insert(struct tree_node *node, int key, double value,stack<tree_node*> &st){
	
	st.push(node);
	if (node == NULL)
	{
	   node = new tree_node;
	   node->left=NULL;
	   node->right=NULL;
	   node->key=key;
	   node->value=value;
	}
	
	if (key < node->key) 
	{
	    insert(node->left,key, value,st);
	}
	
	else if (key > node->key) 
	{
	    /* Insert into right subtree */
	   insert(node->right,key, value,st);
	}
	return node;
}



int size(struct tree_node* node){
	if(node == NULL){
		return 0;
	}
	else
		return size(node->left) + size(node->right) + 1;
}


bool kozlovost(struct tree_node* node){
	int hl=0,hr=0;
	//if(node->left!=NULL){
		hl=size(node->left);
	//}
	cout<<hl;
		return 1;
	}

struct tree_node* speagot_search(stack<tree_node*> &st){
	struct tree_node* node;
	bool kozel;
	while(!st.empty()){
		node=st.top();
		st.pop();
		kozel=kozlovost(node);
		if(kozel!=0)return node;
	}
	return NULL;
}
struct sctree *cstree_add(struct sctree *tree, int key, double value)
{
	
	struct tree_node *node;
	node=tree->head;
	stack<tree_node*> st;
	if (tree == NULL)
	{
	   tree=sctree_create();
	}
	/*if(tree->head==NULL){
		tree->head->key=key;
		tree->head->value=value;
	}*/
	tree->head=insert(node,key,value,st);
	struct tree_node *t;
	t=speagot_search(st);
	tree->size++;
	if(tree->size>tree->max_size)tree->max_size=tree->size;
	return tree;
}


/*struct avltree *avltree_right_rotate(struct avltree *tree)
{
	struct avltree *left;
	left = tree->left;
	tree->left = left->right;
	left->right = tree;
	tree->height = imax2(
	avltree_height(tree->left),
	avltree_height(tree->right)) + 1;
	left->height = imax2(
	avltree_height(left->left),
	tree->height) + 1;
	return left;
}

struct avltree *avltree_left_rotate(struct avltree *tree)
{
	struct avltree *right;
	right = tree->right;
	tree->right = right->left;
	right->left = tree;
	tree->height = imax2(
	avltree_height(tree->left),
	avltree_height(tree->right)) + 1;
	right->height = imax2(
	avltree_height(right->right),
	tree->height) + 1;
	return right;
}

struct avltree *avltree_leftright_rotate(struct avltree *tree)
{
	tree->left = avltree_left_rotate(tree->left);
	return avltree_right_rotate(tree);
}

struct avltree *avltree_rightleft_rotate(struct avltree *tree)
{
	tree->right = avltree_right_rotate(tree->right);
	return avltree_left_rotate(tree);
}
*/
/*
void sctree_print(struct sctree *tree, int level)
{
	int i;
	if (tree == NULL)
		return;
	for (i = 0; i < level; i++)
		printf("\t");
	printf("%d %d\n", tree->key,tree->del);
	avltree_print_dfs(tree->left, level + 1);
	avltree_print_dfs(tree->right, level + 1);
}
*/

/*struct avltree *  avltree_traverse(struct avltree *tree,struct avltree *new)
{	
	
	if(tree == NULL) return new;
	
	new=avltree_traverse(tree->left,new);
	if(tree->value&&tree->del==0) {printf("key= %d\n", tree->key);new = avltree_add(new, tree->key, tree->value);}
	new=avltree_traverse(tree->right,new);
	
	return new;
}*/
/*
struct avltree * avltree_delete(struct avltree *tree, int x)
{	
	struct avltree *t=tree;
	struct avltree *new=NULL;
	tree=avltree_lookup(tree, x);
	tree->del=1;
	d_vert++;
	if(d_vert*2>a_vert){
		d_vert=0;
		a_vert=0;
		tree=t;
		new=avltree_traverse(tree,new);
		return new;
	}
	return t;
}*/

int main()
{
	struct sctree *a=NULL;
	a=sctree_create();
	a=cstree_add(a,1,5);
	a=cstree_add(a,2,5);
	a=cstree_add(a,3,5);a=cstree_add(a,4,5);
	//printf("%d",a->head->key);
	return 0;
}