class TreeNode
{//Constructors-Destructors
public:TreeNode();TreeNode(string);~TreeNode();//Member variables
private:string nodeName;int supportCount;TreeNode *parentNode;vector<TreeNode *> childNodeList;TreeNode *nextHomonymNode;//Member functions
public:string getName();void setName(string);int getSupportCount() const;void setSupportCount(int);TreeNode* getParentNode() const;void setParentNode(TreeNode*);vector<TreeNode*> getChildNodeList() const;void addChild(TreeNode*);TreeNode* findChildNode(string) const;void setChildren(vector<TreeNode*>);void printChildrenNames() const;TreeNode* getNextHomonym() const;void setNextHomonym(TreeNode *nextHomonym);void countIncrement(int);
};

//HeaderTable存储事务数据库的数据
vector<TreeNode*> FPTree::buildHeaderTable(vector<vector<string>> transRecords)
{vector<TreeNode*> F1; //存储满足支持度阈值的节点，并按照支持度降序排列，支持度相等的情况下按照字母顺序排序，所以构建的FP-tree与论文有所不同，但是最终生成的频繁项集是一样的if (transRecords.size() > 0){map<string, TreeNode*> mp;//calculate supportCount of every transRecordsfor (vector<string> record : transRecords){for (string item : record){//if item not in map, put item into map and set supportCount oneif (mp.find(item) == mp.end()){TreeNode *node = new TreeNode(item);node->setSupportCount(1);mp.insert(map<string, TreeNode*>::value_type(item, node));}//if item in map, supportCount plus one else{mp.find(item)->second->countIncrement(1);}}}//put TreeNodes whose supportCount greater than minSupportThreshold into vector F1for (auto iterator = mp.begin(); iterator != mp.end(); iterator++){if (iterator->second->getSupportCount() >= minSupportThreshold){//cout << "iterator->second = " << iterator->second->getSupportCount() << endl;F1.push_back(iterator->second);}}//sort vector F1 by supportCount
        sort(F1.begin(), F1.end(), sortBySupportCount);}return F1;
}

TreeNode* FPTree::buildTree(vector<vector<string>> transRecords, vector<TreeNode*> F1)
{TreeNode *root = new TreeNode(); //根节点rootfor (vector<string> transRecord : transRecords){//拷贝transRecord到record    vector<string> record;for (auto iter = transRecord.begin(); iter != transRecord.end(); iter++){record.push_back(*iter);}record = sortedByF1(record, F1); //根据F1中存储的频繁项集，将record按照支持度降序排列，并且仅保留频繁项集，剔除那些低于支持度阈值的项

//顺序比较record中的节点和FP-tree中的节点，如果record中的节点已经存在于FP-tree中，将该节点的支持度加一，继续比较下一个节点，否则调用addNodes来添加剩余节点到FP-tree中TreeNode *subTreeRoot = root;TreeNode *tmpRoot = nullptr;if (!root->getChildNodeList().empty()){while (!record.empty() && (tmpRoot = subTreeRoot->findChildNode(*(record.begin()))) != nullptr){tmpRoot->countIncrement(1);subTreeRoot = tmpRoot;record.erase(record.begin());}}addNodes(subTreeRoot, &record, F1);}return root; 
}

void FPTree::addNodes(TreeNode *ancestor, vector<string> *record, vector<TreeNode*> F1) 
{if (!record->empty()){while (!record->empty()){string item = *(record->begin());record->erase(record->begin());TreeNode *leafNode = new TreeNode(item);leafNode->setSupportCount(1);leafNode->setParentNode(ancestor);ancestor->addChild(leafNode);for (TreeNode *f1 : F1){if (f1->getName() == item){ while (f1->getNextHomonym() != NULL){f1 = f1->getNextHomonym();}f1->setNextHomonym(leafNode);break;}}addNodes(leafNode, record, F1);}}
}

vector<string> FPTree::sortedByF1(vector<string> transRecord, vector<TreeNode*> F1)
{//如果item是频繁项，则一定对应于F1中的序号，按照该序号对item进行排序，存储到rest中map<string, int> mp;for (string item : transRecord){for (int i = 0; i < F1.size(); i++){TreeNode *tNode = F1[i];if (tNode->getName() == item){mp.insert(map<string, int>::value_type(item, i));}}}vector<pair<string, int>> vec;for (auto iterator = mp.begin(); iterator != mp.end(); iterator++){vec.push_back(make_pair(iterator->first, iterator->second));}sort(vec.begin(), vec.end(), sortByF1);vector<string> rest;for (auto iterator = vec.begin(); iterator != vec.end(); iterator++){rest.push_back((*iterator).first);}return rest;
}

//postPattern存储后缀，比如从HeaderTable中的p节点开始挖掘频繁项时，postPattern为p
void FPTree::FPGrowth(vector<vector<string>> transRecords, vector<string> postPattern)
{vector<TreeNode*> headerTable = buildHeaderTable(transRecords); //构建headerTableTreeNode *treeRoot = buildTree(transRecords, headerTable); //构建FP-tree//递归退出条件：根节点没有孩子节点if (treeRoot->getChildNodeList().size() == 0) {return;}
//输出频繁项集if (!postPattern.empty()){for (TreeNode *header : headerTable){cout << header->getSupportCount() << ends << header->getName() << ends;for (string str : postPattern){cout << str << ends;}cout << endl;}}//遍历headerTable
    for (TreeNode *header : headerTable){vector<string> newPostPattern;newPostPattern.push_back(header->getName());//存储原先的后缀
        if (!postPattern.empty()) {for (string str : postPattern){newPostPattern.push_back(str);}}
//newTransRecords存储前缀节点链
        vector<vector<string>> newTransRecords;TreeNode *backNode = header->getNextHomonym();//通过getNextHomonym遍历同名节点，通过getParentNode获取前缀节点链
        while (backNode != nullptr){int supportCount = backNode->getSupportCount();vector<string> preNodes;TreeNode *parent = backNode; 
while ((parent = parent->getParentNode())->getName().length() != 0){preNodes.push_back(parent->getName());}            while (supportCount-- > 0){newTransRecords.push_back(preNodes);}backNode = backNode->getNextHomonym();
       }FPGrowth(newTransRecords, newPostPattern); //递归构建条件FP-tree
    }
}