TopK代码

Hash表

#ifndef _HASH_H
#define _HASH_H

#include<string.h>
#include<stdio.h>
class HashTable
{
public:
    HashTable(unsigned int size);
    ~HashTable();
    int get(const char *key,unsigned int *value);
    int set(const char *key,unsigned int value);
    int push(const char *key);
    int MAXTopK(unsigned int k);
    int MINTopK(unsigned int k);
private:
    struct Node
    {
        char *key;
        unsigned int value;
        Node *next;

        Node(const char *str,unsigned int v)
        {
            key = new char[strlen(str)+];
            strcpy(key,str);
            value = v;
            next = NULL;
        }
        ~Node()
        {
            delete[] key;
        }
    };
    int Init();
    int Destroy();
    int Hash(const char *key,unsigned int *hashcode);
    int ClearChain(Node *Head);

    Node **TableHead;
    unsigned int TableSize;
    char **kWords;
};
#endif

#include"Hash.h"
#include"Heap.h"

HashTable::HashTable(unsigned int size)
{
    TableHead = NULL;
    TableSize = size;
    Init();
}
HashTable::~HashTable()
{
    Destroy();
}

int HashTable::Init()
{
    if(TableHead != NULL)
    {
        printf("HashTable has been initialized\n");
        return -;
    }
    TableHead = new Node*[TableSize];
    for(unsigned int i=;i<TableSize;i++)
    {
        TableHead[i]=NULL;
    }
    return ;
}

int HashTable::Destroy()
{
    for(unsigned int i=;i<TableSize;i++)
    {
        if(ClearChain(TableHead[i]) < )
        {
            printf("ClearChain error\n");
            return -;
        }
    }
    delete[] TableHead;
    TableHead = NULL;
    return ;
}

int HashTable::get(const char *key,unsigned int *value)
{
    unsigned int hashcode=;
    if(Hash(key,&hashcode) < )
    {
        printf("generate hashcode error");
        return -;
    }
    unsigned int index = hashcode%TableSize;
    Node *p = TableHead[index];
    while(p!=NULL && (strcmp(key,p->key)!=))
    {
        p=p->next;
    }
    if(p!=NULL)
    {
        *value = p->value;
    }
    else
    {
        *value = ;
    }
    return ;
}

int HashTable::set(const char *key,unsigned int value)
{
    unsigned int hashcode=;
    if(Hash(key,&hashcode) < )
    {
        printf("generate hashcode error");
        return -;
    }
    unsigned int index = hashcode%TableSize;
    Node *p = TableHead[index];
    while(p!=NULL && (strcmp(key,p->key)!=))
    {
        p=p->next;
    }
    if(p!=NULL)
    {
        p->value = value;
    }
    else
    {
        Node *q = TableHead[index];
        TableHead[index] = new Node(key,value);
        TableHead[index]->next = q;
    }
    return ;
}

int HashTable::push(const char *key)
{
    unsigned int hashcode=;
    if(Hash(key,&hashcode) < )
    {
        printf("generate hashcode error");
        return -;
    }
    unsigned int index = hashcode%TableSize;
    Node *p = TableHead[index];
    while(p!=NULL && (strcmp(key,p->key)!=))
    {
        p=p->next;
    }
    if(p!=NULL)
    {
        p->value = p->value+;
    }
    else
    {
        Node *q = TableHead[index];
        TableHead[index] = new Node(key,);
        TableHead[index]->next = q;
    }
    return ;
}

int HashTable::Hash(const char *str,unsigned int *hashcode)
{
    *hashcode = ;
    unsigned int hashseed = ;
    while(*str != '\0')
    {
        *hashcode += *hashcode*hashseed + *str;
        str++;
    }
    (*hashcode) & 0x7FFFFFFF;
    return ;
}

int HashTable::ClearChain(Node *Head)
{
    Node *p=Head;
    Node *q;
    while(p != NULL)
    {
        q=p->next;
        delete p;
        p=q;
    }
    Head = NULL;
    return ;
}

int HashTable::MAXTopK(unsigned int k)
{
    Pair *heap = new Pair[k];
    for(unsigned int i=;i<TableSize;i++)
    {
        Node *p=TableHead[i];
        while(p!=NULL)
        {
            if(p->value > heap[].cnt)
            {
                heap[]=Pair(p->key,p->value);
                minHeapIFY(,heap,k);
            }
            p=p->next;
        }
    }
    printf("MAX TopK:\n");
    for(unsigned int j=;j<k;j++)
    {
        printf("%s:%d\n",heap[j].word,heap[j].cnt);
    }
    delete[] heap;
    return ;
}

int HashTable::MINTopK(unsigned int k)
{
    Pair *heap = new Pair[k];
    int s=k;
    for(unsigned int i=;i<TableSize;i++)
    {
        Node *p=TableHead[i];
        while(p!=NULL)
        {
            if(s>)
            {
                s--;
                heap[s]=Pair(p->key,p->value);
            }
            if(s == )
            {
                s--;
                buildMaxHeap(heap,k);
            }
            else
            {
                if(p->value < heap[].cnt)
                {
                    heap[]=Pair(p->key,p->value);
                    maxHeapIFY(,heap,k);
                }
            }
            p=p->next;
        }
    }
    printf("MIN TopK:\n");
    for(unsigned int j=;j<k;j++)
    {
        printf("%s:%d\n",heap[j].word,heap[j].cnt);
    }
    delete[] heap;
    return ;
}

堆

#ifndef _HEAP_H
#define _HEAP_H
#include<string.h>
struct Pair
{
    char *word;
    unsigned int cnt;
    Pair()
    {
        word = NULL;
        cnt = ;
    }
    Pair(const char *str,unsigned int num)
    {
        word = new char[strlen(str)+];
        strcpy(word,str);
        cnt = num;
    }
    ~Pair()
    {
        delete[] word;
        word=NULL;
    }
    const Pair& operator=(const Pair& p)
    {
        delete[] word;
        if(p.word != NULL)
        {
            word = new char[strlen(p.word)+];
            strcpy(word,p.word);
        }
        else
        {
            word = NULL;
        }
        cnt = p.cnt;
        return *this;
    }
};

unsigned int Parent(unsigned int i);
unsigned int Left(unsigned int i);
unsigned int Right(unsigned int i);

void maxHeapIFY(unsigned int i,Pair *p,unsigned int len);
void minHeapIFY(unsigned int i,Pair *p,unsigned int len);

void buildMaxHeap(Pair *p,unsigned int len);
void bulidMinHeap(Pair *p,unsigned int len);

#endif

#include"Heap.h"

unsigned int Parent(unsigned int i)
{
    return (i-)>>;
}

unsigned int Left(unsigned int i)
{
    return (i<<)+;
}

unsigned int Right(unsigned int i)
{
    return (i<<)+;
}

void maxHeapIFY(unsigned int i,Pair *p,unsigned int len)
{
    if(i>=len)
    {
        return;
    }
    unsigned int largest = i;
    unsigned int leftidx = Left(i);
    if(leftidx<len && p[i].cnt<p[leftidx].cnt)
    {
        largest = leftidx;
    }
    unsigned int rightidx = Right(i);
    if(rightidx<len && p[largest].cnt<p[rightidx].cnt)
    {
        largest = rightidx;
    }
    if(largest != i)
    {
        Pair temp(p[i].word,p[i].cnt);
        p[i] = p[largest];
        p[largest]=temp;
        maxHeapIFY(largest,p,len);
    }
}

void minHeapIFY(unsigned int i,Pair *p,unsigned int len)
{
    if(i>=len)
    {
        return;
    }
    unsigned int smallest = i;
    unsigned int leftidx = Left(i);
    if(leftidx<len && p[i].cnt>p[leftidx].cnt)
    {
        smallest = leftidx;
    }
    unsigned int rightidx = Right(i);
    if(rightidx<len && p[smallest].cnt>p[rightidx].cnt)
    {
        smallest = rightidx;
    }
    if(smallest != i)
    {
        Pair temp(p[i].word,p[i].cnt);
        p[i] = p[smallest];
        p[smallest]=temp;
        maxHeapIFY(smallest,p,len);
    }
}

void buildMaxHeap(Pair *p,unsigned int len)
{
    for(int i=len/-;i>=;i--)
    {
        maxHeapIFY(i,p,len);
    }
}

void buildMinHeap(Pair *p,unsigned int len)
{
    for(int i=len/-;i>=;i--)
    {
        minHeapIFY(i,p,len);
    }
}

主函数

#include<stdio.h>
#include"Hash.h"

int main()
{
    char *A[]={"hello","world","spicy","hot","delete","great","spicy","great","great","hello","hot","hello"};
    unsigned int len=sizeof(A)/sizeof(char*);
    HashTable oTable(len);

    for(unsigned int i=;i<len;i++)
    {
        if(oTable.push(A[i])<)
        {
            printf("push error\n");
            return -;
        }
    }

    for(unsigned int i=;i<len;i++)
    {
        unsigned int cnt;
        if(oTable.get(A[i],&cnt)<)
        {
            printf("get error\n");
            return -;
        }
        printf("%s:%d\n",A[i],cnt);
    }

    oTable.MAXTopK();
    oTable.MINTopK();

    return ;
}