散列(C++实现)

散列的构成：散列函数，散列表的存储方式，散列表的冲突解决方法。

1.散列函数

　　较常用的散列函数有除留余数法，数字分析法，平方取中法，折叠法。

2.散列表的存储方式

　　闭散列法（开地址法），用数组存储；开散列法（链地址法），用邻接链表存储。

3.散列表的冲突解决方法

　　主要是针对闭散列中关键码位置冲突的问题，常用的方法有线性探查法，二次探查法，双散列法。

性能分析：在存储方式中，开散列法优于闭散列法；在散列函数中，除留余数法最优。

实现代码：

 

#include<iostream>
using namespace std;
enum kind{Active,Empty,Deleted};
class ArrayHashTable{//闭散列法 
    public:
        ArrayHashTable(const int d,int sz=20){
            tableSize=sz;
            divitor=d;
            table=new int[tableSize];
            info=new kind[tableSize];
            for(int i=0;i<tableSize;i++){
                table[i]=0;
                info[i]=Empty;
            }
        }
        ~ArrayHashTable(){
            delete[] table;
            delete[] info;
        }
        bool findPos(int k,int &i){//寻找k关键码所在位置i 
            i=k%divitor;
            int j=i;
            do{
                if(info[i]==Active&&table[i]==k)
                    return true;
                if(info[i]==Empty) 
                    return false;
                i=(i+1)%tableSize;        
            }
            while(j!=i);
            return false;
        }
        bool insert(int k){//插入关键码k 
            int i;
            if(findPos(k,i))
                return false;
            if(info[i]!=Active){
                table[i]=k;
                info[i]=Active;
                return true;    
            }else
                return false;
        }
        bool remove(int k){//删除关键码k 
            int i;
            if(!findPos(k,i))
                return false;
            table[i]=Deleted;
            return true;
        }
        int *getArray(){
            return table;
        }
    private:
        int divitor;
        int tableSize;
        int *table;
        kind *info;
};


class Node{
    public:
        int data;
        Node *next;
        Node(int d,Node *n=NULL){
            data=d;
            next=n;
        }
};
class LinkedHashTable{//开散列法
    public:
        LinkedHashTable(int d,int sz=20){
            tableSize=sz;
            divitor=d;
            hs=new Node*[sz];
            for(int i=0;i<sz;i++)
            hs[i]=new Node(0);
        }
        ~LinkedHashTable(){
            delete []hs;
        }
        bool findPos(int k,Node *&p,Node *&last){
            int i=k%divitor;
            last=hs[i];
            p=hs[i]->next;
            while(p!=NULL&&p->data!=k){
                p=p->next;
                last=last->next;
            } 
            if(p!=NULL&&p->data==k)
                return true;
             else
                 return false;
        }
        bool insert(int k){
            Node *p,*last;
            int i=k%divitor;
            if(findPos(k,p,last))
                return false;
            last->next=new Node(k);    
            return true;
        }
        bool remove(int k){
            Node *p,*last;
            if(!findPos(k,p,last))
                return false;
            last->next=p->next;
            return true;
        }
        Node **getArray(){
            return hs;
        }
    private:
        int divitor;
        int tableSize;
        Node **hs;
};

void test(Node *&q){
    q=new Node(4);
} 
int main(){
    //闭散列法 
//    ArrayHashTable *hs=new ArrayHashTable(11,12);
//    int a[]={37,25,14,36,49,68,57,11};
//    for(int i=0;i<8;i++)
//        hs->insert(a[i]);
//    int *array=hs->getArray();
//    for(int i=0;i<12;i++){
//        cout<<array[i]<<" ";
//    }
//    delete hs;

    //开散列法 
//    LinkedHashTable *hs=new LinkedHashTable(11,12);
//    int a[]={37,25,14,36,49,68,57,11};
//    for(int i=0;i<8;i++)
//        hs->insert(a[i]);
//    Node **array=hs->getArray();
//    for(int i=0;i<12;i++){
//        Node *p=array[i]->next;
//        while(p!=NULL){
//            cout<<p->data<<" ";
//            p=p->next;
//        }
//        cout<<endl;
//    }
//    delete hs;
    return 0;
}