48 files changed, 3739 insertions(+), 0 deletions(-)

A README.org
A chapter1/README.org
A chapter1/fraction.py
A chapter1/logic_gates.py
A chapter1/monkey_type.py
A chapter2/README.org
A chapter2/dice.py
A chapter3/README.org
A chapter3/anagram.py
A chapter3/check_performance.py
A chapter3/exercises.py
A chapter3/find_minimum.py
A chapter4/README.org
A chapter4/dequeue.py
A chapter4/list.py
A chapter4/queue.py
A chapter4/stack.py
A chapter5/README.org
A chapter5/Recursion/2021-11-05_21-45-54_screenshot.png
A chapter5/Stack_frames/2021-11-05_21-46-34_screenshot.png
A chapter5/base_converter.py
A chapter5/euclid.py
A chapter5/factorial.py
A chapter5/recursion.py
A chapter5/stack_frame.py
A chapter5/tree.py
A chapter6/README.org
A chapter6/binary_search.py
A chapter6/bubble_sort.py
A chapter6/hash.py
A chapter6/hash_string.py
A chapter6/insertion_sort.py
A chapter6/map.py
A chapter6/merge_sort.py
A chapter6/quicksort.py
A chapter6/selection_sort.py
A chapter6/sequential_search.py
A chapter6/shell_sort.py
A chapter7/README.org
A chapter7/avl.py
A chapter7/binary_heap.py
A chapter7/binary_search_tree.py
A chapter7/parse_tree.py
A chapter7/tree_aslist.py
A chapter7/tree_asrefererence.py
A chapter7/tree_traversal.py
A chapter8/graph.py
A chapter8/word_ladder.py

@@ 1,7 @@
+* Runestone
+
+See https://runestone.academy/ns/books/published//pythonds/index.html
+
+These repos are my answers to the exercises in the book.
+
+Still need to look at the 8th and ninth chapter.

@@ 1,6 @@
+* Chapter 1
+
+Not much to do here, since I'm already confortable with python I chose
+to skip some of the exercises.
+
+And since I'm already doing the NAND book with the logic gates I got a bit lazy.

@@ 1,46 @@
+#!/usr/bin/python3
+
+
+"""
+The goal here is to override magic method for our Fraction object
+like gt,lt,sub,multiply,divide...
+"""
+
+def gcd(m,n):
+    while m%n != 0:
+        oldm = m
+        oldn = n
+
+        m = oldn
+        n = oldm%oldn
+    return n
+
+class Fraction:
+     def __init__(self,top,bottom):
+         self.num = top
+         self.den = bottom
+
+     def __str__(self):
+         return str(self.num)+"/"+str(self.den)
+
+     def show(self):
+         print(self.num,"/",self.den)
+
+     def __add__(self,otherfraction):
+         newnum = self.num*otherfraction.den + \
+                      self.den*otherfraction.num
+         newden = self.den * otherfraction.den
+         common = gcd(newnum,newden)
+         return Fraction(newnum//common,newden//common)
+
+     def __eq__(self, other):
+         firstnum = self.num * other.den
+         secondnum = other.num * self.den
+
+         return firstnum == secondnum
+
+x = Fraction(1,2)
+y = Fraction(2,3)
+print(x+y)
+print(x == y)
+

@@ 1,143 @@
+#!/usr/bin/python3
+
+"""
+Create a two new gate classes, one called NorGate the other called
+NandGate. NandGates work like AndGates that have a Not attached to the
+output. NorGates work lake OrGates that have a Not attached to the
+output.
+
+Create a series of gates that prove the following equality NOT (( A
+and B) or (C and D)) is that same as NOT( A and B ) and NOT (C and
+D). Make sure to use some of your new gates in the simulation.
+"""
+
+class LogicGate:
+
+    def __init__(self,n):
+        self.name = n
+        self.output = None
+
+    def getLabel(self):
+        return self.name
+
+    def getOutput(self):
+        self.output = self.performGateLogic()
+        return self.output
+
+
+class BinaryGate(LogicGate):
+
+    def __init__(self,n):
+        super(BinaryGate, self).__init__(n)
+
+        self.pinA = None
+        self.pinB = None
+
+    def getPinA(self):
+        if self.pinA == None:
+            return int(input("Enter Pin A input for gate "+self.getLabel()+"-->"))
+        else:
+            return self.pinA.getFrom().getOutput()
+
+    def getPinB(self):
+        if self.pinB == None:
+            return int(input("Enter Pin B input for gate "+self.getLabel()+"-->"))
+        else:
+            return self.pinB.getFrom().getOutput()
+
+    def setNextPin(self,source):
+        if self.pinA == None:
+            self.pinA = source
+        else:
+            if self.pinB == None:
+                self.pinB = source
+            else:
+                print("Cannot Connect: NO EMPTY PINS on this gate")
+
+
+class AndGate(BinaryGate):
+
+    def __init__(self,n):
+        BinaryGate.__init__(self,n)
+
+    def performGateLogic(self):
+
+        a = self.getPinA()
+        b = self.getPinB()
+        if a==1 and b==1:
+            return 1
+        else:
+            return 0
+
+class OrGate(BinaryGate):
+
+    def __init__(self,n):
+        BinaryGate.__init__(self,n)
+
+    def performGateLogic(self):
+
+        a = self.getPinA()
+        b = self.getPinB()
+        if a ==1 or b==1:
+            return 1
+        else:
+            return 0
+
+class UnaryGate(LogicGate):
+
+    def __init__(self,n):
+        LogicGate.__init__(self,n)
+
+        self.pin = None
+
+    def getPin(self):
+        if self.pin == None:
+            return int(input("Enter Pin input for gate "+self.getLabel()+"-->"))
+        else:
+            return self.pin.getFrom().getOutput()
+
+    def setNextPin(self,source):
+        if self.pin == None:
+            self.pin = source
+        else:
+            print("Cannot Connect: NO EMPTY PINS on this gate")
+
+
+class NotGate(UnaryGate):
+
+    def __init__(self,n):
+        UnaryGate.__init__(self,n)
+
+    def performGateLogic(self):
+        if self.getPin():
+            return 0
+        else:
+            return 1
+
+
+class Connector:
+
+    def __init__(self, fgate, tgate):
+        self.fromgate = fgate
+        self.togate = tgate
+
+        tgate.setNextPin(self)
+
+    def getFrom(self):
+        return self.fromgate
+
+    def getTo(self):
+        return self.togate
+
+
+def main():
+   g1 = AndGate("G1")
+   g2 = AndGate("G2")
+   g3 = OrGate("G3")
+   g4 = NotGate("G4")
+   c1 = Connector(g1,g3)
+   c2 = Connector(g2,g3)
+   c3 = Connector(g3,g4)
+   print(g4.getOutput())
+
+main()

@@ 1,83 @@
+#!/usr/bin/python3
+
+"""The monkey that types a text if given an infinite amount of time."""
+
+import random
+import string
+
+
+def generate_phrase(best_phrase: str = None) -> str:
+    """Generate a random 28 string phrase."""
+    string_space = string.ascii_lowercase + " "
+    phrase = ""
+    if best_phrase:
+        phrase = best_phrase
+    while len(phrase) != 28:
+        letter = random.choice(string_space)
+        phrase = phrase + letter
+    return phrase
+
+
+def generate_from_best_phrase(best_phrase: str, score: float) -> str:
+    """Generate a phrase from the correct letters gathered so far."""
+    if score == 0:
+        generated_best_phrase = generate_phrase()
+    else:
+        generated_best_phrase = generate_phrase(best_phrase)
+    return generated_best_phrase
+
+
+def generate_score(
+        generated_string: str,
+        target: str
+) -> tuple[float, str]:
+    """Score the generated_phrase compared to the target"""
+    letters_matched = 0
+    letters_correct = ""
+    for letter_generated, letter_target in zip(generated_string, target):
+        if letter_generated == letter_target:
+            letters_matched += 1
+            letters_correct = letters_correct + letter_generated
+        else:
+            break
+    score = (letters_matched / len(generated_string)) * 100
+    return score, letters_correct
+
+
+def infinite_monkey():
+    """This should produce a phrase from Shakespeare given time."""
+    phrases_generated = {}
+    best_phrase = ""
+    best_score = 0.0
+    phrase = generate_phrase()
+    score, letters_correct = generate_score(
+        phrase,
+        "methinks it is like a weasel"
+    )
+    phrases_generated[phrase] = score
+    count = 0
+    while score != 100:
+        best_phrase = max(phrases_generated, key=phrases_generated.get)
+        best_score = phrases_generated[best_phrase]
+        phrase = generate_from_best_phrase(
+            letters_correct, score
+        )
+        score, letters_correct = generate_score(
+            phrase,
+            "methinks it is like a weasel"
+        )
+        if phrase not in phrases_generated:
+            phrases_generated[phrase] = score
+        if count % 1000 == 0:
+            print(f"{count} : {best_phrase} {best_score:.2f} %")
+        count += 1
+    print(f"{count} : {phrase} {score:.2f} %")
+
+
+def main():
+    """Entry point."""
+    infinite_monkey()
+
+
+if __name__ == '__main__':
+    main()

@@ 1,4 @@
+* Chapter 2
+
+This one mostly talks about override of standard methods, pitfalls
+and exercice about it

@@ 1,55 @@
+#!/usr/bin/python3
+
+
+"""PYthon implements the negation of __eq__ if ne not implemented
+same with ohter operators"""
+
+import random
+
+class MSDie:
+    """
+    Multi-sided die
+
+    Instance Variables:
+        current_value
+        num_sides
+
+    """
+
+    def __init__(self, num_sides):
+        self.num_sides = num_sides
+        self.current_value = self.roll()
+
+    def roll(self):
+        self.current_value = random.randrange(1,self.num_sides+1)
+        return self.current_value
+
+    def __str__(self):
+        return str(self.current_value)
+
+    def __repr__(self):
+        return "MSDie({}) : {}".format(self.num_sides, self.current_value)
+
+    def __eq__(self,other):
+        return self.current_value == other.current_value
+
+    def __lt__(self,other):
+        return self.current_value < other.current_value
+
+    def __le__(self, other):
+        return self.current_value <= other.current_value
+
+
+x = MSDie(6)
+y = MSDie(7)
+
+x.current_value = 6
+y.current_value = 5
+
+print(x == y)
+print(x < y)
+print(x > y)
+print(x != y)
+print(x<=y)
+print(x>=y)
+print(x is y)

@@ 1,59 @@
+* Chapter 3
+
+This one 's about algorithm analysis
+
+The big O to compare algorith mregardless of their implementation in language,compiler,time...
+
+Although we do not see this in the summation example, sometimes the performance of an algorithm depends on the exact values of the data rather than simply the size of the problem. For these kinds of algorithms we need to characterize their performance in terms of best case, worst case, or average case performance. The worst case performance refers to a particular data set where the algorithm performs especially poorly. Whereas a different data set for the exact same algorithm might have extraordinarily good performance. However, in most cases the algorithm performs somewhere in between these two extremes (average case). It is important for a computer scientist to understand these distinctions so they are not misled by one particular case.
+
+a=5
+b=6
+c=10
+for i in range(n):
+   for j in range(n):
+      x = i * i
+      y = j * j
+      z = i * j
+for k in range(n):
+   w = a*k + 45
+   v = b*b
+d = 33
+
+The number of assignment operations is the sum of four terms. The first term is the constant 3, representing the three assignment statements at the start of the fragment. The second term is 3n2
+, since there are three statements that are performed n2 times due to the nested iteration. The third term is 2n, two statements iterated n times. Finally, the fourth term is the constant 1, representing the final assignment statement. This gives us T(n)=3+3n2+2n+1=3n2+2n+4. By looking at the exponents, we can easily see that the n2 term will be dominant and therefore this fragment of code is O(n2). Note that all of the other terms as well as the coefficient on the dominant term can be ignored as n grows larger.
+
+if nested loop
+o(n) to the power n
+
+if not nested
+o(n)
+
+see iflog(n) number of steps get reduced as algo goes on
+
+
+
+
+    Algorithm analysis is an implementation-independent way of measuring an algorithm.
+
+    Big-O notation allows algorithms to be classified by their dominant process with respect to the size of the problem.
+
+
+    how to use the timeit module, test function over big range, plot graphically to check time complexity
+
+    also depends on implementation for big oh
+
+
+import timeit
+import random
+
+for i in range(10000,1000001,20000):
+    t = timeit.Timer("random.randrange(%d) in x"%i,
+                     "from __main__ import random,x")
+    x = list(range(i))
+    lst_time = t.timeit(number=1000)
+    x = {j:None for j in range(i)}
+    d_time = t.timeit(number=1000)
+    print("%d,%10.3f,%10.3f" % (i, lst_time, d_time))
+
+
+    Though this works only for small snippets, other tools for real project

@@ 1,79 @@
+#!/usr/bin/python3
+
+# n^2 solution
+
+def anagramSolution1(s1,s2):
+    stillOK = True
+    if len(s1) != len(s2):
+        stillOK = False
+
+    alist = list(s2)
+    pos1 = 0
+
+    while pos1 < len(s1) and stillOK:
+        pos2 = 0
+        found = False
+        while pos2 < len(alist) and not found:
+            if s1[pos1] == alist[pos2]:
+                found = True
+            else:
+                pos2 = pos2 + 1
+
+        if found:
+            alist[pos2] = None
+        else:
+            stillOK = False
+
+        pos1 = pos1 + 1
+
+    return stillOK
+
+print(anagramSolution1('abcd','dcba'))
+
+# depends on the sort
+
+def anagramSolution2(s1,s2):
+    alist1 = list(s1)
+    alist2 = list(s2)
+
+    alist1.sort()
+    alist2.sort()
+
+    pos = 0
+    matches = True
+
+    while pos < len(s1) and matches:
+        if alist1[pos]==alist2[pos]:
+            pos = pos + 1
+        else:
+            matches = False
+
+    return matches
+
+print(anagramSolution2('abcde','edcba'))
+
+# o(n), last loop is always 26
+
+def anagramSolution4(s1,s2):
+    c1 = [0]*26
+    c2 = [0]*26
+
+    for i in range(len(s1)):
+        pos = ord(s1[i])-ord('a')
+        c1[pos] = c1[pos] + 1
+
+    for i in range(len(s2)):
+        pos = ord(s2[i])-ord('a')
+        c2[pos] = c2[pos] + 1
+
+    j = 0
+    stillOK = True
+    while j<26 and stillOK:
+        if c1[j]==c2[j]:
+            j = j + 1
+        else:
+            stillOK = False
+
+    return stillOK
+
+print(anagramSolution4('apple','pleap'))

@@ 1,56 @@
+#!/usr/bin/python3
+
+import random
+from timeit import Timer
+
+# popzero = Timer("x.pop(0)",
+#                 "from __main__ import x")
+# popend = Timer("x.pop()",
+#                "from __main__ import x")
+# print("pop(0)   pop()")
+# for i in range(1000000,100000001,1000000):
+#     x = list(range(i))
+#     pt = popend.timeit(number=1000)
+#     x = list(range(i))
+#     pz = popzero.timeit(number=1000)
+#     print("%15.5f, %15.5f" %(pz,pt))
+
+
+# """Check that the index operation of list is O(1)"""
+# index_begin = Timer("x.index(0)",
+#                 "from __main__ import x")
+# index_last = Timer("x.index(x[-1])",
+#                 "from __main__ import x")
+# print("iteraton, index(0),    index(last_element)")
+# for i in range(1000000,100000001,1000000):
+#     x = list(range(i))
+#     pt = index_begin.timeit(number=1000)
+#     x = list(range(i))
+#     pz = index_last.timeit(number=1000)
+#     print("%d,%15.5f,%15.5f" % (i, pt, pz))
+
+
+# """Check that get and set item for dict are o(1)"""
+# print("Get dict time,    Set dict element time")
+# for i in range(10000,1000001,20000):
+#     t = Timer("x.get(%d)"%i,
+#                      "from __main__ import random,x")
+#     t2 = Timer("x[(%d)] = 9999"%i,
+#                      "from __main__ import random,x")
+#     x = {j:None for j in range(i)}
+#     d_time1 = t.timeit(number=1000)
+#     x = {j:None for j in range(i)}
+#     d_time2 = t2.timeit(number=1000)
+#     print("%d,%10.3f,%10.3f" % (i, d_time1, d_time2))
+
+# """Compare the del operator for list and dict"""
+# Should be o(1) for dict and o(n) for list
+print("iteration,  del dict    del list")
+for i in range(1000000,100000001,1000000):
+    del_timer = Timer("del x[random.randrange(%d)]"%i,
+                    "from __main__ import random, x")
+    x = list(range(i))
+    pt = del_timer.timeit(number=1000)
+    x = {j:None for j in range(i)}
+    pz = del_timer.timeit(number=1000)
+    print("%d, %15.5f, %15.5f" %(i, pz,pt))

@@ 1,15 @@
+#!/usr/bin/python3
+
+# Devise an experiment to verify that the list index operator is O(1)
+
+# Devise an experiment to verify that get item and set item are O(1)
+
+# for dictionaries.
+
+# Devise an experiment that compares the performance of the del operator on lists and dictionaries.
+
+# Given a list of numbers in random order, write an algorithm that works in O(nlog(n))
+
+# to find the kth smallest number in the list.
+
+# Can you improve the algorithm from the previous problem to be linear? Explain.

@@ 1,34 @@
+#!/usr/bin/python3
+
+import random
+from typing import List
+
+def find_minimum(mylist: List[int]) -> int:
+    """This is o(n^2)"""
+    overallmin = mylist[0]
+    for i in mylist:
+        issmallest = True
+        for j in mylist:
+            if i > j:
+                issmallest = False
+        if issmallest:
+            overallmin = i
+    return overallmin
+
+
+def find_minimum_optimized(mylist: List[int]) -> int:
+    """This is o(n)"""
+    minsofar = mylist[0]
+    for i in mylist:
+        if i < minsofar:
+            minsofar = i
+    return minsofar
+
+
+def main():
+    test_list = [random.randint(0,10) for x in range(10)]
+    print(test_list)
+    print(find_minimum(test_list))
+
+if __name__ == '__main__':
+    main()

@@ 1,10 @@
+* Linear structures
+
+4.2. What Are Linear Structures?
+
+We will begin our study of data structures by considering four simple but very powerful concepts. Stacks, queues, deques, and lists are examples of data collections whose items are ordered depending on how they are added or removed. Once an item is added, it stays in that position relative to the other elements that came before and came after it. Collections such as these are often referred to as linear data structures.
+
+Linear structures can be thought of as having two ends. Sometimes these ends are referred to as the “left” and the “right” or in some cases the “front” and the “rear.” You could also call them the “top” and the “bottom.” The names given to the ends are not significant. What distinguishes one linear structure from another is the way in which items are added and removed, in particular the location where these additions and removals occur. For example, a structure might allow new items to be added at only one end. Some structures might allow items to be removed from either end.
+
+These variations give rise to some of the most useful data structures in computer science. They appear in many algorithms and can be used to solve a variety of important problems.
+

@@ 1,53 @@
+#!/usr/bin/python3
+
+
+class Deque:
+    def __init__(self):
+        self.items = []
+
+    def isEmpty(self):
+        return self.items == []
+
+    def addFront(self, item):
+        self.items.append(item)
+
+    def addRear(self, item):
+        self.items.insert(0,item)
+
+    def removeFront(self):
+        return self.items.pop()
+
+    def removeRear(self):
+        return self.items.pop(0)
+
+    def size(self):
+        return len(self.items)
+
+    def __str__(self):
+        return str(self.items)
+
+
+def palchecker(aString: str) -> bool:
+    chardeque = Deque()
+
+    for ch in aString:
+        chardeque.addRear(ch)
+
+    stillEqual = True
+
+    while chardeque.size() > 1 and stillEqual:
+        first = chardeque.removeFront()
+        last = chardeque.removeRear()
+        if first == " ":
+            first = chardeque.removeFront()
+        if last == " ":
+            last = chardeque.removeRear()
+        if first != last:
+            stillEqual = False
+
+    return stillEqual
+
+
+print(palchecker("lsdkjfskf"))
+print(palchecker("radar"))
+print(palchecker('I PREFER PI'))

@@ 1,642 @@
+#!/usr/bin/python3
+
+class Node:
+    def __init__(self,initdata):
+        self.data = initdata
+        self.next = None
+
+    def getData(self):
+        return self.data
+
+    def getNext(self):
+        return self.next
+
+    def setData(self,newdata):
+        self.data = newdata
+
+    def setNext(self,newnext):
+        self.next = newnext
+
+    def __str__(self):
+        return str(self.data, str(self.next))
+
+
+class UnorderedList:
+
+    def __init__(self):
+        self.head = None
+        self.last = None
+
+    def isEmpty(self):
+        return self.head == None
+
+    def add(self,item):
+        temp = Node(item)
+        temp.setNext(self.head)
+        self.head = temp
+        if not self.last:
+            self.last = self.head
+
+    def size(self):
+        current = self.head
+        count = 0
+        while current != None:
+            count = count + 1
+            current = current.getNext()
+
+        return count
+
+    def search(self,item):
+        current = self.head
+        found = False
+        while current != None and not found:
+            if current.getData() == item:
+                found = True
+            else:
+                current = current.getNext()
+
+        return found
+
+    def remove(self,item) -> None:
+        current = self.head
+        previous = None
+        found = False
+        while not found:
+            if current.getData() == item:
+                found = True
+            else:
+                previous = current
+                current = current.getNext()
+                if current is None:
+                    break
+        if previous is None:
+            self.head = current.getNext()
+        elif not found:
+            raise ValueError("The item is not in the list")
+        else:
+            previous.setNext(current.getNext())
+
+    def append(self, item) -> None:
+        """
+        We handle first the case where we append
+        to a list without any node by setting the
+        last node to the head.
+
+        When the list is not empty we simply set the
+        next pointer of the last node recorded to the given
+        node and finally we update the last node to be the given
+        node that is going to be appended.
+        """
+        temp = Node(item)
+        if not self.last:
+            self.head = temp
+            self.last = temp
+        else:
+            self.last.setNext(temp)
+            self.last = temp
+
+    def pop(self, pos=None):
+        """
+        Remove the last element and returns the element.
+
+        The last if else condition is to account for the case
+        where the list only has one node if there is no previous node
+        that means there is only one node and therefore the head should
+        be set to None.
+
+        Otherwise we change the last pointer to None
+        """
+        current = self.head
+        previous = None
+        while current:
+            if not current.getNext():
+                break
+            previous = current
+            current = current.getNext()
+        if not previous:
+            self.head = None
+        else:
+            previous.setNext(None)
+        return current.getData()
+
+    def insert(self, pos, item):
+        temp = Node(item)
+        current = self.head
+        count = 0
+        previous = None
+        while current:
+            if count == pos:
+                break
+            previous = current
+            current = current.getNext()
+            count += 1
+        if not current and pos == 0:
+            self.head = temp
+        else:
+            if not previous:
+                temp.setNext(current)
+                self.head = temp
+            else:
+                previous.setNext(temp)
+                temp.setNext(current)
+
+    def index(self, item) -> int:
+        """-1 to have list[0] == first element"""
+        index = -1
+        found = False
+        current = self.head
+        while current and not found:
+            if current.getData() == item:
+                found = True
+            else:
+                current = current.getNext()
+            index += 1
+        if not found:
+            index = -1
+        return index
+
+    def print_items(self) -> None:
+        current = self.head
+        while current:
+            print(current.getData())
+            current = current.getNext()
+
+    def slice(self):
+        pass
+
+    def __str__(self):
+        elements = ""
+        current = self.head
+        while current:
+            if current == self.head:
+                elements += "[" + str(current.getData())
+            else:
+                if current:
+                    elements += ", "
+                elements += str(current.getData())
+            if not current.getNext():
+                elements += "]"
+            current = current.getNext()
+        return elements
+
+    def __getitem__(self, subscript):
+        if isinstance(subscript, slice):
+            # do your handling for a slice object:
+            count = 0
+            current = self.head
+            second_list = UnorderedList()
+            while count <= subscript.stop:
+                if count == subscript.stop:
+                    count += 1
+                    break
+                current = current.getNext()
+                count += 1
+                second_list.add(current.getData())
+            return second_list
+        else:
+            # Do your handling for a plain index
+            count = 0
+            current = self.head
+            second_list = UnorderedList()
+            while count != subscript:
+                if count == subscript:
+                    count += 1
+                    break
+                current = current.getNext()
+                count += 1
+            if not current:
+                raise IndexError("list index out of range")
+            second_list.add(current.getData())
+            return second_list
+
+#mylist = UnorderedList()
+#mylist.add(31)
+#mylist.add(32)
+#mylist.add(33)
+#mylist.add(38)
+#mylist.append(45)
+#print(mylist)
+#a = mylist[0:2]
+#print(a)
+#mylist.append(45)
+#mylist.print_items()
+#print('------------')
+#mylist.remove(45)
+#mylist.print_items()
+#mylist.add(33)
+#mylist.append(45)
+#mylist.print_items()
+##print(f"{mylist.pop()} pop result")
+#print(f"{mylist.pop(2)} pop result")
+#mylist.print_items()
+#mylist.add(93)
+#mylist.append(7524)
+#mylist.append(75245)
+#mylist.add(26)
+#mylist.append(752455458)
+#mylist.append(451)
+#mylist.print_items()
+#print(f"{mylist.index(752455458)} kjkljklj")
+#mylist.insert(0, 654687865445754)
+#mylist.insert(0, 54)
+#mylist.insert(1, 20)
+#mylist.print_items()
+# mylist.add(26)
+# mylist.add(54)
+# mylist.print_items()
+# 
+# print(mylist.size())
+# print(mylist.search(93))
+# print(mylist.search(100))
+# 
+# mylist.add(100)
+# print(mylist.search(100))
+# print(mylist.size())
+# 
+# mylist.remove(54)
+# print(mylist.size())
+# mylist.remove(93)
+# print(mylist.size())
+# mylist.remove(31)
+# print(mylist.size())
+# print(mylist.search(93))
+
+
+# Ordered List
+
+class OrderedList:
+    def __init__(self):
+        self.head = None
+
+    def search(self,item):
+        current = self.head
+        found = False
+        stop = False
+        while current != None and not found and not stop:
+            if current.getData() == item:
+                found = True
+            else:
+                if current.getData() > item:
+                    stop = True
+                else:
+                    current = current.getNext()
+
+        return found
+
+    def add(self,item):
+        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)
+
+    def isEmpty(self):
+        return self.head == None
+
+    def size(self):
+        current = self.head
+        count = 0
+        while current != None:
+            count = count + 1
+            current = current.getNext()
+
+        return count
+
+    def remove(self, item) -> None:
+        current = self.head
+        previous = None
+        found = False
+        while not found:
+            if current.getData() == item:
+                found = True
+            else:
+                previous = current
+                current = current.getNext()
+
+        if previous == None:
+            self.head = current.getNext()
+        else:
+            previous.setNext(current.getNext())
+
+    def index(self, item) -> int:
+        """-1 to have list[0] == first element"""
+        index = -1
+        found = False
+        current = self.head
+        while current and not found:
+            if current.getData() == item:
+                found = True
+            else:
+                current = current.getNext()
+            index += 1
+        if not found:
+            index = -1
+        return index
+
+    def pop(self, pos=None):
+        """
+        Remove the last element and returns the element.
+
+        The last if else condition is to account for the case
+        where the list only has one node if there is no previous node
+        that means there is only one node and therefore the head should
+        be set to None.
+
+        Otherwise we change the last pointer to None
+        """
+        current = self.head
+        previous = None
+        while current:
+            if not current.getNext():
+                break
+            previous = current
+            current = current.getNext()
+        if not previous:
+            self.head = None
+        else:
+            previous.setNext(None)
+        return current.getData()
+
+
+    def print_items(self) -> None:
+        current = self.head
+        while current:
+            print(current.getData())
+            current = current.getNext()
+
+
+
+#mylist = OrderedList()
+#mylist.add(31)
+#mylist.add(77)
+#mylist.add(17)
+#mylist.add(93)
+#mylist.add(26)
+#mylist.add(54)
+#mylist.print_items()
+##
+##print(f"{mylist.pop()} pop result")
+#print(f"{mylist.index(93)} index result")
+#print("-----------------------")
+#mylist.print_items()
+
+# print(mylist.size())
+# print(mylist.search(93))
+# print(mylist.search(100))
+
+# Stack implemented as a linked list
+
+class StackLinkedList():
+
+    def __init__(self):
+        self.head = None
+        self.last = None
+
+    def isEmpty(self):
+        return self.head is None
+
+    def push(self,item):
+        temp = Node(item)
+        temp.setNext(self.head)
+        self.head = temp
+        if not self.last:
+            self.last = self.head
+
+    def pop(self):
+        current = self.head
+        if current.getNext() is not None:
+            self.head = current.getNext()
+        else:
+            self.head = None
+        return current.getData()
+
+    def peek(self):
+        if self.size() != 0:
+            return self.head.getData()
+
+    def size(self):
+        current = self.head
+        count = 0
+        while current is not None:
+            count = count + 1
+            current = current.getNext()
+
+        return count
+
+    def __str__(self):
+        elements = ""
+        current = self.head
+        while current:
+            if current == self.head:
+                elements += "[" + str(current.getData())
+            else:
+                if current:
+                    elements += ", "
+                elements += str(current.getData())
+            if not current.getNext():
+                elements += "]"
+            current = current.getNext()
+        return elements
+
+
+#stack_list = StackLinkedList()
+#stack_list.push(10)
+#stack_list.push(20)
+#stack_list.push(30)
+#print(stack_list.peek())
+#print(stack_list)
+#print(stack_list.size())
+#print(stack_list.pop())
+#print(stack_list)
+#print(stack_list.peek())
+
+
+# Queue linked list
+
+class QueueLinkedList():
+
+    def __init__(self):
+        self.head = None
+        self.last = None
+
+    def isEmpty(self):
+        return self.head is None
+
+    def enqueue(self,item):
+        temp = Node(item)
+        temp.setNext(self.head)
+        self.head = temp
+        if not self.last:
+            self.last = self.head
+
+    def dequeue(self):
+        current = self.head
+        previous = None
+        return_value = None
+        if not current.getNext():
+            previous = current
+        while current:
+            previous = current
+            current = current.getNext()
+        if not current:
+            self.head = None
+        else:
+            previous.setNext(None)
+            return_value = previous.getData()
+        return return_value
+
+    def size(self):
+        current = self.head
+        count = 0
+        while current is not None:
+            count = count + 1
+            current = current.getNext()
+
+        return count
+
+    def __str__(self):
+        elements = ""
+        current = self.head
+        while current:
+            if current == self.head:
+                elements += "[" + str(current.getData())
+            else:
+                if current:
+                    elements += ", "
+                elements += str(current.getData())
+            if not current.getNext():
+                elements += "]"
+            current = current.getNext()
+        return elements
+
+
+#queue_list = QueueLinkedList()
+#queue_list.enqueue(10)
+#queue_list.enqueue(20)
+#queue_list.enqueue(30)
+#print(queue_list)
+#print(queue_list.size())
+#print(queue_list.dequeue())
+#print(queue_list)
+
+# Dequeue linked list
+
+
+class DequeueLinkedList():
+
+    def __init__(self):
+        self.head = None
+        self.last = None
+
+    def isEmpty(self):
+        return self.head is None
+
+    def addFront(self,item):
+        temp = Node(item)
+        temp.setNext(self.head)
+        self.head = temp
+        if not self.last:
+            self.last = self.head
+
+    def addRear(self):
+        current = self.head
+        previous = None
+        return_value = None
+        if not current.getNext():
+            previous = current
+        while current:
+            previous = current
+            current = current.getNext()
+        if not current:
+            self.head = None
+        else:
+            previous.setNext(None)
+            return_value = previous.getData()
+        return return_value
+
+    def removeFront(self):
+        pass
+
+    def removeRear(self):
+        pass
+
+    def size(self):
+        current = self.head
+        count = 0
+        while current is not None:
+            count = count + 1
+            current = current.getNext()
+
+        return count
+
+    def __str__(self):
+        elements = ""
+        current = self.head
+        while current:
+            if current == self.head:
+                elements += "[" + str(current.getData())
+            else:
+                if current:
+                    elements += ", "
+                elements += str(current.getData())
+            if not current.getNext():
+                elements += "]"
+            current = current.getNext()
+        return elements
+
+
+dequeue_list = DequeueLinkedList()
+dequeue_list.enqueue(10)
+dequeue_list.enqueue(20)
+dequeue_list.enqueue(30)
+
+# Doubly linked list
+# Head reference contains one to first node and one to last node
+
+class DoubleNode:
+    def __init__(self,initdata):
+        self.data = initdata
+        self.next = None
+        self.back = None
+
+    def getData(self):
+        return self.data
+
+    def getBack(self):
+        return self.back
+
+    def getNext(self):
+        return self.next
+
+    def setData(self,newdata):
+        self.data = newdata
+
+    def setBack(self, newback):
+        self.back = newback
+
+    def setNext(self,newnext):
+        self.next = newnext
+
+    def __str__(self):
+        return str(self.data, str(self.back), str(self.next))
+
+
+class DoublyLinkedList():
+    def __init__(self, args):
+        "docstring"
+
+
+
+# Implementation of queue that has o(1) in enqueue and o(1) in dequeue

@@ 1,178 @@
+#!/usr/bin/python3
+
+from typing import List
+import random
+
+class Queue:
+    def __init__(self):
+        self.items = []
+
+    def isEmpty(self):
+        return self.items == []
+
+    def enqueue(self, item):
+        self.items.append(item)
+
+    def dequeue(self):
+        return self.items.pop(0)
+
+    def size(self):
+        return len(self.items)
+
+    def __str__(self):
+        return str(self.items)
+
+
+q = Queue()
+q.enqueue('hello')
+q.enqueue('dog')
+q.enqueue(3)
+q.dequeue()
+
+
+def hotPotato(namelist, num):
+    simqueue = Queue()
+    for name in namelist:
+        simqueue.enqueue(name)
+
+    while simqueue.size() > 1:
+        for i in range(random.randint(0,10)):
+            simqueue.enqueue(simqueue.dequeue())
+
+        simqueue.dequeue()
+
+    return simqueue.dequeue()
+
+# print(
+#     hotPotato(
+#         ["Bill","David","Susan","Jane","Kent","Brad"],7
+#     )
+# )
+
+
+class Printer:
+    def __init__(self, ppm):
+        self.pagerate = ppm
+        self.currentTask = None
+        self.timeRemaining = 0
+
+    def tick(self):
+        if self.currentTask != None:
+            self.timeRemaining = self.timeRemaining - 1
+            if self.timeRemaining <= 0:
+                self.currentTask = None
+
+    def busy(self):
+        if self.currentTask != None:
+            return True
+        else:
+            return False
+
+    def startNext(self,newtask):
+        self.currentTask = newtask
+        # Divided by 2 because we supposed the average
+        # time got reduced
+        self.timeRemaining = (newtask.getPages() * 60/self.pagerate) / 2
+
+
+class Task:
+    def __init__(self,time):
+        self.timestamp = time
+        self.pages = random.randrange(1,21)
+
+    def getStamp(self):
+        return self.timestamp
+
+    def getPages(self):
+        return self.pages
+
+    def waitTime(self, currenttime):
+        return currenttime - self.timestamp
+
+
+def simulation(numSeconds, pagesPerMinute, numberOfStudents):
+
+    labprinter = Printer(pagesPerMinute)
+    printQueue = Queue()
+    waitingtimes = []
+
+    for currentSecond in range(numSeconds):
+
+        if newPrintTask(numberOfStudents):
+            task = Task(currentSecond)
+            printQueue.enqueue(task)
+
+        if (not labprinter.busy()) and (not printQueue.isEmpty()):
+            nexttask = printQueue.dequeue()
+            waitingtimes.append(nexttask.waitTime(currentSecond))
+            labprinter.startNext(nexttask)
+
+        labprinter.tick()
+
+    averageWait=sum(waitingtimes)/len(waitingtimes)
+    print("Average Wait %6.2f secs %3d tasks remaining."%(averageWait,printQueue.size()))
+
+def newPrintTask(numberOfStudents):
+    # The times 2 is because we assume every student uses
+    # the printer twice
+    task_average_per_hour = 3600 // (numberOfStudents * 2)
+    num = random.randrange(1, task_average_per_hour + 1)
+    if num == task_average_per_hour:
+        return True
+    else:
+        return False
+
+for i in range(10):
+    simulation(3600,5, 20)
+
+
+
+def radix10_sorting(numbers: List[str]) -> List[str]:
+    main_bin = Queue()
+
+    bin_0 = Queue()
+    bin_1 = Queue()
+    bin_2 = Queue()
+    bin_3 = Queue()
+    bin_4 = Queue()
+    bin_5 = Queue()
+    bin_6 = Queue()
+    bin_7 = Queue()
+    bin_8 = Queue()
+    bin_9 = Queue()
+
+    digit_bin = {
+        "0": bin_0,
+        "1": bin_1,
+        "2": bin_2,
+        "3": bin_3,
+        "4": bin_4,
+        "5": bin_5,
+        "6": bin_6,
+        "7": bin_7,
+        "8": bin_8,
+        "9": bin_9,
+    }
+
+    for num in numbers:
+        main_bin.enqueue(num)
+        reversed_digit = num[::-1]
+        for digit in reversed_digit:
+            digit_bin[digit].enqueue(main_bin.dequeue())
+
+    # Collect back the value into the main one
+    for d_bin in digit_bin.values():
+        if d_bin.size() != 0:
+            main_bin.enqueue(d_bin.dequeue())
+
+    queued_numbers: List[str] = []
+    while main_bin.size() != 0:
+        queued_numbers.append(main_bin.dequeue())
+
+    return queued_numbers
+
+
+#test_numbers = ["667", "534"]
+#test_numbers = ["2", "1"]
+#test_numbers = ["9", "3", "8", "1"]
+print(radix10_sorting(test_numbers))

@@ 1,292 @@
+#!/usr/bin/python3
+
+"""
+With this structure it is easy
+to get the reverse order of the items inserted
+"""
+
+
+class Stack:
+    def __init__(self):
+        self.items = []
+
+    def isEmpty(self):
+        return self.items == []
+
+    def push(self, item):
+        self.items.append(item)
+
+    def pop(self):
+        return self.items.pop()
+
+    def peek(self):
+        return self.items[len(self.items)-1]
+
+    def size(self):
+        return len(self.items)
+
+    def __str__(self):
+        return str(self.items)
+
+
+m = Stack()
+m.push('x')
+m.push('y')
+m.push('z')
+while not m.isEmpty():
+    m.pop()
+
+test_string = "abc"
+
+def revstring(to_reverse: str) -> str:
+    reversed_string = ""
+    stack = Stack()
+    for letter in to_reverse:
+        stack.push(letter)
+    while not stack.isEmpty():
+        reversed_string = reversed_string + stack.peek()
+        stack.pop()
+    return reversed_string
+
+rev_string = revstring(test_string)
+print(rev_string)
+
+
+def parChecker(symbolString):
+    s = Stack()
+    balanced = True
+    index = 0
+    while index < len(symbolString) and balanced:
+        symbol = symbolString[index]
+        if symbol == "(":
+            s.push(symbol)
+        else:
+            if s.isEmpty():
+                balanced = False
+            else:
+                s.pop()
+
+        index = index + 1
+
+    if balanced and s.isEmpty():
+        return True
+    else:
+        return False
+
+print(parChecker('((()))'))
+print(parChecker('(()'))
+
+def parChecker(symbolString):
+    s = Stack()
+    balanced = True
+    index = 0
+    while index < len(symbolString) and balanced:
+        symbol = symbolString[index]
+        if symbol in "([{":
+            s.push(symbol)
+        else:
+            if s.isEmpty():
+                balanced = False
+            else:
+                top = s.pop()
+                if not matches(top,symbol):
+                       balanced = False
+        index = index + 1
+    if balanced and s.isEmpty():
+        return True
+    else:
+        return False
+
+def matches(open,close):
+    opens = "([{"
+    closers = ")]}"
+    return opens.index(open) == closers.index(close)
+
+
+print(parChecker('{({([][])}())}'))
+print(parChecker('[{()]'))
+
+
+def divideBy2(decNumber):
+    remstack = Stack()
+
+    while decNumber > 0:
+        rem = decNumber % 2
+        remstack.push(rem)
+        decNumber = decNumber // 2
+
+    binString = ""
+    while not remstack.isEmpty():
+        binString = binString + str(remstack.pop())
+
+    return binString
+
+print(divideBy2(42))
+print(divideBy2(17))
+print(divideBy2(45))
+print(divideBy2(96))
+
+
+def baseConverter(decNumber,base):
+    digits = "0123456789ABCDEF"
+
+    remstack = Stack()
+
+    while decNumber > 0:
+        rem = decNumber % base
+        remstack.push(rem)
+        decNumber = decNumber // base
+
+    newString = ""
+    while not remstack.isEmpty():
+        newString = newString + digits[remstack.pop()]
+
+    return newString
+
+#print(baseConverter(25,2))
+#print(baseConverter(25,16))
+
+
+def matches(open,close):
+    opens = "<"
+    closers = ">"
+    return opens.index(open) == closers.index(close)
+
+
+def html_validator(symbolString):
+    opening_angle_bracket = Stack()
+    tags = Stack()
+    excluded_characters = ["\n", " "]
+    balanced = True
+    is_tag = True
+    current_token = ""
+    index = 0
+    while index < len(symbolString) and balanced:
+        symbol = symbolString[index]
+        if symbol in "<":
+            is_tag = True
+            opening_angle_bracket.push(symbol)
+            if symbol not in excluded_characters:
+                current_token += symbol
+        else:
+            if symbol in ">":
+                is_tag = False
+                if symbol not in excluded_characters:
+                    current_token += symbol
+                    if tags.size() !=0 and "</" + tags.peek()[1::] == current_token:
+                        tags.pop()
+                    else:
+                        tags.push(current_token)
+                    current_token = ""
+                top = opening_angle_bracket.pop()
+            else:
+                if symbol not in excluded_characters and is_tag:
+                    current_token += symbol
+        index = index + 1
+    if balanced and opening_angle_bracket.isEmpty() and tags.isEmpty():
+        return True
+    else:
+        if not opening_angle_bracket.isEmpty():
+            print(f"Missing a closing '>' : {opening_angle_bracket.peek()}")
+        if not tags.isEmpty():
+            tag, tag_type = get_missing_tag(tags)
+            print(f"Missing a {tag_type} tag for : {tag}")
+        return False
+
+
+def get_missing_tag(tags: Stack) -> str:
+    tag = ""
+    tag_type = ""
+    while not tag:
+        if tags.size() > 0:
+            if "</" in tags.peek():
+                tags.pop()
+            else:
+                tag = tags.peek()
+        else:
+            break
+    if "</" in tag:
+        tag_type = "opening"
+    else:
+        tag_type = "closing"
+    return tag, tag_type
+
+
+test_html = """
+<html>
+      <title>
+         Example
+      </title>
+   </head>
+
+   <body>
+      <h1>Hello, world</h1>
+   </body>
+</html>
+"""
+
+print(html_validator(test_html))
+
+
+def infixToPostfix(infixexpr):
+    prec = {}
+    prec["*"] = 3
+    prec["/"] = 3
+    prec["+"] = 2
+    prec["-"] = 2
+    prec["("] = 1
+    opStack = Stack()
+    postfixList = []
+    tokenList = infixexpr.split()
+    breakpoint()
+    for token in tokenList:
+        if token in "ABCDEFGHIJKLMNOPQRSTUVWXYZ" or token in "0123456789":
+            postfixList.append(token)
+        elif token == '(':
+            opStack.push(token)
+        elif token == ')':
+            topToken = opStack.pop()
+            while topToken != '(':
+                postfixList.append(topToken)
+                topToken = opStack.pop()
+        else:
+            while (not opStack.isEmpty()) and \
+               (prec[opStack.peek()] >= prec[token]):
+                  postfixList.append(opStack.pop())
+            opStack.push(token)
+
+    while not opStack.isEmpty():
+        postfixList.append(opStack.pop())
+    return " ".join(postfixList)
+
+print(infixToPostfix("( A * B ) + ( C * D )"))
+#print(infixToPostfix("( A + B ) * C - ( D - E ) * ( F + G )"))
+#print(infixToPostfix("( A + B ) * ( C + D ) * ( E + F )"))
+#print(infixToPostfix("A + ( ( B + C ) * ( D + E ) )"))
+#print(infixToPostfix("A * B * C * D + E + F"))
+
+def postfixEval(postfixExpr):
+    operandStack = Stack()
+    tokenList = postfixExpr.split()
+
+    for token in tokenList:
+        if token in "0123456789":
+            operandStack.push(int(token))
+        else:
+            operand2 = operandStack.pop()
+            operand1 = operandStack.pop()
+            result = doMath(token,operand1,operand2)
+            operandStack.push(result)
+    return operandStack.pop()
+
+def doMath(op, op1, op2):
+    if op == "*":
+        return op1 * op2
+    elif op == "/":
+        return op1 / op2
+    elif op == "+":
+        return op1 + op2
+    else:
+        return op1 - op2
+
+print(postfixEval('7 8 + 3 2 + /'))

@@ 1,27 @@
+* Recursion
+
+Recursion is a method of solving problems that involves breaking a problem down into smaller and smaller subproblems until you get to a small enough problem that it can be solved trivially. Usually recursion involves a function calling itself. While it may not seem like much on the surface, recursion allows us to write elegant solutions to problems that may otherwise be very difficult to program.
+
+
+* Stack frames
+
+Each time we make a call to toStr, we push a character on the stack. Returning to the previous example we can see that after the fourth call to toStr the stack would look like Figure 5. Notice that now we can simply pop the characters off the stack and concatenate them into the final result, "1010".
+
+
+#+DOWNLOADED: screenshot @ 2021-11-05 21:46:34
+[[file:Stack_frames/2021-11-05_21-46-34_screenshot.png]]
+
+
+The previous example gives us some insight into how Python implements a recursive function call. When a function is called in Python, a stack frame is allocated to handle the local variables of the function. When the function returns, the return value is left on top of the stack for the calling function to access. Figure 6 illustrates the call stack after the return statement on line 4.
+
+
+
+#+DOWNLOADED: screenshot @ 2021-11-05 21:45:54
+[[file:Recursion/2021-11-05_21-45-54_screenshot.png]]
+
+
+Figure 6: Call Stack Generated from toStr(10,2)
+
+Notice that the call to toStr(2//2,2) leaves a return value of "1" on the stack. This return value is then used in place of the function call (toStr(1,2)) in the expression "1" + convertString[2%2], which will leave the string "10" on the top of the stack. In this way, the Python call stack takes the place of the stack we used explicitly in Listing 4. In our list summing example, you can think of the return value on the stack taking the place of an accumulator variable.
+
+The stack frames also provide a scope for the variables used by the function. Even though we are calling the same function over and over, each call creates a new scope for the variables that are local to the function.

@@ 1,12 @@
+#!/usr/bin/python3
+
+def toStr(n,base):
+   convertString = "0123456789ABCDEF"
+   if n < base:
+      return convertString[n]
+   else:
+      return toStr(n//base,base) + convertString[n%base]
+
+print(toStr(10,2))
+
+print(toStr(1453,16))

@@ 1,26 @@
+#!/usr/bin/python3
+
+def euclid(m: int, n: int) -> int:
+    remainder  = m % n
+    while remainder != 0:
+        remainder  = m % n
+        if remainder == 0:
+            return n
+        m, n = n, remainder
+    else:
+        return n
+
+
+def euclid_improved(m: int, n: int) -> int:
+    remainder  = m % n
+    if remainder == 0:
+        return n
+    else:
+        return euclid_improved(n, remainder)
+
+
+if __name__ == '__main__':
+    m = int(input("Entrez un nombre entier positif m : "))
+    n = int(input("Entrez un nombre entier positif n : "))
+    result = euclid_improved(m, n)
+    print(f"Le PGCD entre {m} et {n} est {result}")

@@ 1,81 @@
+import string
+from typing import List, Dict
+
+def factorial(n: int) -> int:
+    if n <= 1:
+        return 1
+    else:
+        return n * factorial(n - 1)
+
+# print(factorial(5))
+# fac(5) -> 120: 5 * 4 * 3 * 2 * 1
+# fac(4) -> 24: 4 * 3 * 2 * 1
+# fac(3) -> 6 : 3 * 2 * 1
+# fac(2) -> 2 : 2 * 1
+# fac(1) -> 1 : 1
+# fac(0) -> 1
+
+
+def reverse_list(my_list: List[str | int]) -> List[str | int]:
+    if len(my_list) <= 1:
+        return my_list
+    else:
+        return my_list[-1::] + reverse_list(my_list[:-1])
+
+
+test_list = [10,20,30]
+test_list = [1,5,10,20,100,1000,10000]
+#print(reverse_list(test_list))
+
+
+def reverse_string(to_reverse: str) -> str:
+    if len(to_reverse) <= 1:
+        return to_reverse
+    else:
+        return to_reverse[-1] + reverse_string(to_reverse[:-1])
+
+
+test_string = "abc"
+#print(reverse_string(test_string))
+
+def is_palindrome(my_string: str) -> bool:
+    removed_punctuation = my_string.translate(
+        str.maketrans('', '', string.punctuation + '’')
+    )
+    my_string = ''.join(removed_punctuation.lower().split())
+    return bool(my_string == reverse_string(my_string))
+
+test_strings = [
+    "kayak",
+    "radar",
+    "aibohphobia",
+    "Live not on evil",
+    "Reviled did I live, said I, as evil I did deliver",
+    "Go hang a salami; I’m a lasagna hog.",
+    "Able was I ere I saw Elba",
+    "Kanakanak", # a town in Alaska,
+    "Wassamassaw", # a town in South Dakota
+    "madam i’m adam",
+    "hannah",
+    "hello",
+    "x",
+    ""
+]
+#for test_string in test_strings:
+#    print(is_palindrome(test_string))
+
+# Fibonacci sequence
+# The Rule is xn = xn−1 + xn−2 or F_n is the sum of its 2 preceding number
+
+# 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, .
+
+def fibonacci(n: int, memo: Dict[int, int]) -> int:
+    if n <= 1:
+        return n
+    elif n in memo:
+        return memo[n]
+    else:
+        memo[n] = fibonacci(n - 1, memo) + fibonacci(n - 2, memo)
+    return memo[n]
+
+print(fibonacci(998, {0: 1,1: 1}))

@@ 1,162 @@
+#!/usr/bin/python3
+
+def listsum(numList):
+    theSum = 0
+    for i in numList:
+        theSum = theSum + i
+    return theSum
+
+print(listsum([1,3,5,7,9]))
+
+
+def listsum(numList):
+   if len(numList) == 1:
+        return numList[0]
+   else:
+        return numList[0] + listsum(numList[1:])
+
+print(listsum([1,3,5,7,9]))
+
+def toStr(n,base):
+   convertString = "0123456789ABCDEF"
+   if n < base:
+      return convertString[n]
+   else:
+      return toStr(n//base,base) + convertString[n%base]
+
+print(toStr(1453,16))
+
+
+def reverse(s):
+    return s
+
+testEqual(reverse("hello"),"olleh")
+testEqual(reverse("l"),"l")
+testEqual(reverse("follow"),"wollof")
+testEqual(reverse(""),"")
+
+from test import testEqual
+def removeWhite(s):
+    return s
+
+def isPal(s):
+    return False
+
+testEqual(isPal(removeWhite("x")),True)
+testEqual(isPal(removeWhite("radar")),True)
+testEqual(isPal(removeWhite("hello")),False)
+testEqual(isPal(removeWhite("")),True)
+testEqual(isPal(removeWhite("hannah")),True)
+testEqual(isPal(removeWhite("madam i'm adam")),True)
+
+rStack = Stack()
+
+def toStr(n,base):
+    convertString = "0123456789ABCDEF"
+    while n > 0:
+        if n < base:
+            rStack.push(convertString[n])
+        else:
+            rStack.push(convertString[n % base])
+        n = n // base
+    res = ""
+    while not rStack.isEmpty():
+        res = res + str(rStack.pop())
+    return res
+
+print(toStr(1453,16))
+
+
+import turtle
+
+myTurtle = turtle.Turtle()
+myWin = turtle.Screen()
+
+def drawSpiral(myTurtle, lineLen):
+    if lineLen > 0:
+        myTurtle.forward(lineLen)
+        myTurtle.right(90)
+        drawSpiral(myTurtle,lineLen-5)
+
+drawSpiral(myTurtle,100)
+myWin.exitonclick()
+
+import turtle
+
+def tree(branchLen,t):
+    if branchLen > 5:
+        t.forward(branchLen)
+        t.right(20)
+        tree(branchLen-15,t)
+        t.left(40)
+        tree(branchLen-15,t)
+        t.right(20)
+        t.backward(branchLen)
+
+def main():
+    t = turtle.Turtle()
+    myWin = turtle.Screen()
+    t.left(90)
+    t.up()
+    t.backward(100)
+    t.down()
+    t.color("green")
+    tree(75,t)
+    myWin.exitonclick()
+
+main()
+
+
+import turtle
+
+def drawTriangle(points,color,myTurtle):
+    myTurtle.fillcolor(color)
+    myTurtle.up()
+    myTurtle.goto(points[0][0],points[0][1])
+    myTurtle.down()
+    myTurtle.begin_fill()
+    myTurtle.goto(points[1][0],points[1][1])
+    myTurtle.goto(points[2][0],points[2][1])
+    myTurtle.goto(points[0][0],points[0][1])
+    myTurtle.end_fill()
+
+def getMid(p1,p2):
+    return ( (p1[0]+p2[0]) / 2, (p1[1] + p2[1]) / 2)
+
+def sierpinski(points,degree,myTurtle):
+    colormap = ['blue','red','green','white','yellow',
+                'violet','orange']
+    drawTriangle(points,colormap[degree],myTurtle)
+    if degree > 0:
+        sierpinski([points[0],
+                        getMid(points[0], points[1]),
+                        getMid(points[0], points[2])],
+                   degree-1, myTurtle)
+        sierpinski([points[1],
+                        getMid(points[0], points[1]),
+                        getMid(points[1], points[2])],
+                   degree-1, myTurtle)
+        sierpinski([points[2],
+                        getMid(points[2], points[1]),
+                        getMid(points[0], points[2])],
+                   degree-1, myTurtle)
+
+def main():
+   myTurtle = turtle.Turtle()
+   myWin = turtle.Screen()
+   myPoints = [[-100,-50],[0,100],[100,-50]]
+   sierpinski(myPoints,3,myTurtle)
+   myWin.exitonclick()
+
+main()
+
+def moveTower(height,fromPole, toPole, withPole):
+    if height >= 1:
+        moveTower(height-1,fromPole,withPole,toPole)
+        moveDisk(fromPole,toPole)
+        moveTower(height-1,withPole,toPole,fromPole)
+
+def moveDisk(fp,tp):
+    print("moving disk from",fp,"to",tp)
+
+moveTower(3,"A","B","C")

@@ 1,20 @@
+#!/usr/bin/python3
+
+from pythonds.basic import Stack
+
+rStack = Stack()
+
+def toStr(n,base):
+    convertString = "0123456789ABCDEF"
+    while n > 0:
+        if n < base:
+            rStack.push(convertString[n])
+        else:
+            rStack.push(convertString[n % base])
+        n = n // base
+    res = ""
+    while not rStack.isEmpty():
+        res = res + str(rStack.pop())
+    return res
+
+print(toStr(1453,16))

@@ 1,39 @@
+#!/usr/bin/python3
+
+import turtle
+
+#myTurtle = turtle.Turtle()
+#myWin = turtle.Screen()
+
+def drawSpiral(myTurtle, lineLen):
+    if lineLen > 0:
+        myTurtle.forward(lineLen)
+        myTurtle.right(90)
+        drawSpiral(myTurtle,lineLen-5)
+
+#drawSpiral(myTurtle,100)
+#myWin.exitonclick()
+
+def tree(branchLen,t):
+    if branchLen > 5:
+        t.forward(branchLen)
+        t.right(20)
+        tree(branchLen-15,t)
+        breakpoint()
+        t.left(40)
+        tree(branchLen-15,t)
+        t.right(20)
+        t.backward(branchLen)
+
+def main():
+    t = turtle.Turtle()
+    myWin = turtle.Screen()
+    t.left(90)
+    t.up()
+    t.backward(100)
+    t.down()
+    t.color("green")
+    tree(30,t)
+    myWin.exitonclick()
+
+main()

@@ 1,7 @@
+* TODO
+
+- Heapsort
+
+- Prove that heapsort is o(n log n)
+
+- Optimal value for the hash resize, resize when the hash table is full at 50 75 % ? why ?

@@ 1,75 @@
+#!/usr/bin/python3
+
+import random
+
+# def binarySearch(alist, item):
+#     first = 0
+#     last = len(alist)-1
+#     found = False
+
+#     while first<=last and not found:
+#         midpoint = (first + last)//2
+#         if alist[midpoint] == item:
+#             found = True
+#         else:
+#             if item < alist[midpoint]:
+#                 last = midpoint-1
+#             else:
+#                 first = midpoint+1
+
+#     return found
+
+#testlist = [0, 1, 2, 8, 13, 17, 19, 32, 42]
+#print(binarySearch(testlist, 3))
+#print(binarySearch(testlist, 13))
+
+
+def binarySearch(alist, item):
+    if len(alist) == 0:
+        return False
+    else:
+        midpoint = len(alist)//2
+        if alist[midpoint]==item:
+          return True
+        else:
+          if item<alist[midpoint]:
+            return binarySearch(alist[:midpoint],item)
+          else:
+            return binarySearch(alist[midpoint+1:],item)
+
+#testlist = [0, 1, 2, 8, 13, 17, 19, 32, 42,]
+testlist = [3, 5, 6, 8, 11, 12, 14, 15, 17, 18]
+breakpoint()
+print(binarySearch(testlist, 16))
+#print(binarySearch(testlist, 3))
+#print(binarySearch(testlist, 13))
+
+# The same but without the slice
+
+def binarySearch(alist, first, last, item):
+    midpoint = (first + last) // 2
+    if first > last and item != alist[midpoint]:
+        return False
+    else:
+        if alist[midpoint] == item:
+            return True
+        else:
+            if item < alist[midpoint]:
+                return binarySearch(alist, first, midpoint - 1, item)
+            else:
+                return binarySearch(alist, midpoint + 1, last, item)
+
+#testlist = [0, 1, 2, 8, 13, 17, 19, 32, 42,]
+#testlist = [17, 46, 23, 56, 89, 86, 87, 16, 87, 65]
+# print(binarySearch(testlist, 0, len(testlist) - 1,  3))
+# print(binarySearch(testlist, 0, len(testlist) - 1, 13))
+# print(binarySearch(testlist, 0, len(testlist) - 1, 46))
+# [random.randint(10,100) for x in range(random.randint(5,10))]
+
+
+# When we split the list enough times, we end up with a list that has
+# just one item. Either that is the item we are looking for or it is
+# not. Either way, we are done. The number of comparisons necessary to
+# get to this point is i where n2i=1. Solving for i gives us i=logn. The
+# maximum number of comparisons is logarithmic with respect to the
+# number of items in the list. Therefore, the binary search is O(logn).

@@ 1,71 @@
+#!/usr/bin/python3
+
+# The bubble sort makes multiple passes through a list. It compares
+# adjacent items and exchanges those that are out of order. Each pass
+# through the list places the next largest value in its proper place. In
+# essence, each item “bubbles” up to the location where it belongs.
+
+def bubbleSort(alist):
+    for passnum in range(len(alist) - 1, 0, -1):
+        for i in range(passnum):
+            if alist[i] > alist[i+1]:
+                alist[i+1], alist[i] = alist[i], alist[i+1]
+
+alist = [54,26,93,17,77,31,44,55,20]
+alist = [2,3,4,5,1]
+bubbleSort(alist)
+print(alist)
+
+# A bubble sort is often considered the most inefficient sorting method
+# since it must exchange items before the final location is known. These
+# “wasted” exchange operations are very costly. However, because the
+# bubble sort makes passes through the entire unsorted portion of the
+# list, it has the capability to do something most sorting algorithms
+# cannot. In particular, if during a pass there are no exchanges, then
+# we know that the list must be sorted. A bubble sort can be modified to
+# stop early if it finds that the list has become sorted. This means
+# that for lists that require just a few passes, a bubble sort may have
+# an advantage in that it will recognize the sorted list and
+# stop. ActiveCode 2 shows this modification, which is often referred to
+# as the short bubble.
+
+def shortBubbleSort(alist):
+    exchanges = True
+    passnum = len(alist)-1
+    while passnum > 0 and exchanges:
+       exchanges = False
+       for i in range(passnum):
+           if alist[i]>alist[i+1]:
+               exchanges = True
+               temp = alist[i]
+               alist[i] = alist[i+1]
+               alist[i+1] = temp
+       passnum = passnum-1
+
+# alist=[20,30,40,90,50,60,70,80,100,110]
+# shortBubbleSort(alist)
+# print(alist)
+
+# Alternative sort, this one makes less pass if there is like only one
+# item to move backwards
+
+def bubbleSortAlternating(alist):
+    for passnum in range(len(alist) -1, 0, -1):
+        if passnum % 2 == 0:
+            for i in range(passnum):
+                if alist[i] > alist[i+1]:
+                    alist[i+1], alist[i] = alist[i], alist[i+1]
+        else:
+            for i in reversed(range(passnum)):
+                if alist[i] > alist[i+1]:
+                    alist[i+1], alist[i] = alist[i], alist[i+1]
+    print(passnum)
+
+alist = [54,26,93,17,77,31,44,55,20]
+alist = [2,3,4,5,1]
+bubbleSortAlternating(alist)
+print(alist)
+
+# (2,3,4,5,1)
+# (2,3,4,1,5)
+# (1,2,3,4,5)

@@ 1,52 @@
+#!/usr/bin/python3
+
+# Lambda (load factor) = number of items/ tablesize
+
+# 10% full
+# 25% full
+# 50% full
+# 75% full
+# 90% full
+# 99% full
+
+test_values = {0.10, 0.25, 0.50, 0.75, 0.90, 0.99}
+
+
+def succesful_probing(n: int) -> float:
+    avg_comparison = 1/2 * (1 + (1/1-n))
+    return avg_comparison
+
+
+def unsuccesful_probing(n: int) -> float:
+    avg_comparison = 1/2 * (1 + (1/1-n) ** 2)
+    return avg_comparison
+
+
+def succesful_chaining(n: int) -> float:
+    avg_comparison = 1 + n/2
+    return avg_comparison
+
+
+def unsuccesful_chaining(n: int) -> float:
+    avg_comparison = n
+    return avg_comparison
+
+
+print("Succesful probing")
+for count, n in enumerate(test_values, 1):
+    print(count, ": ",  "load factor is : ", n,   "average number of compaisons :",succesful_probing(n))
+
+
+print("Unsuccesful probing")
+for count, n in enumerate(test_values, 1):
+    print(count, ": ",  "load factor is : ", n,   "average number of compaisons :",unsuccesful_probing(n))
+
+
+print("Succesful chaining")
+for count, n in enumerate(test_values, 1):
+    print(count, ": ",  "load factor is : ", n,   "average number of compaisons :",succesful_chaining(n))
+
+
+print("Unsuccesful chaining")
+for count, n in enumerate(test_values, 1):
+    print(count, ": ", "load factor is : ", n,  "average number of compaisons :", unsuccesful_chaining(n))

@@ 1,9 @@
+#!/usr/bin/python3
+
+def hash(astring, tablesize):
+    sum = 0
+    for pos in range(len(astring)):
+        sum = sum + ord(astring[pos])
+
+    return sum%tablesize
+

@@ 1,24 @@
+#!/usr/bin/python3
+
+# We begin by assuming that a list with one item (position 0) is already
+# sorted. On each pass,  one for each item 1 through n−1,  the current
+# item is checked against those in the already sorted sublist. As we
+# look back into the already sorted sublist,  we shift those items that
+# are greater to the right. When we reach a smaller item or the end of
+# the sublist,  the current item can be inserted.
+
+def insertionSort(alist):
+   for index in range(1,  len(alist)):
+
+     currentvalue = alist[index]
+     position = index
+
+     while position > 0 and alist[position-1] > currentvalue:
+         alist[position] = alist[position-1]
+         position = position-1
+
+     alist[position] = currentvalue
+
+alist = [54, 26, 93, 17, 77, 31, 44, 55, 20]
+insertionSort(alist)
+print(alist)

@@ 1,217 @@
+#!/usr/bin/python3
+
+class HashTable:
+    def __init__(self):
+        self.size = 11
+        self.slots = [None] * self.size
+        self.data = [None] * self.size
+        self.load = 0
+        self.load_factor = 0
+
+    def put(self, key, data):
+        # Check the capacity of the map
+        if self.load_factor >= 75:
+            growth_factor = 10
+            self.size = self.size + growth_factor
+            # Need to recalculate the hash for the elements that were in the slots
+            old_slots = self.slots
+            old_datas = self.data
+            self.slots = [None] * self.size
+            self.data = [None] * self.size
+            self.load = 0
+            self.load_factor = int((self.load / self.size) * 100)
+            for old_slot, old_data in zip(old_slots, old_datas):
+                if old_slot is not None:
+                    self.put(old_slot, old_data)
+ 
+        hashvalue = self.hashfunction(key, len(self.slots))
+
+        if self.slots[hashvalue] is None:
+            self.slots[hashvalue] = key
+            self.data[hashvalue] = data
+            self.load += 1
+            self.load_factor = int((self.load / self.size) * 100)
+        else:
+            if self.slots[hashvalue] == key:
+                self.data[hashvalue] = data  #replace
+            else:
+                nextslot = self.rehash(hashvalue,len(self.slots))
+                while self.slots[nextslot] is not None and \
+                      self.slots[nextslot] != key:
+                    nextslot = self.rehash(nextslot, len(self.slots))
+                if self.slots[nextslot] is None:
+                    self.slots[nextslot] = key
+                    self.data[nextslot] = data
+                    self.load += 1
+                    self.load_factor = int((self.load / self.size) * 100)
+                else:
+                    self.data[nextslot] = data #replace
+
+    def hashfunction(self, key, size):
+         return key % size
+
+    def rehash(self, oldhash, size):
+        return (oldhash+1) % size
+
+    def get(self, key):
+      startslot = self.hashfunction(key, len(self.slots))
+
+      data = None
+      stop = False
+      found = False
+      position = startslot
+      while self.slots[position] != None and  \
+                           not found and not stop:
+         if self.slots[position] == key:
+           found = True
+           data = self.data[position]
+         else:
+           position=self.rehash(position,len(self.slots))
+           if position == startslot:
+               stop = True
+      return data
+
+    def __getitem__(self,key):
+        return self.get(key)
+
+    def __setitem__(self,key,data):
+        self.put(key,data)
+
+    def __len__(self):
+        return len([x for x in self.slots if x is not None])
+
+    def __contains__(self, key):
+        # Could also use a try except indexoutofbonds?
+        # that's something that is done for iteration with StopIteration
+        return key in self.slots
+
+    def __delitem__(self, key):
+        startslot = self.hashfunction(key, len(self.slots))
+        stop = False
+        found = False
+        position = startslot
+        while self.slots[position] != None and  \
+                            not found and not stop:
+            if self.slots[position] == key:
+                found = True
+            else:
+                position=self.rehash(position,len(self.slots))
+                if position == startslot:
+                    stop = True
+        del self.slots[position]
+        del self.data[position]
+        self.load -= 1
+        self.load_factor = int((self.load / self.size) * 100)
+
+
+H=HashTable()
+H[54]="cat"
+H[26]="dog"
+H[93]="lion"
+H[17]="tiger"
+H[77]="bird"
+H[31]="cow"
+H[44]="goat"
+H[55]="pig"
+H[20]="chicken"
+print(H.slots)
+print(H.data)
+
+print(H[20])
+
+print(H[17])
+H[20]='duck'
+print(H[20])
+print(H[99])
+print(len(H))
+print(20 in H)
+
+# Filling to capacity
+H[104]="Creeper"
+H[158]="chicken"
+H[24]="turtle"
+H[25]="eagle"
+H[15]="blue eyes white dragon"
+print(H.slots)
+print(H.data)
+print(H[104])
+print(len(H))
+del H[104]
+
+
+class HashTableQuadratic(HashTable):
+    def __init__(self):
+        super().__init__()
+        self.quadratic = 1
+
+    def put(self, key, data):
+        # Check the capacity of the map
+        if self.load_factor >= 75:
+            growth_factor = 10
+            self.size = self.size + growth_factor
+            # Need to recalculate the hash for the elements that were in the slots
+            old_slots = self.slots
+            old_datas = self.data
+            self.slots = [None] * self.size
+            self.data = [None] * self.size
+            self.load = 0
+            self.load_factor = int((self.load / self.size) * 100)
+            for old_slot, old_data in zip(old_slots, old_datas):
+                if old_slot is not None:
+                    self.put(old_slot, old_data)
+ 
+        hashvalue = self.hashfunction(key, len(self.slots))
+
+        if self.slots[hashvalue] is None:
+            self.slots[hashvalue] = key
+            self.data[hashvalue] = data
+            self.load += 1
+            self.load_factor = int((self.load / self.size) * 100)
+        else:
+            if self.slots[hashvalue] == key:
+                self.data[hashvalue] = data  #replace
+            else:
+                self.quadratic = 1
+                nextslot = self.rehash(hashvalue,len(self.slots))
+                while self.slots[nextslot] is not None and \
+                      self.slots[nextslot] != key:
+                    nextslot = self.rehash(nextslot, len(self.slots))
+                if self.slots[nextslot] is None:
+                    self.slots[nextslot] = key
+                    self.data[nextslot] = data
+                    self.load += 1
+                    self.load_factor = int((self.load / self.size) * 100)
+                else:
+                    self.data[nextslot] = data #replace
+
+    def rehash(self, oldhash, size):
+        newhash = oldhash + self.quadratic ** self.quadratic
+        self.quadratic += 1
+        if newhash > self.size - 1:
+            return newhash % self.size
+        return newhash
+
+J = HashTableQuadratic()
+J[54]="cat"
+J[26]="dog"
+J[93]="lion"
+J[17]="tiger"
+J[77]="bird"
+J[31]="cow"
+J[44]="goat"
+J[55]="pig"
+J[20]="chicken"
+
+print(J.slots)
+print(J.data)
+print(len(J))
+
+#J[545]="pig"
+#J[207]="chicken"
+#
+#
+#print(J.slots)
+#print(J.data)
+#print(len(J))
+#
+#(54,26,93,17,77,31,44,55,20)

@@ 1,38 @@
+#!/usr/bin/python3
+
+def mergeSort(alist):
+    print("Splitting ",alist)
+    if len(alist)>1:
+        mid = len(alist)//2
+        lefthalf = alist[:mid]
+        righthalf = alist[mid:]
+
+        mergeSort(lefthalf)
+        mergeSort(righthalf)
+
+        i=0
+        j=0
+        k=0
+        while i < len(lefthalf) and j < len(righthalf):
+            if lefthalf[i] <= righthalf[j]:
+                alist[k]=lefthalf[i]
+                i=i+1
+            else:
+                alist[k]=righthalf[j]
+                j=j+1
+            k=k+1
+
+        while i < len(lefthalf):
+            alist[k]=lefthalf[i]
+            i=i+1
+            k=k+1
+
+        while j < len(righthalf):
+            alist[k]=righthalf[j]
+            j=j+1
+            k=k+1
+    print("Merging ",alist)
+
+alist = [54,26,93,17,77,31,44,55,20]
+mergeSort(alist)
+print(alist)

@@ 1,56 @@
+#!/usr/bin/python3
+
+from typing import List
+
+def quickSort(alist):
+   quickSortHelper(alist, 0, len(alist)-1)
+
+def quickSortHelper(alist, first, last):
+   if first < last:
+      splitpoint = partition(alist, first, last)
+
+      quickSortHelper(alist, first, splitpoint-1)
+      quickSortHelper(alist, splitpoint+1, last)
+
+
+def partition(alist, first, last):
+   pivotvalue = alist[first]
+
+   leftmark = first+1
+#   leftmark = len(alist) // 2
+   rightmark = last
+
+   done = False
+   while not done:
+
+       while leftmark <= rightmark and alist[leftmark] <= pivotvalue:
+           leftmark = leftmark + 1
+
+       while alist[rightmark] >= pivotvalue and rightmark >= leftmark:
+           rightmark = rightmark -1
+
+       if rightmark < leftmark:
+           done = True
+       else:
+           temp = alist[leftmark]
+           alist[leftmark] = alist[rightmark]
+           alist[rightmark] = temp
+
+   #temp = alist[]
+   temp = alist[first]
+   alist[first] = alist[rightmark]
+   #alist[first] = alist[rightmark]
+   alist[rightmark] = temp
+
+   return rightmark
+
+def median_of_three(alist: List[int]) -> int:
+   return 1
+
+#alist = [54, 26]
+#alist = [17, 20, 26, 31, 44, 54, 55, 77, 93]
+#alist = [54, 26, 93, 17, 77, 31, 44, 55, 20]
+alist = [14, 17, 13, 15, 19, 10, 3, 16, 9, 12]
+breakpoint()
+quickSort(alist)
+print(alist)

@@ 1,31 @@
+#!/usr/bin/python3
+
+# The selection sort improves on the bubble sort by making only one
+# exchange for every pass through the list. In order to do this, a
+# selection sort looks for the largest value as it makes a pass and,
+# after completing the pass, places it in the proper location. As with a
+# bubble sort, after the first pass, the largest item is in the correct
+# place. After the second pass, the next largest is in place. This
+# process continues and requires n−1 passes to sort n items, since the
+# final item must be in place after the (n−1)st pass.
+
+# Figure 3 shows the entire sorting process. On each pass, the largest
+# remaining item is selected and then placed in its proper location. The
+# first pass places 93, the second pass places 77, the third places 55,
+# and so on. The function is shown in ActiveCode 1.
+
+def selectionSort(alist):
+   for fillslot in range(len(alist) - 1, 0, -1):
+      positionOfMax = 0
+      for location in range(1, fillslot+1):
+          if alist[location] > alist[positionOfMax]:
+              positionOfMax = location
+
+      alist[fillslot], alist[positionOfMax] = (
+          alist[positionOfMax], alist[fillslot]
+       )
+
+alist = [54,26,93,17,77,31,44,55,20]
+breakpoint()
+selectionSort(alist)
+print(alist)

@@ 1,49 @@
+#!/usr/bin/python3
+
+def sequentialSearch(alist, item):
+    pos = 0
+    found = False
+
+    while pos < len(alist) and not found:
+        if alist[pos] == item:
+            found = True
+        else:
+            pos = pos+1
+
+    return found
+
+testlist = [1, 2, 32, 8, 17, 19, 42, 13, 0]
+print(sequentialSearch(testlist, 3))
+print(sequentialSearch(testlist, 13))
+print(sequentialSearch("abc", "z"))
+
+# Complexity o(n), case where item is present and not present, avg case
+
+def orderedSequentialSearch(alist, item):
+    pos = 0
+    found = False
+    stop = False
+    while pos < len(alist) and not found and not stop:
+        if alist[pos] == item:
+            found = True
+        else:
+            if alist[pos] > item:
+                stop = True
+            else:
+                pos = pos+1
+
+    return found
+
+testlist = [0, 1, 2, 8, 13, 17, 19, 32, 42,]
+print(orderedSequentialSearch(testlist, 3))
+print(orderedSequentialSearch(testlist, 13))
+
+# With this one there is less comparison to do if the item is not present
+# e.g, for a list of integer
+
+# summarizes these results. Note that in the best case we might discover
+# that the item is not in the list by looking at only one item. On
+# average, we will know after looking through only n2 items. However,
+# this technique is still O(n). In summary, a sequential search is
+# improved by ordering the list only in the case where we do not find
+# the item.

@@ 1,28 @@
+#!/usr/bin/python3
+
+def shellSort(alist):
+    sublistcount = len(alist)//2
+    while sublistcount > 0:
+
+      for startposition in range(sublistcount):
+        gapInsertionSort(alist, startposition, sublistcount)
+
+      print("After increments of size", sublistcount, "The list is", alist)
+
+      sublistcount = sublistcount // 2
+
+def gapInsertionSort(alist, start, gap):
+    for i in range(start+gap, len(alist), gap):
+
+        currentvalue = alist[i]
+        position = i
+
+        while position >= gap and alist[position-gap] > currentvalue:
+            alist[position] = alist[position-gap]
+            position = position-gap
+
+        alist[position] = currentvalue
+
+alist = [54, 26, 93, 17, 77, 31, 44, 55, 20]
+shellSort(alist)
+print(alist)

@@ 1,3 @@
+* Chapter 7
+
+- Do the priority Queue

@@ 1,60 @@
+#!/usr/bin/python3
+
+def _put(self,key,val,currentNode):
+    if key < currentNode.key:
+        if currentNode.hasLeftChild():
+                self._put(key,val,currentNode.leftChild)
+        else:
+                currentNode.leftChild = TreeNode(key,val,parent=currentNode)
+                self.updateBalance(currentNode.leftChild)
+    else:
+        if currentNode.hasRightChild():
+                self._put(key,val,currentNode.rightChild)
+        else:
+                currentNode.rightChild = TreeNode(key,val,parent=currentNode)
+                self.updateBalance(currentNode.rightChild)
+
+def updateBalance(self,node):
+    if node.balanceFactor > 1 or node.balanceFactor < -1:
+        self.rebalance(node)
+        return
+    if node.parent != None:
+        if node.isLeftChild():
+                node.parent.balanceFactor += 1
+        elif node.isRightChild():
+                node.parent.balanceFactor -= 1
+
+        if node.parent.balanceFactor != 0:
+                self.updateBalance(node.parent)
+
+def rotateLeft(self,rotRoot):
+    newRoot = rotRoot.rightChild
+    rotRoot.rightChild = newRoot.leftChild
+    if newRoot.leftChild != None:
+        newRoot.leftChild.parent = rotRoot
+    newRoot.parent = rotRoot.parent
+    if rotRoot.isRoot():
+        self.root = newRoot
+    else:
+        if rotRoot.isLeftChild():
+                rotRoot.parent.leftChild = newRoot
+        else:
+            rotRoot.parent.rightChild = newRoot
+    newRoot.leftChild = rotRoot
+    rotRoot.parent = newRoot
+    rotRoot.balanceFactor = rotRoot.balanceFactor + 1 - min(newRoot.balanceFactor, 0)
+    newRoot.balanceFactor = newRoot.balanceFactor + 1 + max(rotRoot.balanceFactor, 0)
+
+def rebalance(self,node):
+  if node.balanceFactor < 0:
+         if node.rightChild.balanceFactor > 0:
+            self.rotateRight(node.rightChild)
+            self.rotateLeft(node)
+         else:
+            self.rotateLeft(node)
+  elif node.balanceFactor > 0:
+         if node.leftChild.balanceFactor < 0:
+            self.rotateLeft(node.leftChild)
+            self.rotateRight(node)
+         else:
+            self.rotateRight(node)

@@ 1,221 @@
+#!/usr/bin/python3
+
+"""Min heap implementation to starts with."""
+
+class BinHeap:
+    def __init__(self):
+        self.heapList = [0]
+        self.currentSize = 0
+        self.heapSize = 3
+
+    def percUp(self,i):
+        while i // 2 > 0:
+            if self.heapList[i] < self.heapList[i // 2]:
+                tmp = self.heapList[i // 2]
+                self.heapList[i // 2] = self.heapList[i]
+                self.heapList[i] = tmp
+            i = i // 2
+
+    def insert(self,k):
+        self.heapList.append(k)
+        self.currentSize = self.currentSize + 1
+        self.percUp(self.currentSize)
+
+    def percDown(self,i):
+        while (i * 2) <= self.currentSize:
+            mc = self.minChild(i)
+            if self.heapList[i] > self.heapList[mc]:
+                tmp = self.heapList[i]
+                self.heapList[i] = self.heapList[mc]
+                self.heapList[mc] = tmp
+            i = mc
+
+    def minChild(self,i):
+        if i * 2 + 1 > self.currentSize:
+            return i * 2
+        else:
+            if self.heapList[i*2] < self.heapList[i*2+1]:
+                return i * 2
+            else:
+                return i * 2 + 1
+
+    def delMin(self):
+        retval = self.heapList[1]
+        self.heapList[1] = self.heapList[self.currentSize]
+        self.currentSize = self.currentSize - 1
+        self.heapList.pop()
+        self.percDown(1)
+        return retval
+
+    def findMin(self):
+        return self.heapList[1]
+
+    def isEmpty(self):
+        return bool(len(self.heapList) <= 1)
+
+    def size(self):
+        return len(self.heapList[1:])
+
+    def buildHeap(self,alist):
+        i = len(alist) // 2
+        self.currentSize = len(alist)
+        self.heapList = [0] + alist[:]
+        while (i > 0):
+            self.percDown(i)
+            i = i - 1
+
+    def __str__(self):
+        return str(self.heapList)
+
+bh = BinHeap()
+#bh.buildHeap(
+#    [5, 9, 11, 14, 18, 19, 21, 33, 17, 27]
+#)
+bh.buildHeap([9,5,6,2,3])
+print(bh.heapList)
+
+# print(bh.delMin())
+# print(bh.delMin())
+# print(bh.delMin())
+# print(bh.delMin())
+# print(bh.delMin())
+
+# bh.insert(5)
+# bh.insert(9)
+# bh.insert(11)
+# bh.insert(14)
+# bh.insert(18)
+# bh.insert(19)
+# bh.insert(21)
+# bh.insert(33)
+# bh.insert(17)
+# bh.insert(27)
+
+# print(bh.delMin())
+# print(bh.delMin())
+# print(bh.delMin())
+# print(bh.delMin())
+# print(bh.delMin())
+# print(bh.delMin())
+# print(bh.delMin())
+# print(bh.delMin())
+# print(bh.delMin())
+# print(bh.delMin())
+
+
+# Max heap
+
+# Should get 9,6,5,3,2
+
+class maxHeap(BinHeap):
+
+    def findMax(self):
+        return self.heapList[1]
+
+    def percUp(self,i):
+        while i // 2 > 0:
+            if self.heapList[i] >= self.heapList[i // 2]:
+                tmp = self.heapList[i // 2]
+                self.heapList[i // 2] = self.heapList[i]
+                self.heapList[i] = tmp
+            i = i // 2
+
+    def insert(self,k):
+        self.heapList.append(k)
+        self.currentSize = self.currentSize + 1
+        self.percUp(self.currentSize)
+
+    def delMax(self):
+        retval = self.heapList[1]
+        self.heapList[1] = self.heapList[self.currentSize // 2]
+        self.currentSize = self.currentSize - 1
+        self.heapList.pop(1)
+        i = 2 if self.currentSize % 2 == 0 and self.currentSize > 0 else 1
+        self.percUp(i)
+        return retval
+
+    def maxChild(self,i):
+        if i * 2 + 1 > self.currentSize:
+            return i * 2
+        else:
+            if self.heapList[i*2] >= self.heapList[i*2+1]:
+                return i * 2
+            else:
+                return i * 2 + 1
+
+    def percDown(self,i):
+        while (i * 2) <= self.currentSize:
+            mc = self.maxChild(i)
+            if self.heapList[i] <= self.heapList[mc]:
+                tmp = self.heapList[i]
+                self.heapList[i] = self.heapList[mc]
+                self.heapList[mc] = tmp
+            i = mc
+
+    def buildHeap(self,alist):
+        i = len(alist) // 2
+        self.currentSize = len(alist)
+        self.heapList = [0] + alist
+        while (i > 0):
+            self.percDown(i)
+            i = i - 1
+
+mh = maxHeap()
+breakpoint()
+mh.buildHeap(
+       [5, 9, 11, 14, 18, 19, 21, 33, 17, 27]
+)
+#mh.buildHeap([9,5,6,2,3])
+print(mh.heapList)
+# # mh.insert(9)
+# # mh.insert(5)
+# # mh.insert(6)
+# # mh.insert(2)
+# # mh.insert(3)
+
+# mh.insert(5)
+# mh.insert(9)
+# mh.insert(11)
+# mh.insert(14)
+# mh.insert(18)
+# mh.insert(19)
+# mh.insert(21)
+# mh.insert(33)
+# mh.insert(17)
+# mh.insert(27)
+
+print(mh.delMax())
+print(mh.delMax())
+print(mh.delMax())
+print(mh.delMax())
+print(mh.delMax())
+print(mh.delMax())
+print(mh.delMax())
+print(mh.delMax())
+print(mh.delMax())
+print(mh.delMax())
+
+
+
+class PriorityQueue(BinHeap):
+
+    def enqueue(self, value):
+        self.insert(value)
+
+    def dequeue(self):
+        return self.heapList.pop(1)
+
+
+# priority_queue = PriorityQueue()
+# priority_queue.enqueue(9)
+# priority_queue.enqueue(1)
+# priority_queue.enqueue(8)
+# priority_queue.enqueue(2)
+
+# print(priority_queue.dequeue())
+# print(priority_queue.dequeue())
+
+
+class heapSort():
+    """Using the buildHeap method, write a sorting function that can sort a list in O(n log(n)) time."""
+    pass

@@ 1,241 @@
+#!/usr/bin/python3
+
+class TreeNode:
+    def __init__(self,key,val,left=None,right=None,parent=None):
+        self.key = key
+        self.payload = val
+        self.leftChild = left
+        self.rightChild = right
+        self.parent = parent
+
+    def hasLeftChild(self):
+        return self.leftChild
+
+    def hasRightChild(self):
+        return self.rightChild
+
+    def isLeftChild(self):
+        return self.parent and self.parent.leftChild == self
+
+    def isRightChild(self):
+        return self.parent and self.parent.rightChild == self
+
+    def isRoot(self):
+        return not self.parent
+
+    def isLeaf(self):
+        return not (self.rightChild or self.leftChild)
+
+    def hasAnyChildren(self):
+        return self.rightChild or self.leftChild
+
+    def hasBothChildren(self):
+        return self.rightChild and self.leftChild
+
+    def spliceOut(self):
+        if self.isLeaf():
+            if self.isLeftChild():
+                self.parent.leftChild = None
+            else:
+                self.parent.rightChild = None
+        elif self.hasAnyChildren():
+            if self.hasLeftChild():
+                if self.isLeftChild():
+                    self.parent.leftChild = self.leftChild
+                else:
+                    self.parent.rightChild = self.leftChild
+                self.leftChild.parent = self.parent
+            else:
+                if self.isLeftChild():
+                    self.parent.leftChild = self.rightChild
+                else:
+                    self.parent.rightChild = self.rightChild
+                self.rightChild.parent = self.parent
+
+    def findSuccessor(self):
+        succ = None
+        if self.hasRightChild():
+            succ = self.rightChild.findMin()
+        else:
+            if self.parent:
+                   if self.isLeftChild():
+                       succ = self.parent
+                   else:
+                       self.parent.rightChild = None
+                       succ = self.parent.findSuccessor()
+                       self.parent.rightChild = self
+        return succ
+
+    def findMin(self):
+        current = self
+        while current.hasLeftChild():
+            current = current.leftChild
+        return current
+
+    def replaceNodeData(self,key,value,lc,rc):
+        self.key = key
+        self.payload = value
+        self.leftChild = lc
+        self.rightChild = rc
+        if self.hasLeftChild():
+            self.leftChild.parent = self
+        if self.hasRightChild():
+            self.rightChild.parent = self
+
+    def __iter__(self):
+       if self:
+          if self.hasLeftChild():
+                 for elem in self.leftChiLd:
+                    yield elem
+          yield self.key
+          if self.hasRightChild():
+                 for elem in self.rightChild:
+                    yield elem
+
+
+
+class BinarySearchTree:
+
+    def __init__(self):
+        self.root = None
+        self.size = 0
+
+    def length(self):
+        return self.size
+
+    def __len__(self):
+        return self.size
+
+    def put(self,key,val):
+        if self.root:
+            self._put(key,val,self.root)
+        else:
+            self.root = TreeNode(key,val)
+        self.size = self.size + 1
+
+    def _put(self,key,val,currentNode):
+        if key < currentNode.key:
+            if currentNode.hasLeftChild():
+                   self._put(key,val,currentNode.leftChild)
+            else:
+                   currentNode.leftChild = TreeNode(key,val,parent=currentNode)
+        elif key == currentNode.key:
+            currentNode.payload = val
+        else:
+            if currentNode.hasRightChild():
+                   self._put(key,val,currentNode.rightChild)
+            else:
+                   currentNode.rightChild = TreeNode(key,val,parent=currentNode)
+
+    def __setitem__(self,k,v):
+       self.put(k,v)
+
+    def get(self,key):
+       if self.root:
+           res = self._get(key,self.root)
+           if res:
+                  return res.payload
+           else:
+                  return None
+       else:
+           return None
+
+    def _get(self,key,currentNode):
+       if not currentNode:
+           return None
+       elif currentNode.key == key:
+           return currentNode
+       elif key < currentNode.key:
+           return self._get(key,currentNode.leftChild)
+       else:
+           return self._get(key,currentNode.rightChild)
+
+    def __getitem__(self,key):
+       return self.get(key)
+
+    def __contains__(self,key):
+       if self._get(key,self.root):
+           return True
+       else:
+           return False
+
+    def delete(self,key):
+      if self.size > 1:
+         nodeToRemove = self._get(key,self.root)
+         if nodeToRemove:
+             self.remove(nodeToRemove)
+             self.size = self.size-1
+         else:
+             raise KeyError('Error, key not in tree')
+      elif self.size == 1 and self.root.key == key:
+         self.root = None
+         self.size = self.size - 1
+      else:
+         raise KeyError('Error, key not in tree')
+
+    def __delitem__(self,key):
+       self.delete(key)
+
+    def remove(self,currentNode):
+         if currentNode.isLeaf(): #leaf
+           if currentNode == currentNode.parent.leftChild:
+               currentNode.parent.leftChild = None
+           else:
+               currentNode.parent.rightChild = None
+         elif currentNode.hasBothChildren(): #interior
+           succ = currentNode.findSuccessor()
+           succ.spliceOut()
+           currentNode.key = succ.key
+           currentNode.payload = succ.payload
+
+         else: # this node has one child
+           if currentNode.hasLeftChild():
+             if currentNode.isLeftChild():
+                 currentNode.leftChild.parent = currentNode.parent
+                 currentNode.parent.leftChild = currentNode.leftChild
+             elif currentNode.isRightChild():
+                 currentNode.leftChild.parent = currentNode.parent
+                 currentNode.parent.rightChild = currentNode.leftChild
+             else:
+                 currentNode.replaceNodeData(currentNode.leftChild.key,
+                                    currentNode.leftChild.payload,
+                                    currentNode.leftChild.leftChild,
+                                    currentNode.leftChild.rightChild)
+           else:
+             if currentNode.isLeftChild():
+                 currentNode.rightChild.parent = currentNode.parent
+                 currentNode.parent.leftChild = currentNode.rightChild
+             elif currentNode.isRightChild():
+                 currentNode.rightChild.parent = currentNode.parent
+                 currentNode.parent.rightChild = currentNode.rightChild
+             else:
+                 currentNode.replaceNodeData(currentNode.rightChild.key,
+                                    currentNode.rightChild.payload,
+                                    currentNode.rightChild.leftChild,
+                                    currentNode.rightChild.rightChild)
+
+
+
+
+mytree = BinarySearchTree()
+mytree[3]="red"
+mytree[4]="blue"
+mytree[6]="yellow"
+mytree[2]="at"
+
+print(mytree[6])
+print(mytree[2])
+print(mytree[3])
+print(mytree[4])
+
+print("----------------")
+
+# Overriding the second slot
+
+mytree[2]="ataz"
+
+print(mytree[6])
+print(mytree[2])
+print(mytree[3])
+print(mytree[4])
+

@@ 1,94 @@
+#!/usr/bin/python3
+
+import operator
+from pythonds.basic import Stack
+from pythonds.trees import BinaryTree
+
+
+def buildParseTree(fpexp: str) -> BinaryTree:
+    fplist = []
+    for token in fpexp:
+        is_last_token_number = False
+        is_cur_token_number = False
+        try:
+            is_cur_token_number = isinstance(int(token), int)
+        except ValueError:
+            pass
+        try:
+            if len(fplist) > 0:
+                is_last_token_number = bool(int(fplist[-1]))
+        except ValueError:
+            pass
+        if token == ' ':
+            continue
+        elif len(fplist) > 0 and is_last_token_number and is_cur_token_number:
+            fplist[-1] = fplist[-1] + token
+        else:
+            fplist.append(token)
+
+    pStack = Stack()
+    eTree = BinaryTree('')
+    pStack.push(eTree)
+    currentTree = eTree
+
+    for i in fplist:
+        if i == '(':
+            currentTree.insertLeft('')
+            pStack.push(currentTree)
+            currentTree = currentTree.getLeftChild()
+
+        elif i in ['+', '-', '*', '/']:
+            currentTree.setRootVal(i)
+            currentTree.insertRight('')
+            pStack.push(currentTree)
+            currentTree = currentTree.getRightChild()
+
+        elif i == ')':
+            currentTree = pStack.pop()
+
+        elif i not in ['+', '-', '*', '/', ')']:
+            try:
+                currentTree.setRootVal(int(i))
+                parent = pStack.pop()
+                currentTree = parent
+
+            except ValueError:
+                raise ValueError("token '{}' is not a valid integer".format(i))
+
+    return eTree
+
+
+pt = buildParseTree("( ( 10 + 5 ) * 3 )")
+pt2 = buildParseTree("((10+5)*3)")
+pt3 = buildParseTree("((14897+4874)*3)")
+pt.postorder()  # defined and explained in the next section
+
+def evaluate(parseTree: BinaryTree):
+    """Evaluate a parse tree."""
+    opers = {
+        '+': operator.add,
+        '-': operator.sub,
+        '*': operator.mul,
+        '/': operator.truediv,
+        ' ': operator.or_,
+        ' ': operator.and_,
+        ' ': operator.is_not,
+    }
+
+    leftC = parseTree.getLeftChild()
+    rightC = parseTree.getRightChild()
+
+    if leftC and rightC:
+        fn = opers[parseTree.getRootVal()]
+        return fn(evaluate(leftC), evaluate(rightC))
+    else:
+        return parseTree.getRootVal()
+
+
+print(evaluate(pt))
+print(evaluate(pt2))
+print(evaluate(pt3))
+
+
+def calc_derivative(parseTree: BinaryTree) -> int:
+    pass

@@ 1,60 @@
+#!/usr/bin/python3
+
+def BinaryTree(r):
+    return [r, [], []]
+
+def insertLeft(root,newBranch):
+    t = root.pop(1)
+    if len(t) > 1:
+        root.insert(1,[newBranch,t,[]])
+    else:
+        root.insert(1,[newBranch, [], []])
+    return root
+
+def insertRight(root,newBranch):
+    t = root.pop(2)
+    if len(t) > 1:
+        root.insert(2,[newBranch,[],t])
+    else:
+        root.insert(2,[newBranch,[],[]])
+    return root
+
+def getRootVal(root):
+    return root[0]
+
+def setRootVal(root,newVal):
+    root[0] = newVal
+
+def getLeftChild(root):
+    return root[1]
+
+def getRightChild(root):
+    return root[2]
+
+r = BinaryTree(3)
+insertLeft(r,4)
+insertLeft(r,5)
+insertRight(r,6)
+insertRight(r,7)
+l = getLeftChild(r)
+print(l)
+
+setRootVal(l,9)
+print(r)
+insertLeft(l,11)
+print(r)
+print(getRightChild(getRightChild(r)))
+
+
+def build_tree():
+    r = BinaryTree("a")
+    insertLeft(r,'b')
+    left = getLeftChild(r)
+    insertRight(left, 'd')
+    insertRight(r,'c')
+    right = getRightChild(r)
+    insertLeft(right,'e')
+    insertRight(right,'f')
+    return r
+
+tree = build_tree()

@@ 1,61 @@
+#!/usr/bin/python3
+
+class BinaryTree:
+    def __init__(self,rootObj):
+        self.key = rootObj
+        self.leftChild = None
+        self.rightChild = None
+
+    def insertLeft(self,newNode):
+        if self.leftChild == None:
+            self.leftChild = BinaryTree(newNode)
+        else:
+            t = BinaryTree(newNode)
+            t.leftChild = self.leftChild
+            self.leftChild = t
+
+    def insertRight(self,newNode):
+        if self.rightChild == None:
+            self.rightChild = BinaryTree(newNode)
+        else:
+            t = BinaryTree(newNode)
+            t.rightChild = self.rightChild
+            self.rightChild = t
+
+
+    def getRightChild(self):
+        return self.rightChild
+
+    def getLeftChild(self):
+        return self.leftChild
+
+    def setRootVal(self,obj):
+        self.key = obj
+
+    def getRootVal(self):
+        return self.key
+
+
+r = BinaryTree('a')
+print(r.getRootVal())
+print(r.getLeftChild())
+r.insertLeft('b')
+print(r.getLeftChild())
+print(r.getLeftChild().getRootVal())
+r.insertRight('c')
+print(r.getRightChild())
+print(r.getRightChild().getRootVal())
+r.getRightChild().setRootVal('hello')
+print(r.getRightChild().getRootVal())
+
+def build_tree():
+    r = BinaryTree('a')
+    r.insertLeft('b')
+    r.insertRight('c')
+    r.getLeftChild().insertRight('d')
+    r.getRightChild().insertLeft('e')
+    r.getRightChild().insertRight('f')
+    return r
+
+tree = build_tree()
+print(tree)

@@ 1,84 @@
+#!/usr/bin/python3
+
+from pythonds.trees import BinaryTree
+import operator
+
+def preorder(tree):
+    if tree:
+        print(tree.getRootVal())
+        preorder(tree.getLeftChild())
+        preorder(tree.getRightChild())
+
+
+def preorder(self):
+    print(self.key)
+    if self.leftChild:
+        self.leftChild.preorder()
+    if self.rightChild:
+        self.rightChild.preorder()
+
+
+def postorder(tree):
+    if tree != None:
+        postorder(tree.getLeftChild())
+        postorder(tree.getRightChild())
+        print(tree.getRootVal())
+
+def postordereval(tree):
+    opers = {'+':operator.add, '-':operator.sub, '*':operator.mul, '/':operator.truediv}
+    res1 = None
+    res2 = None
+    if tree:
+        res1 = postordereval(tree.getLeftChild())
+        res2 = postordereval(tree.getRightChild())
+        if res1 and res2:
+            return opers[tree.getRootVal()](res1,res2)
+        else:
+            return tree.getRootVal()
+
+
+def inorder(tree):
+  if tree != None:
+      inorder(tree.getLeftChild())
+      print(tree.getRootVal())
+      inorder(tree.getRightChild())
+
+
+def printexp(tree):
+  sVal = ""
+  if tree:
+      if tree.getLeftChild() is None:
+          sVal = printexp(tree.getLeftChild())
+      else:
+          sVal = '(' + printexp(tree.getLeftChild())
+      sVal = sVal + str(tree.getRootVal())
+      if tree.getLeftChild() is None:
+          sVal = sVal + printexp(tree.getRightChild())
+      else:
+          sVal = sVal + printexp(tree.getRightChild())+')'
+  return sVal
+
+# Tree traversals examples
+
+r = BinaryTree('a')
+r.insertLeft('b')
+r.insertRight('c')
+r.getRightChild().insertRight('helloRight')
+r.getLeftChild().insertLeft('helloLeft')
+
+inorder(r)
+
+# Evaluating expressions
+
+r = BinaryTree('*')
+r.insertLeft('+')
+r.getLeftChild().insertLeft(10)
+r.getLeftChild().insertRight(20)
+r.insertRight(2)
+
+# (((10)+(20))*(2)) -> ((10+20)*2)
+
+
+print(postordereval(r))
+
+print(printexp(r))

@@ 1,73 @@
+#!/usr/bin/python3
+
+
+class Vertex:
+    def __init__(self,key):
+        self.id = key
+        self.connectedTo = {}
+
+    def addNeighbor(self,nbr,weight=0):
+        self.connectedTo[nbr] = weight
+
+    def getConnections(self):
+        return self.connectedTo.keys()
+
+    def getId(self):
+        return self.id
+
+    def getWeight(self,nbr):
+        return self.connectedTo[nbr]
+
+    def __str__(self):
+        return str(self.id) + ' connectedTo: ' + str([x.id for x in self.connectedTo])
+
+
+class Graph:
+    def __init__(self):
+        self.vertList = {}
+        self.numVertices = 0
+
+    def addVertex(self,key):
+        self.numVertices = self.numVertices + 1
+        newVertex = Vertex(key)
+        self.vertList[key] = newVertex
+        return newVertex
+
+    def addEdge(self,f,t,weight=0):
+        if f not in self.vertList:
+            nv = self.addVertex(f)
+        if t not in self.vertList:
+            nv = self.addVertex(t)
+        self.vertList[f].addNeighbor(self.vertList[t], weight)
+
+    def getVertex(self,n):
+        if n in self.vertList:
+            return self.vertList[n]
+        else:
+            return None
+
+    def getVertices(self):
+        return self.vertList.keys()
+
+    def __contains__(self,n):
+        return n in self.vertList
+
+    def __iter__(self):
+        return iter(self.vertList.values())
+
+
+g = Graph()
+for i in range(6):
+   g.addVertex(i)
+print(g.vertList)
+g.addEdge(0,5,2)
+g.addEdge(1,2,4)
+g.addEdge(2,3,9)
+g.addEdge(3,4,7)
+g.addEdge(3,5,3)
+g.addEdge(4,0,1)
+g.addEdge(5,4,8)
+g.addEdge(5,2,1)
+for v in g:
+   for w in v.getConnections():
+       print("( %s , %s )" % (v.getId(), w.getId()))

@@ 1,56 @@
+#!/usr/bin/python3
+
+from pythonds.graphs import Graph
+
+def buildGraph(wordFile):
+    d = {}
+    g = Graph()
+    wfile = open(wordFile,'r')
+    # create buckets of words that differ by one letter
+    for line in wfile:
+        word = line[:-1]
+        for i in range(len(word)):
+            bucket = word[:i] + '_' + word[i+1:]
+            if bucket in d:
+                d[bucket].append(word)
+            else:
+                d[bucket] = [word]
+    # add vertices and edges for words in the same bucket
+    for bucket in d.keys():
+        for word1 in d[bucket]:
+            for word2 in d[bucket]:
+                if word1 != word2:
+                    g.addEdge(word1,word2)
+    return g
+
+
+
+from pythonds.graphs import Graph, Vertex
+from pythonds.basic import Queue
+
+def bfs(g,start):
+  start.setDistance(0)
+  start.setPred(None)
+  vertQueue = Queue()
+  vertQueue.enqueue(start)
+  while (vertQueue.size() > 0):
+    currentVert = vertQueue.dequeue()
+    for nbr in currentVert.getConnections():
+      if (nbr.getColor() == 'white'):
+        nbr.setColor('gray')
+        nbr.setDistance(currentVert.getDistance() + 1)
+        nbr.setPred(currentVert)
+        vertQueue.enqueue(nbr)
+    currentVert.setColor('black')
+
+
+def traverse(y):
+    x = y
+    while (x.getPred()):
+        print(x.getId())
+        x = x.getPred()
+    print(x.getId())
+
+
+g = buildGraph()
+traverse(g.getVertex('sage'))