Done precourse 1

Exercise_1.py

@@ -1,21 +1,35 @@
+# Time Complexity : O(1) for push, pop, peek, size, show operations
+# Space Complexity : O(n) where n is the number of elements in the stack
+
 class myStack:
   #Please read sample.java file before starting.
   #Kindly include Time and Space complexity at top of each file
      def __init__(self):
+          self.arr =[]
 
      def isEmpty(self):
+          return len(self.arr) == 0
 
      def push(self, item):
+          self.arr.append(item)
 
      def pop(self):
-
-
+        result = None
+        if not self.isEmpty():
+             result = self.peek()
+             del self.arr[-1]
+        return result
+
      def peek(self):
+          if not self.isEmpty():
+              return self.arr[-1]
 
      def size(self):
+          return len(self.arr)
 
      def show(self):
-
+          # What is the requirement of this method? Should it just return the stack elements in a list or print them?
+          return self.arr
 
 s = myStack()
 s.push('1')

Exercise_2.py

@@ -1,3 +1,7 @@
+# Time Complexity : O(1) for push, peek, size operations
+# Time Complexity : O(n) for pop 
+# Space Complexity : O(n) where n is the number of elements in the stack
+
 
 class Node:
     def __init__(self, data):
@@ -6,10 +10,41 @@ def __init__(self, data):
 
 class Stack:
     def __init__(self):
-
+        self.head = Node(None)
+        self.last = Node(None)
+        self.last.next = self.head
+        self.size = 0
+
+    def isEmpty(self):
+        return self.currSize() == 0
+
     def push(self, data):
-
+        newNode = Node(data)
+        self.last.next.next = newNode
+        self.last.next = newNode
+        self.size+=1
+
+    def currSize(self):
+        return self.size
+
     def pop(self):
+        if self.size == 0:
+            return None
+        lastNode = self.last.next
+        tmpNode = Node(None)
+        tmpNode.next = self.head
+        while tmpNode.next.next != None and  tmpNode.next.next != lastNode:
+            tmpNode.next = tmpNode.next.next
+        self.last.next = tmpNode.next
+        self.last.next.next = None
+        self.size-=1
+        return lastNode.data
+
+    def peek(self):
+        if self.isEmpty():
+            return None
+        return self.last.next.data
+
 
 a_stack = Stack()
 while True:
@@ -28,5 +63,7 @@ def pop(self):
             print('Stack is empty.')
         else:
             print('Popped value: ', int(popped))
+    elif operation == 'currsize':
+        print(a_stack.currSize())
     elif operation == 'quit':
         break

Exercise_3.py

@@ -3,30 +3,52 @@ class ListNode:
     A node in a singly-linked list.
     """
     def __init__(self, data=None, next=None):
+        self.data = data
+        self.next = next
 
 class SinglyLinkedList:
     def __init__(self):
         """
         Create a new singly-linked list.
         Takes O(1) time.
         """
-        self.head = None
+        self.head = ListNode()
+
 
     def append(self, data):
         """
         Insert a new element at the end of the list.
         Takes O(n) time.
         """
+        newNode = ListNode(data)
+        self.last.next.next = newNode
 
     def find(self, key):
         """
         Search for the first element with `data` matching
         `key`. Return the element or `None` if not found.
         Takes O(n) time.
         """
+        tmpNode = ListNode(None, self.head)
+        while tmpNode.next != None:
+            if tmpNode.next.data == key:
+                return tmpNode.next
+            tmpNode.next = tmpNode.next.next
+        return None
 
     def remove(self, key):
         """
         Remove the first occurrence of `key` in the list.
         Takes O(n) time.
         """
+
+        prevNode = ListNode(None, self.head)
+        currNode = ListNode(None, self.head.next)
+        while currNode.next != None:
+            if currNode.next.data == key:
+                prevNode.next.next = currNode.next.next
+                break
+            else:
+                prevNode.next = currNode.next
+                currNode.next = currNode.next.next
+        return