算法训练-堆

1、堆

堆代码实现与堆排序

#include<iostream>
#include<queue>
#include <math.h>
using namespace std;

#define MAX_HEAP_SIZE 11

/************************************************************************/
/*

6
3#4
1#9    2#8
10#7    5#    ##     ##


*/
/************************************************************************/

typedef union myheap
{
	int m_size;
	int m_heapmem[MAX_HEAP_SIZE];
}*ptrHeap;

void init_heap(ptrHeap* heap, int size = 10){
	if (size + 1>MAX_HEAP_SIZE)
	{
		printf("out of memery\n"); return;
	}
	*heap = (ptrHeap)malloc(sizeof(myheap));
	int temp[10] = { 6, 3, 4, 1, 9, 2, 8, 10, 7, 5 };
	(*heap)->m_size = size;
	for (int i = 0; i < size; ++i)
	{
		(*heap)->m_heapmem[i + 1] = temp[i];
	}
}
void swap(int& a, int& b){
	if (a == b)
	{
		return;
	}
	a = a^b;
	b = a^b;
	a = a^b;
}

//完全二叉树 逐层层序遍历，堆在数组中存储时的程序遍历只需遍历一遍数组即可，时间复杂度为O(n)
/*
教训总结：
写代码前一定要想将思路理顺了，跟着逻辑走，而不要跟着记忆走，“隐约的记得好像其他类似的做法是这样的”这样的思维方式很有问题，抓不住问题的本质，即使顺着记忆做出来了，下次也可能会忘记，
而且容易沉溺于“想不起上次的做法”而苦恼的境地。

*/
void dump_heap(ptrHeap heap){
	int size = heap->m_size;
	queue<int> level;
	level.push(heap->m_heapmem[1]);

	int i = 0;
	int le = 0;
	while (i<size)
	{
		while (!level.empty())
		{
			printf(" %d ", level.front()); level.pop();
			i++;
		}
		printf("\n");

		//找到各层结点的开始下标和结束下标（太傻叉了 这个实现，完全没有必要用队列啊）
		for (int j = i / 2 + 1; j < i / 2 + 1 + (int)pow(2, le) && 2 * j <= size; ++j)
		{
			level.push(heap->m_heapmem[j * 2]);
			if (2 * j + 1 <= size)
			{
				level.push(heap->m_heapmem[j * 2 + 1]);
			}
		}
		le++;
	}
}


void dump_heap2(ptrHeap heap)
{
	int size = heap->m_size;
	int maxlevel = size / 2;
	int count = 0;
	//找到各层的起点和终点下标，然后进行遍历
	for (int level = 0; level < maxlevel && count < size; ++level){
		int startIndex = (1 << level)            /* (int)pow(2, level)*/;
		int endIndex = startIndex + (1 << level) /*(int)pow(2, level)*/;

		for (; startIndex < endIndex && startIndex<=size; ++startIndex){
			printf("%d ", heap->m_heapmem[startIndex]);
			count++;
		}
		printf("\n");
	}
}

void heapify(ptrHeap* heap, int parent,int size){
	int maxIndex = 0;
	int left = 0;
	int right = 0;
	while (true)
	{
		maxIndex = parent;
		left = parent * 2;
		right = left + 1;

		if ((*heap)->m_heapmem[maxIndex] < (*heap)->m_heapmem[left] && (left <= size)){
			maxIndex = left;
		}
		if ((*heap)->m_heapmem[maxIndex] < (*heap)->m_heapmem[right] && (right <= size)){
			maxIndex = right;
		}
		if (maxIndex == parent){
			break;
		}
		swap((*heap)->m_heapmem[parent], (*heap)->m_heapmem[maxIndex]);
		parent = maxIndex;
	}
}
void dump(ptrHeap heap){
	printf("\n");
	int size = heap->m_size;
	for (int i = 1; i <= size; ++i){
		printf(" %d ", heap->m_heapmem[i]);
	}
	printf("\n");
}
void build_heap(ptrHeap heap)
{
	int size = heap->m_size;
	for (int i = size / 2; i > 0; --i){
		heapify(&heap, i,size);
	}
}
void heap_sort(ptrHeap pHeap){
	
	int size = pHeap->m_size;
	while (size>1)
	{
		//堆化
		for (int i = size / 2; i > 0; --i){
			heapify(&pHeap, i,size);
		}
		//堆化后将最大元素(第一个元素)放在最后一位
		swap(pHeap->m_heapmem[1], pHeap->m_heapmem[size]);
		size--;
	}

}


int main()
{
	ptrHeap pHeap = nullptr;
	cout << "before build heap:" << endl;
	init_heap(&pHeap);
	dump_heap2(pHeap);
	cout << "after build heap:" << endl;
	build_heap(pHeap);
	dump_heap2(pHeap);

	printf("before heap sort:\n");
	dump(pHeap);
	printf("after heap sort:\n");
	heap_sort(pHeap);
	dump(pHeap);
	system("pause");
	return 0;
}