Cacher is the code snippet organizer for pro developers

class Stack():

   def __init__(self):

      self.stack = []


   def push(self,item):
      self.stack.append(item)


   def pop(self):
      if self.isEmpty():
         return None
      else:
         return self.stack.pop()

   def peek(self):
      if self.isEmpty():
         return None
      else:
         return self.stack[-1]

   def isEmpty(self):
      return self.stack == []

   def size(self):
      return len(self.stack)


class Queue():

   def __init__(self):
      self.queue = []

   def enqueue(self,item):
      self.queue.append(item)

   def dequeue(self):
      if self.isEmpty():
         return None
      else:
         return self.queue.pop(0)

   def isEmpty(self):
      return self.queue == []

   def size(self):
      return len(self.queue)

class Node():

   def __init__(self, value=0):
      self.val = value
      self.next = None


class UnorderedList:

   def __init__(self):
      self.head = None

   def size(self):

      cur = self.head
      length = 0
      while(cur!=None):
         length += 1
         cur = cur.next
      return length

   def empty(self):
      return self.head==None

   def value_at(self,index):
      if index>self.size():
         raise IndexError
      else:
         cur = self.head
         while(index>0):
            cur = cur.next
            index-=1
         return cur.val

   def push_front(self,value):
      temp = Node(value)
      if self.empty():
         self.head = temp
      else:
         temp.next = self.head
         self.head = temp

   def pop_front(self):
      if self.empty():
         return None
      else:
         temp = self.head
         self.head = self.head.next
         return temp.val

   def push_back(self,value):
      if self.empty():
         temp = Node(value)
         temp.next = None
         self.head = temp
      else:
         cur = self.head
         while(cur.next!=None):
            cur = cur.next
         temp = Node(value)
         temp.next = None
         cur.next = temp

   def pop_back(self):
      if self.empty():
         return None
      if self.head.next == None:
         temp = self.head.val
         self.head = None
         return temp
      else:
         cur = self.head
         while(cur.next.next!=None):
            cur = cur.next
         temp = cur.next.val
         cur.next = None
         return temp

   def display(self):
      print("current in linklist:")
      cur = self.head
      while(cur!=None):
         print(cur.val)
         cur = cur.next

class OrderedList:

   def __init__(self):
      self.head = None

   def size(self):

      cur = self.head
      length = 0
      while(cur!=None):
         length += 1
         cur = cur.next
      return length

   def empty(self):
      return self.head==None

   def value_at(self,index):
      if index>self.size():
         raise IndexError
      else:
         cur = self.head
         while(index>0):
            cur = cur.next
            index-=1
         return cur.val

   def add(self,item):
      """
      Brilliant Method for the add function for ordered linked list
      use two pointer
      the previous is always pointing at the last element.
      this is super cool!!!
      """
      current = self.head
      previous = None
      stop = False
      while current != None and not stop:
         if current.getData() > item:
            stop = True
         else:
            previous = current
            current = current.getNext()

      temp = Node(item)
      if previous == None:
         temp.setNext(self.head)
         self.head = temp
      else:
         temp.setNext(current)
         previous.setNext(temp)



class Heap:

   def __init__(self):
      self.heaplist = [0]
      self.currentSize = 0

   def percUp(self,i):
      while i //2>0:
         if self.heaplist[i//2]<self.heaplist[i]:
            self.heaplist[i//2],self.heaplist[i] = self.heaplist[i], self.heaplist[i//2]
         i = i//2
      return 
   
   def insert(self,x):
      self.heaplist.append(x)
      self.currentSize+=1
      self.percUp(currentSize)
      return