diff --git a/Exercise_1.py b/Exercise_1.py
index 532833f5d..e49562bc2 100644
--- a/Exercise_1.py
+++ b/Exercise_1.py
@@ -1,22 +1,38 @@
+# Time Complexity : all O(1) show O(n)
+# Space Complexity : all O(1) show O(n)
+# Did this code successfully run on Leetcode : na
+# Any problem you faced while coding this : na
+
 class myStack:
   #Please read sample.java file before starting.
   #Kindly include Time and Space complexity at top of each file
      def __init__(self):
+          self.stack = []
          
      def isEmpty(self):
+          return len(self.stack) == 0
          
      def push(self, item):
+          self.stack.append(item)
          
      def pop(self):
-        
+        if self.isEmpty():
+             raise IndexError("stack empty")
+        return self.stack.pop()
         
      def peek(self):
+        if self.isEmpty():
+          raise IndexError("stack empty")
+        return self.stack[-1]
         
      def size(self):
-         
+          return len(self.stack)
+     
      def show(self):
+          return self.stack
          
 
+
 s = myStack()
 s.push('1')
 s.push('2')
diff --git a/Exercise_2.py b/Exercise_2.py
index b11492215..e52f34365 100644
--- a/Exercise_2.py
+++ b/Exercise_2.py
@@ -1,15 +1,44 @@
+# Time Complexity : all O(1) 
+# Space Complexity : all O(1) data structire itself O(n)
+# Did this code successfully run on Leetcode : na
+# Any problem you faced while coding this : na
 
 class Node:
     def __init__(self, data):
-       self.data = data
-       self.next = None
- 
+        self.data = data
+        self.next = None
+
 class Stack:
     def __init__(self):
+        self.head = None
+
         
     def push(self, data):
+        newNode = Node(data)
+        if not self.head:
+            self.head=newNode
+            self.head.next= None
+        else:
+            newNode.next=self.head
+            self.head = newNode
+
         
     def pop(self):
+        if not self.head:
+            print("Stack Underflow")
+            return 0
+        newHead = self.head.next
+        self.head.next = None
+        retVal = self.head.data
+        self.head = newHead
+        return retVal
+        
+        
+
+
+
+
+
         
 a_stack = Stack()
 while True:
diff --git a/Exercise_3.py b/Exercise_3.py
index a5d466b59..a2dc71ec9 100644
--- a/Exercise_3.py
+++ b/Exercise_3.py
@@ -3,6 +3,8 @@ 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):
@@ -17,6 +19,17 @@ def append(self, data):
         Insert a new element at the end of the list.
         Takes O(n) time.
         """
+        if not self.head:
+            self.head= ListNode(data)
+            return
+
+        iter = self.head
+        while iter.next is not None:
+            iter = iter.next
+        
+        iter.next = ListNode(data)
+        return
+        
         
     def find(self, key):
         """
@@ -24,9 +37,32 @@ def find(self, key):
         `key`. Return the element or `None` if not found.
         Takes O(n) time.
         """
+        if not self.head:
+            return None
+        iter = self.head
+        while iter and iter.data != key:
+            iter = iter.next
+        if iter and iter.data == key:
+            return iter
+        return None
+
         
     def remove(self, key):
         """
         Remove the first occurrence of `key` in the list.
         Takes O(n) time.
         """
+        if not self.head:
+            return 
+        if self.head.data == key:
+            self.head = self.head.next
+            return 
+        
+        iter = self.head
+        while iter.next and iter.next.data != key:
+            iter = iter.next
+        
+        if iter.next and iter.next.data == key:
+            iter.next = iter.next.next 
+        
+        return