Added a solution for reversing Linked Lists

Мето Трајковски · Мето Трајковски · commit 88c4e7e02cdb · 2019-11-16T00:52:52.000+01:00
diff --git a/Backtracking/jumping_numbers.py b/Backtracking/jumping_numbers.py
@@ -13,7 +13,7 @@
 Make a tree (DFS way/backtracking), for each next digit take the last digit, go up and down 
 (example: 123, last digit is 3, so next digit should be 2 or 4).
     Time Complexity:    O(9 * 2^(NumOfDigits(N) - 1))
-    Space Complexity:   O(1)
+    Space Complexity:   O(1)        , recursion stack will have depth 9 (but this can be considered as constant)
 '''
 
 
@@ -39,11 +39,11 @@ def jumping_num(num, x, result):
     last_digit = num % 10
     next_num = num * 10
 
-    # go down
+    # decrease the last digit by one
     if last_digit != 0:
         jumping_num(next_num + last_digit - 1, x, result)
     
-    # go up
+    # increase the last digit by one
     if last_digit != 9:
         jumping_num(next_num + last_digit + 1, x, result)
     
diff --git a/Linked Lists/reverse_ll.py b/Linked Lists/reverse_ll.py
@@ -0,0 +1,84 @@
+'''
+Reverse a linked list
+
+Reverse a linked list in one iteration without using additional space.
+
+Input: 1 -> 2 -> 3 -> 4
+Output: 4 -> 3 -> 2 -> 1
+
+=========================================
+Iterate LL and change the pointer of the current nodes to point to the previous nodes.
+    Time Complexity:    O(N)
+    Space Complexity:   O(1)
+Solution 2: Same approach using recursion.
+    Time Complexity:    O(N)
+    Space Complexity:   O(N)        , because of the recursion stack (the stack will be with N depth till the last node of the linked list is reached)
+
+'''
+
+
+############
+# Solution #
+############
+
+class ListNode:
+    def __init__(self, v, n=None):
+        self.val = v
+        self.next = n
+
+def reverse_ll(ll):
+    prev_node = None
+
+    while ll is not None:
+        # save the current node
+        current = ll
+        # go to the next node        
+        ll = ll.next
+
+        # change the pointer of the current node to point to the previous node
+        current.next = prev_node
+        # save the current node for the next iteration 
+        prev_node = current
+        
+    return prev_node
+
+##############
+# Solution 2 #
+##############
+
+def reverse_ll_2(ll):
+    return reverse(ll, None)
+
+def reverse(node, prev_node):
+    if node is None:
+        # the end of the ll is reached, return the previous node
+        # that'll be the first node in the reversed ll
+        return prev_node
+    
+    # send node.next as current node and node as previous node in the next step
+    result = reverse(node.next, node)
+    # change the pointer of the current node to point to the previous node
+    node.next = prev_node
+
+    return result
+
+
+###########
+# Testing #
+###########
+
+# Test 1
+# Correct result => 4 -> 3 -> 2 -> 1
+ll = ListNode(1, ListNode(2, ListNode(3, ListNode(4))))
+kk = reverse_ll(ll)
+while kk is not None:
+    print(kk.val)
+    kk = kk.next
+
+# Test 2
+# Correct result => 4 -> 3 -> 2 -> 1
+ll = ListNode(1, ListNode(2, ListNode(3, ListNode(4))))
+kk = reverse_ll_2(ll)
+while kk is not None:
+    print(kk.val)
+    kk = kk.next
diff --git a/README.md b/README.md
@@ -130,12 +130,13 @@ If the problems from [LeetCode](https://leetcode.com/) are not enough and you ne
 - [Topcoder](http://topcoder.com/)
 - [Project Euler](https://projecteuler.net/)
 - [Codility](https://codility.com/)
-- [Daily Coding Problem](https://www.dailycodingproblem.com/)
 - [CoderByte](https://coderbyte.com/)
 - [CodingBat](http://codingbat.com/)
 - [CodeAbbey](http://codeabbey.com/)
 - [Wolfram Challenges](https://challenges.wolfram.com/)
 - [CS Academy](https://csacademy.com/)
+- [Daily Coding Problem](https://www.dailycodingproblem.com/)
+- [Daily Interview Pro](http://dailyinterviewpro.com/)
 - [Codewars](http://www.codewars.com/)
 - [SPOJ](http://www.spoj.com/)
 - [Online Judge](https://onlinejudge.org/)
diff --git a/Trees/find_second_largest_node.py b/Trees/find_second_largest_node.py
@@ -6,7 +6,7 @@
 =========================================
 Traverse tree and compare the current value with the saved 2 values.
 	Time Complexity: 	O(N)
-	Space Complexity: 	O(1)
+	Space Complexity: 	O(LogN)        , because of the recursion stack (but this is if the tree is balanced), worst case O(N) if the tree is one branch.
 '''
 
 
diff --git a/Trees/find_second_largest_node_bst.py b/Trees/find_second_largest_node_bst.py
@@ -6,8 +6,8 @@
 =========================================
 There are 4 possible cases (see the details in the code). 
 Only 1 branch is searched to the end (leaf), not the whole tree.
-	Time Complexity: 	O(LogN)      , if balanced bst, worst case if all elements are in the right branch O(N)
-	Space Complexity: 	O(1)
+	Time Complexity: 	O(LogN)      , this is if the tree is balanced (balanced bst), but the worst case will be if all elements are in the one (the right) branch O(N)
+	Space Complexity: 	O(LogN)      , -||- but this is because of the recursion stack (LogN elements will be in the recursion stack till the leaf is reached)
 '''
 
 
