Python 二进制堆/给类一个最大值

下面是我所做的，但它不能处理insert的最大要求

如何为类指定一个最大值，并在insert中检查它，然后删除最不重要的元素。然后找出实现中最不重要的元素

在试图解决这个问题时遇到了一些问题

import math
import random

class BinaryHeap:
def __init__(self, array, direction=1, size=100):
    if(size > len(array)):
        self.size = len(array)
    else:
        self.size = size;
    self.bBinaryHeap = array[:]
    if 0 < direction:
        self.compare = self.greater
    else:
        self.compare = self.less
    self.buildBinaryHeap()

def node(self, index):
    return (index << 1) + 1

def parent(self, index):
    return (index - 1) >> 1

def bBinaryHeapifyDown(self, index): 
    swap = self.bBinaryHeap[index]
    while self.node(index) < self.size:
        node = self.node(index)
        if node + 1 < self.size and self.compare(self.bBinaryHeap[node], self.bBinaryHeap[node + 1]) > 0:
            node += 1
        if self.compare(swap, self.bBinaryHeap[node]) > 0:
            self.bBinaryHeap[index] = self.bBinaryHeap[node];
        else:
            break
        index = node
    self.bBinaryHeap[index] = swap

def upheapify(self, index):  
    while 0 < index and self.compare(self.bBinaryHeap[index], self.bBinaryHeap[self.parent(index)]) < 0:
        parent = self.parent(index)
        swap = self.bBinaryHeap[parent]
        self.bBinaryHeap[parent] = self.bBinaryHeap[index]
        self.bBinaryHeap[index] = swap
        index = parent

def buildBinaryHeap(self):
    indices = range(0, int(self.size / 2))
    reversed(indices)
    for index in indices:
        self.bBinaryHeapifyDown(index)

def insert(self, value):
    self.shrink()
    index = self.size
    self.bBinaryHeap[index] = value
    self.size += 1
    self.upheapify(index)

def search(self, value):
    for index in range(self.size):
        if self.bBinaryHeap[index] == value:
            return index

def delete(self, value):
    index = self.search(value)
    self.size -= 1
    self.bBinaryHeap[index] = self.bBinaryHeap[self.size]
    parent = self.parent(index)
    if (index == 0) or (self.compare(self.bBinaryHeap[parent], self.bBinaryHeap[index]) < 0):
        self.bBinaryHeapifyDown(index)
    else:
        self.upheapify(index)

def shrink(self):
    capacity = len(self.bBinaryHeap)
    if capacity == self.size:
        self.bBinaryHeap.extend([0] * capacity)

def greater(self, value1, value2):
    if value1 == value2:
        return 0
    elif value1 < value2:
        return 1
    elif value1 > value2:
        return -1

def less(self, value1, value2):
    if value1 == value2:
        return 0
    elif value1 < value2:
        return -1
    elif value1 > value2:
        return 1

def getLevel(self, index):
    return int(math.floor(math.log(index + 1, 2)))

def displayBinaryHeap(self):
    printBinaryHeap = str(self.bBinaryHeap)
    height = self.getLevel(self.size)
    previous = -1
    for index in range(self.size):
        getLevel = self.getLevel(index)
        n = height - getLevel
        indent = int(math.pow(2, n + 1) - 2)
        spacing = 2 * indent
        if getLevel != previous:
            printBinaryHeap += '\n'
            printBinaryHeap += ' ' * indent
            previous = getLevel
        else:
            printBinaryHeap += ' ' * spacing
        printBinaryHeap += '%4d' % self.bBinaryHeap[index]
    print(printBinaryHeap)



if __name__ == "__main__":
size =10
array = [random.randint(0, 100) for i in range(size)]
bBinaryHeap = BinaryHeap(array, 1, 100)
print('Binary bBinaryHeap:')
bBinaryHeap.displayBinaryHeap()

导入数学
随机输入
类二进制堆：
def uuu init uuuu（self，array，direction=1，size=100）：
如果（大小>透镜（阵列））：
self.size=len（数组）
其他：
自我尺寸=尺寸；
self.bBinaryHeap=数组[：]
如果0<方向：
自我比较=自我更大
其他：
self.compare=self.less
self.buildBinaryHeap（）
def节点（自身，索引）：
返回（索引>1）
def BBINARYEAPPYDOWN（自身，索引）：
swap=self.bBinaryHeap[index]
而self.node（index）0:
节点+=1
如果self.compare（swap，self.bBinaryHeap[node]）>0：
self.bBinaryHeap[index]=self.bBinaryHeap[node]；
其他：
打破
索引=节点
self.bBinaryHeap[index]=交换
def自动校准（自我，索引）：
而0值2：
返回-1
def less（自身、值1、值2）：
如果value1==value2：
返回0
elif值1<值2：
返回-1
elif值1>值2：
返回1
def getLevel（自我，索引）：
返回int（math.floor（math.log（索引+1,2）））
def displayBinaryHeap（自身）：
printBinaryHeap=str（self.bBinaryHeap）
高度=self.getLevel（self.size）
先前=-1
对于范围内的索引（self.size）：
getLevel=self.getLevel（索引）
n=高度-getLevel
缩进=整数（数学功率（2，n+1）-2）
间距=2*缩进
如果getLevel！=上一个：
printBinaryHeap+='\n'
printBinaryHeap+=''*缩进
previous=getLevel
其他：
printBinaryHeap+=''*间距
printBinaryHeap+='%4d'%self.bBinaryHeap[索引]
打印（printBinaryHeap）
如果名称=“\uuuuu main\uuuuuuuu”：
尺寸=10
数组=[random.randint（01100）表示范围内的i（大小）]
bBinaryHeap=BinaryHeap（数组，1100）
打印（'Binary bBinaryHeap:'）
bBinaryHeap.displayBinaryHeap（）

您的代码有许多缩进错误。在python中，缩进计数

关于该代码：

if 0 < direction:
    self.compare = self.greater
else:
    self.compare = self.less

并在插入中检查它

然后删除最不重要的元素

然后找出实现中最不重要的元素是什么

---

我该如何把它写进我的代码中，我知道你在做什么。我必须重做整个事情吗？

class BinaryHeap:
    pass

BinaryHeap.max = 10
print(BinaryHeap.max)

--output:--
10

class BinaryHeap:
    max = 10

    def insert(self):
        print(self.max)


bh = BinaryHeap()
bh.insert()

--output:--
10

x = 0b1111
print(x) #15

y = x >> 1
print("{:b}".format(y))  #111
print(y)  #7

x = 0b1110
print(x)  #=>14

b_str = "{:b}".format(x)
print(repr(b_str)) #=> '1110'

for direction in [1, -1]:
    if direction > 0:
        least_signif = b_str[-1]
    else:
        least_signif = b_str[0]

    print(least_signif)


--output:--
0
1