C语言中的二叉树和堆详解

typedef int DataType;
struct Node
{
 struct Node* _firstChild1; //第一个孩子结点
 struct Node* _pNextBrother; //指向其下一个兄弟结点
 DataType _data; //结点中的数据域
};

typedef int BTDataType;
// 二叉链
struct BinaryTreeNode
{
 struct BinTreeNode* _pLeft; //指向当前节点左孩子
 struct BinTreeNode* _pRight; //指向当前节点右孩子
 BTDataType _data; //当前节点值域
}
// 三叉链
struct BinaryTreeNode
{
 struct BinTreeNode* _pParent; //指向当前节点的双亲
 struct BinTreeNode* _pLeft; //指向当前节点左孩子
 struct BinTreeNode* _pRight; //指向当前节点右孩子
 BTDataType _data; //当前节点值域
}；

void PreOrder(BTNode* root)//前序遍历
{
	if (root == NULL)
	{
		printf("# ");//为空打印#
		return;
	}
	printf("%d ", root->data);
	PreOrder(root->left);
	PreOrder(root->right);
}
void InOrder(BTNode* root)//中序遍历
{
	if (root == NULL)
	{
		printf("# ");//为空打印#
		return;
	}
	InOrder(root->left);
	printf("%d", root->data);
	InOrder(root->right);
}
void PostOrder(BTNode* root)//后序遍历
{
	if (root == NULL)
	{
		printf("# ");//为空打印#
		return;
	}
	PostOrder(root->left);
	PostOrder(root->right);
	printf("%d ", root->data);
}

void HeapInit(Heap* ph)//堆的初始化
{
	assert(ph);
	ph->arr = NULL;
	ph->capacity = ph->size = 0;
}
void HeapDestroy(Heap* ph)//堆的销毁
{
	assert(ph);
	free(ph->arr);
	ph->arr = NULL;
	ph->size = ph->capacity = 0;
}
void Swap(HeapDataType* child, HeapDataType* parent)//交换堆数组内容
{
	HeapDataType tmp = *child;
	*child = *parent;
	*parent = tmp;
}
void AdjustUp(int* arr, int child)//向上调整函数
{
	while (child > 0)
	{
		int parent = (child - 1) / 2;
		if (arr[parent] > arr[child])
		{
			Swap(&arr[child], &arr[parent]);//交换堆数组内容
			child = parent;
		}
		else
		{
			break;
		}
	}
}
void HeapPush(Heap* ph, HeapDataType x)//插入数据
{
	assert(ph);
	if (ph->capacity == ph->size)
	{
		int newcapacity = ph->capacity = 0 ? 4 : ph->capacity * 2;
		HeapDataType* tmp = (HeapDataType*)realloc(ph->arr, sizeof(HeapDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("malloc");
			exit(-1);
		}
		ph->arr = tmp;
		ph->capacity = newcapacity;
	}
	ph->arr[ph->size] = x;
	ph->size++;
	AdjustUp(ph->arr, ph->size - 1);//向上调整函数
}
void AdjustDown(HeapDataType* arr, int size, int parent)//向下调整函数
{
	int child = parent * 2 + 1;
	while (child < size)
	{
		if (child + 1 < size && arr[child] > arr[child + 1])
		{
			child++;
		}
		if (arr[parent] > arr[child])
		{
			Swap(&arr[parent], &arr[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
void HeapPop(Heap* ph)//堆的删除
{
	assert(ph);
	assert(!HeapEmpty(ph));
	Swap(&ph->arr[0], &ph->arr[ph->size - 1]);
	ph->size--;
	AdjustDown(ph->arr, ph->size, 0);//向下调整函数
}
HeapDataType HeapTop(Heap* ph)//返回堆顶元素
{
	assert(ph);
	assert(!HeapEmpty(ph));
	return ph->arr[0];
}
bool HeapEmpty(Heap* ph)//堆的判空
{
	assert(ph);
	return ph->size == 0;
}
int HeapSize(Heap* ph)//返回堆中元素个数
{
	assert(ph);
	return ph->size;
}
void HeapPrint(Heap* ph)//打印堆中数据
{
	assert(ph);
	assert(!HeapEmpty(ph));
	for (int i = 0; i < ph->size; i++)
	{
		printf("%d ", ph->arr[i]);
	}
	printf("\n");
}

void HeapSort(int* arr, int sz)
{
	int end1 = (sz - 1 - 1) / 2;//求最后一个节点的父节点，这个父节点即最后一个非叶子节点
	for (int i = end1; i >= 0; i--)
	{
		AdjustDown(arr, sz, i);
	}
	//开始排序
	//升序 -- 用大堆
	//降序 -- 用小堆
	int end2 = sz - 1;
	while (end2 > 0)
	{
		Swap(&arr[0], &arr[end2]);
		AdjustDown(arr, end2, 0);
		end2--;
	}
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}