Fixed space complexities

Author: Мето Трајковски

Diff for: Arrays/kth_smallest.py

@@ -16,7 +16,7 @@
 This solution is based on the quick sort algorithm (pivoting, divide and conquer).
 More precisly in-place quick sort. Recursive solution.
    Time Complexity:     O(N)    , O(N + N/2 + N/4 + N/8 + ... + 1 = 2*N = N)
-   Space Complexity:    O(LogN) , because of the recursion stack (if this doesn't count, then O(1))
+   Space Complexity:    O(LogN) , because of the recursion stack
 Completely the same algorithm as the previous one, but without recursion. This solution is cleaner.
     Time Complexity:    O(N)
     Space Complexity:   O(1)

Diff for: Arrays/reverse_array.py

@@ -8,7 +8,7 @@
 
 =========================================
 Reverse the whole array by swapping pair letters in-place (first with last, second with second from the end, etc).
-Exist 2 more "Pythonic" ways of reversing arrays/strings:
+Exist 2 more "Pythonic" ways of reversing arrays/strings (but not in-place, they're creating a new list):
 - reversed_arr = reversed(arr)
 - reversed_arr = arr[::-1]
 But I wanted to show how to implement a reverse algorithm step by step so someone will know how to implement it in other languages.

Diff for: Linked Lists/remove_nth_ll.py

@@ -12,7 +12,7 @@
     Space Complexity:   O(1)
 Recursive solution.
     Time Complexity:    O(N)
-    Space Complexity:   O(N)  (Because of the stack of recursive calls)
+    Space Complexity:   O(N)  , because of the recursive calls stack
 '''
 
 

Diff for: Math/unique_paths.py

@@ -45,7 +45,7 @@ def unique_paths(n, m):
         comb /= i
         lvl -= 1
 
-    return int(comb + 0.001) # 0.001 just in case because of overflow
+    return int(comb + 0.001) # 0.001 just in case, because of overflow
 
 
 ###########

Diff for: Other/find_min_path.py

@@ -38,11 +38,7 @@ def find_min_path(board, start, end):
     m = len(board[0])
 
     # create a visited array
-    visited = []
-    for row in range(n):
-        visited.append([])
-        for el in range(m):
-            visited[row].append(False)
+    visited = [[False for el in range(m)] for row in range(n)]
 
     queue = deque()
     queue.append((start, 0))

Diff for: Other/generate_parentheses.py

@@ -4,7 +4,7 @@
 Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.
 
 Input: 3
-Output: 
+Output:
         [
             '((()))',
             '(()())',
@@ -16,7 +16,7 @@
 =========================================
 This problem could be solved in several ways (using stack, queue, or just a simple list - see letter_combinations.py), all of them have the same complexity.
 I'll solve it using simple recursive algorithm.
-    Time Complexity:    O(4^N)      , O(2^(2*N)) = O(2^N)
+    Time Complexity:    O(4^N)      , O(2^(2*N)) = O(4^N)
     Space Complexity:   O(4^N)
 '''
 

Diff for: Other/power.py

@@ -6,7 +6,7 @@
 =========================================
 Using divide and conquer approach.
     Time Complexity:    O(LogB)
-    Space Complexity:   O(LogB)     , because of recursion call stack
+    Space Complexity:   O(LogB)     , because of recursion calls stack
 '''
 
 ############

Diff for: Other/river_sizes.py

@@ -21,7 +21,7 @@
 This problem can be solved using DFS or BFS.
 If 1 is found, find all horizontal or vertical neighbours (1s), and mark them as 0.
     Time Complexity:    O(N*M)
-    Space Complexity:   O(R)        , R = num of rivers
+    Space Complexity:   O(N*M)     , because of recursion calls stack
 '''
 
 

Diff for: Strings/zigzag_conversion.py

@@ -15,7 +15,7 @@
 Go row by row and using the steps logic build the new string by jumping chars.
 Middle rows have 2 times more elements than the first and last row.
     Time Complexity:    O(N)
-    Space Complexity:   O(1)
+    Space Complexity:   O(N)
 '''
 
 

Diff for: Trees/unival_trees.py

@@ -17,7 +17,7 @@
 =========================================
 Simple tree traversal solution.
     Time Complexity:    O(N)
-    Space Complexity:   O(1)
+    Space Complexity:   O(N)    , because of the recursion stack (but this is if the tree is one branch), O(LogN) if the tree is balanced.
 '''