class ArrayQueue(Queue):
def __init__(self, capacity: int = 10):
self.__data = Array(capacity)
def get_size(self):
return self.__data.get_size()
def enqueue(self, ele):
self.__data.add_to_last(ele)
def is_empty(self):
return self.__data.is_empty()
def dequeue(self):
return self.__data.remove_first()
def get_front(self):
return self.__data.get_first()
def get_capacity(self):
return self.__data.get_capacity()
def __str__(self):
bstr = 'ArrayQueue size: %d, capacity: %d\n' % (self.__data.get_size(), self.__data.get_capacity())
bstr += 'front ['
for i in range(self.__data.get_size()):
bstr += '' + str(self.__data.get(i))
if i != self.__data.get_size() - 1:
bstr += ', '
bstr += '] tail'
return bstr
class ArrayQueue(QueueBase):
def __init__(self, capacity=0):
self._array = Array(capacity)
def get_size(self):
return self._array.get_size()
def is_empty(self):
return self._array.is_empty()
def get_capacity(self):
return self.get_capacity()
def enqueue(self, e):
self._array.add_last(e)
def dequeue(self):
return self._array.remove_first()
def get_front(self):
return self._array.get_first()
def __str__(self):
return str('<chapter_05_Stack_Queue.queue.ArrayQueue> : {}'.format(
self._array))
def __repr__(self):
return self.__str__()
class IndexHeap:
def __init__(self, capacity):
# data 表示为元素的数组
self._data = Array(capacity=capacity)
# index[i] 数组表示为对堆中第i的位置上的元素
self._index = Array(capacity=capacity)
# reversed[i] 为i的在索引堆位置是index逆运算
self._reversed = Array(capacity=capacity)
for i in range(capacity):
self._reversed.add(i, -1)
self.capacity = capacity
self.count = 0
def getSize(self):
return self.count
def getCapacity(self):
return self.capacity
def isEmpty(self):
return self.count == 0
def add(self, i, ele):
self._data.add(i, ele)
self._index.add_last(i)
self._reversed.set(i, self.count)
self.count += 1
self._shiftUp(self._data.get_size() - 1)
def extractMin(self):
if self.count < 0:
raise ValueError("capacity should be >0")
ele = self._data.get(self._index.get_first())
self._index.set(0, self._index.get_last())
self.count -= 1
if self.count != 0:
self._index.remove_last()
self._shiftDown(0)
return ele
def leftChid(self, index):
return 2 * index + 1
def rightChild(self, index):
return 2 * index + 2
def _shiftDown(self, index):
if index < 0:
raise ValueError("index should be postive")
cur = self._data.get(self._index.get(index))
cur_index = self._index.get(index)
while self.leftChid(index) < self._index.get_size():
max_index = self.leftChid(index)
if self.rightChild(index) < self._index.get_size(
) and self._data.get(self._index.get(
self.rightChild(index))) < self._data.get(
self._index.get(self.leftChid(index))):
max_index = self.rightChild(index)
if self._data.get(self._index.get(max_index)) < cur:
self._index._data[max_index], self._index._data[
index] = self._index._data[index], self._index._data[
max_index]
self._reversed.set(self._index.get(max_index), max_index)
self._reversed.set(self._index.get(index), index)
index = max_index
else:
break
def _shiftUp(self, index):
if index < 0:
raise ValueError("index should be postive")
cur = self._data.get(self._index.get(index))
cur_index = self._index.get(index)
while (index - 1) // 2 >= 0:
parent = (index - 1) // 2
if self._data.get(self._index.get(parent)) > cur:
self._index._data[parent], self._index._data[
index] = self._index._data[index], self._index._data[
parent]
self._reversed.set(self._index.get(index), index)
self._reversed.set(self._index.get(parent), parent)
index = (index - 1) // 2
else:
break
def extractMinIndex(self):
if self.count < 0:
raise ValueError("capacity should be >0")
ele = self._index.get(0)
self._index.set(0, self._index.get_last())
self._reversed.set(self._index.get(0), 0)
# self._reversed.set(self._index.get_last(), -1)
self.count -= 1
if self.count != 0:
self._reversed.set(self._index.get_last(), -1)
self._index.remove_last()
self._shiftDown(0)
return ele
def contains(self, index):
return self._reversed.get(index) != -1
def getItem(self, index):
assert self.contains(index)
return self._data.get(index)
def change(self, i, item):
assert self.contains(i)
j = self._reversed.get(i)
if self._data.get(i) > item:
self._data.set(i, item)
self._shiftUp(j)
else:
self._data.set(i, item)
self._shiftDown(j)
# 找到index中的i的位置 index[j] == i
# 之后shiftUp(j),shiftDown(j)
# o(n)
# for j, w in enumerate(self._index):
# if w == i:
# self._shiftDown(j)
# self._shiftUp(j)
# return
def __str__(self):
return str(
' heap_value: {}, heap_index:{},heap_reversed:{},capacity: {},size:{}'
.format(self._data, self._index, self._reversed, self.capacity,
self.count))
