Startpunkten
This commit is contained in:
272
Binary_Search_Tree/huvud.cpp
Normal file
272
Binary_Search_Tree/huvud.cpp
Normal file
@@ -0,0 +1,272 @@
|
||||
//########################################################
|
||||
// LAB 4 I PUMA
|
||||
// CRILLE & ROBIN 980120
|
||||
// BINÄRT SÖK TRÄD
|
||||
//========================================================
|
||||
|
||||
#ifndef _HEADER_
|
||||
#define _HEADER_ //definiera _HEADER_
|
||||
#include <iostream.h> //för in och utmatning
|
||||
#include <conio.h> //för getch()
|
||||
#include <assert.h> //för assert()
|
||||
#include <stddef.h> //för definition av NULL
|
||||
#include <string.h> //för säker inmatning
|
||||
#include <stdlib.h> //för atoi()
|
||||
#include <fstream.h> //för save & load
|
||||
|
||||
const int FALSE = 0; //boolsk variabel
|
||||
const int TRUE = !FALSE; //boolsk variabel
|
||||
const int BUFFERSIZE = 100; //för säker inmatning
|
||||
const int NAMESIZE = 8; //för MS-DOS 6.0
|
||||
|
||||
typedef int bool; //definierar boolsk variabel
|
||||
typedef int dataType; //sätter datatypen
|
||||
struct treeNode; //förvarnar datorn om en struct
|
||||
typedef treeNode* ptrType; //ger en pekartype till en struct
|
||||
struct treeNode //en nod i trädet
|
||||
{
|
||||
dataType data;
|
||||
ptrType left;
|
||||
ptrType right;
|
||||
treeNode(dataType item, ptrType left, ptrType right);
|
||||
};
|
||||
#include "tree.cpp" //inkluderar trädets funktioner
|
||||
#endif //avslutar _HEADER_ definition
|
||||
|
||||
//#####################################################
|
||||
// SÄKER INMATNING
|
||||
// ser till att bara heltal matas in
|
||||
// returnerar värdet om ok, annars nytt försök
|
||||
//=====================================================
|
||||
int mataIn()
|
||||
{
|
||||
char buffer[BUFFERSIZE];
|
||||
int f;
|
||||
do
|
||||
{
|
||||
cin >> buffer;
|
||||
if (strcmp(buffer,"0") == 0)
|
||||
return 0;
|
||||
else
|
||||
{
|
||||
f = atoi(buffer);
|
||||
if (f!=0)
|
||||
return f;
|
||||
else
|
||||
cout <<" Inget tal, försok igen: ";
|
||||
}
|
||||
}while (!f);
|
||||
}
|
||||
//########################################################
|
||||
// SÄTTER IN EN NOD I TRÄD
|
||||
// calls: treeClass::insert
|
||||
// calls: mataIn
|
||||
//========================================================
|
||||
void _insert(treeClass &myTree)
|
||||
{
|
||||
dataType item;
|
||||
cout <<" Vad vill du sätta in i trädet: ";
|
||||
item=mataIn();
|
||||
myTree.insert(myTree.root,item);
|
||||
}
|
||||
//########################################################
|
||||
// TAR BORT EN NOD UR TRÄD
|
||||
// calls: treeClass::del
|
||||
// calls: treeClass::isEmpty
|
||||
// calls: mataIn
|
||||
//========================================================
|
||||
void _del(treeClass &myTree)
|
||||
{
|
||||
if(!myTree.isEmpty())
|
||||
{
|
||||
dataType item;
|
||||
cout << " Vad vill du ta bort : ";
|
||||
item=mataIn();
|
||||
if(myTree.seek(myTree.root, item) != NULL)
|
||||
{
|
||||
myTree.del(myTree.root, item);
|
||||
return;
|
||||
}
|
||||
else
|
||||
cout << " Noden " << item << " finns inte. ";
|
||||
}
|
||||
else
|
||||
cout << " Du har inte gjort något träd ännu... ";
|
||||
getch();
|
||||
}
|
||||
//########################################################
|
||||
// SKRIVER UT I PREORDER
|
||||
// calls: treeClass::preOrder
|
||||
// calls: treeClass::isEmpty
|
||||
// calls: mataIn
|
||||
//========================================================
|
||||
void _preOrder(treeClass myTree)
|
||||
{
|
||||
if(!myTree.isEmpty())
|
||||
myTree.preOrder(myTree.root);
|
||||
else
|
||||
cout << " Du har inte gjort något träd ännu... ";
|
||||
getch();
|
||||
}
|
||||
//########################################################
|
||||
// SKRIVER UT I INORDER
|
||||
// calls: treeClass::inOrder
|
||||
// calls: treeClass::isEmpty
|
||||
// calls: mataIn
|
||||
//========================================================
|
||||
void _inOrder(treeClass myTree)
|
||||
{
|
||||
if(!myTree.isEmpty())
|
||||
myTree.inOrder(myTree.root);
|
||||
else
|
||||
cout << " Du har inte gjort något träd ännu... ";
|
||||
getch();
|
||||
}
|
||||
//########################################################
|
||||
// SKRIVER UT I POSTORDER
|
||||
// calls: treeClass::postOrder
|
||||
// calls: treeClass::isEmpty
|
||||
// calls: mataIn
|
||||
//========================================================
|
||||
void _postOrder(treeClass myTree)
|
||||
{
|
||||
if(!myTree.isEmpty())
|
||||
myTree.postOrder(myTree.root);
|
||||
else
|
||||
cout << " Du har inte gjort något träd ännu... ";
|
||||
getch();
|
||||
}
|
||||
//########################################################
|
||||
// SÖKER I TRÄDET
|
||||
// calls: treeClass::seek
|
||||
// calls: treeClass::isEmpty
|
||||
// calls: mataIn
|
||||
//========================================================
|
||||
void _seek(treeClass myTree)
|
||||
{
|
||||
if(!myTree.isEmpty())
|
||||
{
|
||||
dataType item;
|
||||
cout << " Mata in sökta värdet: ";
|
||||
item=mataIn();
|
||||
if(myTree.seek(myTree.root, item) != NULL)
|
||||
cout << " Ja, noden "<< item << " fanns med...";
|
||||
else
|
||||
cout << " Nej, noden "<< item << " fanns inte med...";
|
||||
}
|
||||
else
|
||||
cout << " Du har inte gjort något träd ännu... ";
|
||||
getch();
|
||||
}
|
||||
//########################################################
|
||||
// SPARAR TRÄDET PÅ FIL
|
||||
// calls: treeClass::save
|
||||
// calls: treeClass::isEmpty
|
||||
//========================================================
|
||||
void _save(treeClass myTree)
|
||||
{
|
||||
if(!myTree.isEmpty())
|
||||
{
|
||||
fstream fil;
|
||||
char filnamn[NAMESIZE];
|
||||
cout << " Ange filnamn att spara: ";
|
||||
cin >> filnamn;
|
||||
fil.open(filnamn,ios::out|ios::binary);
|
||||
myTree.save(myTree.root, fil);
|
||||
fil.close();
|
||||
}
|
||||
else
|
||||
{
|
||||
cout << " Du har inte gjort något träd ännu...";
|
||||
getch();
|
||||
}
|
||||
}
|
||||
//########################################################
|
||||
// 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 treeClass::insert
|
||||
// calls: treeClass::isEmpty
|
||||
//========================================================
|
||||
void _load(treeClass &myTree)
|
||||
{
|
||||
if(myTree.isEmpty())
|
||||
{
|
||||
fstream fil;
|
||||
dataType item;
|
||||
char filnamn[NAMESIZE];
|
||||
cout << " Ange filnamn att hämta: ";
|
||||
cin >> filnamn;
|
||||
fil.open(filnamn,ios::in|ios::binary);
|
||||
if(fil)
|
||||
while(fil.peek() != EOF)
|
||||
{
|
||||
fil.read((char*)&item,sizeof(item));
|
||||
myTree.insert(myTree.root, item);
|
||||
}
|
||||
else
|
||||
{
|
||||
cout << " Filen finns inte...";
|
||||
getch();
|
||||
}
|
||||
fil.close();
|
||||
}
|
||||
else
|
||||
{
|
||||
cout << " Det finns redan värden i trädet. \n"
|
||||
<< " Du måste ta bort samtliga noder \n"
|
||||
<< " eller starta om programmet före \n"
|
||||
<< " du kan hämta ett träd från fil \n";
|
||||
getch();
|
||||
}
|
||||
}
|
||||
//########################################################
|
||||
// MENY ITEMS
|
||||
// skriver ut menyn på skärmen
|
||||
//========================================================
|
||||
void meny()
|
||||
{
|
||||
clrscr();
|
||||
cout << " \n BINÄRT SÖK TRÄD "
|
||||
<< " \n --------------- "
|
||||
<< " \n 1. Lägg till nod "
|
||||
<< " \n 2. Ta bort nod "
|
||||
<< " \n 3. Sök efter nod "
|
||||
<< " \n 4. Skriv ut i preorder "
|
||||
<< " \n 5. Skriv ut i inorder "
|
||||
<< " \n 6. Skriv ut i postorder "
|
||||
<< " \n 7. Spara trädet på fil "
|
||||
<< " \n 8. Hämta träd från fil "
|
||||
<< " \n 0. Avsluta ";
|
||||
gotoxy(2,14); //ställer markören under menyn
|
||||
}
|
||||
//########################################################
|
||||
// MAIN FUNCTION
|
||||
// skapar trädet myTree av typen treeClass
|
||||
// calls: alla drivrutiner
|
||||
//========================================================
|
||||
void main()
|
||||
{
|
||||
treeClass myTree;
|
||||
char val = TRUE;
|
||||
do
|
||||
{
|
||||
meny();
|
||||
cin >> val;
|
||||
switch (val)
|
||||
{
|
||||
case '1' : _insert(myTree);break;
|
||||
case '2' : _del(myTree);break;
|
||||
case '3' : _seek(myTree);break;
|
||||
case '4' : _preOrder(myTree);break;
|
||||
case '5' : _inOrder(myTree);break;
|
||||
case '6' : _postOrder(myTree);break;
|
||||
case '7' : _save(myTree);break;
|
||||
case '8' : _load(myTree);break;
|
||||
case '0' : cout << " Programmet avslutat";break;
|
||||
default : cout << " Felaktigt val";
|
||||
getch();
|
||||
}
|
||||
}while(val != '0');
|
||||
}
|
||||
|
||||
226
Binary_Search_Tree/tree.cpp
Normal file
226
Binary_Search_Tree/tree.cpp
Normal file
@@ -0,0 +1,226 @@
|
||||
//########################################################
|
||||
// TREE.CPP
|
||||
// innehåller funktioner för trädet
|
||||
//========================================================
|
||||
|
||||
class treeClass
|
||||
{
|
||||
public:
|
||||
treeClass();
|
||||
~treeClass(){};
|
||||
ptrType root;
|
||||
ptrType seek(ptrType root, dataType item);
|
||||
bool isEmpty();
|
||||
void insert(ptrType &root,dataType item);
|
||||
void del(ptrType &root,dataType item);
|
||||
void delRoot(ptrType &root);
|
||||
void delLeft(ptrType &root, dataType &item);
|
||||
void preOrder(ptrType treeNode);
|
||||
void inOrder(ptrType treeNode);
|
||||
void postOrder(ptrType treeNode);
|
||||
void save(ptrType root, fstream &fil);
|
||||
};
|
||||
//########################################################
|
||||
// SKAPAR ETT TRÄD & SÄTTER ROOT TILL NULL
|
||||
//========================================================
|
||||
treeClass::treeClass():root(NULL)
|
||||
{
|
||||
}
|
||||
//########################################################
|
||||
// SKAPAR EN NOD
|
||||
//========================================================
|
||||
treeNode::treeNode(dataType item, ptrType L, ptrType R):data(item),left(L),right(R)
|
||||
{
|
||||
}
|
||||
//########################################################
|
||||
// KOLLAR OM DET FINNS NODER I TRÄDET
|
||||
// pre: TRUE
|
||||
// post: TRUE om trädet är tomt
|
||||
// post: FALSE om det finns noder i trädet
|
||||
//========================================================
|
||||
bool treeClass::isEmpty()
|
||||
{
|
||||
if (root==NULL)
|
||||
return TRUE;
|
||||
else
|
||||
return FALSE;
|
||||
}
|
||||
//########################################################
|
||||
// SKRIVER UT TRÄDET I PREORDER
|
||||
// pre: att trädet inte är tomt
|
||||
// post: trädet har skrivits ut i preOrder
|
||||
// calls: preOrder (rekursivt)
|
||||
//========================================================
|
||||
void treeClass::preOrder(ptrType treeNode)
|
||||
{
|
||||
if(treeNode)
|
||||
{
|
||||
cout << " ";
|
||||
cout << treeNode->data;
|
||||
preOrder(treeNode->left);
|
||||
preOrder(treeNode->right);
|
||||
}
|
||||
}
|
||||
//########################################################
|
||||
// SKRIVER UT TRÄDET I INORDER
|
||||
// pre: att trädet inte är tomt
|
||||
// post: trädet har skrivits ut i inOrder
|
||||
// calls: inOrder (rekursivt)
|
||||
//========================================================
|
||||
void treeClass::inOrder(ptrType treeNode)
|
||||
{
|
||||
if(treeNode)
|
||||
{
|
||||
inOrder(treeNode->left);
|
||||
cout << treeNode->data << " ";
|
||||
inOrder(treeNode->right);
|
||||
}
|
||||
}
|
||||
//########################################################
|
||||
// SKRIVER UT TRÄDET I POSTORDER
|
||||
// pre: att trädet inte är tomt
|
||||
// post: trädet har skrivits ut i postOrder
|
||||
// calls: postOrder (rekursivt)
|
||||
//========================================================
|
||||
void treeClass::postOrder(ptrType treeNode)
|
||||
{
|
||||
if(treeNode)
|
||||
{
|
||||
postOrder(treeNode->left);
|
||||
postOrder(treeNode->right);
|
||||
cout << treeNode->data << " ";
|
||||
}
|
||||
}
|
||||
//########################################################
|
||||
// SÖKER EFTER ETT ELEMENT I TRÄDET
|
||||
// pre: att trädet inte är tomt
|
||||
// post: NULL om noden inte fanns
|
||||
// post: sökta värdet om värdet fanns
|
||||
// calls: seek (rekursivt)
|
||||
//========================================================
|
||||
ptrType treeClass::seek(ptrType root, dataType item)
|
||||
{
|
||||
ptrType treeNodeFound;
|
||||
if(root == NULL)
|
||||
treeNodeFound = NULL;
|
||||
else if (root->data == item)
|
||||
treeNodeFound = root;
|
||||
else if (root->data > item)
|
||||
treeNodeFound = seek(root->left, item);
|
||||
else
|
||||
treeNodeFound = seek(root->right, item);
|
||||
return treeNodeFound;
|
||||
}
|
||||
//########################################################
|
||||
// SÄTTER IN EN NOD I TRÄDET
|
||||
// pre: att inmatningen är ett heltal
|
||||
// post: trädet har fått en ny nod insatt
|
||||
// på rätt plats i trädet.
|
||||
// calls: insert (rekursivt)
|
||||
//========================================================
|
||||
void treeClass::insert(ptrType &root,dataType item)
|
||||
{
|
||||
if(root==NULL)
|
||||
root=new treeNode(item,NULL,NULL);
|
||||
else if(item < root->data)
|
||||
insert(root->left,item);
|
||||
else
|
||||
insert(root->right,item);
|
||||
}
|
||||
//########################################################
|
||||
// TAR BORT EN NODEN TILL VÄNSTER
|
||||
// pre: att det finns ett träd
|
||||
// pre: att noden finns
|
||||
// post: noden har tagits ur trädet och
|
||||
// de andra noderna sitter nu rätt placerade
|
||||
// calls: delLeft (rekursivt)
|
||||
//========================================================
|
||||
void treeClass::delLeft(ptrType &root, dataType &item)
|
||||
{
|
||||
if((root != NULL) && (root->left == NULL))
|
||||
{
|
||||
item = root->data;
|
||||
ptrType delPtr = root;
|
||||
root = root->right;
|
||||
delPtr->right = NULL;
|
||||
delete delPtr;
|
||||
}
|
||||
else
|
||||
delLeft(root->left, item);
|
||||
}
|
||||
//########################################################
|
||||
// TAR BORT NODEN OM DEN ÄR EN ROT
|
||||
// pre: att det finns ett träd
|
||||
// pre: att noden finns
|
||||
// post: noden har tagits ur trädet och
|
||||
// de andra noderna sitter nu rätt placerade
|
||||
//========================================================
|
||||
void treeClass::delRoot(ptrType &root)
|
||||
{
|
||||
ptrType delPtr;
|
||||
dataType nyItem;
|
||||
|
||||
if(root != NULL)
|
||||
{
|
||||
if((root->left == NULL) && (root->right == NULL))
|
||||
{
|
||||
delete root;
|
||||
root = NULL;
|
||||
}
|
||||
else if(root->left == NULL)
|
||||
{
|
||||
delPtr = root;
|
||||
root = root->right;
|
||||
delPtr->right = NULL;
|
||||
delete delPtr;
|
||||
}
|
||||
else if(root->right == NULL)
|
||||
{
|
||||
delPtr = root;
|
||||
root = root->left;
|
||||
delPtr->left = NULL;
|
||||
delete delPtr;
|
||||
}
|
||||
else
|
||||
{
|
||||
delLeft(root->right, nyItem);
|
||||
root->data = nyItem;
|
||||
}
|
||||
}
|
||||
}
|
||||
//########################################################
|
||||
// TAR BORT EN NOD UR TRÄDET
|
||||
// pre: att det finns ett träd
|
||||
// pre: att noden finns
|
||||
// post: noden har tagits ur trädet och
|
||||
// de andra noderna sitter nu rätt placerade
|
||||
// calls: delRoot om noden är en rot
|
||||
// calls: del (rekursivt)
|
||||
//========================================================
|
||||
void treeClass::del(ptrType &root, dataType item)
|
||||
{
|
||||
if(item==root->data)
|
||||
delRoot(root);
|
||||
else if(item < root->data)
|
||||
del(root->left, item);
|
||||
else
|
||||
del(root->right,item);
|
||||
}
|
||||
//########################################################
|
||||
// SPARAR TRÄDET PÅ FIL
|
||||
// läser av nodens värde i alla noder i
|
||||
// preorder och skriver de på filen.
|
||||
// pre: att det finns ett träd
|
||||
// post: trädet har sparats på fil
|
||||
// calls: save (rekursivt)
|
||||
//========================================================
|
||||
void treeClass::save(ptrType root, fstream &fil)
|
||||
{
|
||||
if(root)
|
||||
{
|
||||
fil.write((char*)&root->data,sizeof(root));
|
||||
save(root->left,fil);
|
||||
save(root->right,fil);
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user