my priority_queue order is wrong

See more:

C++

STL

My program has a priority_queue that doesn't work correctly ! when I pop element from that priority_queue return element with out any order!

I write two class , first class is parent of second class.

first class:

//===========================================
class treeNode
{
public:
	treeNode();	//constructor
	treeNode(int );	//constructor
	virtual void display(void) const;	//show tree object in terminal
	friend bool operator <(const treeNode &, const treeNode &);
	friend bool operator >(const treeNode &, const treeNode &);

	int iterate;
	treeNode *left;
	treeNode *right;
};

treeNode::treeNode()
{
	iterate = 1;
	left = NULL;
	right = NULL;
}

treeNode::treeNode(int i)
{
	iterate = i;
	left = NULL;
	right = NULL;
}


bool operator <(const treeNode &a, const treeNode &b)
{
	if (a.iterate < b.iterate)
	{
		return true;
	}
	else
	{
		return false;
	}
}

bool operator >(const treeNode &a, const treeNode &b)
{
	if (a.iterate > b.iterate)
	{
		return true;
	}
	else
	{
		return false;
	}
}

void treeNode::display(void) const
{
	std::cout << iterate << endl;
}

second class:

//===========================================

class letter : public treeNode
{
public:
	letter();		//constructor
	letter(char);	//constructor
	letter(char, int);	//constructor
	friend bool operator <(const letter &, const letter &);
	friend bool operator >(const letter &, const letter &);
	void display(void) const;	//show letter object in terminal

	char character;
};

letter::letter() : treeNode()
{
}

letter::letter(char ch) : character(ch), treeNode(1)
{
}

letter::letter(char ch, int i) : character(ch), treeNode(i)
{
}

bool operator <(const letter &a, const letter &b)
{
	if (a.iterate < b.iterate)
	{
		return true;
	}
	else
	{
		return false;
	}
}

bool operator >(const letter &a, const letter &b)
{
	if (a.iterate > b.iterate)
	{
		return true;
	}
	else
	{
		return false;
	}
}


void letter::display(void) const
{
	if (character == '\n')
	{
		std::cout << setw(8) << "new line" << " , " << setw(6) << iterate << endl;
	}
	else
	{
		if (character == ' ')
		{
			std::cout << setw(8) << "space" << " , " << setw(6) << iterate << endl;
		}
		else
		{
			std::cout << setw(8) << character << " , " << setw(6) << iterate << endl;
		}
	}
}
//===========================================

I write below function for read a file to understand number of iteration of each character that exist in file , it work correctly and I use that in next function.

//===========================================
//read file and find number of iterate for each char
map< char, letter > countEachLetterInFile(string addOfFile)
{
	string str;
	letter *tempLetter;
	map < char, letter > letterMap;
	map < char, letter >::iterator mapIter;
	ifstream fp(addOfFile, ios::in);

	//check validatly of file and path of file
	if (!fp)
	{
		cerr << "something wrong while opening file!" << endl;
		exit(1);
	}
	
	//read file line by line
	while (getline(fp, str))
	{
		str += '\n';
		//move in string character by character
		for (int i = 0; i < str.size(); i++)
		{
			
			mapIter = letterMap.find(str.at(i));
			
			if (mapIter == letterMap.end())
			{
				tempLetter = new letter(str.at(i));
				letterMap[str.at(i)] = *tempLetter;
				delete[]tempLetter;
			}
			else
			{
				letterMap[str.at(i)].iterate++;
			}		
		}
	}

	mapIter = letterMap.find('\n');

	if (mapIter != letterMap.end())
	{
		letterMap['\n'].iterate--;
	}

	return letterMap;
}

problem occur in this function , in this function is a priority_queue of treeNode * .
I fill that with a map (output of previous function , values in map are correct and hasn't any problem) .

//===========================================
//make huffman tree and return <char , string> and save <string , char> in file
map < char, string > makeHuffmanTree(map< char, letter > mapOfLetter)
{
	treeNode *tempTreeNode;
	map < char, string > huffmanCode;
	map < char, letter >::iterator mapIter;
	
	priority_queue<treeNode *, vector<treeNode *>, greater<treeNode *> > letterPriorityQueue;
	
	for (mapIter = mapOfLetter.begin(); mapIter != mapOfLetter.end(); mapIter++)
	{
		letterPriorityQueue.push( new letter(mapIter->second.character, mapIter->second.iterate));	
	}
	
	//
	//wrong order !!
	//
	//
	std::cout << letterPriorityQueue.size() << endl;
    int size = letterPriorityQueue.size();
	for (int i = 0; i < size; i++)
	{
		letterPriorityQueue.top()->display();
		letterPriorityQueue.pop();
	}

	/*while (letterPriorityQueue.size() > 2)
	{

	}*/

	return huffmanCode;
}

values in map :

http://open-mind.ir/wp-content/uploads/2015/03/11.png[^]

when I read priority_queue :

http://open-mind.ir/wp-content/uploads/2015/03/2.png[^]