From 8e6d06327056ba1e42a7be81674ef7ccd09a9628 Mon Sep 17 00:00:00 2001
From: Ofer Baharav <oferbaharav@gmail.com>
Date: Sat, 19 Sep 2020 16:46:37 -0700
Subject: [PATCH 1/3] Assignment Module 1 for Sprint 2

---
 singly_linked_list/singly_linked_list.py | 61 ++++++++++++++++++++++++
 stack/singly_linked_list.py              | 61 ++++++++++++++++++++++++
 stack/stack.py                           | 19 ++++++--
 stack/test_stack.py                      |  2 +-
 4 files changed, 138 insertions(+), 5 deletions(-)
 create mode 100644 stack/singly_linked_list.py

diff --git a/singly_linked_list/singly_linked_list.py b/singly_linked_list/singly_linked_list.py
index e69de29bb2..d502465936 100644
--- a/singly_linked_list/singly_linked_list.py
+++ b/singly_linked_list/singly_linked_list.py
@@ -0,0 +1,61 @@
+class Node:
+    def __init__(self, value):
+        self.value = value
+        self.next_node = None
+
+    def __str__(self):
+        return f"value = {self.value} next_node = {self.next_node}"
+
+class LinkedList:
+    def __init__(self):
+        self.tail = None
+        self.head = None
+
+    def __str__(self):
+        return f"head={self.head} tail={self.tail}"
+
+    def add_to_tail(self, value):
+        node = Node(value)
+        if self.tail == None:
+            self.head = node
+        else:
+            self.tail.next_node = node
+
+        self.tail = node
+
+
+    def remove_head(self):
+        if self.head == None:
+            return None
+
+        node = self.head
+        self.head = self.head.next_node
+        if self.head == None:
+            self.tail = None
+             
+        return node.value
+
+    def remove_tail(self):
+        if self.tail == None:
+            return None
+
+        value = self.tail.value
+        if self.head == self.tail:
+            self.head = None
+            self.tail = None
+            return value
+        
+        node = self.head
+        while node.next_node != self.tail:
+            node = node.next_node
+
+        self.tail = node
+        self.tail.next_node = None
+        
+        return value
+    
+
+
+    
+
+    
\ No newline at end of file
diff --git a/stack/singly_linked_list.py b/stack/singly_linked_list.py
new file mode 100644
index 0000000000..d502465936
--- /dev/null
+++ b/stack/singly_linked_list.py
@@ -0,0 +1,61 @@
+class Node:
+    def __init__(self, value):
+        self.value = value
+        self.next_node = None
+
+    def __str__(self):
+        return f"value = {self.value} next_node = {self.next_node}"
+
+class LinkedList:
+    def __init__(self):
+        self.tail = None
+        self.head = None
+
+    def __str__(self):
+        return f"head={self.head} tail={self.tail}"
+
+    def add_to_tail(self, value):
+        node = Node(value)
+        if self.tail == None:
+            self.head = node
+        else:
+            self.tail.next_node = node
+
+        self.tail = node
+
+
+    def remove_head(self):
+        if self.head == None:
+            return None
+
+        node = self.head
+        self.head = self.head.next_node
+        if self.head == None:
+            self.tail = None
+             
+        return node.value
+
+    def remove_tail(self):
+        if self.tail == None:
+            return None
+
+        value = self.tail.value
+        if self.head == self.tail:
+            self.head = None
+            self.tail = None
+            return value
+        
+        node = self.head
+        while node.next_node != self.tail:
+            node = node.next_node
+
+        self.tail = node
+        self.tail.next_node = None
+        
+        return value
+    
+
+
+    
+
+    
\ No newline at end of file
diff --git a/stack/stack.py b/stack/stack.py
index 6e6d660ac7..6a9fcf1280 100644
--- a/stack/stack.py
+++ b/stack/stack.py
@@ -10,16 +10,27 @@
 3. What is the difference between using an array vs. a linked list when 
    implementing a Stack?
 """
+from singly_linked_list import LinkedList
+
 class Stack:
     def __init__(self):
         self.size = 0
-        # self.storage = ?
+        self.storage = LinkedList()
 
     def __len__(self):
-        pass
+        return self.size
 
     def push(self, value):
-        pass
+        self.storage.add_to_tail(value)
+        self.size+=1 
+        return value
 
     def pop(self):
-        pass
+        if self.size == 0:
+            return None
+        self.size-=1
+        return self.storage.remove_tail()
+
+#3. The difference between using an array and using a stack is:
+#in array you append and pop
+#in linked lists you use add_to_tail and remove_tail
\ No newline at end of file
diff --git a/stack/test_stack.py b/stack/test_stack.py
index 0d79509d76..ded40a82d8 100644
--- a/stack/test_stack.py
+++ b/stack/test_stack.py
@@ -14,7 +14,7 @@ def test_len_returns_correct_length_after_push(self):
         self.assertEqual(len(self.stack), 1)
         self.stack.push(4)
         self.assertEqual(len(self.stack), 2)
-        self.stack.push(6)
+        self.stack.push(6)  
         self.stack.push(8)
         self.stack.push(10)
         self.stack.push(12)

From c8f58a8964f1a6fb5a7d74a013d28df234f8febe Mon Sep 17 00:00:00 2001
From: Ofer Baharav <oferbaharav@gmail.com>
Date: Sat, 19 Sep 2020 20:21:02 -0700
Subject: [PATCH 2/3] second part of the first module assignmentfor sprint 2

---
 queue/queue.py              | 15 +++++++++
 queue/singly_linked_list.py | 61 +++++++++++++++++++++++++++++++++++++
 2 files changed, 76 insertions(+)
 create mode 100644 queue/singly_linked_list.py

diff --git a/queue/queue.py b/queue/queue.py
index 0d2599ded7..80d98d75e5 100644
--- a/queue/queue.py
+++ b/queue/queue.py
@@ -13,16 +13,31 @@
 Stretch: What if you could only use instances of your Stack class to implement the Queue?
          What would that look like? How many Stacks would you need? Try it!
 """
+from singly_linked_list import LinkedList  
+
 class Queue:
     def __init__(self):
         self.size = 0
         # self.storage = ?
+        self.storage = LinkedList()
     
     def __len__(self):
         pass
+        return self.size
 
     def enqueue(self, value):
         pass
+        self.storage.add_to_tail(value)
+        self.size +=1 
+            
 
     def dequeue(self):
         pass
+        if self.size == 0:
+            return None
+        value = self.storage.remove_head()
+        self.size -=1
+        return value
+        
+#3. instead of using append and pop(0) on python lists
+# I'm using add_to_tail and remove_head on linked LinkedListTests
diff --git a/queue/singly_linked_list.py b/queue/singly_linked_list.py
new file mode 100644
index 0000000000..d502465936
--- /dev/null
+++ b/queue/singly_linked_list.py
@@ -0,0 +1,61 @@
+class Node:
+    def __init__(self, value):
+        self.value = value
+        self.next_node = None
+
+    def __str__(self):
+        return f"value = {self.value} next_node = {self.next_node}"
+
+class LinkedList:
+    def __init__(self):
+        self.tail = None
+        self.head = None
+
+    def __str__(self):
+        return f"head={self.head} tail={self.tail}"
+
+    def add_to_tail(self, value):
+        node = Node(value)
+        if self.tail == None:
+            self.head = node
+        else:
+            self.tail.next_node = node
+
+        self.tail = node
+
+
+    def remove_head(self):
+        if self.head == None:
+            return None
+
+        node = self.head
+        self.head = self.head.next_node
+        if self.head == None:
+            self.tail = None
+             
+        return node.value
+
+    def remove_tail(self):
+        if self.tail == None:
+            return None
+
+        value = self.tail.value
+        if self.head == self.tail:
+            self.head = None
+            self.tail = None
+            return value
+        
+        node = self.head
+        while node.next_node != self.tail:
+            node = node.next_node
+
+        self.tail = node
+        self.tail.next_node = None
+        
+        return value
+    
+
+
+    
+
+    
\ No newline at end of file

From 696fc534f391f13ab108903c433405064c918d02 Mon Sep 17 00:00:00 2001
From: Ofer Baharav <oferbaharav@gmail.com>
Date: Sun, 20 Sep 2020 18:49:11 -0700
Subject: [PATCH 3/3] Module 2 Sprint 2

---
 doubly_linked_list/doubly_linked_list.py | 88 ++++++++++++++++++++++--
 stack/stack.py                           |  2 +-
 2 files changed, 85 insertions(+), 5 deletions(-)

diff --git a/doubly_linked_list/doubly_linked_list.py b/doubly_linked_list/doubly_linked_list.py
index 6f91b43a9b..dd55387d19 100644
--- a/doubly_linked_list/doubly_linked_list.py
+++ b/doubly_linked_list/doubly_linked_list.py
@@ -28,6 +28,16 @@ def __len__(self):
     """
     def add_to_head(self, value):
         pass
+        self.length +=1
+        node =  ListNode(value)
+        if self.head == None:
+            self.head = node
+            self.tail = node 
+        else:
+            node.next = self.head
+            self.head.prev = node
+            self.head = node
+        
         
     """
     Removes the List's current head node, making the
@@ -36,7 +46,16 @@ def add_to_head(self, value):
     """
     def remove_from_head(self):
         pass
-            
+        if self.head == None:
+            return None
+        node = self.head
+        self.length -=1 
+        self.head = node.next
+        if self.head == None:
+            self.tail = None
+        else:
+            self.head.prev = None
+        return node.value   
     """
     Wraps the given value in a ListNode and inserts it 
     as the new tail of the list. Don't forget to handle 
@@ -44,6 +63,15 @@ def remove_from_head(self):
     """
     def add_to_tail(self, value):
         pass
+        self.length +=1
+        node =  ListNode(value)
+        if self.tail == None:
+            self.head = node
+            self.tail = node 
+        else:
+            node.prev = self.tail
+            self.tail.next = node 
+            self.tail = node
             
     """
     Removes the List's current tail node, making the 
@@ -52,20 +80,56 @@ def add_to_tail(self, value):
     """
     def remove_from_tail(self):
         pass
-            
+        if self.tail == None:
+            return None
+        node = self.tail
+        self.length -=1
+        self.tail = node.prev
+        print("Quote Tail", self.tail)
+        if self.tail == None:
+            self.head = None
+        else:
+            self.tail.next = None
+        return node.value
+
+   
     """
     Removes the input node from its current spot in the 
     List and inserts it as the new head node of the List.
     """
     def move_to_front(self, node):
         pass
-        
+    #disloging code:
+        if node.prev != None:
+            node.prev.next = node.next
+        if node.next != None:
+            node.next.prev = node.prev 
+        if self.tail == node:
+            self.tail = node.prev
+
+        node.next = self.head
+        self.head.prev = node
+        self.head = node
+
+
     """
     Removes the input node from its current spot in the 
     List and inserts it as the new tail node of the List.
     """
     def move_to_end(self, node):
         pass
+    #disloging code:
+        if node.prev != None:
+            node.prev.next = node.next
+        if node.next != None:
+            node.next.prev = node.prev 
+        if self.head == node:
+            self.head = node.next
+        node.next = None
+        node.prev = self.tail
+        self.tail.next = node
+        self.tail = node
+        
 
     """
     Deletes the input node from the List, preserving the 
@@ -73,10 +137,26 @@ def move_to_end(self, node):
     """
     def delete(self, node):
         pass
+        self.length -= 1
 
+        if node.prev != None:
+            node.prev.next = node.next
+        if node.next != None:
+            node.next.prev = node.prev 
+        if self.head == node:
+            self.head = node.next
+        if self.tail == node:
+            self.tail = node.prev
     """
     Finds and returns the maximum value of all the nodes 
     in the List.
     """
     def get_max(self):
-        pass
\ No newline at end of file
+        pass
+        max_value = self.head.value
+        node = self.head
+        while node != None:
+            if node.value > max_value:
+                max_value = node.value
+            node = node.next
+        return max_value
diff --git a/stack/stack.py b/stack/stack.py
index 6a9fcf1280..2dd773a678 100644
--- a/stack/stack.py
+++ b/stack/stack.py
@@ -23,7 +23,7 @@ def __len__(self):
     def push(self, value):
         self.storage.add_to_tail(value)
         self.size+=1 
-        return value
+        
 
     def pop(self):
         if self.size == 0: