c++实现堆排序 及二叉树操作

#include <iostream>
using namespace std;

#if 0

void HeapAdjust(int* array, int size, int parent)
{
	int child = parent * 2 + 1;
	while (child < size)
	{
		// 找左右孩子中较大的孩子
		if (child+1 < size && array[child+1] > array[child])
		{
			child += 1;
		}

		if (array[parent] < array[child])
		{
			swap(array[parent], array[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
			return;
	}
}
// 堆排序
void HeapSort(int* array, int size)
{
	// 1. 创建堆---向下调整
	//    升序---->大堆   降序---小堆

	// 找倒数第一个非叶子节点
	int root = ((size - 2) >> 1);
	for (; root >= 0; --root)
		HeapAdjust(array, size, root);

	// 2. 堆删除的思想---向下调整
	int end = size - 1;
	while (end)
	{
		swap(array[0], array[end]);
		HeapAdjust(array, end, 0);
		--end;
	}
}

int main()
{
	int array[] = {3,4,1,9,0,6,8,5,2,7};
	HeapSort(array, sizeof(array) / sizeof(array[0]));
	return 0;
}
#endif

#if 0
template<class T, class Compare>
void HeapAdjust(T* array, int size, int parent, Compare com)
{
	int child = parent * 2 + 1;
	while (child < size)
	{
		// 找左右孩子中较大的孩子
		if (child + 1 < size && com(array[child + 1], array[child]))
		{
			child += 1;
		}

		if (com(array[child], array[parent]))
		{
			swap(array[parent], array[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
			return;
	}
}


// 堆排序
template<class T, class Compare>
void HeapSort(T* array, int size, Compare com)
{
	// 1. 创建堆---向下调整
	//    升序---->大堆   降序---小堆

	// 找倒数第一个非叶子节点
	int root = ((size - 2) >> 1);
	for (; root >= 0; --root)
		HeapAdjust(array, size, root, com);

	// 2. 堆删除的思想---向下调整
	int end = size - 1;
	while (end)
	{
		swap(array[0], array[end]);
		HeapAdjust(array, end, 0, com);
		--end;
	}
}

#include <functional>

int main()
{
	int array[] = { 3, 4, 1, 9, 0, 6, 8, 5, 2, 7 };
	HeapSort(array, sizeof(array) / sizeof(array[0]), less<int>());
	//sort(array, array + sizeof(array) / sizeof(array[0]), greater<int>())
	return 0;
}
#endif

#include <vector>

// 孩子表示法
struct BTNode
{
	BTNode(int data)
	: _pLeft(nullptr)
	, _pRight(nullptr)
	, _data(data)
	{}

	BTNode* _pLeft;
	BTNode* _pRight;
	int _data;
};

// A B D C E F
BTNode* CreateBinTree(const vector<int>& v, int& index, const int invalid)
{
	BTNode* pRoot = nullptr;
	if (index < v.size() && invalid != v[index])
	{
		// 创建根节点pRoot
		pRoot = new BTNode(v[index]);

		// 创建pRoot的左子树
		pRoot->_pLeft = CreateBinTree(v, ++index, invalid);

		// 创建pRoot的右子树
		pRoot->_pRight = CreateBinTree(v, ++index, invalid);
	}

	return pRoot;
}

void Destroy(BTNode*& pRoot)
{
	if (pRoot)
	{
		Destroy(pRoot->_pLeft);
		Destroy(pRoot->_pRight);
		delete pRoot;
		pRoot = nullptr;
	}
}

// 遍历：对二叉树中的每个节点进行某种操作，并且每个节点只操作一次
// 前序、中序、后序
// 操作：将节点中的值域打印
void PreOrder(BTNode* pRoot)
{
	if (pRoot)
	{
		cout << pRoot->_data << " ";
		PreOrder(pRoot->_pLeft);
		PreOrder(pRoot->_pRight);
	}
}

#include <stack>
void PreOrderNor(BTNode* pRoot)
{
	if (nullptr == pRoot)
		return;

	stack<BTNode*> s;
	s.push(pRoot);

	while (!s.empty())
	{
		BTNode* pCur = s.top();
		s.pop();
		cout << pCur->_data << " ";

		if (pCur->_pRight)
			s.push(pCur->_pRight);

		if (pCur->_pLeft)
			s.push(pCur->_pLeft);
	}
}

void InOrder(BTNode* pRoot)
{
	if (pRoot)
	{
		InOrder(pRoot->_pLeft);
		cout << pRoot->_data << " ";
		InOrder(pRoot->_pRight);
	}
}

void InOrderNor(BTNode* pRoot)
{
	if (nullptr == pRoot)
		return;

	stack<BTNode*> s;
	BTNode* pCur = pRoot;

	while (!s.empty() || pCur)
	{
		// 找以pRoot为根的二叉树最左侧的节点，并保存其所经路径中所有节点
		while (pCur)
		{
			s.push(pCur);
			pCur = pCur->_pLeft;
		}

		pCur = s.top();
		cout << pCur->_data << " ";
		s.pop();
		pCur = pCur->_pRight;
	}
}

void PostOrder(BTNode* pRoot)
{
	if (pRoot)
	{
		PostOrder(pRoot->_pLeft);
		PostOrder(pRoot->_pRight);
		cout << pRoot->_data << " ";
	}
}

void PostOrderNor(BTNode* pRoot)
{
	if (nullptr == pRoot)
		return;

	stack<BTNode*> s;
	BTNode* pCur = pRoot;
	BTNode* pPrev = nullptr;

	while (!s.empty() || pCur)
	{
		// 找以pRoot为根的二叉树最左侧的节点，并保存其所经路径中所有节点
		while (pCur)
		{
			s.push(pCur);
			pCur = pCur->_pLeft;
		}

		BTNode* pTop = s.top();
		// pTop右子树不存在
		// pTop右子树已经遍历
		if (nullptr == pTop->_pRight ||
			pTop->_pRight == pPrev)
		{
			cout << pTop->_data << " ";
			pPrev = pTop;
			s.pop();
		}
		else
		{
			pCur = pTop->_pRight;
		}
	}
}

#include <queue>
void LevelOrder(BTNode* pRoot)
{
	if (nullptr == pRoot)
		return;

	queue<BTNode*> q;
	q.push(pRoot);

	while (!q.empty())
	{
		BTNode* pCur = q.front();
		cout << pCur->_data << " ";

		if (pCur->_pLeft)
			q.push(pCur->_pLeft);

		if (pCur->_pRight)
			q.push(pCur->_pRight);

		q.pop();
	}
}

size_t Height(BTNode* pRoot)
{
	if (nullptr == pRoot)
		return 0;

	size_t leftHeight = Height(pRoot->_pLeft);
	size_t rightHeight = Height(pRoot->_pRight);

	return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}

size_t GetBTreeNode(BTNode* pRoot)
{
	if (nullptr == pRoot)
		return 0;

	return GetBTreeNode(pRoot->_pLeft) + 
		   GetBTreeNode(pRoot->_pRight) + 1;
}

size_t GetLeafNode(BTNode* pRoot)
{
	if (nullptr == pRoot)
		return 0;

	if (nullptr == pRoot->_pLeft && nullptr == pRoot->_pRight)
	{
		return 1;
	}

	return GetLeafNode(pRoot->_pLeft) + GetLeafNode(pRoot->_pRight);
}

size_t GetKLevelNodeCount(BTNode* pRoot, size_t K)
{
	if (nullptr == pRoot || 0 == K)
		return 0;

	if (1 == K)
		return 1;

	return GetKLevelNodeCount(pRoot->_pLeft, K - 1) +
		   GetKLevelNodeCount(pRoot->_pRight, K - 1);
}

BTNode* GetParent(BTNode* pRoot, BTNode* pNode)
{
	if (nullptr == pRoot || pRoot == pNode)
		return nullptr;

	if (pRoot->_pLeft == pNode || pRoot->_pRight == pNode)
		return pRoot;

	BTNode* pParent = GetParent(pRoot->_pLeft, pNode);
	if (pParent)
		return pParent;

	return GetParent(pRoot->_pRight, pNode);
}

// 前序 中序
BTNode* _ReBuildTree(const vector<int>& pre, int& index, const vector<int>& In, int left, int right)
{
	if (left >= right)
		return nullptr;

	// 1. 从前序遍历结果中获取根节点
	BTNode* pRoot = new BTNode(pre[index]);

	// 2. 从中序遍历结果确认根的左右子树
	size_t InIdx = left;
	while (In[InIdx] != pre[index])
		InIdx++;

	// [left, InIdx)
	// [InIdx+1, right)

	if (left < InIdx)
		pRoot->_pLeft = _ReBuildTree(pre, ++index, In, left, InIdx);

	if (index+1 < right)
		pRoot->_pRight = _ReBuildTree(pre, ++index, In, InIdx + 1, right);

	return pRoot;
}

BTNode* ReBuildTree(const vector<int>& pre, const vector<int>& In)
{
	int index = 0;
	return _ReBuildTree(pre, index, In, 0, In.size());
}

int main()
{
	vector<int> v{ 1, 2, 3, -1,-1,-1,4, 5, -1,-1,6 };
	int index = 0;
	BTNode* pRoot = CreateBinTree(v, index, -1);
	PreOrder(pRoot);
	PreOrderNor(pRoot);
	cout << endl;

	InOrder(pRoot);
	InOrderNor(pRoot);
	cout << endl;

	PostOrder(pRoot);
	PostOrderNor(pRoot);
	Destroy(pRoot);

	vector<int> Pre{ 1, 2, 3, 4, 5, 6 };
	vector<int> In{3,2,1,5,4,6};
	BTNode* pNewRoot = ReBuildTree(Pre, In);
	return 0;
}