コード例 #1
0
int construct_tree(NODE* root, char *input_string, int index)
{
	if(input_string == NULL)
	{
		return NULL;
	}
	if(input_string[index-1]=='\0' || input_string[index-1]=='$')
	{
		root->left_child = NULL;
		root->right_child = NULL;
		return index;
	}
	int result;
	result = create_number(input_string,index);
	if(result!=NULL)
	{
		NODE *temp = (NODE*)malloc(sizeof(NODE));
		temp->data = result;
		root->left_child = temp;
	}
	else if(result==NULL)
	{
		root->left_child = NULL;
	}
	if(root->left_child!=NULL)
	{
		index = next_element_in_string(input_string,index);
		index = construct_tree(root->left_child,input_string,index);
	}
	index = next_element_in_string(input_string,index);
	result = create_number(input_string,index);
	if(result!=NULL)
	{
		NODE *temp = (NODE*)malloc(sizeof(NODE));
		temp->data = result;
		root->right_child = temp;
	}
	else if(result==NULL)
	{
		root->right_child = NULL;
	}
	if(root->right_child!=NULL)
	{
		index = next_element_in_string(input_string,index);
		index = construct_tree(root->right_child,input_string,index);
		return index;
	}
	else if(root->right_child==NULL)
	{
		return index;
	}
}
コード例 #2
0
void test_array_to_tree_convertor()
{
	char input[4][36] = {"1,2,3,4","1,2","1,2,3","1,2,3,4,5,6,7,8,9,10,11,12,13,14,15"};
	char output[4][52] = {
					  "3,2,1,$,-,4,$",
					  "2,1,$",
					  "2,1,$,3,$",
					  "8,4,2,1,$,3,$,6,5,$,7,$,12,10,9,$,11,$,14,13,$,15,$"
					 };
	int iter_loop, index;
	for(iter_loop=0;iter_loop<4;iter_loop++)
	{
		printf("%d-->",iter_loop+1);
		NODE *root1 = string_to_tree_converter(input[iter_loop]);
		NODE *root2 = (NODE*)malloc(sizeof(NODE));

		index = next_element_in_string(output[iter_loop],0);
		root2->data = create_number(output[iter_loop],index);
		index = next_element_in_string(output[iter_loop],index);
		construct_tree(root2,output[iter_loop],index);

		(tree_comparator(root1,root2) == 1)?(printf("ACCEPTED\n")):(printf("REJECTED\n"));
		delete_tree(root1);
		delete_tree(root2);
	}
}
コード例 #3
0
ファイル: main.c プロジェクト: AgamAgarwal/minix
/*===========================================================================*
 *				construct_tree				     *
 *===========================================================================*/
static void construct_tree(struct inode *dir, struct file *files)
{
	/* Construct a tree of static files from a null-terminated array of
	 * file structures, recursively creating directories which have their
	 * associated data point to child file structures.
	 */
	struct file *file;
	struct inode *node;
	struct inode_stat stat;

	stat.uid = SUPER_USER;
	stat.gid = SUPER_USER;
	stat.size = 0;
	stat.dev = NO_DEV;

	for (file = files; file->name != NULL; file++) {
		stat.mode = file->mode;

		node = add_inode(dir, file->name, NO_INDEX, &stat, (index_t) 0,
			(cbdata_t) file->data);

		assert(node != NULL);

		if (S_ISDIR(file->mode))
			construct_tree(node, (struct file *) file->data);
	}
}
コード例 #4
0
void MAXIMUM_NODE_IN_TREE()
{
	char input[5][52] = {   
					  "1,$",
					  "2,4,1,$,-,3,$",
					  "1,2,$,-",
					  "1,3,$,2,$",
					  "14,1,4,2,$,6,$,10,8,$,12,$,13,3,15,$,5,$,9,7,$,11,$"
					 };
	int expected_output[6] = {1,4,2,3,15};
	int iter_loop, index;
	for(iter_loop=0;iter_loop<5;iter_loop++)
	{
		NODE *root = (NODE*)malloc(sizeof(NODE));
		index = next_element_in_string(input[iter_loop],0);
		root->data = create_number(input[iter_loop],index);
		index = next_element_in_string(input[iter_loop],index);
		construct_tree(root,input[iter_loop],index);
		
		int previous_value = root->data;
		Inorder(root,&previous_value);
		(expected_output[iter_loop]==previous_value)?printf("ACCEPTED\n"):printf("REJECTED\n");
		delete_tree(root);
	}
}
コード例 #5
0
ファイル: main.c プロジェクト: AgamAgarwal/minix
/*===========================================================================*
 *				init_hook				     *
 *===========================================================================*/
static void init_hook(void)
{
	/* Initialization hook. Generate the static part of the tree.
	 */
	static int first_time = 1;
	struct inode *root;

	if (first_time) {
		root = get_root_inode();

		construct_tree(root, root_files);

		first_time = 0;
	}
}
コード例 #6
0
ファイル: dfs.c プロジェクト: BreezeZhang/datastruct
void construct_tree(struct st_tree *st)
{
	char check = 0;
	st->lchild = st->rchild = NULL;
	printf("\nplease scanf data: ");
	scanf("%c", &st->data);
	fflush(stdin);
	printf("\ndo it construct left child: ");
	scanf("%c", &check);
	fflush(stdin);
	if(check == 'y')
	{
		st->lchild = (struct st_tree*)malloc(sizeof(struct st_tree));
		construct_tree(st->lchild);
	}
	printf("\ndo it construct right child: ");
	scanf("%c", &check);
	fflush(stdin);
	if(check == 'y')
	{
		st->rchild = (struct st_tree*)malloc(sizeof(struct st_tree));
		construct_tree(st->rchild);
	}
}
コード例 #7
0
ファイル: threaded.c プロジェクト: sjlee2016/datastructure
int main()
{
	/* initialize a head node */
	// 직접작성
	threadedPointer head = (threadedPointer)malloc(sizeof(threadedTree));
	head->rightChild = head;
	head->rightThread = FALSE;
	head->leftThread = FALSE;
	construct_tree(head);   // 다음 페이지 참고
	insert(head->leftChild->rightChild, 'E');
	insert(head->leftChild->leftChild->rightChild, 'F');
	insert(head->leftChild->leftChild, 'G');
	tinorder(head);

	return 0;
}
コード例 #8
0
void test_convert_string_to_tree()
{
	char input[9][104] = {"([8,8],[4,8],[2,4],[1,2],[3,2],[6,4],[5,6],[7,6],[12,8],[10,12],[9,10],[11,10],[14,12],[13,14],[15,14])",
					     "([8,8],[4,8],[2,4],[6,4],[5,6],[7,6],[12,8],[10,12],[9,10],[11,10],[14,12],[13,14],[15,14])",
					     "([8,8],[4,8],[2,4],[1,2],[3,2],[6,4],[5,6],[7,6],[12,8],[10,12],[9,10],[11,10])",
					     "([5,5],[4,5],[2,4],[1,4],[3,5],[6,3],[7,3])",
					     "([5,5],[4,5],[3,5],[6,3],[7,3])",
					     "([5,5],[4,5],[2,4],[1,4],[3,5])",
					     "([1,1],[2,1],[3,1])",
					     "([5,5])",
					     "([1,1],[2,1])"
					    };
	char output[9][86] = {"8,4,2,1,$,3,$,6,5,$,7,$,12,10,9,$,11,$,14,13,$,15,$",
								  "8,4,2,$,6,5,$,7,$,12,10,9,$,11,$,14,13,$,15,$",
								  "8,4,2,1,$,3,$,6,5,$,7,$,12,10,9,$,11,$,-",
								  "5,4,2,$,1,$,3,6,$,7,$",
								  "5,4,$,3,6,$,7,$",
								  "5,4,2,$,1,$,3,$",
								  "1,2,$,3,$",
								  "5,$",
								  "1,2,$,-"
								};
	int iter_loop,index;
	for(iter_loop=0;iter_loop<9;iter_loop++)
	{
		printf("%d-->",iter_loop+1);
		if(input[iter_loop]==NULL || output[iter_loop]==NULL)
		{
			printf("INVALID INPUT");
			continue;
		}

		NODE *root1;
		root1 = driver_for_convert_string_to_tree(input[iter_loop]);
		NODE *root2 = (NODE*)malloc(sizeof(NODE));

		index = next_element_in_string(output[iter_loop],0);
		root2->data = create_number(output[iter_loop],index);
		index = next_element_in_string(output[iter_loop],index);
		construct_tree(root2,output[iter_loop],index);
		(tree_comparator(root1,root2)==1)?printf("ACCEPTED\n"):printf("REJECTED\n");
		delete_tree(root1);
		delete_tree(root2);
	}

}
コード例 #9
0
ファイル: dfs.c プロジェクト: BreezeZhang/datastruct
int main()
{
	struct st_tree root;
	struct st_tree *result1, *result2;
	construct_tree(&root);
	vist_tree(&root);
	result1 = dfs_recursion(&root, cmp, 'y');
	if(result1 == NULL)
		printf("dfs_recursion result is: NULL\n");
	printf("\n dfs_recursion result: %c\n",result1->data);
	result2 = dfs_stack(&root, cmp, 'y');
	if(result2 == NULL)
		printf("dfs_stack result is: NULL\n");
	printf("\n dfs_stack result: %c\n",result2->data);

	return 0;
}
コード例 #10
0
void test_traversal()
{
	char input[10][53] = {"8,-4,2,1,$,3,$,6,5,$,7,$,12,10,9,$,11,$,14,13,$,15,$",
								  "8,4,2,$,6,5,$,7,$,12,10,9,$,11,$,14,13,$,15,$",
								  "8,4,2,1,$,3,$,6,5,$,7,$,12,10,9,$,11,$,-",
								  "5,4,2,$,1,$,3,6,$,7,$",
								  "5,4,$,3,6,$,7,$",
								  "5,4,2,$,1,$,3,$",
								  "1,2,$,3,$",
								  "5,$",
								  "1,2,$,-",
								  '\0'
								};

	int output[10][16] ={
						{8,-4,2,1,3,6,5,7,12,10,9,11,14,13,15},
						{8,4,2,6,5,7,12,10,9,11,14,13,15},
						{8,4,2,1,3,6,5,7,12,10,9,11},
						{5,4,2,1,3,6,7},
						{5,4,3,6,7},
						{5,4,2,1,3},
						{1,2,3},
						{5},
						{1,2},
						NULL
						}; 
	int iter_loop;
	for(iter_loop=0;iter_loop<10;iter_loop++)
	{
		int index;
		NODE *root = (NODE*)malloc(sizeof(NODE));

		index = next_element_in_string(input[iter_loop],0);
		root->data = create_number(input[iter_loop],index);
		index = next_element_in_string(input[iter_loop],index);
		construct_tree(root,input[iter_loop],index);

		int *traversal_array;
		traversal_array = driver_of_traverse_arrays(root);
		(compare_arrays(traversal_array,output[iter_loop]) == 1)?printf("ACCEPTED\n"):printf("REJECTED\n");
		free(traversal_array);
		delete_tree(root);
	}
}
コード例 #11
0
void test_tree_construction()
{
	char inorder[5][36] = { "8,4,9,2,10,5,11,1,12,6,13,3,14,7,15",
							"1,2,3,4",
							"1,2,3",
							"1,2,3,4,5,6,7,8,9,10,11,12,13,14,15",
							"1,2"
							};

	char preorder[5][36] = { "1,2,4,8,9,5,10,11,3,6,12,13,7,14,15",
							 "2,1,3,4",
							 "2,1,3",
							 "8,4,2,1,3,6,5,7,12,10,9,11,14,13,15",
							 "1,2"
						   };

	char expected_tree[5][52] = {"1,2,4,8,$,9,$,5,10,$,11,$,3,6,12,$,13,$,7,14,$,15,$",
		   						 "2,1,$,3,-,4,$",
								 "2,1,$,3,$",
								 "8,4,2,1,$,3,$,6,5,$,7,$,12,10,9,$,11,$,14,13,$,15,$",
								 "1,-,2,$"
								};
	int iter_loop;
	for(iter_loop=0;iter_loop<5;iter_loop++)
	{
		printf("%d-->",iter_loop+1);
		int preorder_index = 0;
		int *inorder_array = string_to_array(inorder[iter_loop]);
		int *preorder_array = string_to_array(preorder[iter_loop]);
		NODE *head  = construct_tree_from_inorder_preorder(inorder_array,preorder_array,0,array_length(inorder_array)-1,&preorder_index);
		NODE *root = (NODE*)malloc(sizeof(NODE));
		int index;
		index = next_element_in_string(expected_tree[iter_loop],0);
		root->data = create_number(expected_tree[iter_loop],index);
		index = next_element_in_string(expected_tree[iter_loop],index);
		construct_tree(root,expected_tree[iter_loop],index);
		(1==tree_comparator(head,root))?printf("ACCEPTED\n"):printf("REJECTED\n");
		delete_tree(head);
		free(inorder_array);
		free(preorder_array);
	}
}
コード例 #12
0
ファイル: cad.c プロジェクト: caomw/ObjectInteraction
CAD* read_cad(FILE *fp, int hog_length)
{
  int i, j, k, part_num, view_num, root_index;
  CAD *cad;
  char buffer[256];

  /* allocate memory */
  cad = (CAD*)malloc(sizeof(CAD));
  if(cad == NULL)
  {
    printf("out of memory\n");
    return NULL;
  }

  /* read part number */
  fscanf(fp, "%d", &part_num);
  cad->part_num = part_num;

  /* read part names */
  cad->part_names = (char**)malloc(sizeof(char*)*part_num);
  if(cad->part_names == NULL)
  {
    printf("out of memory\n");
    return NULL;
  }
  for(i = 0; i < part_num; i++)
  {
    fscanf(fp, "%s", buffer);
    cad->part_names[i] = (char*)malloc(sizeof(char)*(strlen(buffer)+1));
    if(cad->part_names[i] == NULL)
    {
      printf("out of memory\n");
      return NULL;
    }
    strcpy(cad->part_names[i], buffer);
  }

  /* read root indexes */
  cad->roots = (int*)malloc(sizeof(int)*part_num);
  if(cad->roots == NULL)
  {
    printf("out of memory\n");
    return NULL;
  }
  for(i = 0; i < part_num; i++)
    fscanf(fp, "%d", &(cad->roots[i]));

  /* read part templates */
  cad->part_templates = (PARTTEMPLATE**)malloc(sizeof(PARTTEMPLATE*)*part_num);
  if(cad->part_templates == NULL)
  {
    printf("out of memory\n");
    return NULL;
  }
  for(i = 0; i < part_num; i++)
  {
    cad->part_templates[i] = (PARTTEMPLATE*)malloc(sizeof(PARTTEMPLATE));
    if(cad->part_templates[i] == NULL)
    {
      printf("out of memory\n");
      return NULL;
    }
    fscanf(fp, "%d", &(cad->part_templates[i]->width));
    fscanf(fp, "%d", &(cad->part_templates[i]->height));
    cad->part_templates[i]->sbin = HOGBINSIZE;
    cad->part_templates[i]->b0 = (int)round((double)(cad->part_templates[i]->height)/(double)(cad->part_templates[i]->sbin));
    cad->part_templates[i]->b1 = (int)round((double)(cad->part_templates[i]->width)/(double)(cad->part_templates[i]->sbin));
    cad->part_templates[i]->length = cad->part_templates[i]->b0 * cad->part_templates[i]->b1 * hog_length;
    cad->part_templates[i]->weights = NULL; 
  }

  /* read view number */
  fscanf(fp, "%d", &view_num);
  cad->view_num = view_num;

  /* read objects in 2D */
  cad->objects2d = (OBJECT2D**)malloc(sizeof(OBJECT2D*)*view_num);
  if(cad->objects2d == NULL)
  {
    printf("out of memory\n");
    return NULL;
  }
  for(i = 0; i < view_num; i++)
  {
    cad->objects2d[i] = (OBJECT2D*)malloc(sizeof(OBJECT2D));
    if(cad->objects2d[i] == NULL)
    {
      printf("out of memory\n");
      return NULL;
    }
    fscanf(fp, "%f", &(cad->objects2d[i]->azimuth));
    fscanf(fp, "%f", &(cad->objects2d[i]->elevation));
    fscanf(fp, "%f", &(cad->objects2d[i]->distance));
    fscanf(fp, "%d", &(cad->objects2d[i]->viewport_size));
    cad->objects2d[i]->part_num = part_num;
    /* read part locations */
    cad->objects2d[i]->part_locations = (float*)malloc(sizeof(float)*2*part_num);
    if(cad->objects2d[i]->part_locations == NULL)
    {
      printf("out of memory\n");
      return NULL;
    }
    for(j = 0; j < 2*part_num; j++)
      fscanf(fp, "%f", &(cad->objects2d[i]->part_locations[j]));

    /* set occlusion flag */
    cad->objects2d[i]->occluded = (int*)malloc(sizeof(int)*part_num);
    if(cad->objects2d[i]->occluded == NULL)
    {
      printf("out of memory\n");
      return NULL;
    }
    for(j = 0; j < part_num; j++)
    {
      if(cad->objects2d[i]->part_locations[j] != 0)
        cad->objects2d[i]->occluded[j] = 0;
      else
        cad->objects2d[i]->occluded[j] = 1;
    }
    /* read homographies */
    cad->objects2d[i]->homographies = (float**)malloc(sizeof(float*)*part_num);
    if(cad->objects2d[i]->homographies == NULL)
    {
      printf("out of memory\n");
      return NULL;
    }
    for(j = 0; j < part_num; j++)
    {
      if(cad->objects2d[i]->occluded[j] == 1)
        cad->objects2d[i]->homographies[j] = NULL;
      else
      {
        cad->objects2d[i]->homographies[j] = (float*)malloc(sizeof(float)*9);
        if(cad->objects2d[i]->homographies[j] == NULL)
        {
          printf("out of memory\n");
          return NULL;
        }
        for(k = 0; k < 9; k++)
          fscanf(fp, "%f", &(cad->objects2d[i]->homographies[j][k]));
      }
    }

    /* read part shapes */
    cad->objects2d[i]->part_shapes = (float**)malloc(sizeof(float*)*part_num);
    if(cad->objects2d[i]->part_shapes == NULL)
    {
      printf("out of memory\n");
      return NULL;
    }
    for(j = 0; j < part_num; j++)
    {
      if(cad->objects2d[i]->occluded[j] == 1)
        cad->objects2d[i]->part_shapes[j] = NULL;
      else
      {
        cad->objects2d[i]->part_shapes[j] = (float*)malloc(sizeof(float)*8);
        if(cad->objects2d[i]->part_shapes[j] == NULL)
        {
          printf("out of memory\n");
          return NULL;
        }
        for(k = 0; k < 8; k++)
          fscanf(fp, "%f", &(cad->objects2d[i]->part_shapes[j][k]));
      }
    }

    /* read graph */
    cad->objects2d[i]->graph = (int**)malloc(sizeof(int*)*part_num);
    if(cad->objects2d[i]->graph == NULL)
    {
      printf("out of memory\n");
      return NULL;
    }
    for(j = 0; j < part_num; j++)
    {
      cad->objects2d[i]->graph[j] = (int*)malloc(sizeof(int)*part_num);
      if(cad->objects2d[i]->graph[j] == NULL)
      {
        printf("out of memory\n");
        return NULL;
      }
      for(k = 0; k < part_num; k++)
        fscanf(fp, "%d", &(cad->objects2d[i]->graph[j][k]));
    }
  
    /* construct tree */
    fscanf(fp, "%d", &root_index);
    cad->objects2d[i]->root_index = root_index;
    cad->objects2d[i]->tree = construct_tree(part_num, root_index, cad->objects2d[i]->graph);
  }
  return cad;
}
コード例 #13
0
ファイル: Tree.cpp プロジェクト: sushiljacksparrow/Code
					current = current->right;
			}
		}
	}
}

node *construct_tree(int pre[], int pres, pree, int in[], int ins)
{
	if(pree<pres)
		return NULL;
	node *temp = newnode(in[ins]);
	int index = pres;
	for(int i=pres;i<=pree;i++)
		if(pre[i]==in[ins])
			{index = i; break}
	temp->left = construct_tree(pre, pres, index-1, in, ins+1);
	temp->right = construct_tree(pre, index+1, pree, in, ins+1);
	return temp;
}


int main()
{
	struct node *root = newNode(10);
  root->left        = newNode(8);
  root->right       = newNode(2);
  root->left->left  = newNode(3);
  root->left->right = newNode(5);
  root->right->left = newNode(2);
  iterative_inorder(root);
	system("pause");