[Leetcode] 95, 109, 111

95. Unique Binary Search Trees II

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

For example,
Given n = 3, your program should return all 5 unique BST's shown below.

   1         3     3      2      1    \       /     /      / \      \     3     2     1      1   3      2    /     /       \                 \   2     1         2                 3

Solution: 递归建树即可。

Code:

/** * Definition for a binary tree node. * struct TreeNode { *     int val; *     TreeNode *left; *     TreeNode *right; *     TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class Solution {public:    vector<TreeNode*> generateTrees(int n) {        if(n==0) return vector<TreeNode*>();//如果直接返回generateTrees的结果是[[]]，但题目要求返回[]        return generateTrees(1, n);    }private:    vector<TreeNode*> generateTrees(int start, int end){        vector<TreeNode*> ans;        if(start>end){            ans.push_back(NULL);            return ans;        }        for(int i=start; i<=end; i++){            vector<TreeNode*> leftsubtrees = generateTrees(start, i-1);            vector<TreeNode*> rightsubtrees = generateTrees(i+1, end);            for(int j=0; j<leftsubtrees.size(); j++){                for(int q=0; q<rightsubtrees.size(); q++){                    TreeNode* root = new TreeNode(i);                    root->left = leftsubtrees[j];                    root->right = rightsubtrees[q];                    ans.push_back(root);                }            }        }        return ans;    }};

109. Convert Sorted List to Binary Search Tree

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

Solution(1):分治法。每次找到中点，然后将链表分为左右部分，分别求解左子树和右子树。但是因为单链表不能随机访问，因此必须通过遍历找到中点，时间复杂度是O(n^2)。

Code:

/** * Definition for singly-linked list. * struct ListNode { *     int val; *     ListNode *next; *     ListNode(int x) : val(x), next(NULL) {} * }; *//** * Definition for a binary tree node. * struct TreeNode { *     int val; *     TreeNode *left; *     TreeNode *right; *     TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class Solution {public:    TreeNode* sortedListToBST(ListNode* head) {        if(head==NULL) return NULL;                //计算list的长度        int size = 0;        ListNode* cur = head;        while(cur!=NULL){ size++; cur = cur->next;}                //取中点        ListNode* mid = head;        for(int i=0; i<size/2; i++) mid = mid->next;                TreeNode* root = new TreeNode(mid->val);                TreeNode* left = sortedListToBST_Half(head, size/2);        TreeNode* right = sortedListToBST_Half(mid->next, size-size/2-1);                root->left = left;        root->right = right;        return root;    }private:    TreeNode* sortedListToBST_Half(ListNode* head, int size){        if(size==0) return NULL;        ListNode* mid = head;        for(int i=0; i<size/2; i++) mid = mid->next;                TreeNode* root = new TreeNode(mid->val);        TreeNode* left = sortedListToBST_Half(head, size/2);        TreeNode* right = sortedListToBST_Half(mid->next, size-size/2-1);                root->left = left;        root->right = right;        return root;    }};

Solution(2): 因为链表无法自己找中点，因此使用递归让指针指向中点，并且在递归的过程中建树。是一种自底向上的方法，时间复杂度O(n)。

递归调用的过程如图所示：

可以看出，这种方法模拟了一次数据为1-n（代表下标）的二叉树的中序遍历，在遍历的过程中进行建树，同时改变list指针的位置，令其恰好指向跟节点的位置。

Code:

/** * Definition for singly-linked list. * struct ListNode { *     int val; *     ListNode *next; *     ListNode(int x) : val(x), next(NULL) {} * }; *//** * Definition for a binary tree node. * struct TreeNode { *     int val; *     TreeNode *left; *     TreeNode *right; *     TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class Solution {public:    TreeNode* sortedListToBST(ListNode* head) {        if(head==NULL) return NULL;                //计算list的长度        int size = 0;        ListNode* cur = head;        while(cur!=NULL){ size++; cur = cur->next;}                cur = head;        return sortedListToBST(cur, 1, size);    }private:    TreeNode* sortedListToBST(ListNode*& list, int begin, int end){        if(begin>end) return NULL;                int middle = begin + (end-begin+1)/2; //因为标准答案是在左右不均匀时，令左边多一个        TreeNode* leftChild = sortedListToBST(list, begin, middle-1); //递归结束时list指针指向中点        TreeNode* root = new TreeNode(list->val);        root->left = leftChild;        list = list->next;        TreeNode* rightChild = sortedListToBST(list, middle+1, end);        root->right = rightChild;        return root;    }};

111. Minimum Depth of Binary Tree

Given a binary tree, find its minimum depth.

The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.

Code(递归版):

/** * Definition for a binary tree node. * struct TreeNode { *     int val; *     TreeNode *left; *     TreeNode *right; *     TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class Solution {public:    int minDepth(TreeNode* root) {        if(root==NULL) return 0;        int mind = INT_MAX;        getDepth(root, 1, mind);        return mind;    }private:    void getDepth(TreeNode* root, int d, int& mind){        //假定root非空        if(root->left==NULL && root->right==NULL){            if(d<mind) mind = d;            return;        }        if(root->left!=NULL)            getDepth(root->left, d+1, mind);        if(root->right!=NULL)            getDepth(root->right, d+1, mind);            }};

Code(迭代版): 

/** * Definition for a binary tree node. * struct TreeNode { *     int val; *     TreeNode *left; *     TreeNode *right; *     TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class Solution {public:    int minDepth(TreeNode* root) {        if(root==NULL) return 0;                stack<pair<TreeNode*,int>> s;//使用结构pair        s.push(make_pair(root,1));//pair构造        int curh;        int minH = INT_MAX;        TreeNode* cur = NULL;        while(!s.empty()){            cur = s.top().first; //pair取值            curh = s.top().second;             s.pop();            if(cur->left==NULL && cur->right==NULL){                if(curh<minH) minH = curh;                continue;            }            if(cur->left!=NULL){                s.push(make_pair(cur->left,curh+1));            }            if(cur->right!=NULL){                s.push(make_pair(cur->right,curh+1));            }        }        return minH;    }};