struct tree_node {
	tree_node* left;
	tree_node* right;
	int data;

	tree_node(int Data) : left(NULL), right(NULL), data(Data) {
	}
	tree_node() : left(NULL), right(NULL), data(0) {
	}
};

void new_root(const int root_val)
{
	root = new tree_node(root_val);
}

void attach_node(tree_node* new_parent, tree_node * &new_node, int insert_value)
{
	new_node = new tree_node(insert_value);
}

tree_node* insert_node(int ins_val, tree_node *tn, vector<int> d)
{
	if(!tn) tn = root;
	
		if(d[ins_val] < tn->data)
		{
		if(tn->left)
		{
			ins_val++;
			insert_node(ins_val, tn->left, d);
		}
		else
		{
			ins_val++;
			attach_node(tn, tn->left, d[ins_val]);
			
			return tn->left;
		}
		}
		else 
		{
			if(tn->right)
			{
				ins_val++;
				insert_node(ins_val, tn->right, d);
			}
			else 
			{
				ins_val++;
				attach_node(tn, tn->right, d[ins_val]);
				
				return tn->right;
			}
		}
	
}

...
	else 
			{
				ins_val++;
				attach_node(tn, tn->right, d[ins_val]);
				
				return tn->right;
			}
		}
	return tn;
}

int main...
{
...
vector<int> data; 
...//задаем вектору данные
insert_node root(data[0]);
insert_node(0, &root, data);
}

*tree_node* insert_node(int ins_val, tree_node *tn, vector<int> d)
{
	if(ins_val > d.size()-1)
		return root;
	if(!tn) tn = root;
		if(d[ins_val] < tn->data)
		{
		if(tn->left)
		{		
			insert_node(ins_val, tn->left, d);		
		}
		else
		{	
			tn->left = new tree_node(d[ins_val]);	
		}
		}
		else 
		{
			if(tn->right)
			{			
				insert_node(ins_val, tn->right, d);			
			}
			else 
			{		
				tn->right = new tree_node(d[ins_val]);		
			}
		}
		return tn;
}
...
int main ... {
...
for(int i = 1; i != data.size()-1; i++)
	{
		insert_node(i, &root, data);
	}
...
}

tree_node* insert_node(int index, int left, int right, tree_node *tn, vector<int> d)
{
	int temp_index;	
	if(right < left)
		return NULL;
	if(!tn) tn = root;
		if(tn->left)
		{		
			insert_node(index, index - 1, right, tn->left, d);			
		}
		else
		{
			temp_index = (left + index)/2;
			tn->left = new tree_node(d[temp_index]);			
		}		 
		if(tn->right)
			{			
				insert_node(index, left, index + 1, tn->right, d);			
			}
			else 
			{
				temp_index = (index + right)/2;
				tn->right = new tree_node(d[temp_index]);				
			}
		return tn;
}
...
int main ... {
...
data.push_back(1); data.push_back(6); data.push_back(10); data.push_back(3); data.push_back(14); data.push_back(8); 
	sort(data.begin(), data.end());
	int index = (0 + data.size())/2;
	tree_node root(data[index]);
	insert_node(index, 0, data.size()-1, &root, data);
...
}

...
vector<int> numbers;
....

struct Tree
{
	char data;
	Tree *left;
	Tree *right;  
	Tree *parent;  
};

Tree *addToBST(vector<int> numbers, int start, int end)
{
	if(end < start) return NULL;
	int mid = (start + end)/2;

	Tree *r = new Tree;
	r->data = numbers[mid];
	r->left = addToBST(numbers, start, mid-1);
	r->right = addToBST(numbers, mid+1, end);
	return r;
}

Tree *createMinimalBST(vector<int> numbers, int size)
{
	return addToBST(numbers,0,size-1);
}

void Print_BinaryTree(Tree* Node, int l) {
	int i;
	if(Node != NULL) {
		Print_BinaryTree(Node->right, l+1);
		for(i=0; i<l; i++) cout << "    ";
		printf("%4ld", Node->data);
		Print_BinaryTree(Node->left, l+1);
	}
	else cout << endl;
}

int _tmain(int argc, _TCHAR* argv[])
{
		numbers.push_back(3);
		numbers.push_back(6);
		numbers.push_back(14);
		numbers.push_back(8);
		numbers.push_back(10);
		numbers.push_back(1);
		sort(numbers.begin(), numbers.end());
		Tree *newRoot = createMinimalBST(numbers,numbers.size());
		Print_BinaryTree(newRoot, 0);
	getchar();
	return 0;
}