mirror of
https://github.com/heqin-zhu/algorithm.git
synced 2024-03-22 13:30:46 +08:00
Update codebeat badget and remove resident file
This commit is contained in:
mbinary
parent
36ebaecf18
commit
985b29ce65
|
|
@ -6,7 +6,7 @@
|
|||
[]()
|
||||
[](LICENSE)
|
||||
[]()
|
||||
[](https://codebeat.co/projects/github-com-mbinary-algorithm-master)
|
||||
[](https://codebeat.co/projects/github-com-mbinary-algorithm-master)
|
||||
|
||||
>Notes and codes for learning algorithm and data structures :smiley:
|
||||
|
||||
|
|
|
|||
|
|
@ -1,83 +0,0 @@
|
|||
''' mbinary
|
||||
#########################################################################
|
||||
# File : binaryHeap1.py
|
||||
# Author: mbinary
|
||||
# Mail: zhuheqin1@gmail.com
|
||||
# Blog: https://mbinary.xyz
|
||||
# Github: https://github.com/mbinary
|
||||
# Created Time: 2019-04-16 09:41
|
||||
# Description:
|
||||
#########################################################################
|
||||
'''
|
||||
from functools import partial
|
||||
class heap:
|
||||
def __init__(self,lst,reverse = False):
|
||||
self.data= heapify(lst,reverse)
|
||||
self.cmp = partial(lambda i,j,r:cmp(self.data[i],self.data[j],r),r= reverse)
|
||||
def getTop(self):
|
||||
return self.data[0]
|
||||
def __getitem__(self,idx):
|
||||
return self.data[idx]
|
||||
def __bool__(self):
|
||||
return self.data != []
|
||||
def popTop(self):
|
||||
ret = self.data[0]
|
||||
n = len(self.data)
|
||||
cur = 1
|
||||
while cur * 2<=n:
|
||||
chd = cur-1
|
||||
r_idx = cur*2
|
||||
l_idx = r_idx-1
|
||||
if r_idx==n:
|
||||
self.data[chd] = self.data[l_idx]
|
||||
break
|
||||
j = l_idx if self.cmp(l_idx,r_idx)<0 else r_idx
|
||||
self.data[chd] = self.data[j]
|
||||
cur = j+1
|
||||
self.data[cur-1] = self.data[-1]
|
||||
self.data.pop()
|
||||
return ret
|
||||
|
||||
def addNode(self,val):
|
||||
self.data.append(val)
|
||||
self.data = one_heapify(len(self.data)-1)
|
||||
|
||||
|
||||
def cmp(n1,n2,reverse=False):
|
||||
fac = -1 if reverse else 1
|
||||
if n1 < n2: return -fac
|
||||
elif n1 > n2: return fac
|
||||
return 0
|
||||
|
||||
def heapify(lst,reverse = False):
|
||||
for i in range(len(lst)):
|
||||
lst = one_heapify(lst,i,reverse)
|
||||
return lst
|
||||
def one_heapify(lst,cur,reverse = False):
|
||||
cur +=1
|
||||
while cur>1:
|
||||
chd = cur-1
|
||||
prt = cur//2-1
|
||||
if cmp(lst[prt],lst[chd],reverse)<0:
|
||||
break
|
||||
lst[prt],lst[chd] = lst[chd], lst[prt]
|
||||
cur = prt+1
|
||||
return lst
|
||||
def heapSort(lst,reverse = False):
|
||||
lst = lst.copy()
|
||||
hp = heap(lst,reverse)
|
||||
ret = []
|
||||
while hp:
|
||||
ret.append(hp.popTop())
|
||||
return ret
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
from random import randint
|
||||
n = randint(10,20)
|
||||
lst = [randint(0,100) for i in range(n)]
|
||||
print('random : ', lst)
|
||||
print('small-heap: ', heapify(lst))
|
||||
print('big-heap : ', heapify(lst,True))
|
||||
print('ascend : ', heapSort(lst))
|
||||
print('descend : ', heapSort(lst,True))
|
||||
|
|
@ -1,116 +0,0 @@
|
|||
''' mbinary
|
||||
#########################################################################
|
||||
# File : loserTree.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 winnerTree import winnerTree
|
||||
class loserTree:
|
||||
'''if i<=lowExt p = (i+offset)//2
|
||||
else p = (i+n-1-lowExt)//2
|
||||
s is the num of the full subtree node
|
||||
p is the index of tree
|
||||
i is the index of players
|
||||
offset is a num 2^k-1 just bigger than n
|
||||
lowExt is the double node num of the lowest layer of the tree
|
||||
'''
|
||||
def __init__(self,players,reverse=False):
|
||||
self.n=len(players)
|
||||
self.tree = [0]*self.n
|
||||
players.insert(0,0)
|
||||
self.players=players
|
||||
self.reverse=reverse
|
||||
self.getNum()
|
||||
self.tree[0] = self.initTree(1)
|
||||
self.dir=None
|
||||
def getNum(self):
|
||||
i=1
|
||||
while 2*i< self.n:i=i*2
|
||||
if 2*i ==self. n:
|
||||
self.lowExt=0
|
||||
self.s = 2*i-1
|
||||
else:
|
||||
self.lowExt = (self.n-i)*2
|
||||
self.s = i-1
|
||||
self.offset = 2*i-1
|
||||
def treeToArray(self,p):
|
||||
return 2*p-self.offset if p>self.s else 2*p+self.lowExt-self.n+1
|
||||
def arrayToTree(self,i):
|
||||
return (i+self.offset)//2 if i<=self.lowExt else (i-self.lowExt+ self.n-1)//2
|
||||
def win(self,a,b):
|
||||
return a<b if self.reverse else a>b
|
||||
def initTree(self,p):
|
||||
if p>=self.n:
|
||||
delta = p%2 #!!! good job notice delta mark the lchild or rchlid
|
||||
return self.players[self.treeToArray(p//2)+delta]
|
||||
l = self.initTree(2*p)
|
||||
r = self.initTree(2*p+1)
|
||||
if self.win(r,l):
|
||||
self.tree[p] = l
|
||||
self.dir = 'r'
|
||||
return r
|
||||
else :
|
||||
self.tree[p] = r
|
||||
self.dir = 'l'
|
||||
return l
|
||||
def getWinIdx(self,idx=1):
|
||||
while 2*idx<self.n:
|
||||
idx = 2*idx if self.tree[idx].dir == 'l' else idx*2+1
|
||||
return self.treeToArray(idx)
|
||||
def winner(self):
|
||||
i = self.getWinIdx()
|
||||
i = i+1 if self.players[i] !=self.tree[0] else i
|
||||
return self.tree[0],i
|
||||
def getOppo(self,i,x,p):
|
||||
oppo=None
|
||||
if 2*p<self.n:oppo=self.tree[2*p]
|
||||
elif i<=self.lowExt:oppo=self.players[i-1+i%2*2]
|
||||
else:
|
||||
lpl= self.players[2*p+self.lowExt-self.n+1]
|
||||
oppo = lpl if lpl!=x else self.players[2*p+self.lowExt-self.n+2]
|
||||
return oppo
|
||||
def update(self,i,x):
|
||||
''' i is 1-indexed which is the num of player
|
||||
and x is the new val of the player '''
|
||||
self.players[i]=x
|
||||
p = self.arrayToTree(i)
|
||||
oppo =self.getOppo(i,x,p)
|
||||
self.tree[p],winner = x , oppo if self.win(oppo,x) else oppo,x
|
||||
p=p//2
|
||||
while p:
|
||||
l = self.tree[p*2]
|
||||
r = None
|
||||
if 2*p+1<self.n:r=self.tree[p*2+1] #notice this !!!
|
||||
else:r = self.players[2*p+self.lowExt-self.n+1]
|
||||
self.tree[p] = l if self.win(l,r) else r
|
||||
p=p//2
|
||||
# to do update-func the change of every node's dir and loser
|
||||
|
||||
if __name__ =='__main__':
|
||||
s= [4,1,6,7,9,5234,0,2,7,4,123]
|
||||
t = winnerTree(s)
|
||||
for i in s:
|
||||
val,idx=t.winner()
|
||||
print(val,idx)
|
||||
t.update(idx,-1)
|
||||
|
||||
|
||||
'''
|
||||
[0, 4, 1, 6, 7, 9, 5234, 0, 2, 123] [0, 5234, 9, 5234, 6, 9, 5234, 123, 4]
|
||||
5234 6
|
||||
123 9
|
||||
9 5
|
||||
7 4
|
||||
6 3
|
||||
4 1
|
||||
2 8
|
||||
1 2
|
||||
0 7
|
||||
-1 1
|
||||
'''
|
||||
Loading…
Reference in New Issue
Block a user