Time_Space_Complexity_Data_Structures-Completed.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Time/Space Complexity - Intro to Data Structures (User Defined)\n",
    "\n",
    "### Topics to discuss today:\n",
    "\n",
    "<ul>\n",
    "    <li>Time and Space Complexity - What is it/How do we measure it</li>\n",
    "    <li>Asymptotic Analysis</li>\n",
    "    <li><strong>Data Structures</strong></li>\n",
    "    <li>Some of the popular sorting algorithms</li>\n",
    "</ul>\n",
    "\n",
    "### Data Structures to discuss:\n",
    "- Arrays\n",
    "- Stacks\n",
    "- Queues\n",
    "- Linked Lists\n",
    "    - Singly Linked Lists\n",
    "    - Traversing A Linked List\n",
    "    - Finding a node in a linked list\n",
    "    - Adding to a linked list\n",
    "- Binary Search Trees\n",
    "    - Construction\n",
    "    - Traversal\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Time and Space Complexity\n",
    "\n",
    "#### What is it?\n",
    "\n",
    "Time and space complexity is the measure of how much time a given action(function) will take to solve a problem. In the same fashion, we determine how much a given data structure will need in terms of memory allocation. A problem can have multiple solutions and finding the optimal solution for the problem needs to be analyzed in time and space.\n",
    "\n",
    "#### How do we measure Time and Space Complexity?\n",
    "\n",
    "In order to measure time and space complexity we use Asymptotic analysis. The reason for this is because we need a way to measure different algorithms (functions) based on the size of their inputs in a mathmatical way. For example, we could have a function that is computed as f(n) and another that is g(n^2). All things around the function staying constant, the only thing that changes is the size of the input. Below is the chart that shows the different Asymptotic analysis formats. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table style=\"text-align:center;\" class=\"table table-bordered\">\n",
    "<tbody><tr>\n",
    "<td>constant</td>\n",
    "<td>−</td>\n",
    "<td>Ο(1)</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>logarithmic</td>\n",
    "<td>−</td>\n",
    "<td>Ο(log n)</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>linear</td>\n",
    "<td>−</td>\n",
    "<td>Ο(n)</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Linear Logarithmic</td>\n",
    "<td>−</td>\n",
    "<td>Ο(n log n)</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>quadratic</td>\n",
    "<td>−</td>\n",
    "<td>Ο(n<sup>2</sup>)</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>cubic</td>\n",
    "<td>−</td>\n",
    "<td>Ο(n<sup>3</sup>)</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>polynomial</td>\n",
    "<td>−</td>\n",
    "<td>n<sup>Ο(1)</sup></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>exponential</td>\n",
    "<td>−</td>\n",
    "<td>2<sup>Ο(n)</sup></td>\n",
    "</tr>\n",
    "</tbody></table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In python we benefit from the dynamic array which means the block of memory will expand as needed for the given input to the array. In traditional arrays (depending on the type of operating system) we will usually store our inputs in 4 or 8 consecutive blocks of memory. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Which in python looks like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[23, 4, 6, 15, 5, 7, 23]\n"
     ]
    }
   ],
   "source": [
    "array = [23,4,6,15,5,7,23]\n",
    "print(array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's take a look at some of the time and space analysis of arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n",
      "23\n",
      "4\n",
      "6\n",
      "15\n",
      "5\n",
      "7\n",
      "23\n",
      "[23, 4, 6, 15, 5, 7, 23]\n",
      "[23, 4, 100, 15, 5, 7, 23]\n"
     ]
    }
   ],
   "source": [
    "# Indexing a list\n",
    "# Constant Time and Space - O(1)\n",
    "indexing = array[3]\n",
    "print(indexing)\n",
    "\n",
    "\n",
    "# Searching through a list\n",
    "# Linear Time - O(n) and Constant Space - O(1)\n",
    "for x in array:\n",
    "    print(x)\n",
    "    \n",
    "    \n",
    "# Copy a list\n",
    "# Linear Time - O(n) and Linear Space - O(n)\n",
    "copied_array = array[:]\n",
    "print(copied_array)\n",
    "\n",
    "\n",
    "# Setting an index on a list\n",
    "# Constant Time and Space - O(1)\n",
    "array[2] = 100\n",
    "print(array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "0\n",
      "0\n",
      "0\n",
      "0\n",
      "0\n",
      "0\n",
      "0\n",
      "1\n",
      "4\n",
      "9\n",
      "16\n",
      "25\n",
      "36\n",
      "0\n",
      "4\n",
      "16\n",
      "36\n",
      "64\n",
      "100\n",
      "144\n",
      "0\n",
      "9\n",
      "36\n",
      "81\n",
      "144\n",
      "225\n",
      "324\n",
      "0\n",
      "16\n",
      "64\n",
      "144\n",
      "256\n",
      "400\n",
      "576\n",
      "0\n",
      "25\n",
      "100\n",
      "225\n",
      "400\n",
      "625\n",
      "900\n",
      "0\n",
      "36\n",
      "144\n",
      "324\n",
      "576\n",
      "900\n",
      "1296\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def some_func(arr):\n",
    "    for x in range(len(arr)): # O(n) - Linear Time\n",
    "        arr[x] = x**2 # O(1) - Constant Time\n",
    "    for i in arr: # O(n) - Linear\n",
    "        for j in arr: # O(n) - Linear\n",
    "            print(i * j) # O(1) - Constant\n",
    "    return arr # O(1)\n",
    "\n",
    "some_func(array) # O(n^2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stacks and Queues (Review)\n",
    "\n",
    "** Stacks ** as the name suggests is a data structure that allows for data to follow the Last In First Out priciple(LIFO). Think of a stack of pancakes for example. To get the first pancake you would  start with the top and go down.\n",
    "\n",
    "##### Searching through a stack will be Linear Time O(n) - Constant Space O(1)\n",
    "##### Selecting the first item will be done in Linear Time O(n) - Constant Space O(1)\n",
    "##### Selecting the last item will be done in Constant Time O(1) - Constant Space O(1)\n",
    "##### Adding to the stack will be done in Constant Time O(1) - Constant Space O(1)\n",
    "\n",
    "** Queues ** are similar but in this case follow the First In First Out principle(FIFO). Think of this as a line in a black friday sale. The first person camped out for the big screen tv is the first to get it.\n",
    "\n",
    "##### Searching through a queue will be Linear Time O(n) - Constant Space O(1)\n",
    "##### Selecting the first item will be done in Constant Time O(1) - Constant Space O(1)\n",
    "##### Selecting the last item will be done in Linear Time O(n) - Constant Space O(1)\n",
    "##### Adding to the queue should take Constant Time O(1) - Constant Space O(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "STACK\n",
      "deque([10, 20, 30, 40, 50])\n",
      "50\n",
      "40\n",
      "30\n",
      "20\n",
      "10\n",
      "=========================\n",
      "QUEUE\n",
      "deque(['Dave', 'Claire', 'Matthew', 'Thomas', 'Margaret'])\n",
      "Dave\n",
      "Claire\n",
      "Matthew\n",
      "Thomas\n",
      "Margaret\n"
     ]
    }
   ],
   "source": [
    "# https://docs.python.org/3/library/collections.html\n",
    "from collections import deque\n",
    "\n",
    "print('STACK')\n",
    "stack = deque([10, 20, 30])\n",
    "\n",
    "stack.append(40)\n",
    "stack.append(50)\n",
    "\n",
    "print(stack)\n",
    "\n",
    "while stack:\n",
    "    print(stack.pop())\n",
    "    \n",
    "print('='* 25)\n",
    "\n",
    "print('QUEUE')\n",
    "\n",
    "queue = deque([])\n",
    "\n",
    "queue.append('Dave')\n",
    "queue.append('Claire')\n",
    "queue.append('Matthew')\n",
    "queue.append('Thomas')\n",
    "queue.append('Margaret')\n",
    "\n",
    "print(queue)\n",
    "\n",
    "while queue:\n",
    "    print(queue.popleft())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linked List (Data Structure)\n",
    "\n",
    "A linked list is created by using the node class. We create a Node object and create another class to use this node object. We pass the appropriate values thorugh the node object to point the to the next data elements.\n",
    "\n",
    "There are some advantages and disadvantages with this data structure. **Advantages** Linked Lists can save memory because they can be flexibile with memory management which saves memory. **Disadvantages** Finding or adding to the list requires traversing the entire list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Monday\n",
      "Tuesday\n",
      "Wednesday\n"
     ]
    }
   ],
   "source": [
    "class LinkedListNode:\n",
    "    def __init__(self, value):\n",
    "        self.value = value\n",
    "        self.next = None\n",
    "        \n",
    "    def traverse_list(self):\n",
    "        node = self\n",
    "        while node is not None:\n",
    "            print(node.value)\n",
    "            node = node.next\n",
    "            \n",
    "            \n",
    "node1 = LinkedListNode('Monday')\n",
    "node2 = LinkedListNode('Tuesday')\n",
    "node3 = LinkedListNode('Wednesday')\n",
    "\n",
    "node1.next = node2\n",
    "node2.next = node3\n",
    "\n",
    "node1.traverse_list()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Monday\n",
      "Tuesday\n",
      "Wednesday\n",
      "Thursday\n",
      "Friday\n"
     ]
    }
   ],
   "source": [
    "# Complete Implementation of Linked List\n",
    "\n",
    "# 2 Classes - Node Class and Linked List Class\n",
    "\n",
    "class Node:\n",
    "    def __init__(self, value):\n",
    "        self.value = value\n",
    "        self.next = None\n",
    "        \n",
    "    def __str__(self):\n",
    "        return self.value\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f\"{self.value}>\"\n",
    "    \n",
    "    \n",
    "class LinkedList:\n",
    "    def __init__(self):\n",
    "        # heat attribute points to the first node of the linked list\n",
    "        self.head = None\n",
    "        \n",
    "    # Method that will return a node base on value or return None if it does not exist\n",
    "    def _get_node(self, value_to_get):\n",
    "        # Start with the first node in our linked list\n",
    "        node_to_check = self.head\n",
    "        # while node_to_check is still a node\n",
    "        while node_to_check is not None:\n",
    "            # if the value of the node_to_check is equal to the value_to_get\n",
    "            if node_to_check.value == value_to_get:\n",
    "                # return that node\n",
    "                return node_to_check\n",
    "            # if not, move on to the next node\n",
    "            node_to_check = node_to_check.next\n",
    "        # Once node_to_check becomes None, we know that value to get is not in Linked List\n",
    "        return None\n",
    "        \n",
    "    # Method to add a new node to the front of the linked list\n",
    "    def push_on(self, new_value):\n",
    "        # Create a new node with the value passed in\n",
    "        new_node = Node(new_value)\n",
    "        # Set the new node's next attribute to be the current head\n",
    "        new_node.next = self.head\n",
    "        # Set the new node to be the front of the list (aka head)\n",
    "        self.head = new_node\n",
    "        \n",
    "    # Method to add a new node to the end of the linked list\n",
    "    def append(self, new_value):\n",
    "        # Create a new node with the value passed in\n",
    "        new_node = Node(new_value)\n",
    "        \n",
    "        # Check if the linked list is empty\n",
    "        if self.head is None:\n",
    "            # Set the head to our new node\n",
    "            self.head = new_node\n",
    "        # if not empty\n",
    "        else:\n",
    "            # traverse to the end of the list (aka the node.next is None)\n",
    "            node = self.head\n",
    "            # while the node has a .next attribute\n",
    "            while node.next is not None:\n",
    "                # move on to the next node\n",
    "                node = node.next\n",
    "            # set the last node's next attribute to be the new node\n",
    "            node.next = new_node\n",
    "            \n",
    "    # Method to insert a node to our linked list after a certain node (by value)\n",
    "    def insert_after(self, prev_value, new_value):\n",
    "        # Get the previous node by its value\n",
    "        prev_node = self._get_node(prev_value)\n",
    "        # Check if the previous node exists\n",
    "        if prev_node is None:\n",
    "            print(f\"{prev_value} is not in linked list\")\n",
    "            return\n",
    "        \n",
    "        # Create a new node with the new value passed in\n",
    "        new_node = Node(new_value)\n",
    "        # point the new node's .next to the previous node's .next\n",
    "        new_node.next = prev_node.next\n",
    "        # point the prev_node's next to our new node\n",
    "        prev_node.next = new_node\n",
    "        \n",
    "    # Method to print out all items in the linked list\n",
    "    def traverse_list(self):\n",
    "        # Start at the beginning of the Linked List\n",
    "        node = self.head\n",
    "        # While the node is not a NoneType, continue to loop\n",
    "        while node is not None:\n",
    "            # Print out the node (which will call the Node's __str__ method)\n",
    "            print(node)\n",
    "            # Set the node to the next node in the Linked List\n",
    "            node = node.next\n",
    "        \n",
    "        \n",
    "        \n",
    "weekdays = LinkedList()\n",
    "weekdays.push_on('Wednesday')\n",
    "weekdays.push_on('Monday')\n",
    "weekdays.append('Thursday')\n",
    "weekdays.append('Friday')\n",
    "weekdays.insert_after('Monday', 'Tuesday')\n",
    "weekdays.traverse_list()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.013499975204467773\n",
      "0.0004999637603759766\n"
     ]
    }
   ],
   "source": [
    "a_linked_list = LinkedList()\n",
    "\n",
    "\n",
    "# Adding a new node the end of the list - O(n) - Linear Time\n",
    "start = time.time()\n",
    "\n",
    "for i in range(1000):\n",
    "    a_linked_list.append(i)\n",
    "\n",
    "end = time.time()\n",
    "\n",
    "print(end - start)\n",
    "\n",
    "# Adding a new node to the beginning of the list - O(1) - Constant Time\n",
    "start = time.time()\n",
    "\n",
    "for i in range(1000):\n",
    "    a_linked_list.push_on(i)\n",
    "\n",
    "end = time.time()\n",
    "\n",
    "print(end - start)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Binary Search Trees"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class BST:\n",
    "    def __init__(self, value):\n",
    "        self.value = value\n",
    "        self.left = None\n",
    "        self.right = None\n",
    "        \n",
    "    def __repr__(self):\n",
    "        return f\"{self.value}>\"\n",
    "        \n",
    "    # Add a new node to the tree\n",
    "    def insert(self, new_value):\n",
    "        # if the new value is less than the current node's value\n",
    "        if new_value < self.value:\n",
    "            # if the current node has no left subtree\n",
    "            if self.left is None:\n",
    "                # Set the left subtree to be a new instance of BST\n",
    "                self.left = BST(new_value)\n",
    "            # if the node does have a left subtree\n",
    "            else:\n",
    "                # Call the insert method from the left subtree node\n",
    "                self.left.insert(new_value)\n",
    "        # if new value is greater than or equal\n",
    "        else:\n",
    "            if self.right is None:\n",
    "                self.right = BST(new_value)\n",
    "            else:\n",
    "                self.right.insert(new_value)\n",
    "                \n",
    "    # Return True or False if value in tree\n",
    "    def contains(self, target):\n",
    "        # if target is less than the current node's value\n",
    "        if target < self.value:\n",
    "            # if node's left subtree is empty (None)\n",
    "            if self.left is None:\n",
    "                # We know the target is not in tree because it would be here\n",
    "                return False\n",
    "            # if node does have left subtree\n",
    "            else:\n",
    "                # call the contains method on left subtree and return that value\n",
    "                return self.left.contains(target)\n",
    "        # if target is greater than current node's value\n",
    "        elif target > self.value:\n",
    "            if self.right is None:\n",
    "                return False\n",
    "            else:\n",
    "                return self.right.contains(target)\n",
    "        # if target is equal to node's value\n",
    "        else:\n",
    "            return True\n",
    "    \n",
    "    # Method to get the max value of a tree\n",
    "    def get_max_value(self):\n",
    "        if self.right is None:\n",
    "            return self.value\n",
    "        else:\n",
    "            return self.right.get_max_value()\n",
    "        \n",
    "    # Method to get the min value of a tree\n",
    "    def get_min_value(self):\n",
    "        if self.left is None:\n",
    "            return self.value\n",
    "        else:\n",
    "            return self.left.get_min_value()\n",
    "        \n",
    "    # Remove a node from the tree\n",
    "    def remove(self, value_to_remove, parent=None):\n",
    "        # Move left or right to find the node to delete\n",
    "        if value_to_remove < self.value:\n",
    "            if self.left is not None:\n",
    "                self.left.remove(value_to_remove, self)\n",
    "        elif value_to_remove > self.value:\n",
    "            if self.right is not None:\n",
    "                self.right.remove(value_to_remove, self)\n",
    "        # When we finally find the node to delete\n",
    "        else:\n",
    "            # if the node to delete has both a left and right subtree - node has two children\n",
    "            if self.left is not None and self.right is not None:\n",
    "                # Find the largest value in the left subtree and copy value to the current node\n",
    "                self.value = self.left.get_max_value()\n",
    "                # remove the node from which we copied\n",
    "                self.left.remove(self.value, self)\n",
    "            # if the left or right is None but node has no parent - node has at most one child\n",
    "            elif parent is None:\n",
    "                # if left side is not empty\n",
    "                if self.left is not None:\n",
    "                    # Set root node to current node's left\n",
    "                    self.value = self.left.value\n",
    "                    self.left = self.left.left\n",
    "                    self.right = self.left.right\n",
    "                # if right side is not empty\n",
    "                elif self.right is not None:\n",
    "                    # Set root node to current node's right\n",
    "                    self.value = self.right.value\n",
    "                    self.left = self.right.left\n",
    "                    self.right = self.right.right\n",
    "                # if both are empty\n",
    "                else:\n",
    "                    self.value = None\n",
    "            # if the node to delete\n",
    "            elif parent.left == self:\n",
    "                if self.left is not None:\n",
    "                    parent.left = self.left\n",
    "                else:\n",
    "                    parent.left = self.right\n",
    "            elif parent.right == self:\n",
    "                if self.left is not None:\n",
    "                    parent.right = self.left\n",
    "                else:\n",
    "                    parent.right = self.right\n",
    "                \n",
    "    \n",
    "tree = BST(50)\n",
    "tree.insert(25)\n",
    "tree.insert(15)\n",
    "tree.insert(75)\n",
    "tree.insert(72)\n",
    "tree.insert(85)\n",
    "tree.insert(78)\n",
    "tree.insert(19)\n",
    "tree.get_min_value()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Homework"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Problem 1: Add a .remove method to the LinkedList\n",
    "\n",
    "Add a method to the LinkedList class to remove a node from the list.\n",
    "\n",
    "The method should take in a string of the value to remove and remove the node with that value from the LinkedList."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sunday\n",
      "Monday\n",
      "Tuesday\n",
      "Wednesday\n",
      "Thursday\n",
      "Friday\n",
      "Saturday\n"
     ]
    }
   ],
   "source": [
    "class Node:\n",
    "    def __init__(self, value):\n",
    "        self.value = value\n",
    "        self.next = None\n",
    "        \n",
    "    def __str__(self):\n",
    "        return self.value\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f\"<Node|{self.value}>\"\n",
    "    \n",
    "    \n",
    "class LinkedList:\n",
    "    def __init__(self):\n",
    "        self.head = None\n",
    "        \n",
    "    def _get_node(self, value_to_get):\n",
    "        check = self.head\n",
    "        while check is not None:\n",
    "            if check.value == value_to_get:\n",
    "                return check\n",
    "            check = check.next\n",
    "        return None\n",
    "        \n",
    "    def push_on(self, new_value):\n",
    "        new_node = Node(new_value)\n",
    "        new_node.next = self.head\n",
    "        self.head = new_node\n",
    "        \n",
    "    def append(self, new_value):\n",
    "        new_node = Node(new_value)\n",
    "        \n",
    "        if self.head is None:\n",
    "            self.head = new_node\n",
    "        else:\n",
    "            node = self.head\n",
    "            while node.next is not None:\n",
    "                node = node.next\n",
    "            node.next = new_node\n",
    "            \n",
    "    def insert_after(self, prev_value, new_value):\n",
    "        prev_node = self._get_node(prev_value)\n",
    "        if prev_node is None:\n",
    "            print(f\"{prev_value} is not in linked list\")\n",
    "            return\n",
    "        \n",
    "        new_node = Node(new_value)\n",
    "        new_node.next = prev_node.next\n",
    "        prev_node.next = new_node\n",
    "        \n",
    "    def traverse_list(self):\n",
    "        node = self.head\n",
    "        while node:\n",
    "            print(node) \n",
    "            node = node.next\n",
    "    \n",
    "    def remove(self, value_to_remove):\n",
    "        pass\n",
    "            \n",
    "    \n",
    "weekdays = LinkedList()\n",
    "list_of_days = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']\n",
    "for day in list_of_days:\n",
    "    weekdays.append(day)\n",
    "\n",
    "# weekdays.remove('Wednesday')\n",
    "\n",
    "weekdays.traverse_list()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}