Leetcode中几道二叉树题 I

一、二叉搜索树 (Binary Search Tree)

题目一：Recover Binary Search Tree

Two elements of a binary search tree (BST) are swapped by mistake. Recover the tree without changing its structure.

思路：利用搜查树的特性——中序遍历的结果是有序的，可以找打两个交换值，然后再重新遍历恢复原值。

class Solution {
private:
    int first, second, last;
public:
    void recoverTree(TreeNode *root) {
        if(root==NULL) return;
        first=1<<12;
        second=1<<12;
        last=-1<<12;
        findSwapNodes(root);
        recoverSwapNodes(root);
    }
    
    void recoverSwapNodes(TreeNode *root){
        if(root==NULL) return;
        recoverSwapNodes(root->left);
        if(first==root->val){
            root->val=second;
        }
        else if(second==root->val){
            root->val=first;
        }
        recoverSwapNodes(root->right);
    }
    
    void findSwapNodes(TreeNode *root){
        if(root==NULL) return;
        findSwapNodes(root->left);
        if(root->val<last){
            if(second==1<<12){ 
                second=last;
                first=root->val;
            }
            if(root->val<first) first=root->val;
        }
        last=root->val;
        findSwapNodes(root->right);
    }    
};

题目二：Convert Sorted List to Binary Search Tree

Given a singly linked list where elements are sorted in ascending order, convert it to height balanced BST

思路：将链表均分成两半，各递归构造根节点的左右子树。

class Solution {
public:
    TreeNode *sortedListToBST(ListNode *head) {
        if(head==NULL) return NULL;
        if(head->next==NULL) return new TreeNode(head->val);
        
        TreeNode *newhead=NULL;
        ListNode *p1, *p2;
        p2=head;
        p1=head->next; //使得p2在中间位置的前二位
        while(p1 && p1->next && p1->next->next){
            p1=p1->next->next;
            p2=p2->next;
        }
        p1=p2->next;
        p2->next=NULL;
        newhead=new TreeNode(p1->val);
        if(p1->next) newhead->right=sortedListToBST(p1->next);
        newhead->left=sortedListToBST(head); 
        return newhead;
    }
};

题目三： Convert Sorted Array to Binary Search Tree

Given an array where elements are sorted in ascending order, convert it to a height balanced BST

思路：思路同上！注意二分递归是注意边界条件。

class Solution {
public:
    TreeNode *sortedArrayToBST(vector<int> &num) {
        if(num.size()==0) return NULL;
        return sortedArrayToBST(num, 0, num.size()-1);
    }
    
    TreeNode *sortedArrayToBST(vector<int>& num, int start, int end){
        TreeNode *head=NULL;
        if(start<=end){
            int mid=(start+end)/2;
            head=new TreeNode(num[mid]);
            if(start<mid){  //边界条件
                head->left=sortedArrayToBST(num, start, mid-1);
            }
            if(mid<end){
                head->right=sortedArrayToBST(num, mid+1, end);
            }
        }
        return head;
    }
};

题目四：Unique Binary Search Trees

Given n, how many structurally unique BST's (binary search trees) that store values 1...n?

思路：这道题用BF方法会超时。其实这是一道组合问题。按照数学的方式就能求得解。

class Solution {
public:
    int numTrees(int n) {
        if(n<=0) return 0;
    
        vector<int> result;
        result.push_back(1); //n=0 退化的情况
        result.push_back(1); //n=1
    
        for(int k=2;k<=n;k++) //n>1
        {
            int sum=0;
            for(int i=1;i<=k;i++)
            {
                sum+=(result[i-1]*result[k-i]);
            }
    
            result.push_back(sum);
        }
    
        return result[n];
    }
};

题目五：Unique Binary Search Trees II

Given n, generate all structurally unique BST's (binary search trees) that store values 1..n.

思路：不同于上面那道题，这里必须用枚举的方法。二分递归。这道题最开始我一直被一个weird problem缠住，我也不能理解，为啥出错。下面先贴出错误代码。

class Solution {
public:
    vector<TreeNode*> generateTrees(int low, int high){
        vector<TreeNode*> res;
        if(low<=high){
            TreeNode *root;
            vector<TreeNode*> left, right;
            for(int i=low; i<=high; i++){
                root=new TreeNode(i);
                left.clear();
                right.clear();
				left=generateTrees(low, i-1);
				right=generateTrees(i+1, high);
				if(left.size() && right.size()){
	                for(int j=0; j<left.size(); j++)
	                	for(int k=0; k<right.size(); k++){
							root->left=left[j];
							root->right=right[k];
							res.push_back(root);	
						} 
				}
				else if(left.size() || right.size()){
					for(int j=0; j<left.size(); j++){
						root->left=left[j];
						res.push_back(root);
					}
					for(int j=0; j<right.size(); j++){
						root->right=right[j];
						res.push_back(root);
					}
            	}
            	else res.push_back(root);
			}
        }
        return res;
    }
    
    vector<TreeNode *> generateTrees(int n) {
        vector<TreeNode*> res;
        if(n==0){
            res.push_back(NULL);
            return res;
        }
        return generateTrees(1, n);
    }
};

错误的原因：root的左右孩子节点被覆盖掉了。虽然以为root加入res以后就没啥事了，root本身的值没啥事，但是后面的操作改变了root左右孩子节点的值。还是对指针理解不够深刻！

class Solution {
public:
    vector<TreeNode*> generateTrees(int low, int high){
        vector<TreeNode*> res;
        if(low>high){
            res.push_back(NULL);   //添加叶子节点也是十分必要的呀！
            return res;
        }
        else{
            for(int i=low; i<=high; i++){
				vector<TreeNode*> left=generateTrees(low, i-1);
				vector<TreeNode*> right=generateTrees(i+1, high);
				TreeNode *root;
				for(int j=0; j<left.size(); j++){
                	for(int k=0; k<right.size(); k++){
                	    root=new TreeNode(i);           //root必须放在着这个循环里！
						root->left=left[j];
						root->right=right[k];
						res.push_back(root);	
					} 
				}
			}
			return res;
        }
    }
    
    vector<TreeNode *> generateTrees(int n) {
        vector<TreeNode*> res;
        if(n==0){
            res.push_back(NULL);
            return res;
        }
        return generateTrees(1, n);
    }
};