class DirectedGraph(object):
def __init__(self):
self.V = LinkedList()
def __iter__(self):
return self.V.__iter__()
def add(self, vertex):
self.V.insert(vertex)
class TestLinkedListMethods(unittest.TestCase):
def setUp(self):
# Set up some Elements
self.e1 = LinkedListElement(1)
self.e2 = LinkedListElement(2)
self.e3 = LinkedListElement(3)
self.e4 = LinkedListElement(4)
# Start setting up a LinkedList
self.ll = LinkedList(self.e1)
return
def tearDown(self):
#Clear For Next Test
self.e1 = self.e2 = self.e3 = self.e4 = None
self.ll = None
#TEST FUNCTION
def test_append(self):
#Setup
self.ll.append(self.e2)
self.ll.append(self.e3)
self.assertEqual(self.ll.head.next.value,2)
self.assertEqual(self.ll.head.next.next.value,3)
def test_getPosition(self):
#Setup
self.ll.append(self.e2)
self.ll.append(self.e3)
self.assertEqual(self.ll.get_position(3).value,3)
def test_insert(self):
#Setup
self.ll.append(self.e2)
self.ll.append(self.e3)
# Test insert
self.ll.insert(self.e4,3)
# Should print 4 now
self.assertEqual(self.ll.get_position(3).value,4)
def test_delete(self):
#Setup
self.ll.append(self.e2)
self.ll.append(self.e4)
self.ll.append(self.e3)
# Test delete
self.ll.delete(1)
self.assertEqual(self.ll.get_position(1).value,2)
self.assertEqual(self.ll.get_position(2).value,4)
self.assertEqual(self.ll.get_position(3).value,3)
def test_remove(self):
s = LinkedList()
self.assertRaises(ListOutOfRangeError, s.remove, 0)
s.insert('a', 0)
s.insert('b', 1)
s.insert('c', 2)
self.assertEquals(s.remove(1), 'b')
self.assertEquals(s.get(0), 'a')
self.assertEquals(s.get(1), 'c')
self.assertRaises(ListOutOfRangeError, s.remove, 2)
self.assertEquals(s.remove(1), 'c')
self.assertEquals(s.remove(0), 'a')
self.assertRaises(ListOutOfRangeError, s.remove, 0)
def test_size(self):
s = LinkedList()
s.insert('a', 0)
s.insert('b', 0)
self.assertEquals(s.size(), 2)
s.insert('c', 2)
self.assertEquals(s.size(), 3)
s.remove(0)
self.assertEquals(s.size(), 2)
s.remove(0)
self.assertEquals(s.size(), 1)
s.remove(0)
self.assertEquals(s.size(), 0)
def all_paths_from(root, value):
if root is None:
return []
left_paths = all_paths_from(root.left, value - root.value)
for path in left_paths:
path.insert(Node(root.key, root.value))
right_paths = all_paths_from(root.right, value - root.value)
for path in right_paths:
path.insert(Node(root.key, root.value))
if root.value == value:
path = LinkedList()
path.insert(Node(root.key, root.value))
return left_paths + right_paths + [path]
return left_paths + right_paths
def test_index(self):
s = LinkedList()
s.insert('a', 0)
self.assertEquals(s.index('a'), 0)
self.assertEquals(s.index('b'), None)
s.insert('b', 1)
self.assertEquals(s.index('a'), 0)
self.assertEquals(s.index('b'), 1)
s.insert('c', 1)
self.assertEquals(s.index('a'), 0)
self.assertEquals(s.index('b'), 2)
self.assertEquals(s.index('c'), 1)
s.insert('d', 0)
self.assertEquals(s.index('d'), 0)
self.assertEquals(s.index('a'), 1)
self.assertEquals(s.index('b'), 3)
self.assertEquals(s.index('c'), 2)
def test_get(self):
s = LinkedList()
s.insert('a', 0)
s.insert('b', 0)
s.insert('c', 0)
self.assertEquals(s.get(0), 'c')
self.assertEquals(s.get(1), 'b')
self.assertEquals(s.get(2), 'a')
self.assertRaises(ListOutOfRangeError, s.get, 4)
s.insert('d', 1)
self.assertEquals(s.get(0), 'c')
self.assertEquals(s.get(1), 'd')
self.assertEquals(s.get(2), 'b')
def get_each_depth(binary_tree):
linked_lists = []
current = LinkedList()
current.insert(binary_tree.root)
while not current.empty():
linked_lists.append(current)
children = LinkedList()
for node in current:
if node.left is not None:
children.insert(node.left)
if node.right is not None:
children.insert(node.right)
current = children
return linked_lists
slow = slow.next
return head
# No loop.
return None
def find_loop_start2(linked_list):
"""Given a corrupt circular linked list returns the start of the loop.
Probably not allowed to use Python set.
"""
seen = set()
current = linked_list.head
while current is not None:
if current in seen:
return current
seen.add(current)
current = current.next
return None
linked_list = LinkedList()
for i in xrange(10):
linked_list.insert(Node(i))
# Set up a loop.
x = linked_list.search(0)
y = linked_list.search(5)
x.next = y
y.prev = x
print find_loop_start(linked_list).key
while x is not None:
if x.key in seen:
print "Deleting duplicate with key %s" % x.key
linked_list.delete(x)
else:
seen.add(x.key)
x = x.next
def remove_duplicates2(linked_list):
"""Removes duplicates in a linked list without using a temporary buffer."""
x = linked_list.head
while x is not None:
y = x.next
while y is not None:
if y.key == x.key:
print "Deleting duplicate with key %s" % y.key
linked_list.delete(y)
y = y.next
x = x.next
linked_list = LinkedList()
for _ in xrange(5):
linked_list.insert(Node(1))
for _ in xrange(5):
linked_list.insert(Node(2))
linked_list.traverse()
remove_duplicates2(linked_list)
linked_list.traverse()
def size(linked_list):
size = 0
x = linked_list.head
while x is not None:
size += 1
x = x.next
return size
def check_palindrome2(linked_list):
"""Relies on doubly linked list."""
x = linked_list.head
while x.next is not None:
x = x.next
y = linked_list.head
while y is not None:
if x.key != y.key:
return False
x = x.prev
y = y.next
return True
a = LinkedList()
for i in xrange(9):
a.insert(Node(i))
for i in reversed(xrange(9)):
a.insert(Node(i))
a.traverse()
print check_palindrome_recursive(a)