bool BinTreeNode::operator==(BinTreeNode x)
{
if(data != x.GetData())
return false;
else if(leftChild != x.GetLeftChild())
return false;
else if(rightChild != x.GetRightChild())
return false;
return true;
}
int main()
{
int caseNum; //??????
int originNum, nodeNum; //?????????,?????????
int buff; //??????
BinTreeNode *binBuff; //????
BinTreeNode binTree[MAX_NUM];
cin >> caseNum;
for(int i = 0; i < caseNum; i++)
{
BinTreeNode leftTemp; //?????
BinTreeNode rightTemp; //?????
priority_queue<BinTreeNode> binTreeQueue;
cin >> originNum;
nodeNum = 0;
for(int j = 0; j < originNum; j++)
{
cin >> buff;
binBuff = new BinTreeNode(buff);
binTreeQueue.push(*binBuff);
delete binBuff;
}
for(int j = 0; j < originNum - 1; j++)
{
leftTemp = binTreeQueue.top();
binTreeQueue.pop();
rightTemp = binTreeQueue.top();
binTreeQueue.pop();
binTree[nodeNum++] = leftTemp;
binTree[nodeNum++] = rightTemp; //??????????????????
binBuff = new BinTreeNode(leftTemp.GetData() + rightTemp.GetData(),
&(binTree[nodeNum - 2]), &(binTree[nodeNum - 1]));
binTreeQueue.push(*binBuff);
if(j == originNum - 2)
binTree[nodeNum++] = binTreeQueue.top();
delete binBuff;
}
qsort(binTree, nodeNum, sizeof(BinTreeNode), BinTreeNodeCompare);
BinTreeNode *root = &binTree[nodeNum - 1];
cout << WeighCalculate(root, 0) << endl;
}
return 0;
}
int main(){
BinTreeNode<int> *tree = new BinTreeNode<int>(0);
tree->insertChild(1);
tree->insertChild(2);
tree->getChilds(0)->insertChild(3);
tree->getChilds(0)->insertChild(4);
tree->getChilds(1)->insertChild(5);
tree->getChilds(1)->insertChild(6);
tree->preOrder_r();
std::cout<<std::endl;
tree->postOrder_r();
std::cout<<std::endl;
tree->midOrder_r();
}
BOOL CBinTree::RemoveNode(BinTreeNode* pSearchNode)
{
BinTreeNode* pNode = Find(pSearchNode);
if (!pNode)
return FALSE;
int iCount = mCount;
BinTreeNode* pParent = pNode->GetParent();
// Ok, so it has a parent, then we'll simply just disconnect it.
if (pParent)
{
if (pParent->GetLeftChild() == pNode)
{
pParent->SetLeftChild(NULL);
}
else
{
ASSERT(pParent->GetRightChild() == pNode);
pParent->SetRightChild(NULL);
}
}
else
{
// No parent? Then we're deleting the root node.
ASSERT(pNode == mRoot);
mRoot = NULL;
}
// Disconnected, now we reconnect its children (if any)
// just by adding them as we add any other node. Their
// respective children will come along, since Insert doesnt
// tamper with the inserted node's children.
if (pNode->GetLeftChild())
Insert(pNode->GetLeftChild());
if (pNode->GetRightChild())
Insert(pNode->GetRightChild());
mCount = iCount-1;
// Give the subclass a chance to do stuff to the removed node.
OnRemoveNode(pNode);
return TRUE;
}
bool operator<(BinTreeNode x, BinTreeNode y)
{
return x.GetData() > y.GetData();
}
bool BinTreeNode::operator<(BinTreeNode x)
{
return data > x.GetData(); //???????,?????????????
}
