二叉树的一些常见操作函数

记录一些遇到的二叉树操作函数
√ 树构造函数
√ 先/中/后序遍历
√ 二叉树翻转函数
√ 合并二叉树函数
√ 二叉树搜索
√ 有序数组转二叉搜索树
√单值二叉树
√修建二叉搜索树

struct TreeNode {
      	int val;
      	TreeNode *left;
      	TreeNode *right;
     	TreeNode(int x) : val(x), left(NULL), right(NULL) {}
     };   //二叉树结构体
     
bool CBiTreeB(TreeNode* &T)
{
	int v;
	scanf("%d",&v);  //输入
	if (v== ' '|| v== '\n')    //回车或空格
		T = NULL;       //置空
	else
	{
		T = (TreeNode*)malloc(sizeof(TreeNode)); //分配空间
		if (!T)
			return 0;     //分配空间失败
		T->val= v;       //赋值
		CBiTreeB(T->left);  
		CBiTreeB(T->right);
	}
	return 1;
}

void VisitB(TreeNode* &T)  //先序遍历
{
	if (T)
	{
		printf("%d",T->val);//先根
		VisitB(T->left);      //左子树回调
		VisitB(T->right);      //右子树回调
	}
}

void VisitL(TreeNode* &T)  //中序遍历
{
	if (T)
	{
		VisitL(T->left);     //左子树回调
		printf("%d",T->val);//中根
		VisitL(T->right);     //右子树回调
	}
}

void VisitR(TreeNode&T)  //后序遍历
{
	if (T)
	{
		VisitR(T->left);     //左子树回调
		VisitR(T->right);     //右子树回调
		printf("%d",T->val);//后根
	}
}

//二叉树翻转函数
TreeNode* invertTree(TreeNode* root) {
        if(root == NULL )   return NULL;
        //先序遍历式
        TreeNode* rright = root->right;       //保存右节点
        root->right = invertTree(root->left);//递归到左节点
        root->left = invertTree(rright);        //递归到右节点
        //中序遍历式
        /*invertTree(root->left);  //递归到左节点，但不赋值
        TreeNode* rright = root->right;       //保存右节点
         root->right = root->left;       //左右节点交换
         root->left  = rightNode;
        invertTree(root->left);  //左右节点已经交换过一次*/
        //后序遍历式
        /*TreeNode* rleft =  invertTree(root->left);
        TreeNode* rright = invertTree(root->right);
        root->right = rleft;
        root->left = rright;*/
        return root;
   }
   
  //合并二叉树函数
  TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
        if(t2 == NULL)  return t1;
        if(t1 == NULL)  return t2;
        t1->val += t2->val;
        t1->left = mergeTrees(t1->left, t2->left);
        t1->right = mergeTrees(t1->right, t2->right);
        return t1;
    }
    
  //二叉树搜索
  TreeNode* searchBST(TreeNode* root, int val) {
        if (root == NULL || root->val == val) return root;
        if(root->val > val)       //val在树的左边
            return searchBST(root->left,val);
        else if(root->val < val)  //val在树的右边
            return searchBST(root->right,val);
        return NULL;
        }
        
   //有序数组转二叉搜索树
   //传入数组nums、首位下标low，最后下标high
  TreeNode* arraytoBST(vector<int>& nums, int low, int high)  
    {
        if(low > high) return NULL;
        int mid = low + (high - low ) / 2;
        TreeNode* root = new TreeNode(nums[mid]);
        root->left =  xianxubianli(nums, low, mid - 1);
        root->right = xianxubianli(nums, mid + 1, high);
        return root;
    }
    
	//单值二叉树
    bool isUnivalTree(TreeNode* root) {
        if(root == NULL)
            return true;
        if(root->left != NULL && root->left->val != root->val)
            return false;
        if(root->right != NULL && root->right->val != root->val)
            return false;
        return isUnivalTree(root->left) && isUnivalTree(root->right);
    }

	//修建二叉搜索树
    TreeNode* trimBST(TreeNode* root, int L, int R) {
        if(root == NULL)   //递归到叶结点
            return root;
        if(root->val < L)    //小于L的左子树全部抛弃，递归右子树
            return trimBST(root->right, L, R);
        if(root->val > R)    //大于R的右子树全部抛弃，递归左子树 
            return trimBST(root->left, L, R);
        //正常结点下的不正常左右子树的替换
        root->left = trimBST(root->left, L, R);  
        root->right = trimBST(root->right, L, R);
        return root;
    }
   //未完待续...