Exemple #1
0
 def test_make_heap_2(self):
     array = [10, 15, 37, 22, 56, 86]
     new_heap = Heap()
     new_heap.MakeHeap(array, 2)
     array2 = [10, 15, 6, 22, 34, 86]
     new_heap.MakeHeap(array2, 2)
     etalon_array = [86, 22, 34, 10, 15, 6, None]
     self.assertEqual(new_heap.HeapArray, etalon_array)
Exemple #2
0
 def test_GetMax_make_new3(self):
     array = [10]
     new_heap = Heap()
     new_heap.MakeHeap(array, 1)
     self.assertEqual(new_heap.GetMax(), 10)
     self.assertEqual(new_heap.HeapArray, [None, None, None])
     new_heap.MakeHeap(array, 1)
     self.assertEqual(len(new_heap.HeapArray), 3)
     etalon_array = [10, None, None]
     self.assertEqual(new_heap.HeapArray, etalon_array)
Exemple #3
0
 def test_GetMax_make_new2(self):
     array = [10, 15, 6, 22, 34, 86]
     new_heap = Heap()
     new_heap.MakeHeap(array, 2)
     for key in range(3):
         self.assertEqual(new_heap.GetMax() is not None, True)
     new_heap.MakeHeap(array, 2)
     self.assertEqual(len(new_heap.HeapArray), 7)
     etalon_array = [86, 22, 34, 10, 15, 6, None]
     self.assertEqual(new_heap.HeapArray, etalon_array)
class GetMapFromHeapWithSingleKeyTestCase(unittest.TestCase):
    def setUp(self) -> None:
        self.h = Heap()
        self.h.MakeHeap([11], 1)

    def test(self):
        self.assertEqual(11, self.h.GetMax())
        self.assertIsNone(self.h.HeapArray[0])
Exemple #5
0
 def test_GetMax_Add2(self):
     array = [10, 15, 6, 22, 34, 86, 5]
     new_heap = Heap()
     new_heap.MakeHeap(array, 2)
     for i in range(6):
         self.assertEqual(new_heap.Add(array[i]), False)
     etalon_array = [86, 22, 34, 10, 15, 6, 5]
     self.assertEqual(new_heap.HeapArray, etalon_array)
class GetMapFromHeapTestCase(unittest.TestCase):
    def setUp(self) -> None:
        self.h = Heap()
        self.h.MakeHeap([7, 3, 2, 6, 5, 1, 4, 11, 9, 8], 3)

    def test(self):
        self.assertEqual(11, self.h.GetMax())
        self.assertEqual(9, self.h.HeapArray[0])
        self.assertIsNone(self.h.HeapArray[9])
class AddKeyToEmptyHeapTestCase(unittest.TestCase):
    def setUp(self) -> None:
        self.h = Heap()
        self.h.MakeHeap([], 3)

    def test(self):
        self.assertIsNone(self.h.HeapArray[0])
        self.assertTrue(self.h.Add(0))
        self.assertEqual(0, self.h.HeapArray[0])
Exemple #8
0
 def test_GetMax_Add3(self):
     array = [10, 15, 6, 22, 34, 86]
     new_heap = Heap()
     new_heap.MakeHeap(array, 2)
     for i in range(82):
         self.assertEqual(new_heap.GetMax() is not None, True)
         self.assertEqual(len(new_heap.HeapArray), 7)
         self.assertEqual(new_heap.Add(choice(array)), True)
     self.assertEqual(len(new_heap.HeapArray), 7)
Exemple #9
0
 def test_GetMax_Add(self):
     array = [10, 15, 6, 22, 34, 86]
     new_heap = Heap()
     new_heap.MakeHeap(array, 2)
     for key in range(8):
         self.assertEqual(new_heap.GetMax() is not None, True)
     for i in range(6):
         new_heap.Add(array[i])
     etalon_array = [86, 22, 34, 10, 15, 6, None]
     self.assertEqual(new_heap.HeapArray, etalon_array)
Exemple #10
0
 def test_GetMax(self):
     array = [10, 15, 37, 22, 56, 86]
     new_heap = Heap()
     new_heap.MakeHeap(array, 2)
     roots = [86, 56, 37, 22, 15, 10]
     for ind in range(6):
         self.assertEqual(new_heap.GetMax(), roots[ind])
     empty_array = [None] * 7
     self.assertEqual(len(new_heap.HeapArray), 7)
     self.assertEqual(new_heap.HeapArray, empty_array)
class GenerateHeapTestCase(unittest.TestCase):
    def setUp(self) -> None:
        self.h = Heap()

    def test(self):
        self.assertEqual(0, len(self.h.HeapArray))
        self.h.MakeHeap([7, 3, 2, 6, 5, 1, 4, 11, 9, 8, 10, 0, 15, 12, 20], 3)

        self.assertListEqual(
            [20, 10, 15, 7, 9, 4, 12, 3, 6, 5, 8, 0, 1, 2, 11],
            self.h.HeapArray)
        self.assertFalse(self.h.Add(100))
Exemple #12
0
class TestUM(unittest.TestCase):
    def setUp(self):
        pass

    def test_make_heap_depth(self):
        self.heap = Heap()
        self.heap.MakeHeap([1], 0)
        self.assertEqual(len(self.heap.HeapArray), 1)

        self.heap = Heap()
        self.heap.MakeHeap([1, 2, 3], 1)
        self.assertEqual(len(self.heap.HeapArray), 3)

        self.heap = Heap()
        self.heap.MakeHeap([1, 2, 3, 4, 5, 6, 7], 2)
        self.assertEqual(len(self.heap.HeapArray), 7)

        self.heap = Heap()
        self.heap.MakeHeap([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
                           3)
        self.assertEqual(len(self.heap.HeapArray), 15)

        self.heap = Heap()
        self.heap.MakeHeap([1, 2, 3, 4, 5], 1)
        self.assertEqual(len(self.heap.HeapArray), 3)
        self.assertEqual(self.heap.HeapArray, [3, 1, 2])

    def test_add(self):
        self.heap = Heap()
        self.heap.MakeHeap([11, 9, 4, 7, 8, 3, 1, 2, 5, 6], 3)
        self.assertEqual(len(self.heap.HeapArray), 15)
        self.assertEqual(self.heap.Add(10), True)
        self.assertEqual(len(self.heap.HeapArray), 15)
        self.assertEqual(
            self.heap.HeapArray,
            [11, 10, 4, 7, 9, 3, 1, 2, 5, 6, 8, None, None, None, None])

        self.assertEqual(self.heap.Add(15), True)
        self.assertEqual(
            self.heap.HeapArray,
            [15, 10, 11, 7, 9, 4, 1, 2, 5, 6, 8, 3, None, None, None])

        self.assertEqual(self.heap.Add(13), True)
        self.assertEqual(
            self.heap.HeapArray,
            [15, 10, 13, 7, 9, 11, 1, 2, 5, 6, 8, 3, 4, None, None])

        self.assertEqual(self.heap.Add(12), True)
        self.assertEqual(self.heap.HeapArray,
                         [15, 10, 13, 7, 9, 11, 12, 2, 5, 6, 8, 3, 4, 1, None])

        self.assertEqual(self.heap.Add(14), True)
        self.assertEqual(self.heap.HeapArray,
                         [15, 10, 14, 7, 9, 11, 13, 2, 5, 6, 8, 3, 4, 1, 12])

        self.assertEqual(self.heap.Add(777), False)
        self.assertEqual(self.heap.HeapArray,
                         [15, 10, 14, 7, 9, 11, 13, 2, 5, 6, 8, 3, 4, 1, 12])

        self.heap = Heap()
        self.heap.MakeHeap([11, 9, 4, 7, 8, 3, 1, 2, 5, 6], 1)
        self.assertEqual(self.heap.HeapArray, [11, 9, 4])
        self.assertEqual(self.heap.Add(777), False)

        self.heap = Heap()
        self.heap.MakeHeap([11, 9, 4, 7, 8, 3, 1, 2, 5, 6], 0)
        self.assertEqual(self.heap.HeapArray, [11])
        self.assertEqual(self.heap.Add(777), False)

        self.heap = Heap()
        self.heap.MakeHeap([], 0)
        self.assertEqual(self.heap.HeapArray, [None])
        self.assertEqual(self.heap.Add(777), True)
        self.assertEqual(self.heap.HeapArray, [777])

    def test_get_max(self):
        self.heap = Heap()
        self.heap.MakeHeap([777], 0)
        self.assertEqual(self.heap.GetMax(), 777)
        self.assertEqual(self.heap.GetMax(), -1)

        self.heap = Heap()
        self.heap.MakeHeap([10, 15, 6, 22, 34, 86], 2)
        for i in range(82):
            self.assertEqual(self.heap.GetMax() is not None, True)
            self.assertEqual(len(self.heap.HeapArray), 7)
            self.assertEqual(self.heap.Add(777), True)
        self.assertEqual(len(self.heap.HeapArray), 7)

        self.heap = Heap()
        self.heap.MakeHeap(
            [110, 90, 40, 70, 80, 30, 10, 20, 50, 60, 65, 31, 29, 11, 9], 3)
        self.assertEqual(
            self.heap.HeapArray,
            [110, 90, 40, 70, 80, 31, 11, 20, 50, 60, 65, 30, 29, 10, 9])
        self.assertEqual(self.heap.GetMax(), 110)
        self.assertEqual(
            self.heap.HeapArray,
            [90, 80, 40, 70, 65, 31, 11, 20, 50, 60, 9, 30, 29, 10, None])

        self.heap = Heap()
        self.heap.MakeHeap([11, 9, 4, 7, 8, 3, 1, 2, 5, 6], 3)

        self.assertEqual(self.heap.GetMax(), 11)
        self.assertEqual(
            self.heap.HeapArray,
            [9, 8, 4, 7, 6, 3, 1, 2, 5, None, None, None, None, None, None],
        )

        self.assertEqual(self.heap.GetMax(), 9)
        self.assertEqual(
            self.heap.HeapArray,
            [8, 7, 4, 5, 6, 3, 1, 2, None, None, None, None, None, None, None],
        )

        self.assertEqual(self.heap.GetMax(), 8)
        self.assertEqual(
            self.heap.HeapArray,
            [
                7, 6, 4, 5, 2, 3, 1, None, None, None, None, None, None, None,
                None
            ],
        )

        self.assertEqual(self.heap.GetMax(), 7)
        self.assertEqual(
            self.heap.HeapArray,
            [
                6, 5, 4, 1, 2, 3, None, None, None, None, None, None, None,
                None, None
            ],
        )

        self.assertEqual(self.heap.GetMax(), 6)
        self.assertEqual(
            self.heap.HeapArray,
            [
                5, 3, 4, 1, 2, None, None, None, None, None, None, None, None,
                None, None
            ],
        )

        self.assertEqual(self.heap.GetMax(), 5)
        self.assertEqual(
            self.heap.HeapArray,
            [
                4, 3, 2, 1, None, None, None, None, None, None, None, None,
                None, None, None
            ],
        )

        self.assertEqual(self.heap.GetMax(), 4)
        self.assertEqual(
            self.heap.HeapArray,
            [
                3, 1, 2, None, None, None, None, None, None, None, None, None,
                None, None, None
            ],
        )

        self.assertEqual(self.heap.GetMax(), 3)
        self.assertEqual(
            self.heap.HeapArray,
            [
                2, 1, None, None, None, None, None, None, None, None, None,
                None, None, None, None
            ],
        )

        self.assertEqual(self.heap.GetMax(), 2)
        self.assertEqual(
            self.heap.HeapArray,
            [
                1, None, None, None, None, None, None, None, None, None, None,
                None, None, None, None
            ],
        )

        self.assertEqual(self.heap.GetMax(), 1)
        self.assertEqual(
            self.heap.HeapArray,
            [
                None, None, None, None, None, None, None, None, None, None,
                None, None, None, None, None
            ],
        )

        self.assertEqual(self.heap.GetMax(), -1)
        self.assertEqual(
            self.heap.HeapArray,
            [
                None, None, None, None, None, None, None, None, None, None,
                None, None, None, None, None
            ],
        )
        self.assertEqual(len(self.heap.HeapArray), 15)