Linked lists Benchmark: updated

SilverSolver/assignment1/linked_list_speed_tests/Q2_variant_1.py

@@ -0,0 +1,45 @@
+class single_linked_node:
+    def __init__(self, value=None, child=None):
+        self.child = child
+        self.value = value
+
+def return_k_th_from_end_element(k, start_node):
+    list_len = 0
+    current_node = start_node
+    while (current_node):
+        list_len += 1
+        current_node = current_node.child
+    element_num = list_len - k
+    if element_num < 0 or element_num > list_len:
+        print("wrong k")
+        return None
+    else:
+        current_num  = 0
+        current_node = start_node
+        while(current_node):
+            current_num += 1
+            if current_num == element_num:
+                return current_node.value
+            current_node = current_node.child
+
+def from_iterable(iterable):
+    prev_node = single_linked_node(iterable[0], None)
+    for i in range(1, len(iterable)):
+        prev_node = single_linked_node(iterable[i], prev_node)
+    return prev_node
+
+
+if __name__ == "__main__":
+    # Demonstration of the functional
+    test_list = [single_linked_node(0, None)]
+    for i in range(1, 10):
+        test_list.append(single_linked_node(i, test_list[-1]))
+    print("we generated list 0 <- 1 <- 2 <- 3 <- 4 <- 5 <- 6 <- 7 <- 8 <- 9 for example")
+
+    current_node = test_list[-1] 
+    while (current_node):
+        current_node = current_node.child
+
+    print("choose k for testing return_k_th_from_end_element function")
+    k = int(input())
+    print(return_k_th_from_end_element(k, test_list[-1]))

SilverSolver/assignment1/linked_list_speed_tests/Q2_variant_2.py

@@ -0,0 +1,57 @@
+from collections import deque
+
+class single_linked_node:
+
+    def __init__(self, value=None, child=None):
+        self.child = child
+        self.value = value
+
+    def __getitem__(self, k, one_pass=True):
+        list_len = 0
+        visited_nodes = deque(maxlen=-k + 1)
+        current_node = self
+        while (current_node):
+            # if we want optimize by time and do one_pass through the
+            # linked list, we should keep k last visited nodes
+            if one_pass:
+                visited_nodes.append(current_node)                
+            list_len += 1
+            current_node = current_node.child
+        element_num = list_len + k
+        if element_num > list_len or element_num <= 0:
+            raise IndexError("Index '%s' is out of range, due the length of the list is '%s'"\
+                             % (-k, list_len))
+        else:
+            if one_pass:
+                return visited_nodes.popleft().value
+            else:
+                # if we didn't keep k last visited nodes, we will go
+                # through the linked list again
+                current_num  = 0
+                current_node = self
+                while(current_node):
+                    current_num += 1
+                    if current_num == element_num:
+                        return current_node.value
+                    current_node = current_node.child
+
+
+def from_iterable(iterable):
+    prev_node = single_linked_node(iterable[0], None)
+    for i in range(1, len(iterable)):
+        prev_node = single_linked_node(iterable[i], prev_node)
+    return prev_node
+
+def return_k_th_from_end_element(k, node):
+    return node[-k]
+
+
+if __name__ == "__main__":
+    # Demonstration of the functional
+
+    iterable = [i for i in range(10)]
+    example_list = from_iterable(iterable) 
+    print("we generated list 0 <- 1 <- 2 <- 3 <- 4 <- 5 <- 6 <- 7 <- 8 <- 9 for example")
+    print("choose k for testing return_k_th_from_end_element function")
+    k = int(input())
+    print(return_k_th_from_end_element(k, example_list))

SilverSolver/assignment1/linked_list_speed_tests/Q2_variant_3.py

@@ -0,0 +1,40 @@
+class single_linked_node:
+
+    def __init__(self, value=None, child=None):
+        self.child = child
+        self.value = value
+
+    def __getitem__(self, k):
+        current_pos = 0
+        k_th_back_node = self
+        current_node = self
+        while (current_node):
+            if current_pos > -k:
+                k_th_back_node = k_th_back_node.child
+            current_node = current_node.child
+            current_pos += 1
+        list_len = current_pos
+        if not k_th_back_node or -k >= list_len:
+            raise IndexError("Index '%s' is out of range, due the length of the list is '%s'"\
+                             % (-k, list_len))
+        return k_th_back_node.value
+
+def from_iterable(iterable):
+    prev_node = single_linked_node(iterable[0], None)
+    for i in range(1, len(iterable)):
+        prev_node = single_linked_node(iterable[i], prev_node)
+    return prev_node
+
+def return_k_th_from_end_element(k, node):
+    return node[-k]
+
+
+if __name__ == "__main__":
+    # Demonstration of the functional
+
+    iterable = [i for i in range(10)]
+    example_list = from_iterable(iterable) 
+    print("we generated list 0 <- 1 <- 2 <- 3 <- 4 <- 5 <- 6 <- 7 <- 8 <- 9 for example")
+    print("choose k for testing return_k_th_from_end_element function")
+    k = int(input())
+    print(return_k_th_from_end_element(k, example_list))