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 ArrayStack(Stack):
def __init__(self, capacity: int = 10):
self.__data = Array(capacity)
def peek(self):
return self.__data.get_last()
def push(self, ele):
self.__data.add_to_last(ele)
def get_size(self):
return self.__data.get_size()
def pop(self):
return self.__data.remove_last()
def is_empty(self):
return self.__data.is_empty()
def __str__(self):
bstr = 'ArrayStack size: %d, capacity: %d\n' % (
self.__data.get_size(), self.__data.get_capacity())
bstr += '['
for i in range(self.__data.get_size()):
bstr += '' + str(self.__data.get(i))
if i != self.__data.get_size() - 1:
bstr += ', '
bstr += '] top'
return bstr
class ArrayStack(StackBase):
"""使用自定义的Array实现"""
def __init__(self, capacity=0):
self._array = Array(capacity=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._array.get_capacity()
def __str__(self):
return str('<chapter_05_Stack_Queue.stack.ArrayStack> : {}'.format(
self._array))
def __repr__(self):
return self.__str__()
def push(self, e):
self._array.add_last(e)
def pop(self):
return self._array.remove_last()
def peek(self):
return self._array.get_last()
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 MaxHeap(object):
def __init__(self, arr=None):
if arr is None:
self.__data = Array()
elif isinstance(arr, int):
self.__data = Array(arr)
else:
# 如果 arr 不为空，使用 heapify 操作将 arr 整理成堆
self.__data = Array(arr)
i = (self.get_size() - 2) // 2
while i >= 0:
self.__sift_down(i)
i -= 1
# 堆大小
def get_size(self):
return self.__data.get_size()
# 堆是否为空
def is_empty(self):
return self.__data.is_empty()
# 起始索引为0的完全二叉树下，返回给定索引的父结点索引
def get_parent(self, index: int):
if index == 0:
raise IndexError('index-0 has no parent')
return (index - 1) // 2
# 起始索引为0的完全二叉树下，返回给定索引的左孩子索引
def get_left_child(self, index: int):
return 2 * index + 1
# 起始索引为0的完全二叉树下，返回给定索引的右孩子索引
def get_right_child(self, index: int):
return 2 * index + 2
# 向堆内添加新元素 e
def add(self, e):
self.__data.add_to_last(e)
self.__sift_up(self.__data.get_size() - 1)
# 上浮操作
def __sift_up(self, index: int):
while index > 0 and self.__data.get(self.get_parent(index)) < self.__data.get(index):
self.__data.swap(index, self.get_parent(index))
index = self.get_parent(index)
# 获取堆内最大元素
def get_max(self):
if self.get_size() == 0:
raise IndexError('heap is empty')
return self.__data.get(0)
# 获取并从堆内删除最大元素
def extract_max(self):
ret = self.get_max()
self.__data.set(0, ret)
self.__data.remove_last()
self.__sift_down(0)
return ret
# 下沉操作
def __sift_down(self, index: int):
while self.get_left_child(index) < self.get_size():
j = self.get_left_child(index)
if j + 1 < self.get_size() and self.__data.get(j + 1) > self.__data.get(j):
j += 1
if self.__data.get(index) > self.__data.get(j):
break
else:
self.__data.swap(index, j)
index = j
# 取出堆内元素最大值，并替换为新值
def replace(self, ele):
ret = self.get_max()
self.__data.set(0, ele)
self.__sift_down(0)
return ret
class MaxHeap:
def __init__(self, arr=None, capacity=None):
if isinstance(arr, Array):
self._data = arr
for i in range(self._parent(arr.get_size() - 1), -1, -1):
self._sift_down(i)
return
if not capacity:
self._data = Array()
else:
self._data = Array(capacity=capacity)
def size(self):
return self._data.get_size()
def is_empty(self):
return self._data.is_empty()
# 返回完全二叉树数组表示中，一个索引所表示的元素的父亲节点的索引 i // 2
def _parent(self, index):
if index == 0:
raise ValueError('index-0 doesn\'t have parent.')
return (index - 1) // 2
# 返回完全二叉树数组表示中，一个索引所表示的元素的左孩子节点的索引 2 * i + 1
def _left_child(self, index):
return index * 2 + 1
# 返回完全二叉树数组表示中，一个索引所表示的元素的右孩子节点的索引 2 * i + 2
def _right_child(self, index):
return index * 2 + 2
def add(self, e):
self._data.add_last(e)
self._sift_up(self._data.get_size() - 1)
def _sift_up(self, index):
cur = self._data.get(index)
while index > 0 and self._data.get(self._parent(index)) < cur:
self._data.set(index, self._data.get(self._parent(index)))
index = self._parent(index)
self._data.set(index, cur)
def find_max(self):
if self._data.get_size() == 0:
raise ValueError('Can not find_max when heap is empty.')
return self._data.get(0)
def extract_max(self):
ret = self.find_max()
self._data.swap(0, self._data.get_size() - 1)
self._data.remove_last()
self._sift_down(0)
return ret
def _sift_down(self, index):
while self._left_child(index) < self.size():
right = self._right_child(index)
left = self._left_child(index)
max = self._data.get(left)
max_index = left
if right < self.size() and max < self._data.get(right):
right_chid = self._data.get(right)
max = right_chid
max_index = right
if max > self._data.get(index):
self._data.swap(max_index, index)
index = max_index
else:
break
def replace(self, e):
ret = self.find_max()
# 这样可以一次logn完成
self._data.set(0, e)
self._sift_down(0)
return ret
