GitBook: [master] 4 pages modified

Author: just4once

README.md

@@ -8,10 +8,6 @@ To clone the repo
 git clone https://github.com/just4once/leetcode.git
 ```
 
-{% hint style="success" %}
-Success.
-{% endhint %}
-
 To clone the repo with username
 
 ```

leetcode/divide-and-conquer/169-majority-element.md

@@ -24,12 +24,84 @@ Output: 2
 
 ## Thought Process {#thought-process}
 
-1. asd
+1. Sorting
+   1. Time complexity O\(nlogn\)
+   2. Space complexity O\(1\)
+2. HashMap
+   1. Time complexity O\(n\)
+   2. Space complexity O\(n\)
+3. Divide and Conquer
+   1. 
+4. Boyer-Moore Voting Algorithm
+   1. O\(n\)
 
 ## Solution
 
 ```java
+class Solution {
+    public int majorityElement(int[] nums) {
+        Arrays.sort(nums);
+        return nums[nums.length/2];
+    }
+}
+```
+
+```java
+class Solution {
+    public int majorityElement(int[] nums) {
+        int major = 0, count = 0;
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int num : nums) map.put(num, map.getOrDefault(num, 0) + 1);
+        for (int key : map.keySet()) {
+            if (map.get(key) > count) {
+                count = map.get(key);
+                major = key;
+            }
+        }
+        return major;
+    }
+}
+```
 
+```java
+class Solution {
+    public int majorityElement(int[] nums) {
+        return getMajor(nums, 0, nums.length - 1);
+    }
+    
+    private int getMajor(int[] nums, int lo, int hi) {
+        if (lo == hi) return nums[lo];
+        int mi = lo + (hi - lo) / 2;
+        int left = getMajor(nums, lo, mi);
+        int right = getMajor(nums, mi + 1, hi);
+        if (left == right) return left;
+        int leftCount = countInRange(nums, left, lo, mi);
+        int rightCount = countInRange(nums, right, mi + 1, hi);
+        return leftCount > rightCount ? left : right;
+    }
+    
+    private int countInRange(int[] nums, int target, int lo, int hi) {
+        int count = 0;
+        for (int i = lo; i <= hi; i++) {
+            if (nums[i] == target) count++;
+        }
+        return count;
+    }
+}
+```
+
+```java
+class Solution {
+    public int majorityElement(int[] nums) {
+        int major = 0, count = 0;
+        for (int i = 0; i < nums.length; i++) {
+            if (count == 0) major = nums[i];
+            if (major == nums[i]) count++;
+            else count--;
+        }
+        return major;
+    }
+}
 ```
 
 ## Additional {#additional}

leetcode/divide-and-conquer/215-kth-largest-element-in-an-array.md

@@ -1,4 +1,88 @@
 # 215-kth-largest-element-in-an-array
 
+## Question {#question}
 
+[https://leetcode.com/problems/kth-largest-element-in-an-array/description/](https://leetcode.com/problems/kth-largest-element-in-an-array/description/)
+
+Find the **k** th largest element in an unsorted array. Note that it is the kth largest element in the sorted order, not the kth distinct element.
+
+**Example 1:**
+
+```text
+Input: [3,2,1,5,6,4] and k = 2
+Output: 5
+```
+
+**Example 2:**
+
+```text
+Input: [3,2,3,1,2,4,5,5,6] and k = 4
+Output: 4
+```
+
+**Note:**   
+You may assume k is always valid, 1 ≤ k ≤ array's length.
+
+## Thought Process {#thought-process}
+
+1. MinHeap
+   1. Use min heap to store up to K elements
+   2. Everytime, when the heap is full, we poll one out
+   3. At the end the process the Kth largest element in at the top
+   4. Time complexity O\(nlogk\)
+   5. Space complexity O\(K\)
+2. QuickSelect
+   1. Using quick select we can optimize the algorithm's complexity to be O\(n\)
+   2. Space complexity O\(1\)
+
+## Solution
+
+```java
+class Solution {
+    public int findKthLargest(int[] nums, int k) {
+        PriorityQueue<Integer> pq = new PriorityQueue<>();
+        for (int num : nums) {
+            pq.offer(num);
+            if (pq.size() > k) pq.poll();
+        }
+        return pq.peek();
+    }
+}
+```
+
+```java
+class Solution {
+    public int findKthLargest(int[] nums, int k) {
+        int lo = 0, hi = nums.length - 1;
+        k = nums.length - k;
+        while (lo < hi) {
+            int pivotId = quickSelect(nums, lo, hi);
+            if (pivotId == k) return nums[k];
+            else if (pivotId < k) lo = pivotId + 1;
+            else hi = pivotId - 1;
+        }
+        return nums[lo];
+    }
+    
+    private int quickSelect(int[] nums, int lo, int hi) {
+        int pivot = lo;
+        while (lo <= hi) {
+            while (lo <= hi && nums[lo] <= nums[pivot]) lo++;
+            while (lo <= hi && nums[hi] > nums[pivot]) hi--;
+            if (lo >= hi) break;
+            swap(nums, lo, hi);
+        }
+        swap(nums, pivot, hi);
+        return hi;
+    }
+    
+    private void swap(int[] nums, int i, int j) {
+        int tmp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = tmp;
+    }
+}
+```
+
+## Additional {#additional}
 

template/leetcode.md

@@ -4,6 +4,8 @@
 
 
 
+
+
 ## Thought Process {#thought-process}
 
 1. asd