Leet Code 面试题 04.02. 最小高度树 同 《108. 将有序数组转换为二叉搜索树》（二分法传参初探）

给定一个有序整数数组，元素各不相同且按升序排列，编写一个算法，创建一棵高度最小的二叉搜索树。
示例:
给定有序数组: [-10,-3,0,5,9],
一个可能的答案是：[0,-3,9,-10,null,5]，它可以表示下面这个高度平衡二叉搜索树：
0
/ \
-3 9
/ /
-10 5

• 正确题解（没错这道题我拉了）

struct TreeNode *creatnewnode(int num){
      struct TreeNode* temp = malloc(sizeof(struct TreeNode));
        temp->right = NULL;
        temp->left = NULL;
        temp->val = num;
        return temp;
}//空结点的创建
struct TreeNode* recursionsortedarray(int* nums, int lo, int hi)
{
	if (lo >= hi) return NULL;
	int mid = (hi + lo) / 2;
    struct TreeNode* root =  creatnewnode(nums[mid]);
    root->left = recursionsortedarray(nums, lo, mid);
    root->right = recursionsortedarray(nums, mid + 1, hi);
    return root;
}
struct TreeNode* sortedArrayToBST(int* nums, int numsSize){
    return recursionsortedarray(nums, 0, numsSize);
}

1、空结点的创建不需要解释
2、recursionsortedarray函数挺妙的，因为这道题需要用到二分法，我就是在二分法这跌了跟头。本函数完美绕开了我的复杂实现过程，利用一个low和一个high角标实现了二分法。
3、最先进行检验，若low>high肯定停止，即如指针交叉了。每次被当做结点的肯定是中间的数字，下面的结点也是四分点，四分点也可以用low和mid，high和mid实现，左低右高。即mid是由low和high构造的中间点，非常的重要。此方法将输入到方法中的数组进行切分，每个函数从中间切开，第二次在当前函数的前后四分点切开。
4、递归结束，返回root，妙哉。本方法的精华就是二分的很妙，以后可以套用这个highlow后构造当前mid方法

• 我的overtime错误题解

typedef struct{//这个是链子
    struct TreeNode* root;
}Tree;
void insert(Tree* tree, int value){//二叉搜索树的构建

	/*空结点的构建*/
	struct TreeNode* node =(struct TreeNode*)malloc(sizeof(struct TreeNode));
	node -> val = value;
	node -> left = NULL;
	node -> right = NULL;
	/*空结点的构建*/

	if(tree->root == NULL){//若树为空，则让新创建的节点成为树根
		tree->root = node;
	}
	else{//进行排序与比较
	//即正宗的二叉搜索树构建过程
		struct TreeNode* temp = tree->root;
		while(temp!=NULL){
			if(value<temp->val){
				if(temp->left==NULL){//原结点左边是空直接放上去就OK
					temp->left=node;
					return;
				}
				else{
					temp=temp->left;//不是空的就继续向左节点搜索
				}
			}
			else{//alue大于当前结点data值
				if(temp->right==NULL){//原结点右边是空直接放上去就OK
					temp->right=node;
					return;
				}
				else{
					temp=temp->right; //不是空的就继续遍历右结点
				}
			}
		}
	}
}

void erfenfa(Tree* tree,int* nums,int low,int high){
	//root为中间位置
	int mid;
	
	mid=(low+high)/2;
	if(low<high){
        insert(tree,nums[mid]);
        erfenfa(tree,nums,low,mid);
        erfenfa(tree,nums,mid,high);
    }
	
}

struct TreeNode* sortedArrayToBST(int* nums, int numsSize){
    if (numsSize == 0)  return NULL;
  //  int f;
    Tree tree;
    tree.root=NULL;
    //写一个方法吧
    erfenfa(&tree,nums,0,numsSize);
	 
   // f = numsSize - 1;
   //傻逼addresssantinizer
    
    return tree.root;
}

我想利用二叉搜索树的插入来实现，之后发现我背的insert算法也只是保证插入后此树是二叉搜索树，而不保证是满的，不出意外可能会出现一边倒情况，过了是例外，不过确实是二叉搜索树。后来我看了大佬的二分想法之后也想进行二分插入，编写了一个负责插入的函数，即“erfenfa”。运行后，经典的overtime，哈哈哈哈哈哈擦。
感觉是意料之中，因为insert这个函数太拉了，适合无序结点构造二叉搜索树，而不是有序构造，其算法结构为了保证是二叉搜索树，进行多次比较，浪费了好多内存，增加了时间，overtime在正常不过了。
大佬的方法运用递归在每次函数运行的时候左右子树的指向，时间空间复杂度均为最小。

我的思考：有序结点插入是否真的有必要单独进行插入函数的构建，或者说指向左右子树在递归过程中是不可能独立的，这种非独立性和及其节省时空复杂度的编法是否真的好呢？或者说在什么时候构建插入函数，在什么时候不构建插入函数，使用递归呢？