自适应哈夫曼编码C++

C++实现自适应（动态）哈夫曼编码，读入txt文本编码并将结果输出到指定txt文本中

#include “adaptiveHuffman.h“
int AdaptiveHuffman::sum = 1;


BinaryTree::BinaryTree（int numint weight）{
    p_root = new Node（nullptrnullptrnullptr）;
    p_root->num = num;
    p_root->weight = weight;
}

BinaryTree::~BinaryTree（）
{
    deleteNode（p_root）;
}

bool BinaryTree::swap（Node * p_nodeA Node * p_nodeB）
{
    if（p_nodeA==nullptr||p_nodeB==nullptr||p_nodeA==p_nodeB）
        return false;
    Node *pTemp;
    if （getBrotherState（p_nodeA）==LeftChild） {
        if （getBrotherState（p_nodeB）==LeftChild） {
            pTemp = p_nodeA->parent->leftChild;
            p_nodeA->parent->leftChild = p_nodeB->parent->leftChild;
            p_nodeB->parent->leftChild = pTemp;
        }
        else {
            pTemp = p_nodeA->parent->leftChild;
            p_nodeA->parent->leftChild = p_nodeB->parent->rightChild;
            p_nodeB->parent->rightChild = pTemp;
        }
    }
    else {
        if （getBrotherState（p_nodeB）==LeftChild） {
            pTemp = p_nodeA->parent->rightChild;
            p_nodeA->parent->rightChild = p_nodeB->parent->leftChild;
            p_nodeB->parent->leftChild = pTemp;
        }
        else {
            pTemp = p_nodeA->parent->rightChild;
            p_nodeA->parent->rightChild = p_nodeB->parent->rightChild;
            p_nodeB->parent->rightChild = pTemp;

        }
    }
    pTemp = p_nodeA->parent;
    p_nodeA->parent = p_nodeB->parent;
    p_nodeB->parent = pTemp;
    return true;

}

bool BinaryTree::addNode（Node * parent Node * p_child Brother brotherState）
{
    if（parent==nullptr||p_child==nullptr）
        return false;
    if （brotherState == LeftChild） {
        if （parent->leftChild != nullptr） {
            std::cout << “error:left child exist!“ << std::endl;
            return false;
        }
        parent->leftChild = p_child;
    }
    else if （brotherState == RightChild） {
        if （parent->rightChild != nullptr） {
            std::cout << “error:right child exist!“ << std::endl;
            return false;
        }
        parent->rightChild = p_child;
    }
    else {
        std::cout << “error:brotherState is wrong!“ << std::endl;
        return false;
    }
    p_child->parent = parent;
    return true;
}

Node * BinaryTree::findNode（Node *p）
{
    Node *p_node = p_root;
    std::queue queue;
    queue.push（p_node）;
    while （!queue.empty（）） {
        p_node = queue.front（）;
        if （p_node == p） {
            return p_node;
        }
        queue.pop（）;
        if （p_node->leftChild != nullptr） {
            queue.push（p_node->leftChild）;
        }
        if （p_node->rightChild != nullptr） {
            queue.push（p_node->rightChild）;
        }
    }
    return nullptr;
}

bool BinaryTree::setNodeNum（Node* p_node int num）
{
    if（p_node==nullptr）
        return false;
    else {
        p_node->num = num;
        return true;
    }
}

bool BinaryTree::isAncestor（Node * p_nodeChild Node * p_nodeAncestor）
{
    while （p_nodeChild != p_root） {
        if （p_nodeChild == 

 属性            大小     日期    时间   名称
----------- ---------  ---------- -----  ----
     文件        7599  2018-12-20 15:18  adaptiveHuffman.cpp
     文件        1449  2018-12-20 15:13  adaptiveHuffman.h