Merge pull request #14 from nickolasteixeira/chapter2

Chapter2 - more singly linked list problems

Author: fvntr

Python/chapter02/2.1 - Remove Dups/Nick.py

@@ -1,4 +1,7 @@
 #!/usr/bin/python3
+'''
+Remove Dups! Write code to remove duplicates from an unsorted linked list. FOLLOW UP How would you solve this problem if a temporary buffer is not allowed?
+'''
 import unittest
 
 

Python/chapter02/2.4 - Partition/Nick.py

@@ -0,0 +1,91 @@
+#!/usr/bin/python3
+
+import unittest
+
+
+class Node:
+    def __init__(self, data, next=None):
+        self.data = data
+        self.next = next
+
+    def __str__(self):
+        return str(self.data)
+
+
+class SinglyLinkedList:
+    def __init__(self):
+        self.head = None
+
+    def addNode(self, data):
+        node = Node(data)
+        if self.head is None:
+            self.head = node
+        else:
+            temp = self.head
+            while temp.next:
+                temp = temp.next
+            temp.next = node
+        print('Node added to LL--->', data)
+
+    def printList(self):
+        if self.head is None:
+            print('No LinkedList to print')
+            return
+
+        temp = self.head
+        while temp:
+            print(temp.data)
+            temp = temp.next
+
+    def partition(self, part):
+        '''However, in a linked list, the situation is much easier. Rather than shifting and swapping elements, we can actually create two different linked lists: one for elements less than x, and one for elements greater than or equal to x.'''
+        if self.head is None:
+            print('No LinkedList to print')
+            return
+
+        temp = self.head
+        before = SinglyLinkedList()
+        after = SinglyLinkedList()
+        while temp.next:
+            if temp.data >= part:
+                after.addNode(temp.data)
+            else:
+                before.addNode(temp.data)
+            temp = temp.next
+
+        # combine the two linked lists
+        self.head = before.head
+        temp = before.head
+        while temp.next:
+            temp = temp.next
+        temp.next = after.head
+
+
+class Test(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        cls.l = SinglyLinkedList()
+        cls.l.printList()
+        cls.l.addNode(3)
+        cls.l.addNode(20)
+        cls.l.addNode(21)
+        cls.l.addNode(5)
+        cls.l.addNode(8)
+        cls.l.addNode(5)
+        cls.l.addNode(10)
+        cls.l.addNode(2)
+        cls.l.addNode(1)
+        cls.l.printList()
+
+    @classmethod
+    def tearDownClass(cls):
+        pass
+
+    def test1(self):
+        self.l.partition(5)
+        self.l.printList()
+
+
+if __name__ == '__main__':
+    unittest.main()

Python/chapter02/2.5 - Sum Lists/Nick.py

@@ -0,0 +1,103 @@
+#!/usr/bin/python3
+
+import unittest
+
+
+class Node:
+    def __init__(self, data, next=None):
+        self.data = data
+        self.next = next
+
+
+class SinglyLinkedList:
+    def __init__(self):
+        self.head = None
+
+    def addNode(self, data):
+        node = Node(data)
+        if not self.head:
+            self.head = node
+        else:
+            temp = self.head
+            while temp.next:
+                temp = temp.next
+            temp.next = node
+        print("Node added -->", data)
+
+    def printList(self):
+        temp = self.head
+        while temp:
+            print(temp.data)
+            temp = temp.next
+
+    def findLength(self, ll):
+        if not ll.head:
+            print('No list to traverse')
+            return
+        temp = ll.head
+        count = 0
+        while temp:
+            count += 1
+            temp = temp.next
+        return count
+
+    def turnIntoNum(self, ll, direction=True):
+        '''if direction = true, then sum in place
+            if direction = false, then reverse the ll to sum'''
+
+        if not ll.head:
+            print('No list to traverse')
+            return
+        num = 0
+        length = self.findLength(ll)
+        if direction:
+            power = length - 1
+        n = 0
+        temp = ll.head
+        while n < length:
+            if direction:
+                num += temp.data * (10 ** power)
+                power -= 1
+            else:
+                num += temp.data * (10 ** n)
+            temp = temp.next
+            n += 1
+        print("Number to sum", num)
+        return num
+
+    def addTwoLinkedLists(self, l1, l2, direction=True):
+        num1 = self.turnIntoNum(l1, direction)
+        num2 = self.turnIntoNum(l2, direction)
+        if num1 and num2:
+            return num1 + num2
+        else:
+            print('No numbers to return')
+            return
+
+
+class Test(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.l = SinglyLinkedList()
+        cls.l.addNode(7)
+        cls.l.addNode(1)
+        cls.l.addNode(6)
+
+        cls.k = SinglyLinkedList()
+        cls.k.addNode(5)
+        cls.k.addNode(9)
+        cls.k.addNode(2)
+
+    @classmethod
+    def tearDownClass(cls):
+        pass
+
+    def test1(self):
+        sumReverse = self.l.addTwoLinkedLists(self.l, self.k, False)
+        print('Sum ->', sumReverse)
+        sumLL = self.l.addTwoLinkedLists(self.l, self.k)
+        print('Sum ->', sumLL)
+
+
+if __name__ == '__main__':
+    unittest.main()

Python/chapter02/2.6 - Palindrome/Nick.py

@@ -0,0 +1,70 @@
+#!/usr/bin/python3
+
+import unittest
+
+
+class Node:
+    def __init__(self, data, next=None):
+        self.data = data
+        self.next = next
+
+
+class SinglyLinkedList:
+    def __init__(self):
+        self.head = None
+
+    def appendNode(self, data):
+        node = Node(data)
+        if not self.head:
+            self.head = node
+        else:
+            temp = self.head
+            while temp.next:
+                temp = temp.next
+            temp.next = node
+        print('Node added to LL-->', data)
+
+    def isPalindrome(self):
+        if not self.head:
+            print('No LL to traverse')
+            return
+
+        pali = []
+        temp = self.head
+        while temp:
+            pali.append(temp.data)
+            temp = temp.next
+
+        strpali = ''.join(pali)
+        return strpali == strpali[::-1]
+
+
+class Test(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.l = SinglyLinkedList()
+        cls.l.appendNode('r')
+        cls.l.appendNode('a')
+        cls.l.appendNode('c')
+        cls.l.appendNode('e')
+        cls.l.appendNode('c')
+        cls.l.appendNode('a')
+        cls.l.appendNode('r')
+
+        cls.k = SinglyLinkedList()
+        cls.k.appendNode('n')
+        cls.k.appendNode('i')
+        cls.k.appendNode('c')
+        cls.k.appendNode('k')
+
+    @classmethod
+    def tearDownClass(cls):
+        pass
+
+    def test1(self):
+        self.assertTrue(self.l.isPalindrome())
+        self.assertFalse(self.k.isPalindrome())
+
+
+if __name__ == '__main__':
+    unittest.main()