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
;
}
};

题目五：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);
}
};