added env, tests for lists, started stacks & queue

Author: marcus-24

Diff for: .vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "python.pythonPath": "C:\\Users\\Marcus\\anaconda3\\envs\\dsa_env\\python.exe"
+}

Diff for: README.md

@@ -4,4 +4,4 @@ This repository serves as my live notes as I learn Data Structures and Algorithm
 # References
 
 1. https://www.codecademy.com/learn/learn-data-structures-and-algorithms-with-python
-
+2. https://medium.com/@Emmanuel.A/data-structure-queue-python-9e5439d2ceea

Diff for: environment.yml

@@ -0,0 +1,11 @@
+name: dsa_env
+channels:
+  - conda-forge
+  - defaults
+dependencies:
+  - pip
+  - python=3.10
+  - pylint
+  - pytest
+  - pip:
+    - -e .

Diff for: __init__.py renamed to mydsa/__init__.py

@@ -0,0 +1,122 @@
+# standard imports
+from typing import Any
+
+# local imports
+from mydsa.nodes import Node
+
+class DoublyLinkedList:
+
+    def __init__(self):
+        self._head_node: Node = None
+        self._tail_node: Node = None
+
+    def add_to_head(self, new_value: Any) -> None:
+        """Add node to beginning of list"""
+        new_head = Node(new_value)
+        current_head = self._head_node
+
+        if current_head != None:
+            current_head.prev_node = new_head
+            new_head.next_node = current_head
+
+        self._head_node = new_head
+
+        if self._tail_node == None:
+            self._tail_node = new_head
+
+    def add_to_tail(self, new_value: Any) -> None:
+        """Add node to end of the list"""
+        new_tail = Node(new_value)
+        current_tail = self._tail_node
+
+        if current_tail != None:
+            current_tail.next_node = new_tail
+            new_tail.prev_node = current_tail
+
+        self._tail_node = new_tail
+
+        if self._head_node == None:  # if list is empty
+            self._head_node = new_tail
+    
+    def remove_head(self) -> Any:
+        """Remove head node from list"""
+        removed_head = self._head_node
+
+        if removed_head == None:
+            return None
+
+        self._head_node = removed_head.next_node
+
+        if self._head_node != None:
+            self._head_node.prev_node = None
+
+        if removed_head == self._tail_node:
+            self.remove_tail()
+
+        return removed_head.value
+
+    def remove_tail(self) -> Any:
+        """Remove tail node from list"""
+        removed_tail = self._tail_node
+
+        if removed_tail == None:
+            return None
+
+        self._tail_node = removed_tail.prev_node
+
+        if self._tail_node != None:
+            self._tail_node.next_node = None
+
+        if removed_tail == self._head_node:
+            self.remove_head()
+
+        return removed_tail.value
+
+    def remove_by_value(self, value_to_remove: Any) -> Any:
+        """Remove node that contains given value."""
+        node_to_remove = None
+        current_node = self._head_node
+
+        '''Find value to remove'''
+        while current_node != None:
+            if current_node.value == value_to_remove:
+                node_to_remove = current_node
+                break
+
+            current_node = current_node.next_node
+
+        '''restructure list'''
+        if node_to_remove == None:  # value not found
+            return None
+
+        if node_to_remove == self._head_node:
+            self.remove_head()
+
+        elif node_to_remove == self._tail_node:
+            self.remove_tail()
+        
+        else:  # if node is in the middle of the list
+            next_node = node_to_remove.next_node
+            prev_node = node_to_remove.prev_node
+            next_node.prev_node = prev_node
+            prev_node.next_node = next_node
+
+        return node_to_remove
+
+    def __str__(self) -> str:
+        string_list = []
+        current_node = self._head_node
+        while current_node:
+            if current_node.value != None:
+                string_list.append(str(current_node.value))
+                current_node = current_node.next_node  # iterate to the next node
+
+        return ' <-> '.join(string_list)
+
+if __name__ == "__main__":
+    doubly_list = DoublyLinkedList()
+    print(doubly_list)
+    doubly_list.add_to_head(1)
+    doubly_list.add_to_tail(2)
+    doubly_list.add_to_head(3)
+    print(doubly_list)

Diff for: mydsa/doubly_linked_list.py

@@ -1,6 +1,9 @@
+# standard imports
 from __future__ import annotations
 from typing import Any
-from nodes import Node
+
+# local imports 
+from mydsa.nodes import Node
 
 
 class LinkedList:
@@ -32,7 +35,7 @@ def __str__(self):
         return ' -> '.join(string_list)
 
     def remove_node(self, value_to_remove: Any) -> None:
-        """Remove node(s) that contains given value."""
+        """Remove node that contains given value."""
         current_node = self.head_node
         if current_node.value == value_to_remove:  # if head_node contains value to remove
             self._head_node = current_node.next_node

Diff for: linked_list.py renamed to mydsa/linked_list.py

@@ -0,0 +1,39 @@
+from nodes import Node
+from typing import Any
+
+
+class Queue:
+
+    def __init__(self):
+        self._head: Node = None
+        self._tail: Node = None
+
+    def is_empty(self) -> bool:
+        return self._head == None
+
+    def peek(self) -> Any:
+        return self._head.value
+
+    def enqueue(self, value) -> None:
+        """Add node """
+        new_head = Node(value)
+        current_head = self._head_node
+
+        if current_head != None:
+            current_head.prev_node = new_head
+            new_head.next_node = current_head
+
+        self._head_node = new_head
+
+        if self._tail_node == None:
+            self._tail_node = new_head
+
+    def dequeue(self) -> Any:
+        value = self._head.value
+        self._head = self._head.next_node
+        if self._head_node == None:
+            self._tail_node = None
+
+        return value
+        
+

Diff for: mydsa/myqueue.py

@@ -3,16 +3,20 @@
 
 
 class Node:
+
     """A node is a base data structure used to store any value and point to 
     other nodes. This data structure can be used to build other data structures such as 
     linked listed and trees.
     """
 
-    def __init__(self, 
+    def __init__(self,
                  value: Any,
-                 next_node: Node = None):
+                 next_node: Node=None,
+                 prev_node: Node=None):
+
         self._value = value
         self._next_node = next_node
+        self._prev_node = prev_node
 
     @property
     def next_node(self) -> Node:
@@ -26,6 +30,11 @@ def next_node(self, next_node: Node) -> None:
     def value(self) -> Any:
         return self._value
 
+    @property
+    def prev_node(self) -> Node:
+        return self._prev_node
 
-class DoublyNode:
-    pass
+    @prev_node.setter
+    def prev_node(self, prev_node: Node) -> None:
+        self._prev_node = prev_node
+    

Diff for: nodes.py renamed to mydsa/nodes.py

@@ -0,0 +1,27 @@
+from nodes import Node
+from typing import Any, Optional
+
+class Stack:
+
+    def __init__(self, limit: int=1000):
+        self._top_item = None
+        self._size = 0
+        self._limit = limit
+
+    def push(self, value: Any) -> None:
+        if self.has_space():
+            item = Node(value)
+            item.next_node = self._top_item
+            self._top_item = item
+            self._size += 1
+        else:
+            print('All out of space')
+
+    def pop(self) -> Optional[Any]:
+        if self._size > 0:
+            item_to_remove = self._top_item
+            self._top_item = item_to_remove.next_node
+            self._size -= 1
+            return item_to_remove.value
+        else:
+            print('This stack is totally empty.')

Diff for: mydsa/stacks.py

@@ -0,0 +1,30 @@
+import os
+from setuptools import setup
+
+# Utility function to read the README file.
+# Used for the long_description.  It's nice, because now 1) we have a top level
+# README file and 2) it's easier to type in the README file than to put a raw
+# string in below ...
+
+
+def read(fname: str) -> str:
+    """Reads README file
+    Args:
+        fname (str): path to readme file
+    Returns:
+        str: contents in readme
+    """
+    full_path = os.path.join(os.path.dirname(__file__), fname)
+    with open(full_path, encoding="utf-8") as file:
+        return file.read()
+
+
+setup(
+      name="DSA-Lessons",
+      version="0.0.1",
+      author="Marcus Allen",
+      author_email="[email protected]",
+      url="https://github.com/marcus-24/DSA_Journey",
+      long_description=read('README.md'),
+      py_modules=[]
+)

Diff for: setup.py

@@ -0,0 +1,72 @@
+# standard imports
+import pytest
+import sys
+
+# local imports
+from mydsa.doubly_linked_list import DoublyLinkedList
+
+@pytest.fixture
+def sample_list() -> DoublyLinkedList:
+    mylist = DoublyLinkedList()
+    for idx in range(3):
+        mylist.add_to_head(idx)
+
+    return mylist
+
+def test_empty_list():
+    mylist = DoublyLinkedList()
+    assert str(mylist) == ''
+
+def test_add_single_value_to_head():
+    mylist = DoublyLinkedList()
+    mylist.add_to_head(1)
+    assert str(mylist) == '1'
+
+def test_add_multiple_values_to_head():
+    mylist = DoublyLinkedList()
+    for idx in range(3):
+        mylist.add_to_head(idx)
+    assert str(mylist) == '2 <-> 1 <-> 0'
+
+def test_add_single_value_to_tail():
+    mylist = DoublyLinkedList()
+    mylist.add_to_tail(1)
+    assert str(mylist) == '1'
+
+def test_add_multiple_values_to_tail():
+    mylist = DoublyLinkedList()
+    for idx in range(3):
+        mylist.add_to_tail(idx)
+    assert str(mylist) == '0 <-> 1 <-> 2'
+
+def test_remove_single_head(sample_list: DoublyLinkedList):
+    sample_list.remove_head()
+    assert str(sample_list) == '1 <-> 0'
+
+def test_remove_two_heads(sample_list: DoublyLinkedList):
+    for _ in range(2):
+        sample_list.remove_head()
+
+    assert str(sample_list) == '0'
+
+def test_remove_all_heads(sample_list: DoublyLinkedList):
+    for _ in range(3):
+        sample_list.remove_head()
+
+    assert str(sample_list) == ''
+
+def test_remove_single_tail(sample_list: DoublyLinkedList):
+    sample_list.remove_tail()
+    assert str(sample_list) == '2 <-> 1'
+
+def test_remove_two_tails(sample_list: DoublyLinkedList):
+    for _ in range(2):
+        sample_list.remove_tail()
+    assert str(sample_list) == '2'
+
+def test_remove_middle_value(sample_list: DoublyLinkedList):
+    sample_list.remove_by_value(1)
+    assert str(sample_list) == '2 <-> 0'
+
+if __name__ == "__main__":
+    pytest.main(sys.argv)