tree_node *create_tree(order_node *in,order_node *pre,int num)
{
    tree_node *temp;
    order_node *q;
    int i,j;
    if(num==0)
        return NULL;
    temp=(tree_node*)malloc(sizeof(tree_node));
    temp->num=pre->num;
    temp->lchild=NULL;
    temp->rchild=NULL;
    if(num==1)
        return temp;
    q=in;
    for(i=0;q->num!=pre->num;++i)
    {
        q=q->next;
    }
    temp->lchild=create_tree(in,pre->next,i);
    for(j=1;j<=i+1;++j)
    {
        pre=pre->next;
    }
    temp->rchild=create_tree(q->next,pre,num-i-1);
    return temp;
}

void create_tree(node *root)
{
     char c;
    // if(root==NULL)
     {
     
     root->left=NULL;
     root->right=NULL;
     }
     printf("Enter the node \n");
     scanf("%d",&(root->data));
  
            printf("Does %d have a left node ??",root->data);
            fflush(stdin);
            scanf("%c",&c);
            if(c=='y')
            {
            	root->left= (node*)malloc(sizeof(node));
 		       create_tree(root->left);
            }
           
            fflush(stdin);
             printf("Does %d have a right node ??",root->data);
            scanf("%c",&c);
            if(c=='y')
            {
               root->right= (node*)malloc(sizeof(node));
 		       create_tree(root->right);
            }
            
}

pnode_t create_tree(char * str, int len)
{
        pnode_t p = NULL;
	char *strl, *strr;
	int numl, numr, i;
        int item = 0;
	if(len <= 2)
		return NULL;
	for (i = 0; i < len; i++) 
	{
	        printf("%c", str[i]);
	}
        printf("\n");
	if(str[0] == '(' && str[len - 1] == ')'){
		strl = str + 1;
		while(*strl != '('){
                        item = item*10 + (*strl - '0');
                        strl++;
                }
                printf("item = %d\n", item);
                p = create(item);
		numl = find(strl);
		p->l = create_tree(strl, numl);
		strr = strl + numl;
		numr = find(strr);
		p->r = create_tree(strr, numr);
	}
	return p;
}

void build_tree(BiTreePtr pT){
    SqQueue *Q = create_queue_seq(NULL, sizeof(BiTreePtr));
    enqueue_seq(Q, &pT);
    
    while (!queue_seq_empty(Q)) {
        BiTreePtr T = NULL;
        dequeue_seq(Q, &T);
        
        if (!queue_seq_empty(T->pdata->unpickedQueue)) {
            BiTreePtr lchildT = create_tree(NULL);
            BiTreePtr rchildT = create_tree(NULL);
            
            char chPick;
            lchildT->pdata->unpickedQueue = copy_queue_seq(T->pdata->unpickedQueue);
            lchildT->pdata->pickedQueue = copy_queue_seq(T->pdata->pickedQueue);
            dequeue_seq(lchildT->pdata->unpickedQueue, &chPick);
            enqueue_seq(lchildT->pdata->pickedQueue, &chPick);
            
            rchildT->pdata->unpickedQueue = copy_queue_seq(lchildT->pdata->unpickedQueue);
            rchildT->pdata->pickedQueue = copy_queue_seq(T->pdata->pickedQueue);
            
            T->lchild = lchildT;
            T->rchild = rchildT;
            
            enqueue_seq(Q, &T->lchild);
            enqueue_seq(Q, &T->rchild);
            
        }
    }
    
    desotry_queue_seq(Q);
}

int create_tree(quad_tree tree[], char str[], int pos, int width, int *black_count)
{
	int new_pos;
	tree[pos].type = str[pos];
	tree[pos].width = width;
	if(str[pos] == 'p')
	{
		int bc;
		tree[pos].rt = &tree[pos+1];
		new_pos = create_tree(tree, str, pos+1, width/2, &bc);
		tree[pos].black_count = bc;
		tree[pos].lt = &tree[new_pos];
		new_pos = create_tree(tree, str, new_pos, width/2, &bc);
		tree[pos].black_count += bc;
		tree[pos].lb = &tree[new_pos];
		new_pos = create_tree(tree, str, new_pos, width/2, &bc);
		tree[pos].black_count += bc;
		tree[pos].rb = &tree[new_pos];
		new_pos = create_tree(tree, str, new_pos, width/2, &bc);
		tree[pos].black_count += bc;
		*black_count = tree[pos].black_count;
		return new_pos;
	}
	else
	{
		*black_count = tree[pos].black_count = str[pos] == 'f' ? width*width : 0;
		return pos+1;
	}
}

// assuming that values are unique
void insert(Tree *root, int val) {
	// right
	if (val > root->val) {
		// recurse
		if (root->right != NULL) {
			insert(root->right, val);
		}
		// leaf
		else {
			root->right = create_tree(val);
			root->right->parent = root;
		}
	}

	// left
	else {
		// recurse
		if (root->left != NULL) {
			insert(root->left, val);
		}
		// leaf
		else {
			root->left = create_tree(val);
			root->left->parent = root;
		}
	}
}

//Create a new btree.
BTREE create_tree(DATA a[], int i, int size)
{
	if (i >= size)
		return NULL;
	else
		return (init_node(a[i],
				create_tree(a, 2 * i + 1, size),
				create_tree(a, 2 * i + 2, size)));
}

void create_tree(ptree *root)
{
    char c = getchar();
    if (c == '#') {
        *root = NULL;
    } else {
        init_node(root, sizeof(stree));
        (*root)->data = c;
        create_tree(&(*root)->lc);
        create_tree(&(*root)->rc);
    }
}

void create_tree(struct tnode **node, char **ch)
{
    char temp = **ch;
    (*ch)++;
    if (temp == 'X')
        *node = NULL;
    else {
        *node = (struct tnode *) malloc(sizeof(struct tnode));
        (*node)->data = temp;
        create_tree(&((*node)->left), ch);
        create_tree(&((*node)->right), ch);
    }
}

/* creat a tree */
BTree * create_tree(BTree *T)
{
    int data;
    scanf("%d", &data);
    if(data == 0){
        T = NULL;
    }else{
        T = (BTree *)malloc(sizeof(struct TreeNode));
        T->data = data;
        T->left = create_tree(T->left);
        T->right = create_tree(T->right);
    }
    return T;
}

int main()
{  tree_node_t *st1, *st2;
   int success;
   long i, k; 
   int  *m;
   int o[3] = {0,2,4};
   st1 = create_tree();
   st2 = create_tree();
   printf("Made two Trees\n");
   for( i=0; i < 400000; i++)
   {  k = 3*i; 
      success = insert( st1, k, &(o[1]) ); 
      if( success != 0 )
      {  printf("  insert %d failed in st1, return value %d\n", k, success);
         exit(-1);
      }
      success = insert( st2, k, &(o[2]) ); 
      if( success != 0 )
      {  printf("  insert %d failed in st2, return value %d\n", k, success);
         exit(-1);
      }
   }
   printf("Passed 800000 inserts.\n");
   for( i=0; i< 400000; i++)
   {  if( i%2 == 0 )
      {  m = delete(st1, 3*i );
      }
      else
	{  m = delete(st2, 3*i );
      }
      if( m == NULL )
         printf(" delete failed for %d, returned NULL\n", 3*i);
      else if ( (i%2==0 && *m !=2) || (i%2==1 && *m != 4))
	 printf(" delete failed for %d, returned %d\n", 3*i, *m);
   }
   printf("Passed 400000 deletes.\n");
   for( i=0; i< 1200000; i++)
   {  m = find(st1,i);
      if( i%3 == 0 && (i/3)%2 == 1 )
      {  if (m== NULL)
	    printf(" find failed on st1 for %d, returned NULL\n", i);
         else if (*m != 2 )
            printf(" find failed on st1 for %d, returned %d instead of 2\n", i,*m );
      }
      else if (m != NULL)
            printf(" find failed on st1 for %d, returned non-NULL pointer\n", i);
   }
   printf("Passed 1200000 finds. End of test.\n");
   return(0);
}

int main()
{
	int tc, bc;
	char str1[1500], str2[1500];
	scanf("%d", &tc);
	while(tc--)
	{
		scanf("%s%s", str1, str2);
		create_tree(tree1, str1, 0, 32, &bc);
		create_tree(tree2, str2, 0, 32, &bc);
		printf("There are %d black pixels.\n", count_black(tree1, tree2));
	}
	return 0;
}

TreeNode* create_tree()
{
	int iTemp;
	TreeNode *pRoot = NULL;
	scanf("%d",&iTemp);
	if(iTemp == -1)
	{
		return NULL;
	}
	pRoot = (TreeNode*)malloc(sizeof(TreeNode));
	pRoot->iVal = iTemp;
	pRoot->pLeft = create_tree();
	pRoot->pRight = create_tree();
	return pRoot;
}

int main()
{
    std::vector<int> arr = {10, 5, 16, 12, 20};
    Node *pRoot = create_tree(arr);
    std::copy(arr.begin(), arr.end(), std::ostream_iterator<int>(std::cout, " "));
    return 1;
}

void main()
{
  TREE *tree=create_tree();
  start_gem();
  parse(tree);
  stop_gem();
}

int main ()
{
	short flag = 11;							/// flag for menu
	leaf *root;									/// root of tree

	root = new leaf;
	root->parent = NULL;						/// totaly null root of tree
	root->son_l = NULL;							
	root->son_r = NULL;							
	root->val = NULL;							

	while(1)
	{
		switch (give_mFlag())					/// give flag
		{
		case 1: 
			create_tree(root);					/// create tree
			printf("\n....tree was created");
			break;
		case 2:
			print_tree(root);					/// print tree
			break;
		case 0:
			delete_tree(root);					/// destroy tree 
			printf("\n....tree was destroied"); 
			flag = EXIT_WHILE;					/// and exit from programm
			break;
		}
		if (flag == EXIT_WHILE) break;
	}

	getchar();
	getchar();
}

void test_avl_tree_lookup(void)
{
	AVLTree *tree;
	int i;
	int *value;

	/* Create a tree and look up all values */

	tree = create_tree();

	for (i=0; i<NUM_TEST_VALUES; ++i) {
		value = avl_tree_lookup(tree, &i);

		assert(value != NULL);
		assert(*value == i);
	}

	/* Test invalid values */

	i = -1;
	assert(avl_tree_lookup(tree, &i) == NULL);
	i = NUM_TEST_VALUES + 1;
	assert(avl_tree_lookup(tree, &i) == NULL);
	i = 8724897;
	assert(avl_tree_lookup(tree, &i) == NULL);

	avl_tree_free(tree);
}

text_t *create_text()
{
	text_t *text;
	text = (text_t *) malloc(sizeof(text_t));
	text->searchtree = create_tree();
	return text;
}

int main() {
	int retval;
	test_batch_runner *runner = test_batch_runner_new();

	version(runner);
	constructor(runner);
	accessors(runner);
	node_check(runner);
	iterator(runner);
	iterator_delete(runner);
	create_tree(runner);
	hierarchy(runner);
	parser(runner);
	render_html(runner);
	utf8(runner);
	line_endings(runner);
	numeric_entities(runner);
	test_cplusplus(runner);

	test_print_summary(runner);
	retval =  test_ok(runner) ? 0 : 1;
	free(runner);

	return retval;
}

void main()
{
    int size=0;
    order_node *pre,*in;
    pre=(order_node*)malloc(sizeof(order_node));
    in=(order_node*)malloc(sizeof(order_node));
    tree_node *root;
    printf("Enter data in pre order(-999 to end)\n");
    create_order(pre);
    printf("Enter data in in-order(-999 to end)\n");
    create_order(in);
    size = get_size(in);
    root=create_tree(in,pre,size);
    printf("\nData in tree in preorder rec\n");
    rec_pre(root);
    printf("\nData in tree in inorder rec\n");
    rec_in(root);
    printf("\nData in tree in posorder rec\n");
    rec_pos(root);
    printf("\nData in tree in preorder nrec\n");
    nrec_pre(root);
    printf("\nData in tree in inorder nrec\n");
    nrec_in(root);
    printf("\nData in tree in posorder nrec\n");
    nrec_pos(root);
    printf("\n\nPress Enter to exit...");
    getch();
}