From 1abbf2c5cf36d03d8af67610e085143c90175676 Mon Sep 17 00:00:00 2001
From: Harsheet-saxena <harshsaxena1999@gmail.com>
Date: Wed, 11 Mar 2020 16:08:32 +0530
Subject: [PATCH 01/12] TreeNode check added

---
 pydatastructs/trees/heaps.py            | 8 +++++++-
 pydatastructs/trees/tests/test_heaps.py | 8 ++++++++
 2 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/pydatastructs/trees/heaps.py b/pydatastructs/trees/heaps.py
index 66f7f4b7b..ee5843492 100644
--- a/pydatastructs/trees/heaps.py
+++ b/pydatastructs/trees/heaps.py
@@ -23,7 +23,7 @@ class BinaryHeap(Heap):
 
     elements : list, tuple
         Optional, by default 'None'.
-        List/tuple of initial elements in Heap.
+        List/tuple of initial TreeNodes in Heap.
 
     heap_property : str
         The property of binary heap.
@@ -80,6 +80,12 @@ def __new__(cls, elements=None, heap_property="min"):
             raise ValueError("%s is invalid heap property"%(heap_property))
         if elements is None:
             elements = []
+        else:
+            #to check if all elements provided are TreeNodes
+            check_node = map(lambda x: type(x)==type(TreeNode(1,1)),elements)
+            is_node = all(check_node)
+            if(not is_node):
+                raise TypeError("Elements have to be list/tuple of TreeNode")
         obj.heap = elements
         obj._last_pos_filled = len(elements) - 1
         obj._build()
diff --git a/pydatastructs/trees/tests/test_heaps.py b/pydatastructs/trees/tests/test_heaps.py
index 5c455f86c..f2b32ca4f 100644
--- a/pydatastructs/trees/tests/test_heaps.py
+++ b/pydatastructs/trees/tests/test_heaps.py
@@ -47,6 +47,14 @@ def test_BinaryHeap():
     sorted_elements = [min_heap.extract().key for _ in range(8)]
     assert expected_sorted_elements == sorted_elements
 
+    #To test ValueError on non TreeNode list
+    non_TreeNode_elements = [
+                (7, 7), TreeNode(25, 25), TreeNode(100, 100),
+                TreeNode(1, 1), (2, 2), TreeNode(3, 3),
+                TreeNode(17, 17), TreeNode(19, 19), TreeNode(36, 36)
+            ]
+    assert raises(TypeError, lambda:
+                BinaryHeap(elements = non_TreeNode_elements, heap_property='min'))
 def test_BinomialHeap():
 
     # Corner cases

From 3a755fadb3c5aa90e6db3737a49bdd3f4e70d586 Mon Sep 17 00:00:00 2001
From: Harsheet-saxena <harshsaxena1999@gmail.com>
Date: Wed, 11 Mar 2020 18:07:41 +0530
Subject: [PATCH 02/12] Trailing whitespace error solved

---
 .gitignore                              |   1 +
 pydatastructs/trees/__init__.py         |   2 +
 pydatastructs/trees/heaps.py            | 187 ++++++++++++++++++++----
 pydatastructs/trees/tests/test_heaps.py | 100 +++++++++++--
 4 files changed, 246 insertions(+), 44 deletions(-)

diff --git a/.gitignore b/.gitignore
index 32018e91e..0e9c04114 100644
--- a/.gitignore
+++ b/.gitignore
@@ -64,3 +64,4 @@ __pycache__/
 .idea/
 build/
 dist/
+venv/
\ No newline at end of file
diff --git a/pydatastructs/trees/__init__.py b/pydatastructs/trees/__init__.py
index 1cc0a0339..c9dc298cb 100644
--- a/pydatastructs/trees/__init__.py
+++ b/pydatastructs/trees/__init__.py
@@ -22,6 +22,8 @@
 
 from .heaps import (
     BinaryHeap,
+    TernaryHeap,
+    DHeap,
     BinomialHeap
 )
 __all__.extend(heaps.__all__)
diff --git a/pydatastructs/trees/heaps.py b/pydatastructs/trees/heaps.py
index ee5843492..c8dfa8f87 100644
--- a/pydatastructs/trees/heaps.py
+++ b/pydatastructs/trees/heaps.py
@@ -5,6 +5,8 @@
 
 __all__ = [
     'BinaryHeap',
+    'TernaryHeap',
+    'DHeap',
     'BinomialHeap'
 ]
 
@@ -14,9 +16,10 @@ class Heap(object):
     """
     pass
 
-class BinaryHeap(Heap):
+
+class DHeap(Heap):
     """
-    Represents Binary Heap.
+    Represents D-ary Heap.
 
     Parameters
     ==========
@@ -26,7 +29,6 @@ class BinaryHeap(Heap):
         List/tuple of initial TreeNodes in Heap.
 
     heap_property : str
-        The property of binary heap.
         If the key stored in each node is
         either greater than or equal to
         the keys in the node's children
@@ -41,8 +43,8 @@ class BinaryHeap(Heap):
     Examples
     ========
 
-    >>> from pydatastructs.trees.heaps import BinaryHeap
-    >>> min_heap = BinaryHeap(heap_property="min")
+    >>> from pydatastructs.trees.heaps import DHeap
+    >>> min_heap = DHeap(heap_property="min", d=3)
     >>> min_heap.insert(1, 1)
     >>> min_heap.insert(5, 5)
     >>> min_heap.insert(7, 7)
@@ -52,7 +54,7 @@ class BinaryHeap(Heap):
     >>> min_heap.extract().key
     4
 
-    >>> max_heap = BinaryHeap(heap_property='max')
+    >>> max_heap = DHeap(heap_property='max', d=2)
     >>> max_heap.insert(1, 1)
     >>> max_heap.insert(5, 5)
     >>> max_heap.insert(7, 7)
@@ -65,13 +67,14 @@ class BinaryHeap(Heap):
     References
     ==========
 
-    .. [1] https://en.m.wikipedia.org/wiki/Binary_heap
+    .. [1] https://en.wikipedia.org/wiki/D-ary_heap
     """
-    __slots__ = ['_comp', 'heap', 'heap_property', '_last_pos_filled']
+    __slots__ = ['_comp', 'heap', 'd', 'heap_property', '_last_pos_filled']
 
-    def __new__(cls, elements=None, heap_property="min"):
+    def __new__(cls, elements=None, heap_property="min", d=4):
         obj = Heap.__new__(cls)
         obj.heap_property = heap_property
+        obj.d = d
         if heap_property == "min":
             obj._comp = lambda key_parent, key_child: key_parent <= key_child
         elif heap_property == "max":
@@ -79,23 +82,24 @@ def __new__(cls, elements=None, heap_property="min"):
         else:
             raise ValueError("%s is invalid heap property"%(heap_property))
         if elements is None:
-            elements = []
+            elements = DynamicOneDimensionalArray(TreeNode, 0)
         else:
             #to check if all elements provided are TreeNodes
             check_node = map(lambda x: type(x)==type(TreeNode(1,1)),elements)
             is_node = all(check_node)
             if(not is_node):
                 raise TypeError("Elements have to be list/tuple of TreeNode")
+
         obj.heap = elements
-        obj._last_pos_filled = len(elements) - 1
+        obj._last_pos_filled = obj.heap._last_pos_filled
         obj._build()
         return obj
 
     def _build(self):
         for i in range(self._last_pos_filled + 1):
-            self.heap[i].left, self.heap[i].right = \
-                2*i + 1, 2*i + 2
-        for i in range((self._last_pos_filled + 1)//2, -1, -1):
+            self.heap[i]._leftmost, self.heap[i]._rightmost = \
+                self.d*i + 1, self.d*i + self.d
+        for i in range((self._last_pos_filled + 1)//self.d, -1, -1):
             self._heapify(i)
 
     def _swap(self, idx1, idx2):
@@ -109,15 +113,15 @@ def _swap(self, idx1, idx2):
     def _heapify(self, i):
         while True:
             target = i
-            l = 2*i + 1
-            r = 2*i + 2
+            l = self.d*i + 1
+            r = self.d*i + self.d
 
-            if l <= self._last_pos_filled:
-                target = l if self._comp(self.heap[l].key, self.heap[target].key) \
-                        else i
-            if r <= self._last_pos_filled:
-                target = r if self._comp(self.heap[r].key, self.heap[target].key) \
-                        else target
+            for j in range(l, r+1):
+                if j <= self._last_pos_filled:
+                    target = j if self._comp(self.heap[j].key, self.heap[target].key) \
+                            else target
+                else:
+                    break
 
             if target != i:
                 self._swap(target, i)
@@ -125,7 +129,6 @@ def _heapify(self, i):
             else:
                 break
 
-
     def insert(self, key, data):
         """
         Insert a new element to the heap according to heap property.
@@ -147,10 +150,10 @@ def insert(self, key, data):
         self.heap.append(new_node)
         self._last_pos_filled += 1
         i = self._last_pos_filled
-        self.heap[i].left, self.heap[i].right = 2*i + 1, 2*i + 2
+        self.heap[i]._leftmost, self.heap[i]._rightmost = self.d*i + 1, self.d*i + self.d
 
         while True:
-            parent = (i - 1)//2
+            parent = (i - 1)//self.d
             if i == 0 or self._comp(self.heap[parent].key, self.heap[i].key):
                 break
             else:
@@ -175,23 +178,143 @@ def extract(self):
         else:
             element_to_be_extracted = TreeNode(self.heap[0].key, self.heap[0].data)
             self._swap(0, self._last_pos_filled)
-            self.heap[self._last_pos_filled] = TreeNode(float('inf') if self.heap_property == 'min'
-                                                                else float('-inf'), None)
-            self._heapify(0)
-            self.heap.pop()
+            self.heap.delete(self._last_pos_filled)
             self._last_pos_filled -= 1
+            self._heapify(0)
             return element_to_be_extracted
 
     def __str__(self):
         to_be_printed = ['' for i in range(self._last_pos_filled + 1)]
         for i in range(self._last_pos_filled + 1):
             node = self.heap[i]
-            to_be_printed[i] = (node.left if node.left <= self._last_pos_filled else None,
-                                node.key, node.data,
-                                node.right if node.right <= self._last_pos_filled else None)
+            if node._leftmost <= self._last_pos_filled:
+                if node._rightmost <= self._last_pos_filled:
+                    children = [x for x in range(node._leftmost, node._rightmost + 1)]
+                else:
+                    children = [x for x in range(node._leftmost, self._last_pos_filled + 1)]
+            else:
+                children = []
+            to_be_printed[i] = (node.key, node.data, children)
         return str(to_be_printed)
 
 
+class BinaryHeap(DHeap):
+    """
+    Represents Binary Heap.
+
+    Parameters
+    ==========
+
+    elements : list, tuple
+        Optional, by default 'None'.
+        List/tuple of initial elements in Heap.
+
+    heap_property : str
+        If the key stored in each node is
+        either greater than or equal to
+        the keys in the node's children
+        then pass 'max'.
+        If the key stored in each node is
+        either less than or equal to
+        the keys in the node's children
+        then pass 'min'.
+        By default, the heap property is
+        set to 'min'.
+
+    Examples
+    ========
+
+    >>> from pydatastructs.trees.heaps import BinaryHeap
+    >>> min_heap = BinaryHeap(heap_property="min")
+    >>> min_heap.insert(1, 1)
+    >>> min_heap.insert(5, 5)
+    >>> min_heap.insert(7, 7)
+    >>> min_heap.extract().key
+    1
+    >>> min_heap.insert(4, 4)
+    >>> min_heap.extract().key
+    4
+
+    >>> max_heap = BinaryHeap(heap_property='max')
+    >>> max_heap.insert(1, 1)
+    >>> max_heap.insert(5, 5)
+    >>> max_heap.insert(7, 7)
+    >>> max_heap.extract().key
+    7
+    >>> max_heap.insert(6, 6)
+    >>> max_heap.extract().key
+    6
+
+    References
+    ==========
+
+    .. [1] https://en.m.wikipedia.org/wiki/Binary_heap
+    """
+    def __new__(cls, elements=None, heap_property="min"):
+        obj = DHeap.__new__(cls, elements, heap_property, 2)
+        return obj
+
+
+class TernaryHeap(DHeap):
+    """
+    Represents Ternary Heap.
+
+    Parameters
+    ==========
+
+    elements : list, tuple
+        Optional, by default 'None'.
+        List/tuple of initial elements in Heap.
+
+    heap_property : str
+        If the key stored in each node is
+        either greater than or equal to
+        the keys in the node's children
+        then pass 'max'.
+        If the key stored in each node is
+        either less than or equal to
+        the keys in the node's children
+        then pass 'min'.
+        By default, the heap property is
+        set to 'min'.
+
+    Examples
+    ========
+
+    >>> from pydatastructs.trees.heaps import TernaryHeap
+    >>> min_heap = TernaryHeap(heap_property="min")
+    >>> min_heap.insert(1, 1)
+    >>> min_heap.insert(5, 5)
+    >>> min_heap.insert(7, 7)
+    >>> min_heap.insert(3, 3)
+    >>> min_heap.extract().key
+    1
+    >>> min_heap.insert(4, 4)
+    >>> min_heap.extract().key
+    3
+
+    >>> max_heap = TernaryHeap(heap_property='max')
+    >>> max_heap.insert(1, 1)
+    >>> max_heap.insert(5, 5)
+    >>> max_heap.insert(7, 7)
+    >>> min_heap.insert(3, 3)
+    >>> max_heap.extract().key
+    7
+    >>> max_heap.insert(6, 6)
+    >>> max_heap.extract().key
+    6
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/D-ary_heap
+    .. [2] https://ece.uwaterloo.ca/~dwharder/aads/Algorithms/d-ary_heaps/Ternary_heaps/
+    """
+    def __new__(cls, elements=None, heap_property="min"):
+        obj = DHeap.__new__(cls, elements, heap_property, 3)
+        return obj
+
+
 class BinomialHeap(Heap):
     """
     Represents binomial heap.
diff --git a/pydatastructs/trees/tests/test_heaps.py b/pydatastructs/trees/tests/test_heaps.py
index f2b32ca4f..b1ccffe72 100644
--- a/pydatastructs/trees/tests/test_heaps.py
+++ b/pydatastructs/trees/tests/test_heaps.py
@@ -1,13 +1,12 @@
-from pydatastructs.trees.heaps import BinaryHeap, BinomialHeap
+from pydatastructs.trees.heaps import BinaryHeap, TernaryHeap, BinomialHeap, DHeap
+from pydatastructs.linear_data_structures.arrays import DynamicOneDimensionalArray
 from pydatastructs.miscellaneous_data_structures.binomial_trees import BinomialTree
 from pydatastructs.utils.misc_util import TreeNode, BinomialTreeNode
 from pydatastructs.utils.raises_util import raises
 from collections import deque as Queue
 
 def test_BinaryHeap():
-
     max_heap = BinaryHeap(heap_property="max")
-
     assert max_heap.extract() is None
 
     max_heap.insert(100, 100)
@@ -20,13 +19,12 @@ def test_BinaryHeap():
     max_heap.insert(2, 2)
     max_heap.insert(7, 7)
     assert str(max_heap) == \
-    ("[(1, 100, 100, 2), (3, 19, 19, 4), "
-    "(5, 36, 36, 6), (7, 17, 17, 8), "
-    "(None, 3, 3, None), (None, 25, 25, None), "
-    "(None, 1, 1, None), (None, 2, 2, None), (None, 7, 7, None)]")
+        ("[(100, 100, [1, 2]), (19, 19, [3, 4]), "
+        "(36, 36, [5, 6]), (17, 17, [7, 8]), "
+        "(3, 3, []), (25, 25, []), (1, 1, []), "
+        "(2, 2, []), (7, 7, [])]")
 
-    expected_extracted_element = max_heap.heap[0].key
-    assert max_heap.extract().key == expected_extracted_element
+    assert max_heap.extract().key == 100
 
     expected_sorted_elements = [36, 25, 19, 17, 7, 3, 2, 1]
     sorted_elements = []
@@ -39,9 +37,8 @@ def test_BinaryHeap():
                 TreeNode(1, 1), TreeNode(2, 2), TreeNode(3, 3),
                 TreeNode(17, 17), TreeNode(19, 19), TreeNode(36, 36)
             ]
-    min_heap = BinaryHeap(elements = elements, heap_property="min")
-    expected_extracted_element = min_heap.heap[0].key
-    assert min_heap.extract().key == expected_extracted_element
+    min_heap = BinaryHeap(elements=DynamicOneDimensionalArray(TreeNode, 9, elements), heap_property="min")
+    assert min_heap.extract().key == 1
 
     expected_sorted_elements = [2, 3, 7, 17, 19, 25, 36, 100]
     sorted_elements = [min_heap.extract().key for _ in range(8)]
@@ -55,6 +52,85 @@ def test_BinaryHeap():
             ]
     assert raises(TypeError, lambda:
                 BinaryHeap(elements = non_TreeNode_elements, heap_property='min'))
+def test_TernaryHeap():
+    max_heap = TernaryHeap(heap_property="max")
+    assert max_heap.extract() is None
+    max_heap.insert(100, 100)
+    max_heap.insert(19, 19)
+    max_heap.insert(36, 36)
+    max_heap.insert(17, 17)
+    max_heap.insert(3, 3)
+    max_heap.insert(25, 25)
+    max_heap.insert(1, 1)
+    max_heap.insert(2, 2)
+    max_heap.insert(7, 7)
+    assert str(max_heap) == \
+           ('[(100, 100, [1, 2, 3]), (25, 25, [4, 5, 6]), '
+            '(36, 36, [7, 8]), (17, 17, []), '
+            '(3, 3, []), (19, 19, []), (1, 1, []), '
+            '(2, 2, []), (7, 7, [])]')
+
+    assert max_heap.extract().key == 100
+
+    expected_sorted_elements = [36, 25, 19, 17, 7, 3, 2, 1]
+    sorted_elements = []
+    for _ in range(8):
+        sorted_elements.append(max_heap.extract().key)
+    assert expected_sorted_elements == sorted_elements
+
+    elements = [
+        TreeNode(7, 7), TreeNode(25, 25), TreeNode(100, 100),
+        TreeNode(1, 1), TreeNode(2, 2), TreeNode(3, 3),
+        TreeNode(17, 17), TreeNode(19, 19), TreeNode(36, 36)
+    ]
+    min_heap = TernaryHeap(elements=DynamicOneDimensionalArray(TreeNode, 9, elements), heap_property="min")
+    expected_extracted_element = min_heap.heap[0].key
+    assert min_heap.extract().key == expected_extracted_element
+
+    expected_sorted_elements = [2, 3, 7, 17, 19, 25, 36, 100]
+    sorted_elements = [min_heap.extract().key for _ in range(8)]
+    assert expected_sorted_elements == sorted_elements
+
+
+def test_DHeap():
+    assert raises(ValueError, lambda: DHeap(heap_property="none", d=4))
+    max_heap = DHeap(heap_property="max", d=5)
+    assert max_heap.extract() is None
+    max_heap.insert(100, 100)
+    max_heap.insert(19, 19)
+    max_heap.insert(36, 36)
+    max_heap.insert(17, 17)
+    max_heap.insert(3, 3)
+    max_heap.insert(25, 25)
+    max_heap.insert(1, 1)
+    max_heap = DHeap(max_heap.heap, heap_property="max", d=4)
+    max_heap.insert(2, 2)
+    max_heap.insert(7, 7)
+    assert str(max_heap) == \
+           ('[(100, 100, [1, 2, 3, 4]), (25, 25, [5, 6, 7, 8]), '
+           '(36, 36, []), (17, 17, []), (3, 3, []), (19, 19, []), '
+           '(1, 1, []), (2, 2, []), (7, 7, [])]')
+
+    assert max_heap.extract().key == 100
+
+    expected_sorted_elements = [36, 25, 19, 17, 7, 3, 2, 1]
+    sorted_elements = []
+    for _ in range(8):
+        sorted_elements.append(max_heap.extract().key)
+    assert expected_sorted_elements == sorted_elements
+
+    elements = [
+        TreeNode(7, 7), TreeNode(25, 25), TreeNode(100, 100),
+        TreeNode(1, 1), TreeNode(2, 2), TreeNode(3, 3),
+        TreeNode(17, 17), TreeNode(19, 19), TreeNode(36, 36)
+    ]
+    min_heap = DHeap(elements=DynamicOneDimensionalArray(TreeNode, 9, elements), heap_property="min")
+    assert min_heap.extract().key == 1
+
+    expected_sorted_elements = [2, 3, 7, 17, 19, 25, 36, 100]
+    sorted_elements = [min_heap.extract().key for _ in range(8)]
+    assert expected_sorted_elements == sorted_elements
+
 def test_BinomialHeap():
 
     # Corner cases

From 5c1c6acc833d54b46992f0934fac8c5a66ed5462 Mon Sep 17 00:00:00 2001
From: Harsheet Kakar <42893005+HarsheetKakar@users.noreply.github.com>
Date: Wed, 11 Mar 2020 18:13:42 +0530
Subject: [PATCH 03/12] venv removed from gitignore

---
 .gitignore | 1 -
 1 file changed, 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index 0e9c04114..32018e91e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -64,4 +64,3 @@ __pycache__/
 .idea/
 build/
 dist/
-venv/
\ No newline at end of file

From 192b0d62e77a52964d0b0c54e55c2558f6b5dde7 Mon Sep 17 00:00:00 2001
From: Harsheet-saxena <harshsaxena1999@gmail.com>
Date: Wed, 11 Mar 2020 18:41:42 +0530
Subject: [PATCH 04/12] TreeNode check added in heap.py

---
 .gitignore                              |   1 +
 pydatastructs/trees/heaps.py            | 533 ------------------------
 pydatastructs/trees/tests/test_heaps.py | 235 +----------
 3 files changed, 4 insertions(+), 765 deletions(-)

diff --git a/.gitignore b/.gitignore
index 32018e91e..0e9c04114 100644
--- a/.gitignore
+++ b/.gitignore
@@ -64,3 +64,4 @@ __pycache__/
 .idea/
 build/
 dist/
+venv/
\ No newline at end of file
diff --git a/pydatastructs/trees/heaps.py b/pydatastructs/trees/heaps.py
index da5a07c09..6fdb86c27 100644
--- a/pydatastructs/trees/heaps.py
+++ b/pydatastructs/trees/heaps.py
@@ -1,4 +1,3 @@
-<<<<<<< HEAD
 from pydatastructs.utils.misc_util import _check_type, NoneType, TreeNode, BinomialTreeNode
 from pydatastructs.linear_data_structures.arrays import (ArrayForTrees,
      DynamicOneDimensionalArray)
@@ -90,7 +89,6 @@ def __new__(cls, elements=None, heap_property="min", d=4):
             is_node = all(check_node)
             if(not is_node):
                 raise TypeError("Elements have to be list/tuple of TreeNode")
-
         obj.heap = elements
         obj._last_pos_filled = obj.heap._last_pos_filled
         obj._build()
@@ -528,534 +526,3 @@ def delete(self, node):
         """
         self.decrease_key(node, self.find_minimum().key - 1)
         self.delete_minimum()
-=======
-from pydatastructs.utils.misc_util import _check_type, NoneType, TreeNode, BinomialTreeNode
-from pydatastructs.linear_data_structures.arrays import (ArrayForTrees,
-     DynamicOneDimensionalArray)
-from pydatastructs.miscellaneous_data_structures.binomial_trees import BinomialTree
-
-__all__ = [
-    'BinaryHeap',
-    'TernaryHeap',
-    'DHeap',
-    'BinomialHeap'
-]
-
-class Heap(object):
-    """
-    Abstract class for representing heaps.
-    """
-    pass
-
-
-class DHeap(Heap):
-    """
-    Represents D-ary Heap.
-
-    Parameters
-    ==========
-
-    elements : list, tuple
-        Optional, by default 'None'.
-        List/tuple of initial TreeNodes in Heap.
-
-    heap_property : str
-        If the key stored in each node is
-        either greater than or equal to
-        the keys in the node's children
-        then pass 'max'.
-        If the key stored in each node is
-        either less than or equal to
-        the keys in the node's children
-        then pass 'min'.
-        By default, the heap property is
-        set to 'min'.
-
-    Examples
-    ========
-
-    >>> from pydatastructs.trees.heaps import DHeap
-    >>> min_heap = DHeap(heap_property="min", d=3)
-    >>> min_heap.insert(1, 1)
-    >>> min_heap.insert(5, 5)
-    >>> min_heap.insert(7, 7)
-    >>> min_heap.extract().key
-    1
-    >>> min_heap.insert(4, 4)
-    >>> min_heap.extract().key
-    4
-
-    >>> max_heap = DHeap(heap_property='max', d=2)
-    >>> max_heap.insert(1, 1)
-    >>> max_heap.insert(5, 5)
-    >>> max_heap.insert(7, 7)
-    >>> max_heap.extract().key
-    7
-    >>> max_heap.insert(6, 6)
-    >>> max_heap.extract().key
-    6
-
-    References
-    ==========
-
-    .. [1] https://en.wikipedia.org/wiki/D-ary_heap
-    """
-    __slots__ = ['_comp', 'heap', 'd', 'heap_property', '_last_pos_filled']
-
-    def __new__(cls, elements=None, heap_property="min", d=4):
-        obj = Heap.__new__(cls)
-        obj.heap_property = heap_property
-        obj.d = d
-        if heap_property == "min":
-            obj._comp = lambda key_parent, key_child: key_parent <= key_child
-        elif heap_property == "max":
-            obj._comp = lambda key_parent, key_child: key_parent >= key_child
-        else:
-            raise ValueError("%s is invalid heap property"%(heap_property))
-        if elements is None:
-            elements = DynamicOneDimensionalArray(TreeNode, 0)
-        else:
-            #to check if all elements provided are TreeNodes
-            check_node = map(lambda x: type(x)==type(TreeNode(1,1)),elements)
-            is_node = all(check_node)
-            if(not is_node):
-                raise TypeError("Elements have to be list/tuple of TreeNode")
-
-        obj.heap = elements
-        obj._last_pos_filled = obj.heap._last_pos_filled
-        obj._build()
-        return obj
-
-    def _build(self):
-        for i in range(self._last_pos_filled + 1):
-            self.heap[i]._leftmost, self.heap[i]._rightmost = \
-                self.d*i + 1, self.d*i + self.d
-        for i in range((self._last_pos_filled + 1)//self.d, -1, -1):
-            self._heapify(i)
-
-    def _swap(self, idx1, idx2):
-        idx1_key, idx1_data = \
-            self.heap[idx1].key, self.heap[idx1].data
-        self.heap[idx1].key, self.heap[idx1].data = \
-            self.heap[idx2].key, self.heap[idx2].data
-        self.heap[idx2].key, self.heap[idx2].data = \
-            idx1_key, idx1_data
-
-    def _heapify(self, i):
-        while True:
-            target = i
-            l = self.d*i + 1
-            r = self.d*i + self.d
-
-            for j in range(l, r+1):
-                if j <= self._last_pos_filled:
-                    target = j if self._comp(self.heap[j].key, self.heap[target].key) \
-                            else target
-                else:
-                    break
-
-            if target != i:
-                self._swap(target, i)
-                i = target
-            else:
-                break
-
-    def insert(self, key, data):
-        """
-        Insert a new element to the heap according to heap property.
-
-        Parameters
-        ==========
-
-        key
-            The key for comparison.
-        data
-            The data to be inserted.
-
-        Returns
-        =======
-
-        None
-        """
-        new_node = TreeNode(key, data)
-        self.heap.append(new_node)
-        self._last_pos_filled += 1
-        i = self._last_pos_filled
-        self.heap[i]._leftmost, self.heap[i]._rightmost = self.d*i + 1, self.d*i + self.d
-
-        while True:
-            parent = (i - 1)//self.d
-            if i == 0 or self._comp(self.heap[parent].key, self.heap[i].key):
-                break
-            else:
-                self._swap(i, parent)
-                i = parent
-
-    def extract(self):
-        """
-        Extract root element of the Heap.
-
-        Returns
-        =======
-
-        root_element : TreeNode
-            The TreeNode at the root of the heap,
-            if the heap is not empty.
-        None
-            If the heap is empty.
-        """
-        if self._last_pos_filled == -1:
-            return None
-        else:
-            element_to_be_extracted = TreeNode(self.heap[0].key, self.heap[0].data)
-            self._swap(0, self._last_pos_filled)
-            self.heap.delete(self._last_pos_filled)
-            self._last_pos_filled -= 1
-            self._heapify(0)
-            return element_to_be_extracted
-
-    def __str__(self):
-        to_be_printed = ['' for i in range(self._last_pos_filled + 1)]
-        for i in range(self._last_pos_filled + 1):
-            node = self.heap[i]
-            if node._leftmost <= self._last_pos_filled:
-                if node._rightmost <= self._last_pos_filled:
-                    children = [x for x in range(node._leftmost, node._rightmost + 1)]
-                else:
-                    children = [x for x in range(node._leftmost, self._last_pos_filled + 1)]
-            else:
-                children = []
-            to_be_printed[i] = (node.key, node.data, children)
-        return str(to_be_printed)
-
-
-class BinaryHeap(DHeap):
-    """
-    Represents Binary Heap.
-
-    Parameters
-    ==========
-
-    elements : list, tuple
-        Optional, by default 'None'.
-        List/tuple of initial elements in Heap.
-
-    heap_property : str
-        If the key stored in each node is
-        either greater than or equal to
-        the keys in the node's children
-        then pass 'max'.
-        If the key stored in each node is
-        either less than or equal to
-        the keys in the node's children
-        then pass 'min'.
-        By default, the heap property is
-        set to 'min'.
-
-    Examples
-    ========
-
-    >>> from pydatastructs.trees.heaps import BinaryHeap
-    >>> min_heap = BinaryHeap(heap_property="min")
-    >>> min_heap.insert(1, 1)
-    >>> min_heap.insert(5, 5)
-    >>> min_heap.insert(7, 7)
-    >>> min_heap.extract().key
-    1
-    >>> min_heap.insert(4, 4)
-    >>> min_heap.extract().key
-    4
-
-    >>> max_heap = BinaryHeap(heap_property='max')
-    >>> max_heap.insert(1, 1)
-    >>> max_heap.insert(5, 5)
-    >>> max_heap.insert(7, 7)
-    >>> max_heap.extract().key
-    7
-    >>> max_heap.insert(6, 6)
-    >>> max_heap.extract().key
-    6
-
-    References
-    ==========
-
-    .. [1] https://en.m.wikipedia.org/wiki/Binary_heap
-    """
-    def __new__(cls, elements=None, heap_property="min"):
-        obj = DHeap.__new__(cls, elements, heap_property, 2)
-        return obj
-
-
-class TernaryHeap(DHeap):
-    """
-    Represents Ternary Heap.
-
-    Parameters
-    ==========
-
-    elements : list, tuple
-        Optional, by default 'None'.
-        List/tuple of initial elements in Heap.
-
-    heap_property : str
-        If the key stored in each node is
-        either greater than or equal to
-        the keys in the node's children
-        then pass 'max'.
-        If the key stored in each node is
-        either less than or equal to
-        the keys in the node's children
-        then pass 'min'.
-        By default, the heap property is
-        set to 'min'.
-
-    Examples
-    ========
-
-    >>> from pydatastructs.trees.heaps import TernaryHeap
-    >>> min_heap = TernaryHeap(heap_property="min")
-    >>> min_heap.insert(1, 1)
-    >>> min_heap.insert(5, 5)
-    >>> min_heap.insert(7, 7)
-    >>> min_heap.insert(3, 3)
-    >>> min_heap.extract().key
-    1
-    >>> min_heap.insert(4, 4)
-    >>> min_heap.extract().key
-    3
-
-    >>> max_heap = TernaryHeap(heap_property='max')
-    >>> max_heap.insert(1, 1)
-    >>> max_heap.insert(5, 5)
-    >>> max_heap.insert(7, 7)
-    >>> min_heap.insert(3, 3)
-    >>> max_heap.extract().key
-    7
-    >>> max_heap.insert(6, 6)
-    >>> max_heap.extract().key
-    6
-
-    References
-    ==========
-
-    .. [1] https://en.wikipedia.org/wiki/D-ary_heap
-    .. [2] https://ece.uwaterloo.ca/~dwharder/aads/Algorithms/d-ary_heaps/Ternary_heaps/
-    """
-    def __new__(cls, elements=None, heap_property="min"):
-        obj = DHeap.__new__(cls, elements, heap_property, 3)
-        return obj
-
-
-class BinomialHeap(Heap):
-    """
-    Represents binomial heap.
-
-    Parameters
-    ==========
-
-    root_list: list/tuple
-        By default, []
-        The list of BinomialTree object references
-        in sorted order.
-
-    Examples
-    ========
-
-    >>> from pydatastructs import BinomialHeap
-    >>> b = BinomialHeap()
-    >>> b.insert(1, 1)
-    >>> b.insert(2, 2)
-    >>> b.find_minimum().key
-    1
-    >>> b.find_minimum().children[0].key
-    2
-
-    References
-    ==========
-
-    .. [1] https://en.wikipedia.org/wiki/Binomial_heap
-    """
-    __slots__ = ['root_list']
-
-    def __new__(cls, root_list=[]):
-        if not all((_check_type(root, BinomialTree))
-                for root in root_list):
-                    raise TypeError("The root_list should contain "
-                                    "references to objects of BinomialTree.")
-        obj = Heap.__new__(cls)
-        obj.root_list = DynamicOneDimensionalArray(BinomialTree, root_list)
-        return obj
-
-    def merge_tree(self, tree1, tree2):
-        """
-        Merges two BinomialTree objects.
-
-        Parameters
-        ==========
-
-        tree1: BinomialTree
-
-        tree2: BinomialTree
-        """
-        if (not _check_type(tree1, BinomialTree)) or \
-            (not _check_type(tree2, BinomialTree)):
-            raise TypeError("Both the trees should be of type "
-                            "BinomalTree.")
-        ret_value = None
-        if tree1.root.key <= tree2.root.key:
-            tree1.add_sub_tree(tree2)
-            ret_value = tree1
-        else:
-            tree2.add_sub_tree(tree1)
-            ret_value = tree2
-        return ret_value
-
-    def _merge_heap_last_new_tree(self, new_root_list, new_tree):
-        """
-        Merges last tree node in root list with the incoming tree.
-        """
-        pos = new_root_list._last_pos_filled
-        if (new_root_list.size != 0) and new_root_list[pos].order == new_tree.order:
-            new_root_list[pos] = self.merge_tree(new_root_list[pos], new_tree)
-        else:
-            new_root_list.append(new_tree)
-
-    def merge(self, other_heap):
-        """
-        Merges current binomial heap with the given binomial heap.
-
-        Parameters
-        ==========
-
-        other_heap: BinomialHeap
-        """
-        if not _check_type(other_heap, BinomialHeap):
-            raise TypeError("Other heap is not of type BinomialHeap.")
-        new_root_list = DynamicOneDimensionalArray(BinomialTree, 0)
-        i, j = 0, 0
-        while ((i <= self.root_list._last_pos_filled) and
-               (j <= other_heap.root_list._last_pos_filled)):
-            new_tree = None
-            while self.root_list[i] is None:
-                i += 1
-            while other_heap.root_list[j] is None:
-                j += 1
-            if self.root_list[i].order == other_heap.root_list[j].order:
-                new_tree = self.merge_tree(self.root_list[i],
-                                           other_heap.root_list[j])
-                i += 1
-                j += 1
-            else:
-                if self.root_list[i].order < other_heap.root_list[j].order:
-                    new_tree = self.root_list[i]
-                    i += 1
-                else:
-                    new_tree = other_heap.root_list[j]
-                    j += 1
-            self._merge_heap_last_new_tree(new_root_list, new_tree)
-
-        while i <= self.root_list._last_pos_filled:
-            new_tree = self.root_list[i]
-            self._merge_heap_last_new_tree(new_root_list, new_tree)
-            i += 1
-        while j <= other_heap.root_list._last_pos_filled:
-            new_tree = other_heap.root_list[j]
-            self._merge_heap_last_new_tree(new_root_list, new_tree)
-            j += 1
-        self.root_list = new_root_list
-
-    def insert(self, key, data):
-        """
-        Inserts new node with the given key and data.
-
-        key
-            The key of the node which can be operated
-            upon by relational operators.
-
-        data
-            The data to be stored in the new node.
-        """
-        new_node = BinomialTreeNode(key, data)
-        new_tree = BinomialTree(root=new_node, order=0)
-        new_heap = BinomialHeap(root_list=[new_tree])
-        self.merge(new_heap)
-
-    def find_minimum(self, **kwargs):
-        """
-        Finds the node with the minimum key.
-
-        Returns
-        =======
-
-        min_node: BinomialTreeNode
-        """
-        if self.is_empty:
-            raise ValueError("Binomial heap is empty.")
-        min_node = None
-        idx, min_idx = 0, None
-        for tree in self.root_list:
-            if ((min_node is None) or
-                (tree is not None and tree.root is not None and
-                 min_node.key > tree.root.key)):
-                min_node = tree.root
-                min_idx = idx
-            idx += 1
-        if kwargs.get('get_index', None) is not None:
-            return min_node, min_idx
-        return min_node
-
-    def delete_minimum(self):
-        """
-        Deletes the node with minimum key.
-        """
-        min_node, min_idx = self.find_minimum(get_index=True)
-        child_root_list = []
-        for k, child in enumerate(min_node.children):
-            if child is not None:
-                child_root_list.append(BinomialTree(root=child, order=k))
-        self.root_list.delete(min_idx)
-        child_heap = BinomialHeap(root_list=child_root_list)
-        self.merge(child_heap)
-
-    @property
-    def is_empty(self):
-        return self.root_list._last_pos_filled == -1
-
-    def decrease_key(self, node, new_key):
-        """
-        Decreases the key of the given node.
-
-        Parameters
-        ==========
-
-        node: BinomialTreeNode
-            The node whose key is to be reduced.
-        new_key
-            The new key of the given node,
-            should be less than the current key.
-        """
-        if node.key <= new_key:
-            raise ValueError("The new key "
-            "should be less than current node's key.")
-        node.key = new_key
-        while ((not node.is_root) and
-               (node.parent.key > node.key)):
-            node.parent.key, node.key = \
-                node.key, node.parent.key
-            node.parent.data, node.data = \
-                node.data, node.parent.data
-            node = node.parent
-
-    def delete(self, node):
-        """
-        Deletes the given node.
-
-        Parameters
-        ==========
-
-        node: BinomialTreeNode
-            The node which is to be deleted.
-        """
-        self.decrease_key(node, self.find_minimum().key - 1)
-        self.delete_minimum()
->>>>>>> 688ee21830365f6acb59008bbb46ea8cf20e7055
diff --git a/pydatastructs/trees/tests/test_heaps.py b/pydatastructs/trees/tests/test_heaps.py
index ffda993e8..552ef995a 100644
--- a/pydatastructs/trees/tests/test_heaps.py
+++ b/pydatastructs/trees/tests/test_heaps.py
@@ -1,4 +1,3 @@
-<<<<<<< HEAD
 from pydatastructs.trees.heaps import BinaryHeap, TernaryHeap, BinomialHeap, DHeap
 from pydatastructs.linear_data_structures.arrays import DynamicOneDimensionalArray
 from pydatastructs.miscellaneous_data_structures.binomial_trees import BinomialTree
@@ -7,7 +6,9 @@
 from collections import deque as Queue
 
 def test_BinaryHeap():
+
     max_heap = BinaryHeap(heap_property="max")
+
     assert max_heap.extract() is None
 
     max_heap.insert(100, 100)
@@ -53,6 +54,7 @@ def test_BinaryHeap():
             ]
     assert raises(TypeError, lambda:
                 BinaryHeap(elements = non_TreeNode_elements, heap_property='min'))
+
 def test_TernaryHeap():
     max_heap = TernaryHeap(heap_property="max")
     assert max_heap.extract() is None
@@ -92,7 +94,6 @@ def test_TernaryHeap():
     sorted_elements = [min_heap.extract().key for _ in range(8)]
     assert expected_sorted_elements == sorted_elements
 
-
 def test_DHeap():
     assert raises(ValueError, lambda: DHeap(heap_property="none", d=4))
     max_heap = DHeap(heap_property="max", d=5)
@@ -222,233 +223,3 @@ def bfs(heap):
     heap.insert(2, 2)
     heap.insert(7, 7)
     assert bfs(heap) == [[1, 3, 6, 2, 9, 7, 11, 14]]
-=======
-from pydatastructs.trees.heaps import BinaryHeap, TernaryHeap, BinomialHeap, DHeap
-from pydatastructs.linear_data_structures.arrays import DynamicOneDimensionalArray
-from pydatastructs.miscellaneous_data_structures.binomial_trees import BinomialTree
-from pydatastructs.utils.misc_util import TreeNode, BinomialTreeNode
-from pydatastructs.utils.raises_util import raises
-from collections import deque as Queue
-
-def test_BinaryHeap():
-
-    max_heap = BinaryHeap(heap_property="max")
-
-    assert max_heap.extract() is None
-
-    max_heap.insert(100, 100)
-    max_heap.insert(19, 19)
-    max_heap.insert(36, 36)
-    max_heap.insert(17, 17)
-    max_heap.insert(3, 3)
-    max_heap.insert(25, 25)
-    max_heap.insert(1, 1)
-    max_heap.insert(2, 2)
-    max_heap.insert(7, 7)
-    assert str(max_heap) == \
-        ("[(100, 100, [1, 2]), (19, 19, [3, 4]), "
-        "(36, 36, [5, 6]), (17, 17, [7, 8]), "
-        "(3, 3, []), (25, 25, []), (1, 1, []), "
-        "(2, 2, []), (7, 7, [])]")
-
-    assert max_heap.extract().key == 100
-
-    expected_sorted_elements = [36, 25, 19, 17, 7, 3, 2, 1]
-    l = max_heap.heap[0].left
-    l = max_heap.heap[0].right
-    sorted_elements = []
-    for _ in range(8):
-        sorted_elements.append(max_heap.extract().key)
-    assert expected_sorted_elements == sorted_elements
-
-    elements = [
-                TreeNode(7, 7), TreeNode(25, 25), TreeNode(100, 100),
-                TreeNode(1, 1), TreeNode(2, 2), TreeNode(3, 3),
-                TreeNode(17, 17), TreeNode(19, 19), TreeNode(36, 36)
-            ]
-    min_heap = BinaryHeap(elements=DynamicOneDimensionalArray(TreeNode, 9, elements), heap_property="min")
-    assert min_heap.extract().key == 1
-
-    expected_sorted_elements = [2, 3, 7, 17, 19, 25, 36, 100]
-    sorted_elements = [min_heap.extract().key for _ in range(8)]
-    assert expected_sorted_elements == sorted_elements
-
-    #To test ValueError on non TreeNode list
-    non_TreeNode_elements = [
-                (7, 7), TreeNode(25, 25), TreeNode(100, 100),
-                TreeNode(1, 1), (2, 2), TreeNode(3, 3),
-                TreeNode(17, 17), TreeNode(19, 19), TreeNode(36, 36)
-            ]
-    assert raises(TypeError, lambda:
-                BinaryHeap(elements = non_TreeNode_elements, heap_property='min'))
-    
-def test_TernaryHeap():
-    max_heap = TernaryHeap(heap_property="max")
-    assert max_heap.extract() is None
-    max_heap.insert(100, 100)
-    max_heap.insert(19, 19)
-    max_heap.insert(36, 36)
-    max_heap.insert(17, 17)
-    max_heap.insert(3, 3)
-    max_heap.insert(25, 25)
-    max_heap.insert(1, 1)
-    max_heap.insert(2, 2)
-    max_heap.insert(7, 7)
-    assert str(max_heap) == \
-           ('[(100, 100, [1, 2, 3]), (25, 25, [4, 5, 6]), '
-            '(36, 36, [7, 8]), (17, 17, []), '
-            '(3, 3, []), (19, 19, []), (1, 1, []), '
-            '(2, 2, []), (7, 7, [])]')
-
-    assert max_heap.extract().key == 100
-
-    expected_sorted_elements = [36, 25, 19, 17, 7, 3, 2, 1]
-    sorted_elements = []
-    for _ in range(8):
-        sorted_elements.append(max_heap.extract().key)
-    assert expected_sorted_elements == sorted_elements
-
-    elements = [
-        TreeNode(7, 7), TreeNode(25, 25), TreeNode(100, 100),
-        TreeNode(1, 1), TreeNode(2, 2), TreeNode(3, 3),
-        TreeNode(17, 17), TreeNode(19, 19), TreeNode(36, 36)
-    ]
-    min_heap = TernaryHeap(elements=DynamicOneDimensionalArray(TreeNode, 9, elements), heap_property="min")
-    expected_extracted_element = min_heap.heap[0].key
-    assert min_heap.extract().key == expected_extracted_element
-
-    expected_sorted_elements = [2, 3, 7, 17, 19, 25, 36, 100]
-    sorted_elements = [min_heap.extract().key for _ in range(8)]
-    assert expected_sorted_elements == sorted_elements
-
-
-def test_DHeap():
-    assert raises(ValueError, lambda: DHeap(heap_property="none", d=4))
-    max_heap = DHeap(heap_property="max", d=5)
-    assert max_heap.extract() is None
-    max_heap.insert(100, 100)
-    max_heap.insert(19, 19)
-    max_heap.insert(36, 36)
-    max_heap.insert(17, 17)
-    max_heap.insert(3, 3)
-    max_heap.insert(25, 25)
-    max_heap.insert(1, 1)
-    max_heap = DHeap(max_heap.heap, heap_property="max", d=4)
-    max_heap.insert(2, 2)
-    max_heap.insert(7, 7)
-    assert str(max_heap) == \
-           ('[(100, 100, [1, 2, 3, 4]), (25, 25, [5, 6, 7, 8]), '
-           '(36, 36, []), (17, 17, []), (3, 3, []), (19, 19, []), '
-           '(1, 1, []), (2, 2, []), (7, 7, [])]')
-
-    assert max_heap.extract().key == 100
-
-    expected_sorted_elements = [36, 25, 19, 17, 7, 3, 2, 1]
-    sorted_elements = []
-    for _ in range(8):
-        sorted_elements.append(max_heap.extract().key)
-    assert expected_sorted_elements == sorted_elements
-
-    elements = [
-        TreeNode(7, 7), TreeNode(25, 25), TreeNode(100, 100),
-        TreeNode(1, 1), TreeNode(2, 2), TreeNode(3, 3),
-        TreeNode(17, 17), TreeNode(19, 19), TreeNode(36, 36)
-    ]
-    min_heap = DHeap(elements=DynamicOneDimensionalArray(TreeNode, 9, elements), heap_property="min")
-    assert min_heap.extract().key == 1
-
-    expected_sorted_elements = [2, 3, 7, 17, 19, 25, 36, 100]
-    sorted_elements = [min_heap.extract().key for _ in range(8)]
-    assert expected_sorted_elements == sorted_elements
-
-def test_BinomialHeap():
-
-    # Corner cases
-    assert raises(TypeError, lambda:
-                  BinomialHeap(
-                    root_list=[BinomialTreeNode(1, 1), None])
-                  ) is True
-    tree1 = BinomialTree(BinomialTreeNode(1, 1), 0)
-    tree2 = BinomialTree(BinomialTreeNode(2, 2), 0)
-    bh = BinomialHeap(root_list=[tree1, tree2])
-    assert raises(TypeError, lambda:
-                  bh.merge_tree(BinomialTreeNode(2, 2), None))
-    assert raises(TypeError, lambda:
-                  bh.merge(None))
-
-    # Testing BinomialHeap.merge
-    nodes = [BinomialTreeNode(1, 1), # 0
-            BinomialTreeNode(3, 3), # 1
-            BinomialTreeNode(9, 9), # 2
-            BinomialTreeNode(11, 11), # 3
-            BinomialTreeNode(6, 6), # 4
-            BinomialTreeNode(14, 14), # 5
-            BinomialTreeNode(2, 2), # 6
-            BinomialTreeNode(7, 7), # 7
-            BinomialTreeNode(4, 4), # 8
-            BinomialTreeNode(8, 8), # 9
-            BinomialTreeNode(12, 12), # 10
-            BinomialTreeNode(10, 10), # 11
-            BinomialTreeNode(5, 5), # 12
-            BinomialTreeNode(21, 21)] # 13
-
-    nodes[2].add_children(nodes[3])
-    nodes[4].add_children(nodes[5])
-    nodes[6].add_children(nodes[9], nodes[8], nodes[7])
-    nodes[7].add_children(nodes[11], nodes[10])
-    nodes[8].add_children(nodes[12])
-    nodes[10].add_children(nodes[13])
-
-    tree11 = BinomialTree(nodes[0], 0)
-    tree12 = BinomialTree(nodes[2], 1)
-    tree13 = BinomialTree(nodes[6], 3)
-    tree21 = BinomialTree(nodes[1], 0)
-
-    heap1 = BinomialHeap(root_list=[tree11, tree12, tree13])
-    heap2 = BinomialHeap(root_list=[tree21])
-
-    def bfs(heap):
-        bfs_trav = []
-        for i in range(heap.root_list._last_pos_filled + 1):
-            layer = []
-            bfs_q = Queue()
-            bfs_q.append(heap.root_list[i].root)
-            while len(bfs_q) != 0:
-                curr_node = bfs_q.popleft()
-                if curr_node is not None:
-                    layer.append(curr_node.key)
-                    for _i in range(curr_node.children._last_pos_filled + 1):
-                        bfs_q.append(curr_node.children[_i])
-            if layer != []:
-                bfs_trav.append(layer)
-        return bfs_trav
-
-    heap1.merge(heap2)
-    expected_bfs_trav = [[1, 3, 9, 11], [2, 8, 4, 7, 5, 10, 12, 21]]
-    assert bfs(heap1) == expected_bfs_trav
-
-    # Testing Binomial.find_minimum
-    assert heap1.find_minimum().key == 1
-
-    # Testing Binomial.delete_minimum
-    heap1.delete_minimum()
-    assert bfs(heap1) == [[3], [9, 11], [2, 8, 4, 7, 5, 10, 12, 21]]
-    assert raises(ValueError, lambda: heap1.decrease_key(nodes[3], 15))
-    heap1.decrease_key(nodes[3], 0)
-    assert bfs(heap1) == [[3], [0, 9], [2, 8, 4, 7, 5, 10, 12, 21]]
-    heap1.delete(nodes[12])
-    assert bfs(heap1) == [[3, 8], [0, 9, 2, 7, 4, 10, 12, 21]]
-
-    # Testing BinomialHeap.insert
-    heap = BinomialHeap()
-    assert raises(ValueError, lambda: heap.find_minimum())
-    heap.insert(1, 1)
-    heap.insert(3, 3)
-    heap.insert(6, 6)
-    heap.insert(9, 9)
-    heap.insert(14, 14)
-    heap.insert(11, 11)
-    heap.insert(2, 2)
-    heap.insert(7, 7)
-    assert bfs(heap) == [[1, 3, 6, 2, 9, 7, 11, 14]]
->>>>>>> 688ee21830365f6acb59008bbb46ea8cf20e7055

From 8801c9ec6758e71ede73b311753f46a325efb182 Mon Sep 17 00:00:00 2001
From: Harsheet Kakar <42893005+HarsheetKakar@users.noreply.github.com>
Date: Wed, 11 Mar 2020 21:39:11 +0530
Subject: [PATCH 05/12] Update .gitignore

Added new line at the end

Co-Authored-By: Gagandeep Singh <gdp.1807@gmail.com>
---
 .gitignore | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index 0e9c04114..f156e5656 100644
--- a/.gitignore
+++ b/.gitignore
@@ -64,4 +64,4 @@ __pycache__/
 .idea/
 build/
 dist/
-venv/
\ No newline at end of file
+venv/

From 1718d7a8439b51b45ffed91ffe27471691e46223 Mon Sep 17 00:00:00 2001
From: Harsheet Kakar <42893005+HarsheetKakar@users.noreply.github.com>
Date: Wed, 11 Mar 2020 21:39:58 +0530
Subject: [PATCH 06/12] Update pydatastructs/trees/heaps.py

Co-Authored-By: Gagandeep Singh <gdp.1807@gmail.com>
---
 pydatastructs/trees/heaps.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/pydatastructs/trees/heaps.py b/pydatastructs/trees/heaps.py
index 6fdb86c27..ab6f4f218 100644
--- a/pydatastructs/trees/heaps.py
+++ b/pydatastructs/trees/heaps.py
@@ -26,7 +26,8 @@ class DHeap(Heap):
 
     elements : list, tuple
         Optional, by default 'None'.
-        List/tuple of initial TreeNodes in Heap.
+        List/tuple of initial TreeNode in Heap.
+
 
     heap_property : str
         If the key stored in each node is

From 7ed4cb1d8c2ab674d2da3f4c4375f5d00252471a Mon Sep 17 00:00:00 2001
From: Harsheet Kakar <42893005+HarsheetKakar@users.noreply.github.com>
Date: Wed, 11 Mar 2020 21:42:16 +0530
Subject: [PATCH 07/12] Update pydatastructs/trees/tests/test_heaps.py

Co-Authored-By: Gagandeep Singh <gdp.1807@gmail.com>
---
 pydatastructs/trees/tests/test_heaps.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/pydatastructs/trees/tests/test_heaps.py b/pydatastructs/trees/tests/test_heaps.py
index 552ef995a..99a8fbf71 100644
--- a/pydatastructs/trees/tests/test_heaps.py
+++ b/pydatastructs/trees/tests/test_heaps.py
@@ -52,9 +52,8 @@ def test_BinaryHeap():
                 TreeNode(1, 1), (2, 2), TreeNode(3, 3),
                 TreeNode(17, 17), TreeNode(19, 19), TreeNode(36, 36)
             ]
-    assert raises(TypeError, lambda:
+    assert raises(ValueError, lambda:
                 BinaryHeap(elements = non_TreeNode_elements, heap_property='min'))
-
 def test_TernaryHeap():
     max_heap = TernaryHeap(heap_property="max")
     assert max_heap.extract() is None

From cd18a9aa61e625bebd53c0ec40d39d37764e6076 Mon Sep 17 00:00:00 2001
From: Harsheet Kakar <42893005+HarsheetKakar@users.noreply.github.com>
Date: Wed, 11 Mar 2020 21:44:16 +0530
Subject: [PATCH 08/12] Update pydatastructs/trees/tests/test_heaps.py

Co-Authored-By: Gagandeep Singh <gdp.1807@gmail.com>
---
 pydatastructs/trees/tests/test_heaps.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/pydatastructs/trees/tests/test_heaps.py b/pydatastructs/trees/tests/test_heaps.py
index 99a8fbf71..1be126349 100644
--- a/pydatastructs/trees/tests/test_heaps.py
+++ b/pydatastructs/trees/tests/test_heaps.py
@@ -46,7 +46,6 @@ def test_BinaryHeap():
     sorted_elements = [min_heap.extract().key for _ in range(8)]
     assert expected_sorted_elements == sorted_elements
 
-    #To test ValueError on non TreeNode list
     non_TreeNode_elements = [
                 (7, 7), TreeNode(25, 25), TreeNode(100, 100),
                 TreeNode(1, 1), (2, 2), TreeNode(3, 3),

From d9cbefdbf1086ac1fae769ffcd0238bc5e9b619f Mon Sep 17 00:00:00 2001
From: Harsheet Kakar <42893005+HarsheetKakar@users.noreply.github.com>
Date: Wed, 11 Mar 2020 21:44:28 +0530
Subject: [PATCH 09/12] Update pydatastructs/trees/heaps.py

Co-Authored-By: Gagandeep Singh <gdp.1807@gmail.com>
---
 pydatastructs/trees/heaps.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/pydatastructs/trees/heaps.py b/pydatastructs/trees/heaps.py
index ab6f4f218..85b5b0fc9 100644
--- a/pydatastructs/trees/heaps.py
+++ b/pydatastructs/trees/heaps.py
@@ -85,7 +85,6 @@ def __new__(cls, elements=None, heap_property="min", d=4):
         if elements is None:
             elements = DynamicOneDimensionalArray(TreeNode, 0)
         else:
-            #to check if all elements provided are TreeNodes
             check_node = map(lambda x: type(x)==type(TreeNode(1,1)),elements)
             is_node = all(check_node)
             if(not is_node):

From 41b20f0a9a18be218b442dbd70ba3f3d8f45845f Mon Sep 17 00:00:00 2001
From: Harsheet Kakar <42893005+HarsheetKakar@users.noreply.github.com>
Date: Wed, 11 Mar 2020 21:52:27 +0530
Subject: [PATCH 10/12] Update test_heaps.py

---
 pydatastructs/trees/tests/test_heaps.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/pydatastructs/trees/tests/test_heaps.py b/pydatastructs/trees/tests/test_heaps.py
index 1be126349..c7818c7d0 100644
--- a/pydatastructs/trees/tests/test_heaps.py
+++ b/pydatastructs/trees/tests/test_heaps.py
@@ -29,6 +29,8 @@ def test_BinaryHeap():
     assert max_heap.extract().key == 100
 
     expected_sorted_elements = [36, 25, 19, 17, 7, 3, 2, 1]
+    l = max_heap.heap[0].left	
+    l = max_heap.heap[0].right	
     sorted_elements = []
     for _ in range(8):
         sorted_elements.append(max_heap.extract().key)

From 7d87af01b1ff9deabc262fca4606afa81caffbc2 Mon Sep 17 00:00:00 2001
From: Harsheet Kakar <42893005+HarsheetKakar@users.noreply.github.com>
Date: Wed, 11 Mar 2020 21:52:52 +0530
Subject: [PATCH 11/12] Update pydatastructs/trees/heaps.py

Co-Authored-By: Gagandeep Singh <gdp.1807@gmail.com>
---
 pydatastructs/trees/heaps.py | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/pydatastructs/trees/heaps.py b/pydatastructs/trees/heaps.py
index 85b5b0fc9..3aeda0f74 100644
--- a/pydatastructs/trees/heaps.py
+++ b/pydatastructs/trees/heaps.py
@@ -85,10 +85,8 @@ def __new__(cls, elements=None, heap_property="min", d=4):
         if elements is None:
             elements = DynamicOneDimensionalArray(TreeNode, 0)
         else:
-            check_node = map(lambda x: type(x)==type(TreeNode(1,1)),elements)
-            is_node = all(check_node)
-            if(not is_node):
-                raise TypeError("Elements have to be list/tuple of TreeNode")
+            if not all(map(lambda x: _check_type(x, TreeNode), elements)):
+                raise ValueError("Expect a list/tuple of TreeNode got %s"%(elements))
         obj.heap = elements
         obj._last_pos_filled = obj.heap._last_pos_filled
         obj._build()

From d7c25a77fa9536d6ed4efb222338206b52ece2d3 Mon Sep 17 00:00:00 2001
From: Harsheet Kakar <42893005+HarsheetKakar@users.noreply.github.com>
Date: Wed, 11 Mar 2020 22:04:37 +0530
Subject: [PATCH 12/12] trailing spaces removed

---
 pydatastructs/trees/tests/test_heaps.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pydatastructs/trees/tests/test_heaps.py b/pydatastructs/trees/tests/test_heaps.py
index c7818c7d0..3d1ae04d1 100644
--- a/pydatastructs/trees/tests/test_heaps.py
+++ b/pydatastructs/trees/tests/test_heaps.py
@@ -29,8 +29,8 @@ def test_BinaryHeap():
     assert max_heap.extract().key == 100
 
     expected_sorted_elements = [36, 25, 19, 17, 7, 3, 2, 1]
-    l = max_heap.heap[0].left	
-    l = max_heap.heap[0].right	
+    l = max_heap.heap[0].left
+    l = max_heap.heap[0].right
     sorted_elements = []
     for _ in range(8):
         sorted_elements.append(max_heap.extract().key)