add divede and conquer

Author: StephenLeeUSTC

src/solution/mod.rs

@@ -27,3 +27,5 @@ mod s0297_serialize_and_deserialize_binary_tree;
 mod s0461_hamming_distance;
 mod s0508_most_frequent_subtree_sum;
 mod s1035_uncrossed_lines;
+mod s0169_majority_element;
+mod s0153_find_minimum_in_rotated_sorted_array;

src/solution/s0153_find_minimum_in_rotated_sorted_array.rs

@@ -0,0 +1,77 @@
+/**
+ * [153] Find Minimum in Rotated Sorted Array
+ *
+ * Suppose an array of length n sorted in ascending order is rotated between 1 and n times. For example, the array nums = [0,1,2,4,5,6,7] might become:
+ * 
+ * 	[4,5,6,7,0,1,2] if it was rotated 4 times.
+ * 	[0,1,2,4,5,6,7] if it was rotated 7 times.
+ * 
+ * Notice that rotating an array [a[0], a[1], a[2], ..., a[n-1]] 1 time results in the array [a[n-1], a[0], a[1], a[2], ..., a[n-2]].
+ * Given the sorted rotated array nums of unique elements, return the minimum element of this array.
+ * You must write an algorithm that runs in O(log n) time.
+ *  
+ * Example 1:
+ * 
+ * Input: nums = [3,4,5,1,2]
+ * Output: 1
+ * Explanation: The original array was [1,2,3,4,5] rotated 3 times.
+ * 
+ * Example 2:
+ * 
+ * Input: nums = [4,5,6,7,0,1,2]
+ * Output: 0
+ * Explanation: The original array was [0,1,2,4,5,6,7] and it was rotated 4 times.
+ * 
+ * Example 3:
+ * 
+ * Input: nums = [11,13,15,17]
+ * Output: 11
+ * Explanation: The original array was [11,13,15,17] and it was rotated 4 times. 
+ * 
+ *  
+ * Constraints:
+ * 
+ * 	n == nums.length
+ * 	1 <= n <= 5000
+ * 	-5000 <= nums[i] <= 5000
+ * 	All the integers of nums are unique.
+ * 	nums is sorted and rotated between 1 and n times.
+ * 
+ */
+pub struct Solution {}
+
+// problem: https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/
+// discuss: https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+impl Solution {
+    pub fn find_min(nums: Vec<i32>) -> i32 {
+        let mut left = 0;
+        let mut right = nums.len() - 1;
+        let mut mid = 0;
+
+        while (left < right) {
+            mid = (right - left) / 2 + left;
+
+            if (nums[mid] < nums[right]) {
+                right = mid;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return nums[left];
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_153() {
+        assert_eq!(Solution::find_min(vec![1, 2, 3, 0]), 0);
+    }
+}

src/solution/s0169_majority_element.rs

@@ -0,0 +1,59 @@
+
+/**
+ * [169] Majority Element
+ *
+ * Given an array nums of size n, return the majority element.
+ * The majority element is the element that appears more than ⌊n / 2⌋ times. You may assume that the majority element always exists in the array.
+ *  
+ * Example 1:
+ * Input: nums = [3,2,3]
+ * Output: 3
+ * Example 2:
+ * Input: nums = [2,2,1,1,1,2,2]
+ * Output: 2
+ *  
+ * Constraints:
+ * 
+ * 	n == nums.length
+ * 	1 <= n <= 5 * 10^4
+ * 	-2^31 <= nums[i] <= 2^31 - 1
+ * 
+ *  
+ * Follow-up: Could you solve the problem in linear time and in O(1) space?
+ */
+pub struct Solution {}
+
+// problem: https://leetcode.com/problems/majority-element/
+// discuss: https://leetcode.com/problems/majority-element/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn majority_element(nums: Vec<i32>) -> i32 {
+        let target = nums.len() / 2;
+        let mut h = HashMap::new();
+        for e in nums.iter() {
+            let count = h.entry(e).or_insert(0);
+            *count += 1;
+            if *count > target {
+                return *e;
+            }
+        }
+        return 0;
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_169() {
+        assert_eq!(Solution::majority_element(vec![2,2,1,1,1,2,2]), 2);
+        assert_eq!(Solution::majority_element(vec![2,2,3]), 2);
+    }
+}