Fix some typos

Author: enginebai

leetcode/15.3sum.md

@@ -42,7 +42,7 @@ fun threeSum(nums: IntArray): List<List<Int>> {
             } 
 
             // Two sum is less than target, means negative number is too negative, move forward left pointer to "smaller" negative number
-            if (nums[left] + nums[right] < target) {
+            else if (nums[left] + nums[right] < target) {
                 left++
             } else {
                 right--

leetcode/264.ugly-number-ii.md

@@ -4,7 +4,7 @@ What's the next number? It would be the smallest number **all the previously exi
 
 We assume there is one number shown, which is `1`, the next number is `min(2 * 1, 3 * 1, 5 * 1) && not shown before`, that is 2, and you can think that comes from `min(2 * dp[1], 3 * dp[1], 5 * dp[1])`.
 
-Again, what's the next number? now we only need to consider `min(2 * 2, 3 * 1, 5 * 1)`, that would be `min(2 * dp[2], 3 * dp[1], 5 * dp[1])`, that means we have three pointers (for 2, 3, 5 respectively) points to the previous existing number, then we move the pointer if we use that in the round.
+Again, what's the next number? Now we only need to consider `min(2 * 2, 3 * 1, 5 * 1)`, that would be `min(2 * dp[2], 3 * dp[1], 5 * dp[1])`, that means we have three pointers (for 2, 3, 5 respectively) points to the previous existing number, then we move the pointer if we use that in the round.
 
 ```js
 n=1, dp[1] = 1 // base case
@@ -51,33 +51,27 @@ fun nthUglyNumber(n: Int): Int {
 * **Space Complexity**: `O(n)`.
 
 ### Heap
-
 We maintain a min heap and add `2x`, `3x` and `5x` into heap (make sure avoiding duplicate), the result will be the peek.
 
 ```kotlin
 fun nthUglyNumber(n: Int): Int {
-    val factors = intArrayOf(2, 3, 5)
+    val factors = listOf(2L, 3L, 5L)
     val minHeap = PriorityQueue<Long>()
     val seen = hashSetOf<Long>()
-
-    fun checkAndAdd(peek: Long) {
+    var number = 1L
+    minHeap.add(number)
+    seen.add(number)
+    for (i in 0 until n) {
+        number = minHeap.poll()
         factors.forEach { factor ->
-            val newValue = (peek * factor).toLong()
-            if (!seen.contains(newValue)) {
-                minHeap.add(newValue)
-                seen.add(newValue)
+            val next = factor * number
+            if (!seen.contains(next)) {
+                minHeap.add(next)
+                seen.add(next)
             }
         }
     }
-
-    var result = 1
-    minHeap.add(1)
-    for (i in 2..n) {
-        val peek = minHeap.poll()
-        checkAndAdd(peek)
-        result = minHeap.peek().toInt()
-    }
-    return result
+    return number.toInt()
 }
 ```
 

leetcode/33.search-in-rotated-sorted-array.md

@@ -2,7 +2,7 @@
 
 We have to solve with `O(lg n)` time complexity, so we will start from binary search, but we have to decide the left or right part to search for next round, and since the array might be rotated, it won't be sorted for both left and right part, we have modify some logic here:
 
-In each round of binary search, we will split the `array[start..end]` into two parts: `[start..middle - 1]` and  `[middle + 1..end]` and the key point here is that **one of the two parts will be sorted, we have to find the sorted part (the starting value <= the ending value of that part) and we have to check if the target is in that sorted part, if yes, just search that part, otherwise, search another part.
+In each round of binary search, we will split the `array[start..end]` into two parts: `[start..middle - 1]` and  `[middle + 1..end]` and the key point here is that **one of the two parts will be sorted**, we have to find the sorted part (the starting value <= the ending value of that part) and we have to check if the target is in that sorted part, if yes, just search that part, otherwise, search another part.
 
 For example, nums = `[6, 7, 0, 1, 2, 5]`, target = 3:
 * The `middle` = 1, left part = `[6, 7, 0]`, right part = `[2, 5]`.
@@ -12,26 +12,22 @@ For example, nums = `[6, 7, 0, 1, 2, 5]`, target = 3:
 
 ```kotlin
 fun search(nums: IntArray, target: Int): Int {
-    return binarySearch(nums, target, 0, nums.size - 1)
-}
-
-private fun binarySearch(nums: IntArray, target: Int, start: Int, end: Int): Int {
-    if (start > end) return -1
-    
-    val middle = start + (end - start) / 2
-    if (target == nums[middle]) return middle
-    
-    // Left part is sorted
-    if (nums[start] <= nums[middle]) {
-        // The target is within this part
-        if (target in nums[start]..nums[middle]) return binarySearch(nums, target, start, middle - 1)
-        // Otherwise, we search another part.
-        else return binarySearch(nums, target, middle + 1, end)
-    }
-    // Right part is sorted
-    if (nums[middle] <= nums[end]) {
-        if (target in nums[middle]..nums[end]) return binarySearch(nums, target, middle + 1, end)
-        else return binarySearch(nums, target, start, middle - 1)
+    var left = 0
+    var right = nums.size - 1
+    while (left <= right) {
+        val middle = left + (right - left) / 2
+        if (target == nums[middle]) return middle
+        else if (nums[left] <= nums[middle]) {
+            if (target in nums[left]..nums[middle])
+                right = middle - 1
+            else 
+                left = middle + 1
+        } else {
+            if (target in nums[middle]..nums[right])
+                left = middle + 1
+            else
+                right = middle - 1
+        }
     }
     return -1
 }

leetcode/622.design-circular-queue.md

@@ -11,6 +11,9 @@ class MyCircularQueue(k: Int) {
     fun enQueue(value: Int): Boolean {
         if (isFull()) return false
         rear = (rear + 1) % arrays.size
+        // Or we can rotate the pointer to the beginning
+        // rear++
+        // if (rear >= k) rear = 0
         arrays[rear] = value
         size++
         return true
@@ -19,6 +22,9 @@ class MyCircularQueue(k: Int) {
     fun deQueue(): Boolean {
         if (isEmpty()) return false
         front = (front + 1) % arrays.size
+        // Or we can rotate the pointer
+        // front++
+        // if (front >= k) front = 0
         size--
         return true
     }

leetcode/707.design-linked-list.md

@@ -173,4 +173,89 @@ class MyLinkedList() {
         previous?.next = current?.next
     }
 }
+```
+
+## With Sentinel
+```kotlin
+data class Node(
+    var value: Int,
+    var next: Node? = null
+)
+
+class MyLinkedList() {
+    
+    private var head: Node? = null
+
+    fun get(index: Int): Int {
+        var i = 0
+        var current: Node? = head
+        while (i < index) {
+            current = current?.next
+            i++
+        }
+        return current?.value ?: -1
+    }
+
+    fun addAtHead(`val`: Int) {
+        val newNode = Node(`val`, next = head)
+        head = newNode
+    }
+
+    fun addAtTail(`val`: Int) {
+        val sentinel = Node(-1, next = head)
+        var previous: Node? = sentinel
+        var current: Node? = head
+        while (current != null) {
+            previous = current
+            current = current.next
+        }
+        val newNode = Node(`val`, current)
+        previous?.next = newNode
+
+        // Remember to update the head
+        head = sentinel.next
+    }
+
+    fun addAtIndex(index: Int, `val`: Int) {
+        val sentinel = Node(-1, next = head)
+        var previous: Node? = sentinel
+        var current: Node? = head
+        var i = 0
+        while (i < index) {
+            previous = current
+            current = current?.next
+            i++
+        }
+        val newNode = Node(`val`, next = current)
+        previous?.next = newNode
+
+        // Remember to update the head
+        head = sentinel.next
+    }
+
+    fun deleteAtIndex(index: Int) {
+        val sentinel = Node(-1, next = head)
+        var previous: Node? = sentinel
+        var current: Node? = head
+        var i = 0
+        while (i < index) {
+            previous = current
+            current = current?.next
+            i++
+        }
+        previous?.next = current?.next
+        // Remember to update the head
+        head = sentinel.next
+    }
+}
+
+/**
+ * Your MyLinkedList object will be instantiated and called as such:
+ * var obj = MyLinkedList()
+ * var param_1 = obj.get(index)
+ * obj.addAtHead(`val`)
+ * obj.addAtTail(`val`)
+ * obj.addAtIndex(index,`val`)
+ * obj.deleteAtIndex(index)
+ */
 ```

topics/array.md

@@ -76,7 +76,7 @@ Comparison to Linked List, see [Linked List](../topics/linked-list.md) topic.
 * For in-place operation or `O(1)` space complexity, use array itself as a hash table. For example, the value of array ranges from 1 to `n`, where `n` is the size of array, then we can use the *index* to represent.
 
 ## Two Pointers Approach
-* Fast/slow (read/write) pointers: [283. Move Zeroes](../leetcode/283.move-zeros.md) (
+* Fast/slow (read/write) pointers: [283. Move Zeroes](../leetcode/283.move-zeros.md)
 * Left/right pointers: [977. Squares of a Sorted Array](../leetcode/977.squares-of-a-sorted-array.md)
 
 ## Sliding Window Approach

topics/graph.md

@@ -9,15 +9,6 @@ A graph `G = (V, E)`, consists of `V` (set of *vertices*) and `E` (*edges* of ve
 
 ![Graph](../media/graph.png)
 
-* G1: Undirected 
-    * V(G1) = {1, 2, 3, 4, 5, 6}
-    * E(G1) = {(1, 2), (1, 4), (1, 5), (1, 6), (2, 4), (3, 4), (3, 5), (3, 6)}
-* G2: Directed
-    * V(G2) = {1, 2, 3, 4, 5, 6}
-    * E(G2) = {(1, 2), (3, 4), (4, 5), (6, 1), (6, 3)}
-
-> V and E are set, the item in the set is unordered.
-
 ## Representation
 We can represent a graph `G = (V, E)` in adjacency list or matrix.
 
@@ -44,7 +35,7 @@ A1 = [
 * The vertices in each adjacency list are typically stored in a arbitrary order.
 * For both undirected and directed graph, the amount of memory is `Θ(|V| + |E|)` space complexity. (`|V| + |E|` for directed, `|V| + 2 * |E|` for undirected)
 * It takes `Ω(|V|)` time to determine if an edge `(x, y)` is in the graph. (Loop for each vertices takes `O(1)` and `O(|V|)` for searching the adjacent vertices of the vertex `x`)
-* We prefer adjacency matrix when the graph are *sparse*.
+* We prefer adjacency list when the graph are *sparse*.
 * We also can associate *weight* on the edge by storing the weight on the node of the adjacency list. (linked list node can attach extra properties)
 
 > |V| means the size of V.
@@ -91,6 +82,8 @@ S1 = {
 }
 ```
 
+> [Representation comparision](https://www.geeksforgeeks.org/comparison-between-adjacency-list-and-adjacency-matrix-representation-of-graph/)
+
 ## Breadth-first Search (BFS)
 Given a graph `G = (V, E)` (undirected or directed) and source `s`, we "discover" every vertex that is reachable from `s`. It visits all vertices at level `k` before visiting level `k + 1`. It computes the *distance* from `s` to each reachable vertex, and produces a *breadth-first tree* (shortest path) with root `s` with all reachable vertices.
 

topics/stack-queue.md

@@ -189,8 +189,8 @@ class LinkedListQueue<T>: Queue<T> {
         if (isEmpty()) return null
         val value = head?.data
         head = head?.next
-        if (isEmpty()) rear = null
         size--
+        if (isEmpty()) rear = null
         return value
     }
 
@@ -252,7 +252,8 @@ class DynamicArrayQueue<T>: Queue<T> {
 }
 ```
 
-> Verify if it's still true.
+> TODO: Verify if it's still true.
+
 There is a drawback from the above implementation, our size is limited even if we dequeue all elements (we move `head` to the end of array when dequeue, but won't start from 0 again). To solve this case, we introduce [*Circular Queue*](../leetcode/622.design-circular-queue.md).
 
 ## Tips for [Problem Solving](../problems/problems-solutions.md#stack--queue)