Datastrukturer_Algoritmer/Hashing/huvud.cpp

//##################################################################
//	PROGRAMMERINGSUPPGIFT 3
// DATASTRUKTURER OCH ALGORITMER
// HASH TABELL
//==================================================================
//	HUVUD.CPP
//	Filen innehåller huvudprogrammet
//		Christian Ohlsson
//		Ingela Johansson
//		Anna-Maria Haglund
//		Karlstad 981007
//==================================================================

#include "header.hpp"

//###############################################################
// SÄKER INMATNING AV MENYVAL
//		ser till att bara en character matas in
//		som menyval som dessutom måste vara en siffra
//===============================================================
char mataInChar()
{
  bool test = FALSE;
  char temp, svar;
  do {
    temp = getch();
    if(isalnum(temp) && test == FALSE) {
      cout << temp;
      svar = temp;
      test = TRUE;
    }
    else if(temp == BACKSPACE && test == TRUE) {
      gotoxy(wherex()-1, wherey());
      cout << " ";
      gotoxy(wherex()-1, wherey());
      test = FALSE;
    }
  }while(temp != ENTER || test == FALSE);
  return svar;
}
//##################################################################
//Function:
//Task:
//Calls:
//==================================================================
void _insert(hashClass &hashTable)
{
  nameType name;
  numberType number;
  hashNode newNode;
  int location;
  if(hashTable.biggerHash() == FALSE) {
    cout << "\n Skriv in namn:   ";
    cin >> name;
    if(hashTable.search(name) == FALSE) {
      cout << "\n Skriv in nummer: ";
      cin >> number;
      strcpy(newNode.name, name);
      strcpy(newNode.number, number);
      location = hashTable.hash1(name);
      
      if(hashTable.hashPtr[location].exist == FALSE)
	hashTable.insert(location, newNode);
      else
	while(hashTable.hashPtr[location].exist == TRUE) {
	  location = location + hashTable.hash2(hashTable.hash1(newNode.name));
	  if(location > hashTable.getSize())
	    location = location - hashTable.getSize();
	  if(hashTable.hashPtr[location].exist == FALSE) {
	    hashTable.insert(location, newNode);
	    return;
	  }
	}
    }
    else {
      cout << "\n Du har redan satt in " << name << " i katalogen";
      getch();
    }
  }
  else
    hashTable.newHashArray();
}
//##################################################################
//Function:
//Task:
//Calls:
//	TAR BORT EN NOD UR TRÄD
// 	calls: hashClass::del, getSize, search, hash1, hash2
//==================================================================
void _del(hashClass &hashTable)
{
  nameType name;
  int location;
  
  cout << "\n Vem vill du ta bort: ";
  cin >> name;
  if(hashTable.search(name)) {
    if(hashTable.anotherHash() == FALSE) {
      location = hashTable.hash1(name);
      if(strcmp(hashTable.hashPtr[location].name, name) == 0)
	hashTable.del(location);
      else {
	while(hashTable.hashPtr[location].exist == TRUE) {
	  location = location + hashTable.hash2(hashTable.hash1(name));
	  if(location > hashTable.getSize())
	    location = location - hashTable.getSize();
	  if(strcmp(hashTable.hashPtr[location].name, name) == 0)
	    hashTable.del(location);
	}
      }
    }
    else
      hashTable.reHash(hashTable.getSize());
  }
  else {
    cout << " " << name << " finns inte i telefonkatalogen";
    getch();
  }
}
//##################################################################
//Function:
//Task:
//Calls:
//	SKRIVER UT I INORDER
//		calls: hashClass::print
//==================================================================
void _print(hashClass &hashTable)
{
  int size = hashTable.getSize();
  clrscr();
  cout << "Plats"
       << setw(TABSIZE-3)
       << "Namn"
       << setw(TABSIZE)
       << "Nummer"
       << "\n-------------------------------------------";
  for(int i=0 ; i < size ; i++)
    if(hashTable.hashPtr[i].exist == TRUE && hashTable.hashPtr[i].name[0])
      cout << endl
	   << i
	   << setw(TABSIZE)
	   << hashTable.hashPtr[i].name
	   << setw(TABSIZE)
	   << hashTable.hashPtr[i].number;
  cout << "\n\n\n\n Arrayen är nu " << size << " stor"
       << "\n och " << hashTable.checkOccupied() << " platser är upptagna.";
  getch();
  
}
//##################################################################
//Function:
//Task:
//Calls:
// SÖKER I TRÄDET
//		calls: hashClass::search
//		calls: hashClass::isEmpty
//==================================================================
void _search(hashClass &hashTable)
{
  hashNode newNode;
  nameType name;
  
  cout << "\n Mata in namn: ";
  cin >> name;
  if(hashTable.search(name)) {
    newNode = hashTable.getNode(name);
    cout << "\n "
	 << newNode.name
	 << " har telefonnummer "
	 << newNode.number
	 << ".";
  }
  else
    cout << " " << name << " finns inte i telefonkatalogen";
  getch();
}
//##################################################################
//Function:
//Task:
//Calls:
// SPARAR TRÄDET PÅ FIL
//		calls: hashClass::save
//		calls: hashClass::isEmpty
//==================================================================
void _save(hashClass &hashTable)
{
  fstream fil;
  char filnamn[FILENAMESIZE];
  cout << "\n Ange filnamn att spara: ";
  cin >> filnamn;
  fil.open(filnamn,ios::out|ios::binary);
  hashTable.save(fil);
  fil.close();
}
//##################################################################
//Function:
//Task:
//Calls:
// HÄMTAR ETT TRÄD FRÅN EN FIL
//		läser in värdet i varje nod i preorder
//		och sätter in det i trädet i preoder
//		calls hashClass::insert
//		calls: hashClass::isEmpty
//==================================================================
void _load(hashClass &hashTable)
{
  fstream fil;
  int i = 0;
  char filnamn[FILENAMESIZE];
  cout << "\n Ange filnamn att hämta: ";
  cin >> filnamn;
  hashTable.destroyHash(hashTable.getSize());
  fil.open(filnamn,ios::in|ios::binary);
  if(fil) {
    while(fil.peek() != EOF) {
      fil.read((char*)& hashTable.hashPtr[i],sizeof(hashTable.hashPtr[i]));
      hashTable.insert(i, hashTable.hashPtr[i]);
      i++;
    }
  }
  else {
    cerr << "\n Filen finns inte...";
    getch();
  }
  hashTable.reHash(hashTable.getSize());
  fil.close();
}
//##################################################################
//Function:
//Task:
//Calls:
//	DESTROYTREE
//		tar bort hela trädet
//		calls: hashClass::isEmpty
//		calls: hashClass::destroyHash
//==================================================================
void _destroyHash(hashClass &hashTable)
{
  hashTable.destroyHash(hashTable.getSize());
  cerr << "\n Telefonkatalogen är tom...";
  getch();
}
//##################################################################
//Function:
//Task:
//Calls:
//	MENY ITEMS
//		skriver ut menyn på skärmen
//==================================================================
void meny()
{
  clrscr();
  cout << " \n  TELEFON KATALOGEN "
       << " \n  ----------------- "
       << " \n 1. Lägg till person "
       << " \n 2. Ta bort person "
       << " \n 3. Sök efter person "
       << " \n 4. Skriv ut "
       << " \n 5. Spara på fil "
       << " \n 6. Hämta från fil "
       << " \n 7. Radera hela katalogen "
       << " \n 0. Avsluta ";
  gotoxy(2,12);				 			//ställer markören under menyn
}
//##################################################################
//Function:
//Task:
//Calls:
// MAIN FUNCTION
//		skapar trädet hashTable av typen hashClass
//		calls: alla drivrutiner
//==================================================================
void main()
{
  hashClass hashTable;
  char val;
  do {
    meny();
    val = mataInChar();
    switch (val)
      {
      case '1' : _insert(hashTable);break;
      case '2' : _del(hashTable);break;
      case '3' : _search(hashTable);break;
      case '4' : _print(hashTable);break;
      case '5' : _save(hashTable);break;
      case '6' : _load(hashTable);break;
      case '7' : _destroyHash(hashTable);break;
      case '0' : cout << "\n Programmet avslutat";break;
      default  : cerr << "\n Felaktigt val";getch();
      }
  }while(val != '0');
  exit(0);
}