C++实现python标准库中的Counter

看python standard library by exmple里面提到一个Counter容器，它像muliset一样，能够维持一个集合，并在常量时间插入元素、查询某个元素的个数，而且还提供了一个

most_common(n)方法，用于统计频数最大的n个元素，这在读取文本并统计词频的时候显得非常实用。

考虑C++实现的时候，查到一个叫做LFU的东西，https://en.wikipedia.org/wiki/Least_frequently_used，是关于磁盘缓存策略的，基本想法跟这个counter有类似的地方。

http://dhruvbird.com/lfu.pdf 这里有相关的实现。

#include<iostream>
#include<list>
#include<vector>
#include<unordered_map>
using namespace std;
//关键字节点
template<typename T>
struct keyNode{
	typedef T value_type;
	keyNode(){}
	keyNode(T v, keyNode* p, keyNode* n) :val(v), prev(p), next(n){}
	T val;
	keyNode* prev;
	keyNode* next;
};
//计数器节点
template<typename T>
struct countNode{
	countNode(){
		keyhead = new keyNode<T> ;
		keyhead->prev = keyhead->next = NULL;
	}
	~countNode(){
		while (keyhead->next != NULL){
			keyNode<T>* p = keyhead->next;
			keyhead->next = p->next;
			delete p;
		}
		delete keyhead;
	}
	countNode(int f, countNode* p, countNode *n):
		freq(f),prev(p),next(n){
		keyhead = new keyNode<T>;
		keyhead->prev = keyhead->next = NULL;
	}
	keyNode<T>* insertKey(const T& v){
		keyNode<T>* node = new keyNode<T>(v, keyhead, keyhead->next);
		if (keyhead->next != NULL)
			keyhead->next->prev = node;
		keyhead->next = node;
		return node;
	}
	int freq;
	keyNode<T>* keyhead;
	countNode* prev;
	countNode* next;
};

//计数器容器
/***支持如下操作：
	插入(insert) 时间复杂度O(1)
	查找(lookup) 时间复杂度O(1)
	查询最频繁的n个元素(most_common(n)) 时间复杂度o(n)
	删除操作 时间复杂度o(1)
**/
template<typename T>
class Counter{
public:
	Counter(){
		head = new countNode<T>(0, NULL, NULL);
		tail = NULL;
	}
	~Counter(){
		while (head->next != NULL){
			countNode<T>* p = head->next;
			head->next = p->next;
			delete p;
		}
		delete head;
	}
	//插入一个关键字，如果已经存在，频数加1
	void insert(const T& v){
		if (dict.find(v) == dict.end()){
			//关键字是新插入的
			if (head->next == NULL || head->next->freq != 1){
				//需要新建count节点
				countNode<T>* node = new  countNode<T>(1, head, head->next);
				if (head->next == NULL)
					tail = node;
				head->next = node;
				dict[v] = pair<countNode<T>*, keyNode<T>*>(node, node->insertKey(v));
			}
			else{
				dict[v] = 
					pair<countNode<T>*, keyNode<T>*>(head->next, head->next->insertKey(v));
			}
		}
		else{
			//关键字已经存在了	
			//频数必然会有增加，这时对结构的改动较大
			countNode<T>* countAddr = dict[v].first;
			countNode<T>* nextCount = countAddr->next; 
			keyNode<T>* keyAddr = dict[v].second;
			int freq = countAddr->freq;
			//首先从countAddr删除一个keyAddr节点
			keyAddr->prev->next = keyAddr->next;
			if (keyAddr->next != NULL)
				keyAddr->next->prev = keyAddr->prev;
			delete keyAddr;
			if (nextCount == NULL || nextCount->freq != freq + 1){
				//需要加一个countNode节点
				countNode<T>* node = new countNode<T>(freq + 1, countAddr, nextCount);
				if (nextCount != NULL)
					nextCount->prev = node;
				else
					tail = node;
				countAddr->next = node;
				dict[v] = 
					pair<countNode<T>*, keyNode<T>*>(node, node->insertKey(v));

			}
			else{
				dict[v] = 
					pair<countNode<T>*, keyNode<T>*>(nextCount, nextCount->insertKey(v));
			}
			//如果删除的keyNode节点是countNode中最后一个keyNode，就要把countAddr也删除了
			if (countAddr->keyhead->next == NULL){
				countAddr->prev->next = countAddr->next;
				if (countAddr->next != NULL)
					countAddr->next->prev = countAddr->prev;
				delete countAddr;
			}
		}
	}
	//返回关键字的频数
	int lookup(const T& v)const{
		return dict[v].first->freq;
	}
	/**返回频数最高的n个元素
	 返回形式为:(key,count)
	**/
	vector<pair<T, int>> most_common(int n){
		//链表的顺序是频数从低到高的，此时需要从尾节点逆向遍历n个元素
		vector<pair<T, int>> result;
		countNode<T>* countVisitor = tail;
		while (n > 0 && countVisitor != NULL){
			keyNode<T>* keyVisitor = countVisitor->keyhead->next;
			while (n > 0 && keyVisitor != NULL){
				result.emplace_back(keyVisitor->val, countVisitor->freq);
				n--;
				keyVisitor = keyVisitor->next;
			}
			countVisitor = countVisitor->prev;
		}
		return result;
	}
	vector<pair<T, int>> least_common(int n){
		vector<pair<T, int>> result;
		countNode<T>* countVisitor = head->next;
		while (n > 0 && countVisitor !=  NULL){
			keyNode<T>* keyVisitor = countVisitor->keyhead->next;
			while (n > 0 && keyVisitor != NULL){
				result.emplace_back(keyVisitor->val, countVisitor->freq);
				n--;
				keyVisitor = keyVisitor->next;
			}
			countVisitor = countVisitor->next;
		}
		return result;
	}
private:
	countNode<T>* head;
	countNode<T>* tail;
	unordered_map<T, pair<countNode<T>*, keyNode<T>*>> dict;
};
int main(){
	{
		Counter<char> wordCount;
		string s("jfoaedfrerlkmgvj9ejajiokl;fdaks");
		for (auto v : s){
			wordCount.insert(v);
		}
		auto result = wordCount.least_common(3);
	}
	return 0;
}