algorithm-in-python/dataStructure/leftHeap.py

''' mbinary
#########################################################################
# File : leftHeap.py
# Author: mbinary
# Mail: zhuheqin1@gmail.com
# Blog: https://mbinary.xyz
# Github: https://github.com/mbinary
# Created Time: 2018-05-19  23:06
# Description:
#########################################################################
'''

from functools import total_ordering


@total_ordering
class node:
    def __init__(self, val, freq=1, s=1, left=None, right=None):
        self.val = val
        self.freq = freq
        self.s = s
        if left is None or right is None:
            self.left = left if left is not None else right
            self.right = None
        else:
            if left.s < right.s:
                left, right = right, left
            self.left = left
            self.right = right
            self.s += self.right.s

    def __eq__(self, nd):
        return self.val == nd.val

    def __lt__(self, nd):
        return self.val < nd.val

    def __repr__(self):
        return 'node(val=%d,freq=%d,s=%d)' % (self.val, self.freq, self.s)


class leftHeap:
    def __init__(self, root=None):
        self.root = root

    def __bool__(self):
        return self.root is not None

    @staticmethod
    def _merge(root, t):  # -> int
        if root is None:
            return t
        if t is None:
            return root
        if root < t:
            root, t = t, root
        root.right = leftHeap._merge(root.right, t)
        if root.left is None or root.right is None:
            root.s = 1
            if root.left is None:
                root.left, root.right = root.right, None
        else:
            if root.left.s < root.right.s:
                root.left, root.right = root.right, root.left
            root.s = root.right.s+1
        return root

    def insert(self, nd):
        if not isinstance(nd, node):
            nd = node(nd)
        if self.root is None:
            self.root = nd
            return
        if self.root == nd:
            self.root.freq += 1
            return
        prt = self. _findPrt(self.root, nd, None)
        if prt is None:
            self.root = leftHeap._merge(self.root, nd)
        else:
            if prt.left == nd:
                prt.left.freq += 1
            else:
                prt.right.freq += 1

    def remove(self, nd):
        if not isinstance(nd, node):
            nd = node(nd)
        if self.root == nd:
            self.root = leftHeap._merge(self.root.left, self.root.right)
        else:
            prt = self._findPrt(self.root, nd, None)
            if prt is not None:
                if prt.left == nd:
                    prt.left = leftHeap._merge(prt.left.left, prt.left.right)
                else:
                    prt.right = leftHeap._merge(
                        prt.right.left, prt.right.right)

    def find(self, nd):
        if not isinstance(nd, node):
            nd = node(nd)
        prt = self._findPrt(self.root, nd, self.root)
        if prt is None or prt == nd:
            return prt
        elif prt.left == nd:
            return prt.left
        else:
            return prt.right

    def _findPrt(self, root, nd, parent):
        if not isinstance(nd, node):
            nd = node(nd)
        if root is None or root < nd:
            return None
        if root == nd:
            return parent
        l = self._findPrt(root.left, nd, root)
        return l if l is not None else self._findPrt(root.right, nd, root)

    def getTop(self):
        return self.root

    def pop(self):
        nd = self.root
        self.remove(self.root.val)
        return nd

    def levelTraverse(self):
        li = [(self.root, 0)]
        cur = 0
        while li:
            nd, lv = li.pop(0)
            if cur < lv:
                cur = lv
                print()
                print(nd, end=' ')
            else:
                print(nd, end=' ')
            if nd.left is not None:
                li.append((nd.left, lv+1))
            if nd.right is not None:
                li.append((nd.right, lv+1))


if __name__ == '__main__':
    lh = leftHeap()
    data = [(i-3)**2 for i in range(20)]
    for i in data:
        lh . insert(i)
    lh.levelTraverse()
    print()
    for i in data:
        print(lh.getTop())
        if lh.find(i) is not None:
            lh.remove(i)
'''
data = [(i-10)**2 for i in range(20)]
node(100,freq=1,s=3) 
node(81,freq=2,s=3) node(64,freq=2,s=2) 
node(16,freq=2,s=2) node(25,freq=2,s=2) node(49,freq=2,s=1) node(36,freq=2,s=1) 
node(9,freq=2,s=1) node(4,freq=2,s=1) node(1,freq=2,s=1) node(0,freq=1,s=1) 
node(100,freq=1,s=3)
node(81,freq=2,s=3)
node(64,freq=2,s=2)
node(49,freq=2,s=1)
node(36,freq=2,s=3)
node(25,freq=2,s=2)
node(16,freq=2,s=2)
node(9,freq=2,s=1)
node(4,freq=2,s=2)
node(1,freq=2,s=1)
node(0,freq=1,s=1)
None
None
None
None
None
None
None
None
None
'''

'''
data = [(i-3)**2 for i in range(20)]
node(256,freq=1,s=1) 
node(225,freq=1,s=1) 
node(196,freq=1,s=1) 
node(169,freq=1,s=1) 
node(144,freq=1,s=1) 
node(121,freq=1,s=1) 
node(100,freq=1,s=1) 
node(81,freq=1,s=1) 
node(64,freq=1,s=1) 
node(49,freq=1,s=1) 
node(36,freq=1,s=1) 
node(25,freq=1,s=1) 
node(16,freq=1,s=1) 
node(9,freq=2,s=2) 
node(4,freq=2,s=1) node(1,freq=2,s=1) 
node(0,freq=1,s=1) 
node(256,freq=1,s=1)
node(256,freq=1,s=1)
node(256,freq=1,s=1)
node(256,freq=1,s=1)
node(256,freq=1,s=1)
node(256,freq=1,s=1)
node(256,freq=1,s=1)
node(256,freq=1,s=1)
node(256,freq=1,s=1)
node(256,freq=1,s=1)
node(256,freq=1,s=1)
node(256,freq=1,s=1)
node(256,freq=1,s=1)
node(256,freq=1,s=1)
node(256,freq=1,s=1)
node(256,freq=1,s=1)
node(256,freq=1,s=1)
node(256,freq=1,s=1)
node(256,freq=1,s=1)
node(256,freq=1,s=1)
'''