update some pro and add tree traversal

Author: selfboot

Array/164_MaximumGap.py

@@ -9,34 +9,26 @@ class Solution(object):
     And here is a java solution in leetcode's discuss:
     https://leetcode.com/discuss/53636/radix-sort-solution-in-java-with-explanation
     """
+
     def maximumGap(self, nums):
         if not nums:
             return 0
 
-        max_gap = 0
-        max_num = nums[0]
-        for num in nums:
-            if num > max_num:
-                max_num = num
-
+        max_num = max(nums)
+        bucket = [[] for i in range(10)]
         exp = 1
-        sorted_digit = [0 for num in nums]
         while max_num / exp > 0:
-            digits = [0 for i in range(10)]
             for num in nums:
-                digits[(num/exp) % 10] += 1
-            for i in range(1, 10):
-                digits[i] += digits[i-1]
-            for num in nums[::-1]:
-                digit_num = (num/exp) % 10
-                sorted_digit[digits[digit_num]-1] = num
-                digits[digit_num] -= 1
-            nums = sorted_digit
+                bucket[(num / exp) % 10].append(num)
+            nums = []
+            for each in bucket:
+                nums.extend(each)
+            bucket = [[] for i in range(10)]
             exp *= 10
 
         max_gap = 0
         for i in range(1, len(nums)):
-            max_gap = max(max_gap, nums[i]-nums[i-1])
+            max_gap = max(max_gap, nums[i] - nums[i - 1])
         return max_gap
 
 """

BinarySearch/378_KthSmallestElementInSortedMatrix.py

@@ -0,0 +1,28 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+# @Author: [email protected]
+# @Last Modified time: 2016-08-29 10:15:24
+
+
+class Solution(object):
+    """ Heap merge is helpfull.
+    """
+    def kthSmallest(self, matrix, k):
+        import heapq
+        return list(heapq.merge(*matrix))[k - 1]
+
+
+class Solution(object):
+    """ Binary Search can solve this too.
+    """
+    def kthSmallest(self, matrix, k):
+
+
+"""
+[[1]]
+1
+[[1,2,3], [4,5,6], [7,8,9]]
+3
+[[ 1, 5, 9], [10, 11, 13], [12, 13, 15]]
+8
+"""

BinarySearch/README.md

@@ -8,50 +8,54 @@
 * 递归实现时，检查参数的有效性（low/high参数）；
 * 计算二分查找中的中值时防止溢出；
 * 如何查找第一个/最后一个等值？
- 
+
 # 简单实现
 
 下面来看下简单二分查找（数组中不包含重复数字）的两种实现方案。
 
 递归实现如下：
 
-    // 在 nums[begin, end) 中查找 target
-    int binary_search(const vector<int> &nums, int begin, int end, int target){
-        if(begin<0 || begin>=end || end>nums.size()){
-            return -1;
-        }
-        int mid = begin + (end-1 - begin)/2;
+```c++
+// 在 nums[begin, end) 中查找 target
+int binary_search(const vector<int> &nums, int begin, int end, int target){
+    if(begin<0 || begin>=end || end>nums.size()){
+        return -1;
+    }
+    int mid = begin + (end-1 - begin)/2;
+    if(nums[mid] > target){
+        return binary_search(nums, begin, mid, target);
+    }
+    else if(nums[mid] < target){
+        return binary_search(nums, mid+1, end, target);
+    }
+    else{
+        return mid;
+    }
+}
+```
+
+循环实现如下：
+
+```c++
+int binary_search(const vector<int> &nums, int target){
+    int left = 0;
+    int right = nums.size() - 1;
+    while(left <= right){
+        int mid = left + (right-left) / 2; // 防止溢出
+        // int mid = (left+right)/2  
         if(nums[mid] > target){
-            return binary_search(nums, begin, mid, target);
+            right = mid - 1;
         }
         else if(nums[mid] < target){
-            return binary_search(nums, mid+1, end, target);
+            left = mid + 1;
         }
         else{
             return mid;
         }
     }
-
-循环实现如下：
-
-    int binary_search(const vector<int> &nums, int target){
-        int left = 0;
-        int right = nums.size() - 1;
-        while(left <= right){
-            int mid = left + (right-left) / 2; // 防止溢出
-            // int mid = (left+right)/2  
-            if(nums[mid] > target){
-                right = mid - 1;
-            }
-            else if(nums[mid] < target){
-                left = mid + 1;
-            }
-            else{
-                return mid;
-            }
-        }
-        return -1; // 没有找到target
-    }
+    return -1; // 没有找到target
+}
+```
 
 这里说是二分查找，其实严格来说是三分，mid 值有三种情况，分别是大于、小于、等于，对应这三种情况分别更新 left、right，或者返回最终结果。
 
@@ -61,45 +65,49 @@
 
 **对于排序的数组进行查找，二分查找总是应该首先考虑的解决办法。**
 
-## 1 统计数字在排序数组中出现的次数
+## 统计数字在排序数组中出现的次数
 
 简单思路，先用二分查找算法找到一个 target，由于 target 可能出现多次，于是在找到的位置向左右顺序扫描，分别找出第一个和最后一个 target。最差情况下，扫描的时间复杂度能达到O(n)。因此这种方法和从头到尾扫描整个数组统计出现的次数的方法是一样的，效率不够高。
 
 因此可以考虑用二分查找直接找出重复出现的数字的第一个位置和最后一个位置。找出数字第一次出现位置的实现如下，保证了最坏情况下时间复杂度仍然为 O(logn)：
 
-    // 在 nums[begin, end) 中查找 target
-    int getFirstK(int nums[], int length, int k){
-        int left = 0;
-        int right = length-1;
-        while(left<=right){
-            int mid = left + (right-left)/2;
-            if(nums[mid] < k){
-                left = mid + 1;
-            }
-            else if(nums[mid] > k){
-                right = mid - 1;
+```c++
+// 在 nums[begin, end) 中查找 target
+int getFirstK(int nums[], int length, int k){
+    int left = 0;
+    int right = length-1;
+    while(left<=right){
+        int mid = left + (right-left)/2;
+        if(nums[mid] < k){
+            left = mid + 1;
+        }
+        else if(nums[mid] > k){
+            right = mid - 1;
+        }
+        else{
+            if(mid > 0 && nums[mid-1] == k){
+                right = mid-1;  // 不断向左逼近
             }
             else{
-                if(mid > 0 && nums[mid-1] == k){
-                    right = mid-1;  // 不断向左逼近
-                }
-                else{
-                    return mid;
-                }
+                return mid;
             }
         }
-        return -1;
     }
+    return -1;
+}
+```
 
 找到最后一次出现位置的代码，只需要在 mid == k 时稍作处理即可。
 
-    if(mid+1 < length && nums[mid+1] == k){
-        left = mid+1;
-    }
+```c++
+if(mid+1 < length && nums[mid+1] == k){
+    left = mid+1;
+}
+```
 
 Leetcode 上面有一个类似的题目，找出目标数字的最先和最后出现：[34 Search for a Range](https://leetcode.com/problems/search-for-a-range/)
 
-## 2 旋转数组的最小数字
+## 旋转数组的最小数字
 
 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个**非递减序列**的一个旋转，输出旋转数组的最小元素。例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。
 
@@ -110,45 +118,82 @@ Leetcode 上面有一个类似的题目，找出目标数字的最先和最后
 
 判断出 mid 的位置后，需要恰当地去更新 left，right 的值，更新策略的选择将会直接决定 while 循环结束条件。这里我们让 left 位于旋转数组的左半部分，right位于右半部分，循环条件为 left < right。对于left 的更新每次多向右多移动一个位置：mid+1，right 每次更新为 mid，这样当循环终止时，left和right值相同，并且left指向了最小的数字。
 
-    int findMin(vector<int>& nums) {
-        int left = 0;
-        int right = nums.size()-1;
-
-        while(left<right){
-            // When there is no rotate, just return self.nums[start]
-            if(nums[left]<nums[right])  return nums[left];
-            int mid = left + (right-left) / 2;
-            if(nums[left] <= nums[mid]){
-                left = mid+1;
-            }
-            else{
-                right = mid;
-            }
+```c++
+int findMin(vector<int>& nums) {
+    int left = 0;
+    int right = nums.size()-1;
+
+    while(left<right){
+        // When there is no rotate, just return self.nums[start]
+        if(nums[left]<nums[right])  return nums[left];
+        int mid = left + (right-left) / 2;
+        if(nums[left] <= nums[mid]){
+            left = mid+1;
+        }
+        else{
+            right = mid;
         }
-        return nums[left];
     }
+    return nums[left];
+}
+```
 
 如果数组中有重复的数字，那么情况稍微有点复杂，当nums[mid] == nums[left] 时，我们没法判断 mid 在哪一边，因此选择对 left 进行简单的 +1 操作。
 
-    int findMin(vector<int>& nums) {
-        int left=0;
-        int right=nums.size()-1;
-        while(left<right){
-            if(nums[left] < nums[right])   return nums[left];
+```c++
+int findMin(vector<int>& nums) {
+    int left=0;
+    int right=nums.size()-1;
+    while(left<right){
+        if(nums[left] < nums[right])   return nums[left];
+        int mid = left + (right-left)/2;
+        if(nums[left] < nums[mid]){
+            left = mid+1;
+        }
+        else if(nums[left] > nums[mid]){
+            right = mid;
+        }
+        else{
+            left += 1;
+        }
+    }
+    return nums[left];
+}
+```
+
+简单思路，先用二分查找算法找到一个 target，由于 target 可能出现多次，于是在找到的位置向左右顺序扫描，分别找出第一个和最后一个 target。最差情况下，扫描的时间复杂度能达到O(n)。因此这种方法和从头到尾扫描整个数组统计出现的次数的方法是一样的，效率不够高。
+
+因此可以考虑用二分查找直接找出重复出现的数字的第一个位置和最后一个位置。找出数字第一次出现位置的实现如下，保证了最坏情况下时间复杂度仍然为 O(logn)：
+
+    // 在 nums[begin, end) 中查找 target
+    int getFirstK(int nums[], int length, int k){
+        int left = 0;
+        int right = length-1;
+        while(left<=right){
             int mid = left + (right-left)/2;
-            if(nums[left] < nums[mid]){
-                left = mid+1;
+            if(nums[mid] < k){
+                left = mid + 1;
             }
-            else if(nums[left] > nums[mid]){
-                right = mid;
+            else if(nums[mid] > k){
+                right = mid - 1;
             }
             else{
-                left += 1;
+                if(mid > 0 && nums[mid-1] == k){
+                    right = mid-1;  // 不断向左逼近
+                }
+                else{
+                    return mid;
+                }
             }
         }
-        return nums[left];
+        return -1;
     }
 
+找到最后一次出现位置的代码，只需要在 mid == k 时稍作处理即可。
+
+    if(mid+1 < length && nums[mid+1] == k){
+        left = mid+1;
+    }
 
 ## [74 Search a 2D Matrix](https://leetcode.com/problems/search-a-2d-matrix/)
 
@@ -160,10 +205,10 @@ Leetcode 上面有一个类似的题目，找出目标数字的最先和最后
 
 将二维数组看做是排好序的一维数组，然后按照一般的二分查找即可。注意left,right 开始值分别为 0, rows*cols-1，mid 的坐标为 (mid/cols, mid%cols)。
 
-[具体实现](https://github.com/xuelangZF/LeetCode/blob/master/BinarySearch/74_Search2DMatrix.py)
+[具体代码](https://github.com/xuelangZF/LeetCode/blob/master/BinarySearch/74_Search2DMatrix.py)
 
+# 更多阅读  
 
-# 参考  
 [Binary search algorithm](https://en.wikipedia.org/wiki/Binary_search_algorithm)  
 [数据库中二分查找相关问题](http://hedengcheng.com/?p=595)  
 

DynamicProgramming/README.md

@@ -107,5 +107,5 @@
 [Dynamic Programming：From Novice to Advanced](https://www.topcoder.com/community/data-science/data-science-tutorials/dynamic-programming-from-novice-to-advanced/)  
 [什么是动态规划？动态规划的意义是什么？](https://www.zhihu.com/question/23995189/answer/35429905)   
 [动态规划与状态机：最大子序列和问题的扩展](http://liam0205.me/2016/05/13/dynamic-programming-and-state-machine/)  
-
+[hiho一下第113周《Fibonacci》题目分析](http://hihocoder.com/discuss/question/3634)