堆和栈的概念和区别 python_【数据结构】堆

什么是堆？

二叉堆本质上是一颗完全二叉树，它分为两个类型：

最大堆

什么是最大堆？最大堆的任何一个父节点的值，都大于或等于它左右孩子节点的值。

如图：

最小堆

什么又是最小堆？最小堆的任何一个父节点的值，都小于或等于它左右孩子节点的值。

如图：

堆的根节点叫作堆顶。

最大堆和最小堆的特点决定了，最大堆的堆顶是整个堆中的最大元素。最小堆的堆顶是整个堆中的最小元素。

注意：二叉堆虽然是一个完全二叉树，但它的存储方式并不是链式存储，而是顺序存储。换句话说，二叉堆的所有节点都存储在数组当中。如图：

如上图所示，使用数组从索引为1的位置开始进行存储，这是因为计算孩子节点和父亲节点的公式比较方便一些。

但是这样一来，就有一个小的问题，就是将索引为0的位置空出来了，不过对于堆来说，可以不空出来这个位置，区别就在于计算孩子节点和父亲节点的公式发生一点点的改变。

如图：

堆的实现

1、插入节点

当堆插入节点时，插入位置时完全二叉树的最后一个位置。例如插入一个新节点，值为52。

这时，新节点的父节点16比52小，显然不符合最大堆的性质。于是让新节点进行上浮，和父节点交换位置。

继续用节点52和父节点41进行比较，因为41<52，则让新节点继续上浮。

继续用节点52和父节点62进行比较，由于52<62，则不用任何操作。

2、删除节点

堆删除节点的过程和插入节点的过程正好相反，所删除的是处于堆顶的节点。例如删除最大堆的堆顶节点62。

这时，为了继续位置完全二叉树的结构，我们把堆的最后一个节点16临时不倒堆顶位置。

接下来，让栈顶位置的节点16和它的左右孩子进行比较，如果左右孩子节点中最大的一个比节点16还大，那么让节点16下沉。

继续让节点16和它的左右孩子做比较，左右孩子中最大节点是41，由于16<41，则让节点16继续下沉。

继续让节点16和它的左右孩子进行比较，左右孩子中最大节点是15，由于16>15，所以不做任何操作，这样一来堆重新得到了调整。

整体代码如下：

/**

* 描述：基于数组二次封装成动态数组。

*

* Create By ZhangBiao

* 2020/5/14

*/

public class Array {

private E[] data;

private int size;

/**

* 构造函数，传入数组的容量capacity构造Array。

*

* @param capacity 容量大小

*/

public Array(int capacity) {

data = (E[]) new Object[capacity];

size = 0;

}

/**

* 无参数的构造函数，默认数组的容量capacity=10。

*/

public Array() {

this(10);

}

public Array(E[] arr) {

this.data = (E[]) new Object[arr.length];

for (int i = 0; i < arr.length; i++) {

this.data[i] = arr[i];

}

this.size = this.data.length;

}

/**

* 获取数组的容量。

*

* @return

*/

public int getCapacity() {

return data.length;

}

/**

* 获取数组中的元素个数。

*

* @return

*/

public int getSize() {

return size;

}

/**

* 返回数组是否为空。

*

* @return

*/

public boolean isEmpty() {

return size == 0;

}

/**

* 向所有元素后添加一个新元素

*

* @param e

*/

public void addLast(E e) {

/*if (size == data.length) {

throw new IllegalArgumentException("AddLast failed. Array is full.");

}

data[size] = e;

size++;*/

add(size, e);

}

public void addFirst(E e) {

add(0, e);

}

/**

* 在index索引的位置插入一个新元素e

*

* @param index

* @param e

*/

public void add(int index, E e) {

if (index < 0 || index > size) {

throw new IllegalArgumentException("Add failed. Require index >= 0 and index <= size.");

}

if (size == data.length) {

resize(2 * data.length);

}

for (int i = size - 1; i >= index; i--) {

data[i + 1] = data[i];

}

data[index] = e;

size++;

}

/**

* 扩容

*

* @param newCapacity

*/

private void resize(int newCapacity) {

E[] newData = (E[]) new Object[newCapacity];

for (int i = 0; i < size; i++) {

newData[i] = data[i];

}

data = newData;

}

/**

* 获取index索引位置的元素。

*

* @param index

* @return

*/

public E get(int index) {

if (index < 0 || index >= size) {

throw new IllegalArgumentException("Get failed. Index is illgal.");

}

return data[index];

}

/**

* 获取索引为0的元素。

*

* @return

*/

public E getFirst() {

return get(0);

}

/**

* 获取索引为size-1的元素。

*

* @return

*/

public E getLast() {

return get(size - 1);

}

/**

* 修改index索引位置的元素为e。

*

* @param index

* @param e

*/

public void set(int index, E e) {

if (index < 0 || index >= size) {

throw new IllegalArgumentException("Set failed. Index is illegal.");

}

data[index] = e;

}

/**

* 查找数组中是否有元素e。

*

* @param e

* @return

*/

public boolean contains(E e) {

for (int i = 0; i < size; i++) {

if (data[i] == e) {

return true;

}

}

return false;

}

/**

* 查找数组中元素e所在的索引，如果不存在元素e，则返回-1。

*

* @param e

* @return

*/

public int find(E e) {

for (int i = 0; i < size; i++) {

if (data[i] == e) {

return i;

}

}

return -1;

}

/**

* 从数组中删除index位置的元素，返回删除的元素。

*

* @param index

* @return

*/

public E remove(int index) {

if (index < 0 || index >= size) {

throw new IllegalArgumentException("Remove failed. Index is illegal.");

}

E ret = data[index];

for (int i = index + 1; i < size; i++) {

data[i - 1] = data[i];

}

size--;

if (size == data.length / 4 && data.length / 2 != 0) {

resize(data.length / 2);

}

return ret;

}

/**

* 从数组中删除第一个元素并返回删除的元素。

*

* @return

*/

public E removeFirst() {

return remove(0);

}

/**

* 从数组中删除最后一个元素并返回删除的元素。

*

* @return

*/

public E removeLast() {

return remove(size - 1);

}

/**

* 从数组中删除元素e。

*

* @param e

*/

public void removeElement(E e) {

int index = find(e);

if (index != -1) {

remove(index);

}

}

public void swap(int i, int j) {

if (i < 0 || i >= size || j < 0 || j >= size) {

throw new IllegalArgumentException("Index is Illegal");

}

E temp = data[i];

data[i] = data[j];

data[j] = temp;

}

@Override

public String toString() {

StringBuilder res = new StringBuilder();

res.append(String.format("Array: size = %d , capacity = %d\n", size, data.length));

res.append('[');

for (int i = 0; i < size; i++) {

res.append(data[i]);

if (i != size - 1) {

res.append(", ");

}

}

res.append(']');

return res.toString();

}

}

/**

* 描述：基于动态数组实现二叉堆（最大堆）。

*

* Create By ZhangBiao

* 2020/5/14

*/

public class MaxHeap> {

private Array data;

public MaxHeap(int capacity) {

this.data = new Array<>(capacity);

}

public MaxHeap() {

this.data = new Array<>();

}

public MaxHeap(E[] arr) {

this.data = new Array<>(arr);

for (int i = parent(arr.length - 1); i >= 0; i--) {

siftDown(i);

}

}

/**

* 返回堆的元素个数

*

* @return

*/

public int size() {

return data.getSize();

}

/**

* 返回一个布尔值，表示堆是否为空

*

* @return

*/

public boolean isEmpty() {

return data.isEmpty();

}

/**

* 返回完全二叉树的数组表示中，一个索引所表示的元素的父亲节点的索引

*

* @param index

* @return

*/

private int parent(int index) {

if (index == 0) {

throw new IllegalArgumentException("index-0 doesn't have parent");

}

return (index - 1) / 2;

}

/**

* 返回完全二叉树的数组表示中，一个索引所表示的元素的左孩子节点的索引

*

* @param index

* @return

*/

private int leftChild(int index) {

return index * 2 + 1;

}

/**

* 返回完全二叉树的数组表示中，一个索引所表示的元素的右孩子节点的索引

*

* @param index

* @return

*/

private int rightChild(int index) {

return index * 2 + 2;

}

/**

* 向堆中添加元素

*

* @param e

*/

public void add(E e) {

data.addLast(e);

siftUp(data.getSize() - 1);

}

private void siftUp(int k) {

while (k > 0 && data.get(parent(k)).compareTo(data.get(k)) < 0) {

data.swap(k, parent(k));

k = parent(k);

}

}

/**

* 查看堆中的最大元素

*

* @return

*/

public E findMax() {

if (data.getSize() == 0) {

throw new IllegalArgumentException("Can not findMax when heap is empty");

}

return data.get(0);

}

/**

* 取出堆中最大元素

*

* @return

*/

public E extractMax() {

E ret = findMax();

data.swap(0, data.getSize() - 1);

data.removeLast();

siftDown(0);

return ret;

}

private void siftDown(int k) {

while (leftChild(k) < data.getSize()) {

int j = leftChild(k);

if (j + 1 < data.getSize() && data.get(j + 1).compareTo(data.get(j)) > 0) {

j++;

}

if (data.get(k).compareTo(data.get(j)) >= 0) {

break;

}

data.swap(k, j);

k = j;

}

}

public static void main(String[] args) {

int n = 1000000;

MaxHeap maxHeap = new MaxHeap<>();

Random random = new Random();

for (int i = 0; i < n; i++) {

maxHeap.add(random.nextInt(Integer.MAX_VALUE));

}

int[] arr = new int[n];

for (int i = 0; i < n; i++) {

arr[i] = maxHeap.extractMax();

}

for (int i = 1; i < n; i++) {

if (arr[i - 1] < arr[i]) {

throw new IllegalArgumentException("Error");

}

}

System.out.println("Test MaxHeap completed.");

}

/**

* 取出堆中的最大元素并替换成元素e

*

* @param e

* @return

*/

public E replace(E e) {

E ret = findMax();

data.set(0, e);

siftDown(0);

return ret;

}

}