左高树实现最大堆

---

MaxHblt.h

#pragma once
#ifndef MAXHBLT_H
#define MAXHBLT_H
#include"BinaryTreeNode.h"
template<typename Object>
class MaxHblt
{
public:
	MaxHblt();
	MaxHblt(BinaryTreeNode<Object> *root);
	~MaxHblt();
	bool empty() const;
	int size() const;
	int height() const;
	void preOrder() const;
	void inOrder() const;
	void postOrder() const;
	Object top() const;
	Object pop();
	MaxHblt<Object>* push(Object data);
	void initialize(Object *element, int size);
private:
	MaxHblt<Object>* combine(MaxHblt<Object> *Hblt1, MaxHblt<Object> *Hblt2);
	int HbltSize;
	BinaryTreeNode<Object> *Root;

};
#endif;

---

MaxHblt.cpp

#include "MaxHblt.h"
#include<iostream>

using std::cout;
using std::endl;



template<typename Object>
MaxHblt<Object>::MaxHblt()
{
	HbltSize = 0;
}


template<typename Object>
MaxHblt<Object>::MaxHblt(BinaryTreeNode<Object> *root)
{
	HbltSize = root->size();
	Root = root;
}


template<typename Object>
MaxHblt<Object>::~MaxHblt()
{
	delete Root;
}

//判断是否为空
template<typename Object>
bool MaxHblt<Object>::empty() const {
	return HbltSize == 0;
}

//返回元素个数
template<typename Object>
int MaxHblt<Object>::size() const {
	return HbltSize;
}

//返回左高树的高度
template<typename Object>
int MaxHblt<Object>::height() const {
	return Root->height();
}


template<typename Object>
void MaxHblt<Object>::preOrder() const {
	Root->preOrder();
}


template<typename Object>
void MaxHblt<Object>::inOrder() const {
	Root->inOrder();
}


template<typename Object>
void MaxHblt<Object>::postOrder() const {
	Root->postOrder();
}

//返回最大元素
template<typename Object>
Object MaxHblt<Object>::top() const {
	return Root->data();
}

//弹出最大元素
template<typename Object>
Object MaxHblt<Object>::pop() {
	if (empty()) {
		cout << "warning in pop：hblt is empty" << endl;
		return NULL;
	}
	Object _output_ = Root->data();
	Root = combine(
		new MaxHblt<Object>(
			Root->leftChild()
			),
		new MaxHblt<Object>(
			Root->rightChild()
			)
	)->Root;
	HbltSize--;
	return _output_;
}

//添加元素
template<typename Object>
MaxHblt<Object>* MaxHblt<Object>::push(Object data) {
	Root = combine(
		this,
		new MaxHblt<Object>(
			new BinaryTreeNode<Object>(data)
			)
	)->Root;
	HbltSize++;
	return this;
}

//使用数组初始化左高树
template<typename Object>
void MaxHblt<Object>::initialize(Object *element, int size) {
	return;
}

//合并两棵左高树
template<typename Object>
MaxHblt<Object>* MaxHblt<Object>::combine(MaxHblt<Object> *Hblt1, MaxHblt<Object> *Hblt2) {
	if (Hblt1->size() == 0) {
		return Hblt2;
	}
	else if (Hblt2->size() == 0) {
		return Hblt1;
	}
	else {
		BinaryTreeNode<Object> *_root1_ = Hblt1->Root;
		BinaryTreeNode<Object> *_root2_ = Hblt2->Root;
		MaxHblt<Object> *_temp_;
		BinaryTreeNode<Object> *__temp__;
		if (_root1_->data() > _root2_->data()) {
			__temp__ = new BinaryTreeNode<Object>(
				_root1_->data(),
				_root1_->leftChild(),
				combine(new MaxHblt<Object>(_root1_->rightChild()), Hblt2)->Root
				);
		}
		else {
			__temp__ = new BinaryTreeNode<Object>(
				_root2_->data(),
				_root2_->leftChild(),
				combine(new MaxHblt<Object>(_root2_->rightChild()), Hblt1)->Root
				);
		}
		if (__temp__->rightChild()->height() > __temp__->leftChild()->height()) {
			_temp_ = new MaxHblt<Object>(
				new BinaryTreeNode<Object>(
					__temp__->data(),
					__temp__->rightChild(),
					__temp__->leftChild()
					)
				);
		}
		else {
			_temp_ = new MaxHblt<Object>(__temp__);
		}
		return _temp_;
	}
}

//显式实例化
template class MaxHblt<int>;

---

BinaryTreeNode.h

#pragma once
#ifndef BINARYTREENODE_H
#define BINARYTREENODE_H
template<typename Object>
class BinaryTreeNode {
public:
	BinaryTreeNode(const Object& e) {
		this->Element = e;
		this->LeftChild = nullptr;
		this->RightChild = nullptr;
	}
	BinaryTreeNode(const Object& e, BinaryTreeNode<Object>* l, BinaryTreeNode<Object>* r) {
		this->Element = e;
		this->LeftChild = l;
		this->RightChild = r;
	}
	Object data() {
		return Element;
	}
	BinaryTreeNode<Object>* leftChild() {
		return LeftChild;
	}
	BinaryTreeNode<Object>* rightChild() {
		return RightChild;
	}
	int size() {
		if (!this) {
			return 0;
		}
		return LeftChild->size() + RightChild->size() + 1;
	}
	int height() {
		if (!this) {
			return 0;
		}
		int l = LeftChild->height();
		int r = RightChild->height();
		return (l > r ? l : r) + 1;
	}
	void visit() {
		cout << Element << " ";
		//cout << endl;
	}
	void preOrder() {
		visit();
		if (LeftChild) {
			LeftChild->preOrder();
		}
		if (RightChild) {
			RightChild->preOrder();
		}
	}
	void inOrder() {
		if (LeftChild) {
			LeftChild->inOrder();
		}
		visit();
		if (RightChild) {
			RightChild->inOrder();
		}
	}
	void postOrder() {
		if (LeftChild) {
			LeftChild->postOrder();
		}
		if (RightChild) {
			RightChild->postOrder();
		}
		visit();
	}
private:
	Object Element;
	BinaryTreeNode<Object>* LeftChild;
	BinaryTreeNode<Object>* RightChild;
};
#endif