Курсовой проект [Вариант 12-13] / Сравниловка методов / Main

#include <vcl.h>
#include <stdio.h>
#pragma hdrstop
#include "Main.h"
#pragma package(smart_init)
#pragma resource "*.dfm"
TfrmMain *frmMain;

int node_count = 0;
int root_index = 0;

class TfrmMain::Identificator{
public:
    char *Name;
    int Right;
    int Left;
    Identificator (){
        Name = new char[32];
        Right=0;
        Left=0;
    }
    int Hash(){
        return ((Name[0]|Name[strlen(Name)-1]));
    }
};
class TfrmMain::HashIdentificator{
public:
    int iHash;
    char *Name;
    int Right;
    int Left;
    int HashERROR;
    HashIdentificator (){
        Name = new char[32];
        Right=0;
        Left=0;
        iHash=0;
        HashERROR=0;
    }
    int GetCollisionCount(){
        return iHash-1;
    }
    int Hash(){
        iHash++;
        return ((Name[0]|Name[strlen(Name)-1])+iHash);
    }
};
int TfrmMain::AddToHashTableChane(int IDindex,Identificator *IDTable,int *HashTable)
{
    if (!HashTable[IDTable[IDindex].Hash()])
    {
        HashTable[IDTable[IDindex].Hash()]=IDindex;
        mTextChane->Lines->Add((IDTable[IDindex].Name));
        mTextChane->Text=mTextChane->Text+ "->хэш ";
    }
    else
    {
        mTextChane->Lines->Add((IDTable[IDindex].Name));
        mTextChane->Text=mTextChane->Text+ " коллизия ";
        int HashIndex = HashTable[IDTable[IDindex].Hash()];
        int fl=0;
        colis_chane++;
        do
        {
            mTextChane->Text=mTextChane->Text+ "R";
            if(IDTable[HashIndex].Right!=0)
            {
                HashIndex = IDTable[HashIndex].Right;
                colis_chane++;
            }
            else
            {
                IDTable[HashIndex].Right=IDindex;
                fl=1;
            }
        }while(!fl);
    }
}

int TfrmMain::SearchIdChane(char *ID,Identificator *IDTable,int *HashTable)
{
    int HashID=ID[0]|ID[strlen(ID)-1];
    if (!HashTable[HashID])
    {
        return -1;
    }
    else
    {
        int HashIndex = HashTable[HashID];
        int fl=0;
        cmp_count_chane = 1;
        do
        {
            cmp_count_chane++;
            if (strcmp(IDTable[HashIndex].Name,ID)==0) return(HashIndex);
            else
            {
                if (strcmp(IDTable[HashIndex].Name,ID)!=0)
                    if(IDTable[HashIndex].Right!=0) HashIndex = IDTable[HashIndex].Right;
                    else    return -1;
            }
        }while(1);
    }
}
int TfrmMain::NextHash(HashIdentificator *ident, int *hashTable, int HashTableLength){

    int t = ident->Hash();
    if (t>HashTableLength) return -1;
    if (hashTable[t]==0) return t;
    else NextHash(ident,hashTable,HashTableLength);
};
int *TfrmMain::MakeHashTable(HashIdentificator *IdentTable, int IdentTableLength, int HashTableLength){

    int *Hash;
    Hash = new int[HashTableLength+1];
    for (int i=0;i<=HashTableLength;i++) Hash[i] = 0;

    for (int i=1;i<=IdentTableLength;i++){
        int tmp = NextHash(&IdentTable[i],Hash,HashTableLength);
        if (tmp==-1)
            IdentTable[i].HashERROR = 1;
        else
            Hash[tmp] = i;
    }           
    return Hash;
}
void TfrmMain::ShowTable(TStringGrid *sgGrid, int *hashTable, int HashTableLength){
    int j=0;
    for (int i=1;i<=HashTableLength;i++){
        if (hashTable[i]!=0){
            j++;
            sgGrid->RowCount++;
            sgGrid->Rows[j]->Add(i);
            sgGrid->Rows[j]->Add(hashTable[i]);
        }
    }
}
int TfrmMain::HashIdSearch(HashIdentificator *IdentTable, int *hashTable, int HashTableLength, AnsiString Name){
    HashIdentificator ID;
    ID.Name = Name.c_str();

    int tmp=0;
    while (tmp <= HashTableLength){
        tmp = ID.Hash();
        if (hashTable[tmp]!=0){
            cmp_count_rehash++;
            if (strcmp(IdentTable[hashTable[tmp]].Name,ID.Name)==0) {
                cmp_count_rehash++;
                return hashTable[tmp];
            }
        }
    }          
    return 0;
}
__fastcall TfrmMain::TfrmMain(TComponent* Owner)
        : TForm(Owner){

}

void __fastcall TfrmMain::Button1Click(TObject *Sender){
    colis_chane=0;

    int IdentsCount=1;
    char *temp;
    temp = new char[32];

    TableChane = new Identificator[256];
    
    HashTableLen = 255;
    HashIdentTable = new HashIdentificator[HashTableLen+1];

    FILE *inFile;
    inFile=fopen("input.txt","r");

    for (int i=0;i<=255;i++){HashTableChane[i]=0;}

    mTextChane->Lines->Clear();

    while (!feof(inFile)){
        fscanf(inFile, "%s", temp);
        strcpy(TableChane[IdentsCount].Name,temp);
        strcpy(HashIdentTable[IdentsCount].Name,temp);
        AddToHashTableChane(IdentsCount,TableChane,HashTableChane);
        IdentsCount++;

    }

    HashTable = MakeHashTable(HashIdentTable,IdentsCount-1,HashTableLen+1);
    ShowTable(sgHashTable,HashTable,255);

    collision_rehash = 0;
    for (int i=1;i<=IdentsCount;i++){
        if(HashIdentTable[i].GetCollisionCount()!=0)
        collision_rehash++;
    }
    edCollision->Text = IntToStr(collision_rehash-1);

    fclose(inFile);

    //Edit1->Text=colis_tree;
    Edit2->Text=colis_chane;
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::Button2Click(TObject *Sender)
{
    cmp_count_chane=0;
    cmp_count_rehash=0;
    mResChane->Clear();
    mResReHash->Clear();
    int temp=SearchIdChane(edSearch->Text.c_str(),TableChane,HashTableChane);
    if(temp>0)
    {
        mResChane->Lines->Add("Идентификатор найден:");
        mResChane->Lines->Add("адрес в таблице символов ");
        mResChane->Text=mResChane->Text+ IntToStr(temp);
        mResChane->Lines->Add("Количество сравнений:");
        mResChane->Text=mResChane->Text+ IntToStr(cmp_count_chane);
    }
    else mResChane->Lines->Add("Идентификатор не найден");

    int id = HashIdSearch(HashIdentTable,HashTable, HashTableLen, edSearch->Text);
    if(id>0){
        mResReHash->Lines->Add("Идентификатор найден:");
        mResReHash->Lines->Add("адрес в таблице символов ");
        mResReHash->Text=mResReHash->Text + IntToStr(id);
        mResReHash->Lines->Add("Количество сравнений:");
        mResReHash->Text=mResReHash->Text+ IntToStr(cmp_count_rehash-1);
    }
    else mResReHash->Lines->Add("Идентификатор не найден");



}
//---------------------------------------------------------------------------