2019-05-19

Author: JiayangWu

0004.median-of-two-sorted-arrays/median-of-two-sorted-arrays.md

@@ -0,0 +1,23 @@
+<p>There are two sorted arrays <b>nums1</b> and <b>nums2</b> of size m and n respectively.</p>
+
+<p>Find the median of the two sorted arrays. The overall run time complexity should be O(log (m+n)).</p>
+
+<p>You may assume <strong>nums1</strong> and <strong>nums2</strong>&nbsp;cannot be both empty.</p>
+
+<p><b>Example 1:</b></p>
+
+<pre>
+nums1 = [1, 3]
+nums2 = [2]
+
+The median is 2.0
+</pre>
+
+<p><b>Example 2:</b></p>
+
+<pre>
+nums1 = [1, 2]
+nums2 = [3, 4]
+
+The median is (2 + 3)/2 = 2.5
+</pre>

0004.median-of-two-sorted-arrays/median-of-two-sorted-arrays.py

@@ -0,0 +1,57 @@
+from heapq import *
+class MedianFinder(object):
+# 维护两个堆，一个大顶堆，一个小顶堆，小顶堆里的数比大顶堆里的数都要大， 
+# 如果有两个潜在的中位数（两个堆size相同），数据流的中位数就是两个堆顶之和除以2
+# 如果只有一个中位数，就看size更小的那个堆的堆顶
+# 如果新进来的数比小顶堆的数要小，就把它插入大顶堆
+# 如果新进来的数比小顶堆的数要大，就把它插入小顶堆
+# 调整两个堆，使得size 差最大为1
+    def __init__(self):
+        """
+        initialize your data structure here.
+        """
+        self.max_h = list()
+        self.min_h = list()
+        heapify(self.max_h)
+        heapify(self.min_h)
+        
+
+    def addNum(self, num):
+        """
+        :type num: int
+        :rtype: None
+        """
+        heappush(self.min_h, num)
+        heappush(self.max_h, -heappop(self.min_h))
+        if len(self.max_h) > len(self.min_h):
+            heappush(self.min_h, -heappop(self.max_h))
+
+    def findMedian(self):
+        """
+        :rtype: float
+        """
+        max_len = len(self.max_h)
+        min_len = len(self.min_h)
+        if max_len == min_len: #有两个候选中位数
+            return (self.min_h[0] + -self.max_h[0]) / 2.
+        else:#小顶堆的size 一定 >= 大顶堆的size，所以答案就是小顶堆的堆顶
+            return self.min_h[0] / 1.
+            
+# Your MedianFinder object will be instantiated and called as such:
+# obj = MedianFinder()
+# obj.addNum(num)
+# param_2 = obj.findMedian()
+
+class Solution(object):
+    def findMedianSortedArrays(self, nums1, nums2):
+        """
+        :type nums1: List[int]
+        :type nums2: List[int]
+        :rtype: float
+        """
+        mf = MedianFinder()
+        for num in nums1:
+            mf.addNum(num)
+        for num in nums2:
+            mf.addNum(num)
+        return mf.findMedian()

0029.divide-two-integers/divide-two-integers.md

@@ -0,0 +1,25 @@
+<p>Given two integers <code>dividend</code> and <code>divisor</code>, divide two integers without using multiplication, division and mod operator.</p>
+
+<p>Return the quotient after dividing <code>dividend</code> by <code>divisor</code>.</p>
+
+<p>The integer division should truncate toward zero.</p>
+
+<p><strong>Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> dividend = 10, divisor = 3
+<strong>Output:</strong> 3</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> dividend = 7, divisor = -3
+<strong>Output:</strong> -2</pre>
+
+<p><strong>Note:</strong></p>
+
+<ul>
+	<li>Both dividend and divisor&nbsp;will be&nbsp;32-bit&nbsp;signed integers.</li>
+	<li>The divisor will never be 0.</li>
+	<li>Assume we are dealing with an environment which could only store integers within the 32-bit signed integer range: [&minus;2<sup>31</sup>, &nbsp;2<sup>31</sup> &minus; 1]. For the purpose of this problem, assume that your function returns 2<sup>31</sup> &minus; 1 when the division result&nbsp;overflows.</li>
+</ul>

0029.divide-two-integers/divide-two-integers.py

@@ -0,0 +1,31 @@
+class Solution(object):
+    def divide(self, dividend, divisor):
+        """
+        :type dividend: int
+        :type divisor: int
+        :rtype: int
+        """
+        # 计算被除数可以减去多少个除数：
+        op = 1
+        if (dividend > 0 and divisor < 0) or (dividend < 0 and divisor > 0):
+            op = -1
+        
+        dividend, divisor = abs(dividend), abs(divisor)
+        res = 0
+        # cnt = 1
+        while(dividend >= divisor):
+            multidivisor, multi = divisor, 1
+            while(dividend >= multidivisor):
+                res += multi
+                dividend -= multidivisor
+                multi = multi << 1
+                multidivisor = multidivisor <<1
+                print dividend, multidivisor, multi
+            print multi
+                
+            
+        INT_MIN = -(2 **31)
+        INT_MAX = 2 **31 - 1
+        res *= op
+        
+        return res if INT_MIN <= res <= INT_MAX else INT_MAX 

0295.find-median-from-data-stream/find-median-from-data-stream.md

@@ -0,0 +1,34 @@
+<p>Median is the middle value in an ordered integer list. If the size of the list is even, there is no middle value. So the median is the mean of the two middle value.</p>
+For example,
+
+<p><code>[2,3,4]</code>, the median is <code>3</code></p>
+
+<p><code>[2,3]</code>, the median is <code>(2 + 3) / 2 = 2.5</code></p>
+
+<p>Design a data structure that supports the following two operations:</p>
+
+<ul>
+	<li>void addNum(int num) - Add a integer number from the data stream to the data structure.</li>
+	<li>double findMedian() - Return the median of all elements so far.</li>
+</ul>
+
+<p>&nbsp;</p>
+
+<p><strong>Example:</strong></p>
+
+<pre>
+addNum(1)
+addNum(2)
+findMedian() -&gt; 1.5
+addNum(3) 
+findMedian() -&gt; 2
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>Follow up:</strong></p>
+
+<ol>
+	<li>If all integer numbers from the stream are between 0&nbsp;and 100, how would you optimize it?</li>
+	<li>If 99% of all integer numbers from the stream are between 0 and 100, how would you optimize it?</li>
+</ol>

0295.find-median-from-data-stream/find-median-from-data-stream.py

@@ -0,0 +1,45 @@
+from heapq import *
+class MedianFinder(object):
+# 维护两个堆，一个大顶堆，一个小顶堆，小顶堆里的数比大顶堆里的数都要大， 
+# 如果有两个潜在的中位数（两个堆size相同），数据流的中位数就是两个堆顶之和除以2
+# 如果只有一个中位数，就看size更小的那个堆的堆顶
+# 新进来的数都丢进小顶堆，然后把小顶堆的堆顶丢到大顶堆，
+# 调整两个堆，使得size 差最大为1
+    def __init__(self):
+        """
+        initialize your data structure here.
+        """
+        self.max_h = list()
+        self.min_h = list()
+        heapify(self.max_h)
+        heapify(self.min_h)
+        
+
+    def addNum(self, num):
+        """
+        :type num: int
+        :rtype: None
+        """
+        heappush(self.min_h, num)
+        heappush(self.max_h, -heappop(self.min_h))
+        if len(self.max_h) > len(self.min_h):
+            heappush(self.min_h, -heappop(self.max_h))
+
+    def findMedian(self):
+        """
+        :rtype: float
+        """
+        max_len = len(self.max_h)
+        min_len = len(self.min_h)
+        if max_len == min_len: #有两个候选中位数
+            return (self.min_h[0] + -self.max_h[0]) / 2.
+        else:#小顶堆的size 一定 >= 大顶堆的size，所以答案就是小顶堆的堆顶
+            return self.min_h[0] / 1.
+            
+        
+
+
+# Your MedianFinder object will be instantiated and called as such:
+# obj = MedianFinder()
+# obj.addNum(num)
+# param_2 = obj.findMedian()