Code files added

Author: packtpavanr

Chapter04/circularly_linked_list.py

@@ -0,0 +1,96 @@
+class Node:
+    def __init__(self, data=None):
+        self.data = data
+        self.next = None
+
+class CircularList:
+    def __init__(self, data=None):
+        self.head = None
+        self.tail = None
+        self.size = 0
+
+    def clear(self):
+        self.tail = None
+        self.head = None
+
+    def append(self, data):
+        node = Node(data)
+        if self.head:
+            self.head.next = node
+            self.head = node
+        else:
+            self.head = node
+            self.tail = node
+        self.head.next = self.tail
+        self.size += 1
+
+    def delete(self, data):
+        current = self.tail
+        prev = self.tail
+        while prev == current or prev != self.head:
+            if current.data == data:
+                if current == self.tail:
+                    self.tail = current.next
+                    self.head.next = self.tail
+                else:
+                    prev.next = current.next
+                self.size -= 1
+                return
+            prev = current
+            current = current.next
+
+    def iter(self):
+        current = self.tail
+        while current:
+            val = current.data
+            current = current.next
+            yield val
+
+words = CircularList()
+words.append('eggs')
+words.append('ham')
+words.append('spam')
+
+counter = 0
+for word in words.iter():
+    print(word)
+    counter += 1
+    if counter > 1000:
+        break
+
+import sys
+sys.exit()
+
+l.append('foo')
+l.append('bar')
+l.append('bim')
+l.append('baz')
+l.append('quux')
+l.append('duux')
+
+counter = 0
+for item in l.iter():
+    print(item)
+    counter += 1
+    if counter > 1000:
+        break
+
+print("Done iterating. Now we try to delete something that isn't there.")
+l.delete('socks')
+print('back to iterating')
+counter = 0
+for item in l.iter():
+    print(item)
+    counter += 1
+    if counter > 1000:
+        break
+
+print('Let us delete something that is there.')
+l.delete('foo')
+print('back to iterating')
+counter = 0
+for item in l.iter():
+    print(item)
+    counter += 1
+    if counter > 1000:
+        break

Chapter04/doubly_linked_list.py

@@ -0,0 +1,156 @@
+class Node(object):
+    """ A Doubly-linked lists' node. """
+    def __init__(self, data=None, next=None, prev=None):
+        self.data = data
+        self.next = next
+        self.prev = prev
+
+
+class DoublyLinkedList(object):
+    def __init__(self):
+        self.head = None
+        self.tail = None
+        self.count = 0
+
+    def append(self, data):
+        """ Append an item to the list. """
+
+        new_node = Node(data, None, None)
+        if self.head is None:
+            self.head = new_node
+            self.tail = self.head
+        else:
+            new_node.prev = self.tail
+            self.tail.next = new_node
+            self.tail = new_node
+
+        self.count += 1
+
+    def iter(self):
+        """ Iterate through the list. """
+        current = self.head #note subtle change
+        while current:
+            val = current.data
+            current = current.next
+            yield val
+
+    def reverse_iter(self):
+        """ Iterate backwards through the list. """
+        current = self.tail
+        while current:
+            val = current.data
+            current = current.prev
+            yield val
+
+    def delete(self, data):
+        """ Delete a node from the list. """
+        current = self.head
+        node_deleted = False
+        if current is None:
+            node_deleted = False
+
+        elif current.data == data:
+            self.head = current.next
+            self.head.prev = None
+            node_deleted = True
+
+        elif self.tail.data == data:
+            self.tail = self.tail.prev
+            self.tail.next = None
+            node_deleted = True
+
+        else:
+            while current:
+                if current.data == data:
+                    current.prev.next = current.next
+                    current.next.prev = current.prev
+                    node_deleted = True
+                current = current.next
+
+        if node_deleted:
+            self.count -= 1
+
+    def search(self, data):
+        """Search through the list. Return True if data is found, otherwise False."""
+        for node in self.iter():
+            if data == node:
+                return True
+        return False
+
+    def print_foward(self):
+        """ Print nodes in list from first node inserted to the last . """
+        for node in self.iter():
+            print(node)
+
+    def print_backward(self):
+        """ Print nodes in list from latest to first node. """
+        current = self.tail
+        while current:
+            print(current.data)
+            current = current.prev
+
+    def insert_head(self, data):
+        """ Insert new node at the head of linked list. """
+
+        if self.head is not None:
+            new_node = Node(data, None, None)
+            new_node.next = self.head
+            self.head.prev = new_node
+            self.head = new_node
+            self.count += 1
+
+    def reverse(self):
+        """ Reverse linked list. """
+        current = self.head
+        while current:
+            temp = current.next
+            current.next = current.prev
+            current.prev = temp
+            current = current.prev
+
+        # Now reverse the order of head and tail
+        temp = self.head
+        self.head = self.tail
+        self.tail = temp
+
+    def __getitem__(self, index):
+        if index > self.count - 1:
+            raise Exception("Index out of range.")
+        current = self.head # Note subtle change
+        for n in range(index):
+            current = current.next
+        return current.data
+
+    def __setitem__(self, index, value):
+        if index > self.count - 1:
+            raise Exception("Index out of range.")
+        current = self.head # Note subtle change
+        for n in range(index):
+            current = current.next
+        current.data = value
+
+
+dll = DoublyLinkedList()
+dll.append("foo")
+dll.append("bar")
+dll.append("biz")
+dll.append("whew")
+print("Items in List : ")
+dll.print_foward()
+print("List after deleting node with data whew")
+dll.delete("whew")
+dll.print_foward()
+
+print("List count: {}".format(dll.count))
+print("Print list backwards")
+dll.print_backward()
+
+print("Reverse list ")
+dll.reverse()
+dll.print_foward()
+
+print("Append item to front of list")
+dll.insert_head(55)
+dll.print_foward()
+
+print("Get First element: {}".format(dll[0]))

Chapter04/singly_linked_list.py

@@ -0,0 +1,112 @@
+class Node:
+    """ A singly-linked node. """
+    def __init__(self, data=None):
+        self.data = data
+        self.next = None
+
+class SinglyLinkedList:
+    """ A singly-linked list. """
+    def __init__(self):
+        """ Create an empty list. """
+        self.tail = None
+        self.head = None
+        self.count = 0
+
+    def iter(self):
+        """ Iterate through the list. """
+        current = self.tail
+        while current:
+            val = current.data
+            current = current.next
+            yield val
+
+    def append(self, data):
+        """ Append an item to the list """
+        node = Node(data)
+        if self.head:
+            self.head.next = node
+            self.head = node
+        else:
+            self.tail = node
+            self.head = node
+        self.count += 1
+
+    def delete(self, data):
+        """ Delete a node from the list """
+        current = self.tail
+        prev = self.tail
+        while current:
+            if current.data == data:
+                if current == self.tail:
+                    self.tail = current.next
+                else:
+                    prev.next = current.next
+                self.count -= 1
+                return
+            prev = current
+            current = current.next
+
+    def search(self, data):
+        """ Search through the list. Return True if data is found, otherwise
+        False. """
+        for node in self.iter():
+            if data == node:
+                return True
+        return False
+
+    def __getitem__(self, index):
+        if index > self.count - 1:
+            raise Exception("Index out of range.")
+        current = self.tail
+        for n in range(index):
+            current = current.next
+        return current.data
+
+    def __setitem__(self, index, value):
+        if index > self.count - 1:
+            raise Exception("Index out of range.")
+        current = self.tail
+        for n in range(index):
+            current = current.next
+        current.data = value
+
+words = SinglyLinkedList()
+words.append('foo')
+words.append('bar')
+words.append('bim')
+words.append('baz')
+words.append('quux')
+
+print("access by index")
+print("here is a node: {}".format(words[1]))
+
+print("modify by index")
+words[4] = "Quux"
+print("Modified node by index: {}".format(words[4]))
+
+print("This list has {} elements.".format(words.count))
+for word in words.iter():
+    print("Got this data: {}".format(word))
+
+if words.search('foo'):
+    print("Found foo in the list.")
+if words.search('amiga'):
+    print("Found amiga in the list.")
+
+print("Now we try to delete an item")
+words.delete('bim')
+print("List now has {} elements".format(words.count))
+for word in words.iter():
+    print("data: {}".format(word))
+
+print("delete the first item in the list")
+words.delete('foo')
+print("size: {}".format(words.count))
+for word in words.iter():
+    print("data: {}".format(word))
+
+print("delete the last item in the list")
+words.delete('quux')
+print("size: {}".format(words.count))
+for word in words.iter():
+    print("data: {}".format(word))