void FMM2D::recalculate()
{
    if (!m_tree) {
        build_tree();
    }
    reset();
    upward_pass();
    downward_pass();
}

void FMM2D::calculate(bool precond)
{
    reset();
    m_make_prec = precond;
    build_tree();
    upward_pass();
    downward_pass();
    m_make_prec = false;
}

 BihTree(
     const InputIterator & first,
     const InputIterator & last,
     unsigned max_depth = 32,
     unsigned items_per_leaf = 1 ) :
     MAX_DEPTH(max_depth), ITEMS_PER_LEAF(items_per_leaf), m_range(), m_root(), m_depth(0), m_num_nodes(0)
 {
     m_range.insert(m_range.begin(),first,last);
     build_tree(m_root, m_range.begin(), m_range.end(), 0);
 }

void build_tree(int root, int prev)
{
    for(int k = head[root]; k != -1; k = edge[k].next) {
        int v = edge[k].v;
        if(prev == v) continue;
        father[v] = root;
        build_tree(v, root);
        f[root] += f[v];
    }
}

sv::id3_tree::id3_tree(std::vector<sample> d, std::vector<std::string> f) : data(std::move(d)), features(std::move(f))
{
	//map features to set of values
	for (std::size_t i = 0; i < features.size(); ++i)
	{
		for (const auto& s : data) { feature_to_values[features[i]].insert(s.feature_values[i]); }
	}

	root = build_tree(data, features);
}

 NumArray(vector<int> &nums) {
     this->nums = vector<int>(nums);
     n = (int)nums.size();
     
     if (n != 0){
         tree = new TreeNode[4*n];
         build_tree(1, 0, n-1);
         if (n < 15)
             print_tree();
     }
 }

Node* build_tree(FILE* input){
    int bit = read_bit(input);
    if (bit == EOF){
	printf("%s\n", "Error: build_tree shouldn't encounter EOF");
    }
    if (bit == 1){
	char c = read_char(input);
	Node* node = my_malloc(sizeof(Node));
	node->left = NULL;
	node->right = NULL;
	node->next = NULL;
	node->char_val = c;
	return node;
    } else {
	Node* tree = my_malloc(sizeof(Node));
	tree->left = build_tree(input);
	tree->right = build_tree(input);
	return tree;
    }
}

void build_tree(int now, int l, int r)
{
	if(l == r)
	{
		int v;
		std::scanf("%d", &v);
		node[now].ans = node[now].sum = v;
		node[now].ans.l = node[now].ans.r = l;
		node[now].left = node[now].right = node[now].ans;
		node_m[now] = node[now];
		return;
	}

	int m = (l + r) >> 1;
	int a = now << 1, b = a + 1;
	build_tree(a, l, m);
	build_tree(b, m + 1, r);
	merge(node[now], node[a], node[b], max_cmp);
	merge(node_m[now], node_m[a], node_m[b], min_cmp);
}

int main(int argc, char **argv)
{
    int **tree = build_tree();
    for(int i = TREE_SIZE-2; i >= 0; i--)
        for(int j = 0; j <= i; j++)
            tree[i][j] += MAX(tree[i+1][j], tree[i+1][j+1]);

    printf("%d\n", tree[0][0]);

    return 0;
}

void
build_tree(int root, int left, int right)
{
	int mid;

	tree[root].left = left;
	tree[root].right = right;
	if (left == right)
	{
		tree[root].max = tree[root].min = num[left];
	}
	else
	{
		mid = (left + right) / 2;
		build_tree(root * 2, left, mid);
		build_tree(root * 2 + 1, mid + 1, right);
		tree[root].max = max(tree[root * 2].max, tree[root * 2 + 1].max);
		tree[root].min = min(tree[root * 2].min, tree[root * 2 + 1].min);
	}
}

void test_data_data_is_retained(void)
{
   int tree_data[] = { 4 };
   node_t *tree = build_tree(tree_data, ARRAY_SIZE(tree_data));

   TEST_ASSERT_NOT_NULL(tree);
   TEST_ASSERT_EQUAL_INT(4, tree->data);
   TEST_ASSERT_NULL(tree->left);
   TEST_ASSERT_NULL(tree->right);

   free_tree(tree);
}

void kd_tree::build_tree(array_2d<double> &mm){
    
    array_1d<double> i_min,i_max;
    int i;
    
    for(i=0;i<mm.get_cols();i++){
        i_min.set(i,0.0);
        i_max.set(i,1.0);
    }
    
    build_tree(mm,i_min,i_max);
}

	void quadtree::build_tree(const epng::png & source, std::unique_ptr<node> & subroot, uint64_t resolution, uint64_t x, uint64_t y)
	{
		subroot.reset(new node());

		if(resolution == 1){
			subroot->element = *source(x,y);
			return;
		}
		build_tree(source, subroot->northwest, resolution/2, x, y);
		build_tree(source, subroot->northeast, resolution/2, x+resolution/2, y);
		build_tree(source, subroot->southwest, resolution/2, x, y+resolution/2);
		build_tree(source, subroot->southeast, resolution/2, x+resolution/2, y+resolution/2);

		int tmp;
		tmp = (subroot->northwest->element.red + subroot->northeast->element.red + subroot->southwest->element.red + subroot->southeast->element.red)/4;
		subroot->element.red = tmp;
		tmp = (subroot->northwest->element.green + subroot->northeast->element.green + subroot->southwest->element.green + subroot->southeast->element.green)/4;
		subroot->element.green = tmp;
		tmp = (subroot->northwest->element.blue + subroot->northeast->element.blue + subroot->southwest->element.blue + subroot->southeast->element.blue)/4;
		subroot->element.blue = tmp;
	}

node * build_tree(int left,int right)
{
    char ch;
    int i;

    if(left > right) return NULL;

    ch = preorder[pre_index];

    for(i=0; inorder[i] != ch; i++);

    pre_index++;

    node *t= new node;

    t->c = inorder[i];
    t->left = build_tree(left,i-1);
    t->right = build_tree(i+1,right);

    return t;
}

int
main()
{
	NODE	*TPTR = NULL;
	q.nele=0;

	if ((TPTR = build_tree(5)) == NULL) {
		printf ("build tree failed\n");
		err_exit ("btree failed\n");
	}

	bfs(TPTR);
}

int main_test(void){
    BiTree *T = NULL;
    
    init_tree(&T);
    
    process_input(T);
    
    build_tree(T);
    
    traverse_tree(T);
    
    return 0;
}

void test_sorted_data_can_sort_single_number(void)
{
   TEST_IGNORE();
   int tree_data[] = { 2 };
   node_t *tree = build_tree(tree_data, ARRAY_SIZE(tree_data));

   int expected[] = { 2 };
   int *actual = sorted_data(tree);
   TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, ARRAY_SIZE(expected));

   free_tree(tree);
   free(actual);
}

void test_sorted_data_can_sort_if_second_number_is_greater_than_first(void)
{
   TEST_IGNORE();
   int tree_data[] = { 2, 3 };
   node_t *tree = build_tree(tree_data, ARRAY_SIZE(tree_data));

   int expected[] = { 2, 3 };
   int *actual = sorted_data(tree);
   TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, ARRAY_SIZE(expected));

   free_tree(tree);
   free(actual);
}

void test_sorted_data_can_sort_complex_tree(void)
{
   TEST_IGNORE();
   int tree_data[] = { 2, 1, 3, 6, 7, 5 };
   node_t *tree = build_tree(tree_data, ARRAY_SIZE(tree_data));

   int expected[] = { 1, 2, 3, 5, 6, 7 };
   int *actual = sorted_data(tree);
   TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, ARRAY_SIZE(expected));

   free_tree(tree);
   free(actual);
}

void build_tree(int node,int a,int b)
{
	if(a==b)
	{
		T[node].lval=node;
		T[node].rval=node;
		T[node].maxv=arr[a];
		T[node].sum=arr[a];
		return;
	}
	int m=(a+b)/2;
	build_tree(2*node,a,m);
	build_tree(2*node+1,m+1,b);

	T[node].maxv=max2(T[2*node].maxv,T[2*node+1].maxv);
	if(T[2*node+1].lval!=T[2*node+1].rval)
		T[node].sum=max3(T[2*node].maxv+T[2*node+1].maxv,T[2*node].sum,T[2*node+1].sum);
	else if(T[2*node+1].lval==T[2*node+1].rval)
		T[node].sum=max2(T[2*node].maxv+T[2*node+1].maxv,T[2*node].sum);
	T[node].lval=2*node;
	T[node].rval=2*node+1;
}