Ejemplo n.º 1
0
 def test_delete_non_existing(self):
     list = DoublyLinkedList()
     list.insertLast(1, {"a": 1})
     list.insertLast(2, {"b": 2})
     list.insertAfter(2, 3, {"c": 3})
     self.assertEqual(list.delete(4), None)
     self.assertEqual(len(list.array()), 3)
Ejemplo n.º 2
0
 def test_delete_last_existing(self):
     list = DoublyLinkedList()
     list.insertLast(1, {"a": 1})
     list.insertLast(2, {"b": 2})
     list.insertAfter(2, 3, {"c": 3})
     self.assertEqual(list.deleteLast().data['c'], 3)
     self.assertEqual(len(list.array()), 2)
Ejemplo n.º 3
0
 def test_insert_after2(self):
     list = DoublyLinkedList()
     list.insertLast(1, {"a": 1})
     list.insertLast(2, {"b": 2})
     list.insertAfter(2, 3, {"c": 3})
     self.assertEqual(len(list.array()), 3)
     self.assertEqual(list.first.key, 1)
     self.assertEqual(list.first.next.key, 2)
     self.assertEqual(list.last.key, 3)
Ejemplo n.º 4
0
 def test_insert_first(self):
     list = DoublyLinkedList()
     list.insertFirst(1, {"a": 1})
     list.insertFirst(2, {"b": 2})
     list.insertFirst(3, {"c": 3})
     list.insertFirst(4, {"d": 4})
     self.assertEqual(len(list.array()), 4)
     self.assertEqual(list.first.key, 4)
     self.assertEqual(list.last.key, 1)
Ejemplo n.º 5
0
class ListDeque:
    # TODO limit size
    def __init__(self, size=0):
        self.list_obj = DoublyLinkedList()

# top of the stack is

    def list(self):
        return [link.key for link in self.list_obj.array()]

    def isEmpty(self):
        return self.list_obj.isEmpty()

    def insert(self, key):
        self.list_obj.insertLast(key, None)

    def push(self, key):
        self.list_obj.insertFirst(key, None)

    def remove(self):
        if self.isEmpty():
            raise ValueError("Removing from empty deque")
        return self.list_obj.deleteFirst().key

    def pop(self):
        if self.isEmpty():
            raise ValueError("Popping from empty deque")
        return self.list_obj.deleteLast().key

    def head(self):
        if self.isEmpty():
            raise ValueError("Reading head from empty deque")
        return self.list_obj.first.key

    def peek(self):
        if self.isEmpty():
            raise ValueError("Peeking from empty deque")
        return self.list_obj.last.key
Ejemplo n.º 6
0
class TestDoublyLinkedList(unittest.TestCase):

    def setUp(self):
        self.my_list = DoublyLinkedList()

    def test_basic_initialization_and_repr(self):
        self.assertEqual(repr(self.my_list), '[]')

    def test_append(self):
        self.my_list.append(4)
        self.my_list.append(3)
        self.my_list.append(7)
        self.my_list.append(-17)
        self.assertEqual(repr(self.my_list), '[4, 3, 7, -17]')

    def test_prepend(self):
        self.my_list.prepend(4)
        self.my_list.prepend(3)
        self.my_list.prepend(7)
        self.my_list.prepend(-17)
        self.assertEqual(repr(self.my_list), '[-17, 7, 3, 4]')

    def test_insert_after(self):
        self.my_list.insert_after(None, 4)
        self.my_list.insert_after(None, 3)
        self.my_list.insert_after(self.my_list.tail, 7)
        self.my_list.insert_after(self.my_list.head, -17)
        self.assertEqual(repr(self.my_list), '[3, -17, 4, 7]')

    def test_insert_sorted(self):
        self.my_list.insert_after(None, 4)
        self.my_list.insert_after(None, 3)
        self.my_list.insert_after(None, 7)
        self.assertEqual(repr(self.my_list), '[7, 3, 4]')
        self.my_list.insert_sorted(2)
        self.my_list.insert_sorted(8)
        self.assertEqual(repr(self.my_list), '[2, 7, 3, 4, 8]')
        self.my_list.remove(self.my_list.head)
        self.my_list.remove(self.my_list.head)
        self.my_list.remove(self.my_list.head)
        self.my_list.remove(self.my_list.head)
        self.my_list.remove(self.my_list.head)
        self.my_list.insert_sorted(8)
        self.my_list.insert_sorted(7)
        self.my_list.insert_sorted(6)
        self.my_list.insert_sorted(5)
        self.assertEqual(repr(self.my_list), '[5, 6, 7, 8]')

    def test_remove(self):
        self.my_list.append(4)
        self.my_list.append(3)
        self.my_list.append(7)
        self.my_list.append(-17)
        self.assertEqual(repr(self.my_list), '[4, 3, 7, -17]')
        self.my_list.remove(self.my_list.head)
        self.assertEqual(repr(self.my_list), '[3, 7, -17]')
        self.my_list.remove(self.my_list.head.next)
        self.assertEqual(repr(self.my_list), '[3, -17]')
        self.my_list.remove(self.my_list.tail)
        self.assertEqual(repr(self.my_list), '[3]')
        self.my_list.remove(self.my_list.head)
        self.my_list.remove(self.my_list.head)
        self.assertEqual(repr(self.my_list), '[]')

    def test_array(self):
        self.my_list.append(4)
        self.my_list.append(3)
        self.my_list.append(7)
        self.my_list.append(-17)
        self.assertEqual(self.my_list.array(), [4, 3, 7, -17])

    def test_reverse_array(self):
        self.my_list.append(4)
        self.my_list.append(3)
        self.my_list.append(7)
        self.my_list.append(-17)
        self.assertEqual(self.my_list.reverse_array(), [-17, 7, 3, 4])

    def test_search(self):
        self.my_list.append(4)
        self.my_list.append(3)
        self.my_list.append(-17)
        self.my_list.append(7)
        self.assertEqual(self.my_list.search(4).data, 4)
        self.assertEqual(self.my_list.search(3).data, 3)
        self.assertEqual(self.my_list.search(-17).data, -17)
        self.assertEqual(self.my_list.search(17), None)

    def test_reverse(self):
        self.my_list.append(4)
        self.my_list.append(3)
        self.my_list.append(7)
        self.my_list.append(-17)
        self.assertEqual(repr(self.my_list), '[4, 3, 7, -17]')
        self.my_list.reverse()
        self.assertEqual(repr(self.my_list), '[-17, 7, 3, 4]')
        self.my_list.reverse()
        self.assertEqual(repr(self.my_list), '[4, 3, 7, -17]')

    def test_remove_duplicates(self):
        self.my_list.append(4)
        self.my_list.append(3)
        self.my_list.append(3)
        self.my_list.append(3)
        self.my_list.append(7)
        self.my_list.append(-17)
        self.assertEqual(repr(self.my_list), '[4, 3, 3, 3, 7, -17]')
        self.my_list.remove_duplicates()
        self.assertEqual(repr(self.my_list), '[4, 3, 7, -17]')