Хэш-таблицы

// HashTables.cpp : Defines the entry point for the console application.
//
 
#include "stdafx.h"
#include "Hash_Twin_Chain.h"
#include <iostream>
struct AAA
{
    int key;
    char *mas;
    AAA(int k,char*z)
    {
        key=k;
        mas=z;
    }
};
int hf(void* d)
{
    AAA* f = (AAA*)d;
    return f->key;
}
 
int _tmain(int argc, _TCHAR* argv[])
{
    AAA a1(1,"one"),
        a2(1,"two"),
        a3(1,"three");
    hashTC::Object H=hashTC::Create(20,hf);
    bool rc01=H.Insert(&a1),
         rc02=H.Insert(&a2),
         rc03=H.Insert(&a3),
         rc04=H.Delete(&a3);
    listx::Element* eee=H.Search(&a1);
    return 0;
}
//Lists.h
#pragma once
#define LISTNIL (Element*)-1
namespace listx
{
    struct Element
    {
        Element* Prev;
        Element* Next;
        void* Data;
        Element(Element* prev,void* data,Element* next)
        {
            Prev=prev;
            Data=data;
            Next=next;
        }
        Element* GetNext(){return Next;};
        Element* GetPrev(){return Prev;};
    };
    static Element* NIL=LISTNIL;
    enum Permit{ALL=0,NOINSERT=1,NODELETE=2,NOUPDATE=3};
    struct Object
    {
        Element* Head;
        Object(){Head=NIL;};
        Element* GetFirst(){return Head;};
        Element* GetLast();
        Element* Search(void* data);
        bool Insert(void* data);
        bool Delete(Element* e);
        bool Delete(void* data);
        static Permit Perm;
        bool isLockInsert(){return (Perm==NOINSERT||Perm==NOUPDATE);};
        bool isLockDelete(){return (Perm==NODELETE||Perm==NOUPDATE);};
        bool isListEmpty(){return (Head==NIL);};
    };
    Object Create();
    void AppendList(Object& to, const Object& from);
    void CopyList(Object& to, const Object& from);
}
#undef LISTNIL 
 
//Lists.cpp
#include "stdafx.h"
#include "Lists.h"
namespace listx
{
    Permit Object::Perm=ALL;
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    /*bool Object::Insert(void* data)
    {
        bool rc;
        if(rc=!isLockInsert())
        {
            if(Head==NIL) Head=new Element(NIL,data,NIL);
            else this->GetLast()->Next=new Element(this->GetLast(),data,NIL);
        }
        return rc;
    }*/
    bool Object::Insert(void* data)
    {
        bool rc;
        if(rc=!isLockInsert())
        {
            if(Head==NIL) Head=new Element(NIL,data,Head);
            else Head=(Head->Prev=new Element(NIL,data,Head));
        }
        return rc;
    }
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Element* Object::Search(void* data)
    {
        Element* rc=Head;
        while((rc!=NIL)&&(rc->Data!=data)) rc=rc->Next;
        return rc;
    }
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    bool Object::Delete(Element* e)
    {
        bool rc;
        if(rc=!isLockDelete())
        {
            if(rc=(e!=NIL))
            {
                if(e->Next!=NIL) e->Next->Prev=e->Prev;
                if(e->Prev!=NIL) e->Prev->Next=e->Next;
                else Head=e->Next;
                delete e;
            }
        }
        return rc;
    }
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    bool Object::Delete(void* data)
    {
        return Delete(Search(data));
    }
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Element* Object::GetLast()
    {
        listx::Element* e=this->GetFirst(),*rc=this->GetFirst();
        while(e!=listx::NIL)
        {
            rc=e;
            e=e->GetNext();
        };
        return rc;
    }
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    void AppendList(Object& to, const Object& from)
    {
        to.GetLast()->Next=from.Head->Next;
    }
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    void CopyList(Object& to, const Object& from)
    {
        to.Head->Next=from.Head->Next;
    }
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Object Create() {return *(new Object());};
}
//Hash_Twin_Chain.h
#pragma once
#include "Lists.h"
namespace hashTC
{
    struct Object
    {
        int Size;
        int (*FunKey)(void*);
        listx::Object* Hash;
        Object(int size,int (*f)(void*))
        {
            Size=size;
            FunKey=f;
            Hash=new listx::Object[Size];
        };
        int HashFunction(void* data);
        bool Insert(void* data);
        listx::Element* Search(void* data);
//      bool Delete(int key);
        bool Delete(void* data);
    };
    Object Create(int size,int (*f)(void*));
}
//Hash_Twin_chain.cpp
#include "stdafx.h"
#include "Hash_Twin_Chain.h"
#include "Lists.h"
namespace hashTC
{
    Object Create(int size,int (*f)(void*)) {return *(new Object(size,f));}
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    int Object::HashFunction(void* data){return (FunKey(data)%Size);};
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    bool Object::Insert(void* data){return (Hash[HashFunction(data)].Insert(data));};
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    bool Object::Delete(void* data){return (Hash[HashFunction(data)].Delete(data));};
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    listx::Element* Object::Search(void* data){return Hash[HashFunction(data)].Search(data);};
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
}