Move median_of_the_two_sorted_arrays.cpp to /leetcode/array, add path sum and maximum depth solution.

Author: chachaxw

leetcode/median_of_two_sorted_arrays/median_of_two_sorted_arrays.cpp renamed to leetcode/array/median_of_two_sorted_arrays.cpp

@@ -2,7 +2,7 @@
  * @Author: Chacha 
  * @Date: 2019-01-03 17:07:54 
  * @Last Modified by: Chacha
- * @Last Modified time: 2019-01-03 18:01:39
+ * @Last Modified time: 2019-02-15 15:12:59
  */
 
 #include<iostream>
@@ -57,7 +57,7 @@ class Solution {
 
         return max(leftDepth, rightDepth) + 1;
     }
-}
+};
 
 int main() {
     return 0;

leetcode/binary_tree/balanced_binary_tree.cpp

@@ -0,0 +1,52 @@
+/**
+ * @Author: Chacha 
+ * @Date: 2019-02-16 13:26:00 
+ * @Last Modified by: Chacha
+ * @Last Modified time: 2019-02-16 18:30:38
+ */
+
+#include<iostream>
+#include<queue>
+using namespace std;
+
+struct TreeNode {
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution {
+public:
+    int maxDepth(TreeNode* root) {
+        if (root == NULL) return 0;
+
+        queue<TreeNode *> q;
+        q.push(root);
+
+        int max_depth = 0;
+
+        while(!q.empty()){
+            int size = q.size();
+            for(int i = 0; i < size; i++) {
+                TreeNode *node = q.front();
+                q.pop();
+
+                if (node->left) {
+                    q.push(node->left);
+                }
+
+                if (node->right) {
+                    q.push(node->right);
+                }
+            }
+            ++max_depth;
+        }
+        
+        return max_depth;
+    }
+};
+
+int main() {
+    return 0;
+}

leetcode/binary_tree/maximum_depth

@@ -0,0 +1,50 @@
+/**
+ * @Author: Chacha 
+ * @Date: 2019-02-15 15:12:02 
+ * @Last Modified by: Chacha
+ * @Last Modified time: 2019-02-16 11:55:40
+ */
+
+#include<iostream>
+#include<vector>
+using namespace std;
+
+struct TreeNode {
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution {
+public:
+    /**
+     * Given a binary tree and a sum, determine if the tree has a root-to-leaf path such 
+     * that adding up all the values along the path equals the given sum.
+     * 
+     * Example:
+     *  Given the below binary tree and sum = 22
+     *              5
+                   / \
+                  4  8
+                 /  / \
+                11 13  4
+               /  \     \
+              7   2     1
+
+     *  return true, as there exist a root-to-leaf path 5->4->11->2 which sum is 22.
+     * 
+     * Source:
+     *  https://leetcode.com/problems/path-sum/
+     */
+    bool hasPathSum(TreeNode* root, int sum) {
+        if (root == NULL) return false;
+        if (root->val == sum && root->left == NULL && root->right == NULL) return true;
+        return hasPathSum(root->left, sum - root->val) || hasPathSum(root->right, sum - root->val);
+    }
+};
+
+int main() {
+    return 0;
+}
+

leetcode/binary_tree/maximum_depth.cpp

@@ -28,8 +28,12 @@ class Solution {
      *
      * Example:
      *  Given two lists, 3->1->5->null and 5->9->2->null, return 8->0->8->null
+     * 
+     * Source:
+     *  https://www.lintcode.com/en/problem/two-lists-sum/
+     *  https://www.kancloud.cn/kancloud/data-structure-and-algorithm-notes/73006
      */
-    ListNode* twoListsSum(ListNode* l1, ListNode* l2) {
+    ListNode* twoListsSum1(ListNode* l1, ListNode* l2) {
         if (l1 == NULL && l2 == NULL) {
             return NULL;
         }
@@ -59,6 +63,21 @@ class Solution {
 
         return sumList;
     }
+
+    /**
+     * Given two numbers represented by two linked lists, write a function that returns sum list.
+     * The sum list is linked list representation of addition of two input numbers.
+     * 
+     * Example:
+     *  Input:
+     *      First  List: 5->6->3  // represents number 563
+     *      Second List: 8->4->2  // represents number 842
+     *  Output:
+     *      Resultant list: 1->4->0->5  // represents number 1405
+     */
+    ListNode* twoListsSum2(ListNode* l1, ListNode* l2) {
+        
+    }
 };
 
 /* Function to print nodes in a given linked list */
@@ -79,7 +98,7 @@ int main()
     l2->next = new ListNode(9);
     l2->next->next = new ListNode(2);
 
-    ListNode* sum = Solution().twoListsSum(l1, l2);
+    ListNode* sum = Solution().twoListsSum1(l1, l2);
 
     printList(sum);