icoding 排序 堆化

堆化

//2021.6.27
想到一个非递归算法，回头写。

二叉堆一般用数组来表示。例如，根节点在数组中的位置是0，第n个位置的子节点分别在2n+1和 2n+2。 因此，第0个位置的子节点在1和2，1的子节点在3和4。以此类推。这种存储方式便于寻找父节点和子节点。在二叉堆上可以进行插入节点、删除节点、取出值最小的节点、减小节点的值等基本操作。

“最小堆”的定义如下：

typedef struct _otherInfo
{
    int i;
    int j;
}OtherInfo;

typedef struct _minHeapNode
{
    int value;
    OtherInfo otherInfo;
}MinHeapNode, *PMinHeapNode;

typedef struct _minPQ {
    PMinHeapNode heap_array; // 指向堆元素数组
    int heap_size; // 当前堆中的元素个数
    int capacity;  //堆数组的大小
}MinHeap, *PMinHeap;

请实现最小堆的“堆化”函数：

void min_heapify(PMinHeap pq, int i);

其中 pq指向堆，i 为堆元素在数组中的下标。该函数假设元素i对应的子树都已经是最小堆（符合最小堆的要求），但元素i为根的子树并不是最小堆，min_heapify将对元素i及其子树的各结点进行调整，使其为一个最小堆。

（注：假设辅助函数 left、right、parent 和 swap_node 已正确实现，min_heapify 函数可直接使用。）

答案（递归方法）

#include <stdio.h>
#include <stdlib.h>
#include "minbinheap.h"

int condition(PMinHeap pq, int i) {
    if (left(i) < pq->heap_size && right(i) < pq->heap_size)return 1;
    if (left(i) < pq->heap_size && right(i) > pq->heap_size)return -1;
    if (left(i) > pq->heap_size)return 0;
}

int is_change(PMinHeap pq, int n) {
    //left and right both NULL(leaf node),needn't change;
    if (condition(pq, n) == 0)return 0;
    //left exists,but right is NULL;
    if (condition(pq, n) == -1) {
        if (pq->heap_array[left(n)].value < pq->heap_array[n].value)return -1;
        else return 0;
    }
    if (condition(pq, n) == 1) {
        if (pq->heap_array[left(n)].value <= pq->heap_array[right(n)].value && pq->heap_array[left(n)].value < pq->heap_array[n].value)return -1;
        if (pq->heap_array[left(n)].value >= pq->heap_array[right(n)].value && pq->heap_array[right(n)].value < pq->heap_array[n].value)return 1;
        else return 0;
    }
}

void min_heapify(PMinHeap pq, int i) {
    int n = condition(pq, i);
    //left and right both NULL(leaf node)
    if (n == 0)return;
    //left exists,but right is NULL;
    if (n == -1) {
        if (is_change(pq, i) == -1) {
            swap_node(&pq->heap_array[i], &pq->heap_array[left(i)]);
            for (int i = 0; i < pq->heap_size; i++) {
                printf("%d  ", pq->heap_array[i].value);
            }
            printf("\n");
        }
        return;
    }
    //left and right exist
    if (n ==1) {
        min_heapify(pq, left(i));
        min_heapify(pq, right(i));
        n = i;
        while (is_change(pq, n) != 0) {
            if (is_change(pq, n) == -1) {
                swap_node(&pq->heap_array[n], &pq->heap_array[left(n)]);
                n = left(n);
                for (int i = 0; i < pq->heap_size; i++) {
                    printf("%d  ", pq->heap_array[i].value);
                }
                printf("\n");
            }
            else if (is_change(pq, n) == 1) {
                swap_node(&pq->heap_array[n], &pq->heap_array[right(n)]);
                n = right(n);
                for (int i = 0; i < pq->heap_size; i++) {
                    printf("%d  ", pq->heap_array[i].value);
                }
                printf("\n");
            }
        }
    }

}

//2021.7.3  0:22

答案（非递归）

#include <stdio.h>
#include <stdlib.h>
#include "minbinheap.h"

int condition(PMinHeap pq, int i) {
	if (right(i) < pq->heap_size)return 1;
	if (left(i) < pq->heap_size && right(i) >= pq->heap_size)return -1;
	if (left(i) >= pq->heap_size)return 0;
}

int is_change(PMinHeap pq, int n) {
	//left and right both NULL(leaf node),needn't change;
	if (condition(pq, n) == 0)return 0;
	//left exists,but right is NULL;
	if (condition(pq, n) == -1) {
		if (pq->heap_array[left(n)].value < pq->heap_array[n].value)return -1;
		else return 0;
	}
	if (condition(pq, n) == 1) {
		if (pq->heap_array[left(n)].value <= pq->heap_array[right(n)].value && pq->heap_array[left(n)].value < pq->heap_array[n].value)return -1;
		if (pq->heap_array[left(n)].value >= pq->heap_array[right(n)].value && pq->heap_array[right(n)].value < pq->heap_array[n].value)return 1;
		else return 0;
	}
}

void xiachen(PMinHeap pq, int i) {
	int n = i;
	while (is_change(pq, n) != 0) {
		if (is_change(pq, n) == -1) {
			swap_node(&pq->heap_array[n], &pq->heap_array[left(n)]);
			n = left(n);
			for (int i = 0; i < pq->heap_size; i++) {
				printf("%d  ", pq->heap_array[i].value);
			}
			printf("\n");
		}
		else if (is_change(pq, n) == 1) {
			swap_node(&pq->heap_array[n], &pq->heap_array[right(n)]);
			n = right(n);
			for (int i = 0; i < pq->heap_size; i++) {
				printf("%d  ", pq->heap_array[i].value);
			}
			printf("\n");
		}
	}
}

void min_heapify(PMinHeap pq, int i) {
	int l = i, r = i,p;
	//计算左右叶结点下标
	for (; left(l) < pq->heap_size ;  l = left(l));
	for (; right(r) < pq->heap_size ; r= right(r));
	//根据左右叶结点判断最后一个非叶结点下标,用p保存
	if (l < r) p = parent(r);
	else if (l == r)return;
	else if (l > r)p = parent(pq->heap_size - 1);
	while (l != parent(i)) {//遍历所有非叶结点
		l = parent(l);
		r = parent(r);
		while (p != l-1&&p!=-1) {//遍历该深度结点
			xiachen(pq,p);
			p--;
		}
		p = r;
	}
}