Курсовой проект2 / CompareMethods_CBuilder6 / 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{
private:
    int iHash; 
public:
    char *Name;
    int Right;
    int Left;
    int HashERROR;
    Identificator (){
        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);
    }
};


void TfrmMain::AddToTree(int IDindex,Identificator *IDTable)
{
    if (node_count==0){
        root_index = IDindex;
        node_count++;
    }else{
        AnsiString temp(IDTable[IDindex].Name);
        mText->Lines->Add(temp+"    ");
        int fl=0;
        int current_node = root_index;
        do{  
            if (strcmp(IDTable[current_node].Name,IDTable[IDindex].Name)<0){
                mText->Text=mText->Text+ "R";
                if(IDTable[current_node].Right!=0){
                    current_node = IDTable[current_node].Right;
                }else{
                    IDTable[current_node].Right=IDindex;
                    node_count++;
                    fl=1;
                }
            }else{
                mText->Text=mText->Text+ "L";
                if(IDTable[current_node].Left!=0){
                    current_node = IDTable[current_node].Left;
                }else{
                    IDTable[current_node].Left=IDindex;
                    node_count++;
                    fl=1;
                }
            }
        }while(!fl);
    }   
}
int TfrmMain::SearchId(char *ID,Identificator *IDTable){
//    int fl=0;
    int current_node = root_index;
    do{
        cmp_count_tree++;
        if(strcmp(IDTable[current_node].Name,ID)==0) return(current_node);
        if(IDTable[current_node].Left==0 && IDTable[current_node].Right==0) return -1;
        else{
            if (strcmp(IDTable[current_node].Name,ID)<0)
                current_node = IDTable[current_node].Right;
            else{
                current_node = IDTable[current_node].Left;
            }
        }
    }while(1);
}
__fastcall TfrmMain::TfrmMain(TComponent* Owner): TForm(Owner){

};
int TfrmMain::NextHash(Identificator *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(Identificator *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(Identificator *IdentTable, int *hashTable, int HashTableLength, AnsiString Name){
    Identificator 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;
}void __fastcall TfrmMain::Button2Click(TObject *Sender)
{
    cmp_count_tree=0;
    cmp_count_rehash=0;
    mResReHash->Clear();
    mResTree->Clear();

    int temp=SearchId(edSearch->Text.c_str(),TreeIdentTable);
    if(temp>0){
        mResTree->Lines->Add("Идентификатор найден:");
        mResTree->Lines->Add("адрес в таблице символов ");
        mResTree->Text=mResTree->Text+ IntToStr(temp);
        mResTree->Lines->Add("Количество сравнений:");
        mResTree->Text=mResTree->Text+ IntToStr(cmp_count_tree);
    }
    else mResTree->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("Идентификатор не найден");







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


void __fastcall TfrmMain::FormShow(TObject *Sender)
{
int IdentsCount=1;
    char *temp;
    temp = new char[32];

    mInputFile->Lines->LoadFromFile("input.txt");

    HashTableLen = 255;

    TreeIdentTable = new Identificator[256];
    HashIdentTable = new Identificator[HashTableLen+1];

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

    mText->Lines->Clear();

    while (!feof(inFile)){
        fscanf(inFile, "%s", temp);
        strcpy(TreeIdentTable[IdentsCount].Name,temp);
        strcpy(HashIdentTable[IdentsCount].Name,temp);
        AddToTree(IdentsCount,TreeIdentTable);
        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);    
}
//---------------------------------------------------------------------------