diff --git a/book/book_second_edition.pdf b/book/book_second_edition.pdf
index 861a6fb..442a30b 100644
Binary files a/book/book_second_edition.pdf and b/book/book_second_edition.pdf differ
diff --git a/src/abstract_structures/linked_list/hash_table.py b/src/abstract_structures/hash_table.py
similarity index 100%
rename from src/abstract_structures/linked_list/hash_table.py
rename to src/abstract_structures/hash_table.py
diff --git a/src/abstract_structures/linked_list/linked_list_fifo.py b/src/abstract_structures/linked_list/linked_list_fifo.py
index c7777a3..8a75751 100644
--- a/src/abstract_structures/linked_list/linked_list_fifo.py
+++ b/src/abstract_structures/linked_list/linked_list_fifo.py
@@ -1,183 +1,108 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
+#!/usr/bin/python
+
+__author__ = "Mari Wahl"
+__email__ = "marina.w4hl@gmail.com"
 
 ''' A class for a linked list that has the nodes in a FIFO order (such as a queue)'''
 
 
-class Node(object):
-    def __init__(self, value = None, next = None):
-        self.value = value
-        self.next = next
-        
-class LinkList(object):
+from node import Node
+
+
+
+class LinkedListFIFO(object):
+
     def __init__(self):
         self.head = None
-        self.tail = None
         self.length = 0
-    
-    def addNode(self, value):
-        node = Node(value)
-        if not self.head:
-            self.head = node
-        if self.tail:
-            self.tail.next = node
-        self.tail = node
-        self.length += 1
-    
-    def printList(self):
+        self.tail = None # this is different from ll lifo
+
+
+    # print each node's value, starting from the head
+    def _printList(self):
         node = self.head
         while node:
             print(node.value)
-            node = node.next
-     
-    def addInOrder(self, item):
-        new_node = Node(item)
-        node = self.head
-        previous = None
-        stop = False
-        while node and not stop:
-            if node.value > item:
-                stop = True
-            else:
-                previous = node
-                node = node.next
+            node = node.pointer
 
-        if not previous:
-            new_node.next = self.head
-            self.head = new_node
+    # add a node in the first position
+    # read will never be changed again while not empty
+    def _addFirst(self, value):
+        self.length = 1
+        node = Node(value)
+        self.head = node
+        self.tail = node
+
+    # delete a node in the first position, ie
+    # when there is no previous node
+    def _deleteFirst(self):
+        self.length = 0
+        self.head = None
+        self.tail = None
+        print('The list is empty.')
+
+    # add a node in a position different from head,
+    # ie, in the end of the list
+    def _add(self, value):
+        self.length += 1
+        node = Node(value)
+        if self.tail:
+            self.tail.pointer = node
+        self.tail = node
+
+    # delete a node in some position
+    def _delete(self, prev, node):
+        self.length -= 1
+        prev.pointer = node.pointer
+        if not node.pointer:
+            self.tail = prev
+
+    # add nodes in general
+    def addNode(self, value):
+        if not self.head:
+            self._addFirst(value)
         else:
-            new_node.next = node 
-            previous.next = new_node
-    
-            
-    
-    def deleteNode(self, index):
+            self._add(value)
+
+    # locate node with some index
+    def _find(self, index):
         prev = None
         node = self.head
         i = 0
         while node and i < index:
             prev = node
-            node = node.next
+            node = node.pointer
             i += 1
-        if i == index:
-            if not prev:
-                self.head = node.next
-            else:
-                prev.next = node.next
-            self.length -= 1
+        return node, prev, i
+
+    # delete nodes in general
+    def deleteNode(self, index):
+        if not self.head or not self.head.pointer:
+            self._deleteFirst()
         else:
-            print('Index not found!')
-
-
-    def deleteNodeIfOrdered(self, item):
-        node = self.head
-        previous = None
-        found = False
-        while node and not found:
-            if node.value == item:
-                found = True
+            node, prev, i = self._find(index)
+            if i == index:
+                self._delete(prev, node)
             else:
-                previous = node
-                node = node.next
-        
-        if found:
-            if not previous:
-                self.head = node.next
-            else:
-                previous.next = node.next
-        else:
-            print('Node not found!')            
-            
-                       
-    def removeDupl(self):
-        prev = None
-        node = self.head
-        aux_dict = Counter()      
-        while node:           
-            value_here = node.value
-            if aux_dict[value_here] == 0:
-                aux_dict[value_here] = 1
-            else:              
-                if prev == None:
-                    self.head = node.next
-                else:
-                    prev.next = node.next
-                self.length -= 1              
-            prev = node
-            node = node.next   
-            
-    def removeDupl_no_buf(self):
-        node = self.head
-        while node:
-            pivot = node.value
-            pointer = node.next
-            prev = node
-            while pointer:
-                value_here = pointer.value
-                if value_here == pivot:
-                    prev.next = pointer.next
-                    self.length -= 1 
-                prev = pointer
-                pointer = pointer.next
-            node = node.next      
-                    
-    def searchIfOrdered(self, item):
-        node = self.head
-        found = False
-        stop = False
-        while node and not found and not stop:
-            if node.value  == item:
-                found = True
-            else:
-                if node.value > item:
-                    stop = True
-                else:
-                    node = node.next
-        return found                        
-    
-    
-    
-    
-        
-
-from collections import Counter
-
-def main():
-    
-    ll = LinkList()
-    for i in range(1, 10):
-        ll.addNode(i)
-        ll.addNode(i+1)
-    print('Linked List with duplicates:')    
-    ll.printList()
-    print('Length before deleting duplicate is: ', ll.length)
-    ll.removeDupl()
-    ll.printList()
-    print('Lenght after deleting duplicates is: ', ll.length)   
-    
-    ll = LinkList()
-    for i in range(1, 10):
-        ll.addNode(i)
-        ll.addNode(i+1)
-    print('Linked List with duplicates:')    
-    ll.printList()
-    print('Length before deleting duplicate is: ', ll.length)
-    ll.removeDupl_no_buf()
-    ll.printList()
-    print('Lenght after deleting duplicates is: ', ll.length)      
+                print('Node with index {} not found'.format(index))
+
+
 
 
-    ll = LinkList()
-    l1 = [4, 2, 5, 7, 1, 9]
-    for i in l1:
-        ll.addInOrder(i)
-    ll.printList() 
-    print(ll.searchIfOrdered(7))       
-    print(ll.searchIfOrdered(3))    
-    ll.deleteNodeIfOrdered(7)
-    ll.printList() 
 
-    
 if __name__ == '__main__':
-    main()
+    ll = LinkedListFIFO()
+    for i in range(1, 5):
+        ll.addNode(i)
+    print('The list is:')
+    ll._printList()
+    print('The list after deleting node with index 2:')
+    ll.deleteNode(2)
+    ll._printList()
+    print('The list after adding node with value 15')
+    ll._add(15)
+    ll._printList()
+    print("The list after deleting everything...")
+    for i in range(ll.length-1, -1, -1):
+        ll.deleteNode(i)
+    ll._printList()
diff --git a/src/abstract_structures/linked_list/linked_list_lifo.py b/src/abstract_structures/linked_list/linked_list_lifo.py
index ae061ac..186af83 100644
--- a/src/abstract_structures/linked_list/linked_list_lifo.py
+++ b/src/abstract_structures/linked_list/linked_list_lifo.py
@@ -1,82 +1,105 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
+#!/usr/bin/python
+
+__author__ = "Mari Wahl"
+__email__ = "marina.w4hl@gmail.com"
+
+
 
 
 ''' Implement a unordered linked list, i.e. a LIFO linked list (like a stack) '''
 
-class Node(object):
-    def __init__(self, value = None, next = None):
-        self.value = value
-        self.next = next
+from node import Node
+
+class LinkedListLIFO(object):
 
-class LinkList(object):
     def __init__(self):
         self.head = None
-        self.lenght = 0
-        
-    def addNode(self, value):
-        node = Node(value)
-        node.next = self.head
-        self.head = node
-        self.lenght += 1
-        
-    def printList(self):
+        self.length = 0
+
+
+    # print each node's value, starting from the head
+    def _printList(self):
         node = self.head
         while node:
             print(node.value)
-            node = node.next
+            node = node.pointer
 
-    def deleteNode(self, index):
+    # delete a node, given the previous node
+    def _delete(self, prev, node):
+        self.length -= 1
+        if not prev:
+            self.head = node.pointer
+        else:
+            prev.pointer = node.pointer
+
+    # add a new node, pointing to the previous node
+    # in the head
+    def _add(self, value):
+        self.length += 1
+        self.head = Node(value, self.head)
+
+
+    # locate node with some index
+    def _find(self, index):
         prev = None
         node = self.head
         i = 0
         while node and i < index:
             prev = node
-            node = node.next
+            node = node.pointer
             i += 1
-        if index == i:
-            self.lenght -= 1    
-            if prev == None:
-                self.head = node.next
-            else:
-                prev.next = node.next
-        else:
-            print('Node with index {} not found'.format(index))
-         
+        return node, prev, i
 
-    def deleteNodeByValue(self, item):
+    # locate node by value
+    def _find_by_value(self, value):
         prev = None
-        node = self.head       
-        found = False
+        node = self.head
+        found = 0
         while node and not found:
-            if node.value == item:
+            if node.value == value:
                 found = True
             else:
                 prev = node
-                node = node.next
-        if found:
-            self.lenght -= 1 
-            if prev == None:
-                self.head = node.next
-            else:
-                prev.next = node.next
+                node = node.pointer
+        return node, prev, found
+
+
+    # find and delete a node by index
+    def deleteNode(self, index):
+        node, prev, i = self._find(index)
+        if index == i:
+            self._delete(prev, node)
         else:
-            print('Node with value {} not found'.format(item))
+            print('Node with index {} not found'.format(index))
+
+
+    # find and delete a node by value
+    def deleteNodeByValue(self, value):
+        node, prev, found = self._find_by_value(value)
+        if found:
+            self._delete(prev, node)
+        else:
+            print('Node with value {} not found'.format(value))
+
 
 
-def main():
-    ll = LinkList()
-    for i in range(1, 11):
-        ll.addNode(i)
-    print('The list is:')
-    ll.printList()
-    print('The list after deleting node with index 2 (value 8):')
-    ll.deleteNode(2)
-    ll.printList()
-    print('The list after deleting node with value 2 (index 7):')
-    ll.deleteNodeByValue(2)
-    ll.printList()
 
 if __name__ == '__main__':
-    main()
+    ll = LinkedListLIFO()
+    for i in range(1, 5):
+        ll._add(i)
+    print('The list is:')
+    ll._printList()
+    print('The list after deleting node with index 2:')
+    ll.deleteNode(2)
+    ll._printList()
+    print('The list after deleting node with value 3:')
+    ll.deleteNodeByValue(2)
+    ll._printList()
+    print('The list after adding node with value 15')
+    ll._add(15)
+    ll._printList()
+    print("The list after deleting everything...")
+    for i in range(ll.length-1, -1, -1):
+        ll.deleteNode(i)
+    ll._printList()
diff --git a/src/abstract_structures/linked_list/linkedlist.py b/src/abstract_structures/linked_list/linkedlist.py
index 5a8aa6d..c8049c8 100644
--- a/src/abstract_structures/linked_list/linkedlist.py
+++ b/src/abstract_structures/linked_list/linkedlist.py
@@ -12,7 +12,7 @@ class UnorderedList(object):
         temp = Node(item)
         temp.setNext(self.head)
         self.head = temp
-    
+
     def length(self):
         current = self.head
         count = 0
@@ -54,7 +54,7 @@ def test_UnorderedList(module_name='this module'):
     llist.add(10)
     assert(llist.search(22) == True)
     llist.remove(22)
-    assert(llist.search(22) == False)   
+    assert(llist.search(22) == False)
     s = 'Tests in {name} have {con}!'
     print(s.format(name=module_name, con='passed'))
 
diff --git a/src/abstract_structures/linked_list/node.py b/src/abstract_structures/linked_list/node.py
index 5b6caf9..92908fb 100644
--- a/src/abstract_structures/linked_list/node.py
+++ b/src/abstract_structures/linked_list/node.py
@@ -1,23 +1,35 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
+#!/usr/bin/python
+
+__author__ = "Mari Wahl"
+__email__ = "marina.w4hl@gmail.com"
 
 
-class Node(object):        
-    def __init__(self, value):
+class Node(object):
+    def __init__(self, value=None, pointer=None):
         self.value = value
-        self.next = None
+        self.pointer = pointer
 
     def getData(self):
         return self.value
 
     def getNext(self):
-        return self.next
+        return self.pointer
 
     def setData(self, newdata):
         self.value = newdata
 
-    def setNext(self, newnext):
-        self.next = newnext
+    def setNext(self, newpointer):
+        self.pointer = newpointer
 
 
+
+if __name__ == '__main__':
+    L = Node("a", Node("b", Node("c", Node("d"))))
+    assert(L.pointer.pointer.value=='c')
+
+    print(L.getData())
+    print(L.getNext().getData())
+    L.setData('aa')
+    L.setNext(Node('e'))
+    print(L.getData())
+    print(L.getNext().getData())