C++ create_tree函数代码示例

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();
}