贪心算法之哈弗曼树

参考网上代码，其中实现哈弗曼树的地方，使用了贪心准则。

template<typename Type>class BinaryTree;



template<typename Type>void Huffman(Type *,int,BinaryTree<Type> &);



template<typename Type>class BinTreeNode

{

public:

	friend class BinaryTree<Type>;

	friend void Huffman<Type>(Type *,int,BinaryTree<Type> &);

	BinTreeNode():m_pleft(NULL),m_pright(NULL){}

	BinTreeNode(Type item,BinTreeNode<Type> *left=NULL,BinTreeNode<Type> *right=NULL)

		:m_data(item),m_pleft(left),m_pright(right){}

	void Destroy(){		//destroy the tree with the root of the node

		if(this!=NULL)

		{

			this->m_pleft->Destroy();

			this->m_pright->Destroy();

			delete this;

		}

	}

	Type GetData()

	{

		return m_data;

	}

	BinTreeNode<Type> *Copy(const BinTreeNode<Type> *copy);	//copy the node

private:

	BinTreeNode<Type> *m_pleft,*m_pright;

	Type m_data;

};



template<typename Type>BinTreeNode<Type>* BinTreeNode<Type>::Copy(const BinTreeNode<Type> *copy)

{

	if(copy==NULL)

	{

		return NULL;

	}

	BinTreeNode<Type> *temp=new BinTreeNode<Type>(copy->m_data);

	temp->m_pleft=Copy(copy->m_pleft);

	temp->m_pright=Copy(copy->m_pright);

	return temp;

}

#include "BinTreeNode.h"



template<typename Type>void Huffman(Type *,int,BinaryTree<Type> &);



template<typename Type>class BinaryTree

{

public:

	BinaryTree(BinaryTree<Type> &bt1,BinaryTree<Type> &bt2)

	{

		m_proot=new BinTreeNode<Type>(bt1.m_proot->m_data+bt2.m_proot->m_data,bt1.m_proot,bt2.m_proot);

	}

	BinaryTree(Type item)

	{

		m_proot=new BinTreeNode<Type>(item);

	}

	BinaryTree(const BinaryTree<Type> &copy)

	{

		this->m_proot=copy.m_proot;

	}

	BinaryTree()

	{

		m_proot=NULL;

	}

	void Destroy()

	{

		m_proot->Destroy();

	}

	~BinaryTree()

	{

	}

	BinaryTree<Type>& operator=(BinaryTree<Type> copy);

	friend void Huffman<Type>(Type *,int,BinaryTree<Type> &);

	friend bool operator < <Type>(BinaryTree<Type> &l, BinaryTree<Type> & r);

    friend bool operator > <Type>(BinaryTree<Type> &l, BinaryTree<Type> & r);

    friend bool operator <= <Type>(BinaryTree<Type> &l, BinaryTree<Type> & r);

    friend ostream& operator<< <Type>(ostream& ,BinaryTree<Type>&);	//output the data



private:

	BinTreeNode<Type> *m_proot;

	void Print(BinTreeNode<Type> *start,int n=0);	//print the tree with the root of start

};

template<typename Type> bool operator <(BinaryTree<Type> &l, BinaryTree<Type> &r){

    return l.m_proot->GetData() < r.m_proot->GetData();

}



template<typename Type> bool operator >(BinaryTree<Type> &l, BinaryTree<Type> &r){

    return l.m_proot->GetData() > r.m_proot->GetData();

}



template<typename Type> bool operator <=(BinaryTree<Type> &l, BinaryTree<Type> &r){

    return l.m_proot->GetData() <= r.m_proot->GetData();

}





template<typename Type> void BinaryTree<Type>::Print(BinTreeNode<Type> *start, int n){

	if(start==NULL){

		for(int i=0;i<n;i++){

			cout<<"     ";

		}

		cout<<"NULL"<<endl;

		return;

	}

	Print(start->m_pright,n+1);	//print the right subtree

	for(int i=0;i<n;i++){	//print blanks with the height of the node

		cout<<"     ";

	}

	if(n>=0){

		cout<<start->m_data<<"--->"<<endl;//print the node

	}

	Print(start->m_pleft,n+1);	//print the left subtree

}



template<typename Type> ostream& operator<<(ostream& os,BinaryTree<Type>& out){

	out.Print(out.m_proot);

	return os;

}



template<typename Type> BinaryTree<Type>& BinaryTree<Type>::operator=(BinaryTree<Type> copy){

	m_proot=m_proot->Copy(copy.m_proot);

    return *this;

}

#include "BinaryTree.h"

#include "MinHeap.h"



template<typename Type> void Huffman(Type *elements, int n, BinaryTree<Type> &tree){

    BinaryTree<Type> first, second;

    BinaryTree<Type> node[20];

    for (int i=0; i<n; i++){

        node[i].m_proot = new BinTreeNode<Type>(elements[i]);

    }

    MinHeap<BinaryTree<Type> > heap(node, n);



    for (int i=0; i<n-1; i++){

        heap.DeleteMin(first);

        heap.DeleteMin(second);

        

        //using the first and the second minimize element create new tree

        if (first.m_proot->GetData() == second.m_proot->GetData()){

            tree = *(new BinaryTree<Type>(second, first));

        }

        else {

            tree = *(new BinaryTree<Type>(first, second));

        }



        heap.Insert(tree);

    }

}

测试结果图：