fix few details, linked lists

src/abstract_structures/linked_list/linked_list_fifo.py

@@ -1,183 +1,108 @@
-#!/usr/bin/python3
+#!/usr/bin/python
-# mari von steinkirch @2013
+
-# steinkirch at gmail
+__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):
+from node import Node
-    def __init__(self, value = None, next = None):
+
-        self.value = value
+
-        self.next = next
+
+class LinkedListFIFO(object):
 
-class LinkList(object):
     def __init__(self):
         self.head = None
-        self.tail = None
         self.length = 0
+        self.tail = None # this is different from ll lifo
 
-    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):
+    # 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 addInOrder(self, item):
+    # add a node in the first position
-        new_node = Node(item)
+    # read will never be changed again while not empty
-        node = self.head
+    def _addFirst(self, value):
-        previous = None
+        self.length = 1
-        stop = False
+        node = Node(value)
-        while node and not stop:
+        self.head = node
-            if node.value > item:
+        self.tail = node
-                stop = True
+
+    # 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:
-                previous = node
+            self._add(value)
-                node = node.next
 
-        if not previous:
+    # locate node with some index
-            new_node.next = self.head
+    def _find(self, index):
-            self.head = new_node
-        else:
-            new_node.next = node 
-            previous.next = new_node
-    
-            
-    
-    def deleteNode(self, index):
         prev = None
         node = self.head
         i = 0
         while node and i < index:
             prev = node
-            node = node.next
+            node = node.pointer
             i += 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:
+            node, prev, i = self._find(index)
             if i == index:
-            if not prev:
+                self._delete(prev, node)
-                self.head = node.next
             else:
-                prev.next = node.next
+                print('Node with index {} not found'.format(index))
-            self.length -= 1
-        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
-            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)      
-
-
-    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()

src/abstract_structures/linked_list/linked_list_lifo.py

@@ -1,82 +1,105 @@
-#!/usr/bin/python3
+#!/usr/bin/python
-# mari von steinkirch @2013
+
-# steinkirch at gmail
+__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):
+from node import Node
-    def __init__(self, value = None, next = None):
+
-        self.value = value
+class LinkedListLIFO(object):
-        self.next = next
 
-class LinkList(object):
     def __init__(self):
         self.head = None
-        self.lenght = 0
+        self.length = 0
 
-    def addNode(self, value):
-        node = Node(value)
-        node.next = self.head
-        self.head = node
-        self.lenght += 1
 
-    def printList(self):
+    # 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:
+        return node, prev, i
-            self.lenght -= 1    
+
-            if prev == None:
+    # locate node by value
-                self.head = node.next
+    def _find_by_value(self, value):
+        prev = None
+        node = self.head
+        found = 0
+        while node and not found:
+            if node.value == value:
+                found = True
             else:
-                prev.next = node.next
+                prev = node
+                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 index {} not found'.format(index))
 
 
-    def deleteNodeByValue(self, item):
+    # find and delete a node by value
-        prev = None
+    def deleteNodeByValue(self, value):
-        node = self.head       
+        node, prev, found = self._find_by_value(value)
-        found = False
-        while node and not found:
-            if node.value == item:
-                found = True
-            else:
-                prev = node
-                node = node.next
         if found:
-            self.lenght -= 1 
+            self._delete(prev, node)
-            if prev == None:
-                self.head = node.next
         else:
-                prev.next = node.next
+            print('Node with value {} not found'.format(value))
-        else:
+
-            print('Node with value {} not found'.format(item))
 
 
-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()

src/abstract_structures/linked_list/node.py

@@ -1,23 +1,35 @@
-#!/usr/bin/python3
+#!/usr/bin/python
-# mari von steinkirch @2013
+
-# steinkirch at gmail
+__author__ = "Mari Wahl"
+__email__ = "marina.w4hl@gmail.com"
 
 
 class Node(object):
-    def __init__(self, value):
+    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):
+    def setNext(self, newpointer):
-        self.next = newnext
+        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())