堆的简单实现和堆的排序问题

1、什么是堆？首先先了解一下树

了解树：

树我们重点学习的是二叉树

二叉树也有两个不同的特殊结构

1、满二叉树 和 完全二叉树

则堆就是一颗完全二叉树

接下来让我们实现一个堆 这里用数组来创建堆是最好不过的

第一步：初始化

第二步  往堆里插入数据

 这里别忘了还要实现一个swap函数

第三步：删除数据

 第四步：取堆顶是数字

 第五步:求堆的个数

第六步：堆的判空

 第七步：销毁堆

 

然后讲到堆排序问题，如果我们每次要要建一个堆不就很麻烦了吗，我们完全不用这样，可以直接建堆，下面有两个建堆的方式：
方式一：O(N*logN)

 

 

  

 

方拾贰：O(N）

 

 2、利用堆删除的思想来进行排序

建堆和堆排序都用到了向下调整，因此掌握了向下调整，也就掌握了堆排序

//向下调整
void swap(int* a, int* b)
{
	int temp = *a;
	*a = *b;
	*b = temp;
}
void AdjustDown(int* a, int size, int parent)
{
	int child = parent * 2 + 1;
	while (child < size)
	{
		if (a[child + 1] > a[child])
		{
			++child;
		}
		if (child<size && a[child]>a[parent])
		{
			swap(&a[child], &a[parent]);
			parent = child;
			child = (parent * 2) + 1;
		}
		else
		{
			break;
		}
	}
}
int main()
{
	int arr[] = { 11,10,23,15,24 };
	int len = sizeof(arr) / sizeof(arr[0]);
	/*for (int i = 1; i < len; i++)
	{
		AdjustUp(arr, i);
	}*/

	//方式二：向下调整
	for (int i = (len - 1 - 1) / 2; i >= 0; --i)
	{
		AdjustDown(arr, len, i);
	}
	for (int i = 0; i < len; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	//排序
	int end = len - 1;
	while (end)
	{
		swap(&arr[0], &arr[end]);
		AdjustDown(arr, end, 0);
		--end;
	}
	for (int i = 0; i < len; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

 输出结果：

 

完成排序！！ 

 堆的实现完整代码：

typedef struct Heap
{
	int* a;
	int size;
	int capacity;
}Heap;

//堆的初始化
void HeapInit(Heap* hp)
{
	assert(hp);
	hp->a = NULL;
	hp->size = hp->capacity = 0;
}

void swap(int* a, int* b)
{
	int temp = *a;
	*a = *b;
	*b = temp;
}

//判断
void AdjustPush(int* a, int child)
{
	//先求父母
	int parent = (child - 1) / 2;
	while (child>0)
	{
		if (a[child] < a[parent])
		{
			swap(&a[child], &a[parent]);
			child = parent;//孩子到达父母的位置
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

//插入数据
void HeapPush(Heap* hp,int x)
{
	assert(hp);
	//判断是否满了
	if (hp->size == hp->capacity)
	{
		int newcapacity = hp->capacity == 0 ? 4 : hp->capacity * 2;
		int* tmp = realloc(hp->a, sizeof(int) * newcapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		else
		{
			hp->a = tmp;
			hp->capacity = newcapacity;
		}
	}
	hp->a[hp->size] = x;
	hp->size++;
	//判断插入的是否是符合小端或者大端存储的规则
	AdjustPush(hp->a, hp->size-1);
}

void HeapPrint(Heap* hp)
{
	assert(hp);
	for (int i = 0; i < hp->size;++i)
	{
		printf("%d ", hp->a[i]);
	}
	printf("\n");
}


//销毁
void HeapDestory(Heap* hp)
{
	assert(hp);
	free(hp->a);
	hp->size = hp->capacity = 0;
}

//判断是否为空
bool HeapEmpty(Heap* hp)
{
	assert(hp);
	return hp->size == NULL;
}


//向下调整
void AdjustDown(int* a, int size, int parent)
{
	//先默认定义左孩子
	int child = parent * 2 + 1;
	while (child < size)
	{
		if (a[child + 1] < a[child])
		{
			++child;
		}
		//此时的左孩子++变成了右孩子
		if (child+1<size && a[child] < a[parent])
		{
			swap(&a[child], &a[parent]);
			parent = child;//parent到达孩子的位置
			child = parent * 2 + 1;//重新默认小的是左孩子
		}
		else
		{
			break;
		}

	}
}
//删除
void HeapPop(Heap* hp)
{
	assert(hp);
	assert(hp->size>0);
	//向下调整  //找出孩子小的那一个  向下调整
	//先交换头尾的数据
	swap(&(hp->a[0]), &(hp->a[hp->size - 1]));
	hp->size--;
	//向下调整
	AdjustDown(hp->a, hp->size,0);
}

//堆顶
int HeapTop(Heap* hp)
{
	assert(hp);
	assert(!HeapEmpty(hp));
	return hp->a[0];
}

//堆的个数
int HeapSize(Heap* hp)
{
	assert(hp);
	return hp->size;
}
int main()
{
	Heap hp;
	HeapInit(&hp);
	int a[] = { 14,13,11,77,23,54,56,32,26 };
	for (int i = 0; i < sizeof(a) / sizeof(int); ++i)
	{
		HeapPush(&hp, a[i]);
	} 
	///HeapPush(&hp,1);
	HeapPrint(&hp);
	HeapPop(&hp);//堆的删除
	HeapPrint(&hp);//打印堆
	//bool ret=HeapEmpty(&hp);
	int ret=HeapTop(&hp);//取堆顶的数据
	printf("%d\n", ret);
	int count=HeapSize(&hp);//堆的个数
	printf("%d", count);
}

 

如有错误，请多多指教！