solved 5 problems.

Author: coderfive

107.Binary Tree Level Order Traversal II/coderfive/107.cc

@@ -0,0 +1,23 @@
+class Solution {
+public:
+    vector<vector<int>> levelOrderBottom(TreeNode* root) {
+	vector<vector<int>> res;
+	vector<TreeNode*> v, v2, *p = &v, *p2 = &v2;
+	if (!root) return res;
+	v.push_back(root);
+	while (p->size() != 0) {
+	    vector<int> vi;
+	    for (int i = 0; i < p->size(); i++) {
+		vi.push_back((*p)[i]->val);
+		if ((*p)[i]->left) p2->push_back((*p)[i]->left);
+		if ((*p)[i]->right) p2->push_back((*p)[i]->right);
+	    }
+	    res.push_back(std::move(vi));
+	    std::swap (p, p2);
+	    p2->clear();
+	}
+	std::reverse(res.begin(), res.end());
+
+	return res;
+    }
+};

108.Convert Sorted Array to Binary Search Tree/coderfive/108.cc

@@ -0,0 +1,14 @@
+class Solution {
+public:
+    TreeNode* sortedArrayToBST(vector<int>& nums) {
+	return toBST (nums, 0, nums.size());
+    }
+    TreeNode* toBST (const vector<int>& v, int b, int e) {
+	if (b == e) return NULL;
+	int mid = b + (e-b)/2;
+	TreeNode* node = new TreeNode(v[mid]);
+	node->left = toBST(v, b, mid);
+	node->right = toBST(v, mid+1, e);
+	return node;
+    }
+};

109.Convert Sorted List to Binary Search Tree/coderfive/109.cc

@@ -0,0 +1,23 @@
+class Solution {
+public:
+    TreeNode* sortedListToBST(ListNode* head) {
+	int n = 0;
+	ListNode* p = head;
+	while (head) {
+	    n++;
+	    head = head->next;
+	}
+	return toBST(&p, n);
+    }
+    TreeNode* toBST (ListNode** head, int n) {
+	int left_size = n/2;
+	if (n == 0) return NULL;
+	TreeNode* left = toBST(head, left_size);
+	TreeNode* res = new TreeNode((*head)->val);
+	*head = (*head)->next;
+	res->left = left;
+	res->right = toBST(head, n-left_size-1);
+
+	return res;
+    }
+};

110.Balanced Binary Tree/coderfive/110.cc

@@ -0,0 +1,17 @@
+class Solution {
+public:
+    bool isBalanced(TreeNode* root) {
+	int a = 0;
+	return is_b (root, a);
+    }
+    bool is_b (TreeNode* root, int& depth) {
+	if (!root) return true;
+	int a = 0, b = 0;
+	if (!is_b(root->left, a)) return false;
+       	if (!is_b(root->right, b)) return false;
+	if (a < b) std::swap(a, b);
+	if (a-b > 1) return false;
+	depth += a+1;
+	return true;
+    }
+};

111.Minimum Depth of Binary Tree/coderfive/111.cc

@@ -0,0 +1,10 @@
+class Solution {
+public:
+    int minDepth(TreeNode* root) {
+	if (!root) return 0;
+	int left = minDepth(root->left);
+	int right = minDepth(root->right);
+	if (left == 0 || right == 0) return 1+left+right;
+	return 1 + std::min(left, right);
+    }
+};