Startpunkten
This commit is contained in:
76
AVL_tree/header.hpp
Normal file
76
AVL_tree/header.hpp
Normal file
@@ -0,0 +1,76 @@
|
||||
//##################################################################
|
||||
// PROGRAMMERINGSUPPGIFT 2
|
||||
// DATASTRUKTURER OCH ALGORITMER
|
||||
// AVL TRÄD
|
||||
//==================================================================
|
||||
// HEADER.HPP
|
||||
// Filen innehåller definition som används i programmet
|
||||
// Christian Ohlsson
|
||||
// Karlstad 980927
|
||||
//==================================================================
|
||||
#ifndef _header_
|
||||
#define _header_
|
||||
|
||||
#include <iostream.h>
|
||||
#include <fstream.h>
|
||||
#include <iomanip.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
//#include <conio.h>
|
||||
#include <ctype.h>
|
||||
|
||||
const int FALSE = 0; //boolsk variabel
|
||||
const int TRUE = !FALSE; //boolsk variabel
|
||||
const int BUFFERSIZE = 100; //för säker inmatning
|
||||
const int FILENAMESIZE = 8; //för MS-DOS 6.0
|
||||
const int NAMESIZE = 20; //antal tecken som kan matas in som namn
|
||||
const int NUMBERSIZE = 20; //antal tecken som kan matas in som nummer
|
||||
const int ENTER = 13; //ASCII kod för enter
|
||||
const int BACKSPACE = 8; //ASCII kod för backspace
|
||||
|
||||
//typedef int bool; //definierar boolsk variabel
|
||||
typedef char nameType[NAMESIZE]; //sätter nametypen till char
|
||||
typedef char numberType[NUMBERSIZE]; //sätter numberTypen till char
|
||||
struct treeNode; //förvarnar datorn om en struct
|
||||
typedef treeNode* ptrType; //ger en pekartype till en struct
|
||||
struct treeNode{ //en nod i trädet
|
||||
|
||||
nameType name;
|
||||
numberType number;
|
||||
ptrType left;
|
||||
ptrType right;
|
||||
int height;
|
||||
treeNode(nameType oneName,numberType number,
|
||||
ptrType left, ptrType right,
|
||||
int height);
|
||||
};
|
||||
|
||||
class treeClass
|
||||
{
|
||||
public:
|
||||
treeClass();
|
||||
~treeClass(){};
|
||||
ptrType node;
|
||||
ptrType seek(ptrType node, nameType value);
|
||||
bool isEmpty();
|
||||
void destroyTree(ptrType &node);
|
||||
void setHeight(ptrType &node);
|
||||
void rotation(ptrType &node);
|
||||
void inOrder(ptrType treeNode);
|
||||
void del(ptrType &node, nameType oneName);
|
||||
void insert(ptrType &node,nameType oneName,numberType number, int height);
|
||||
void save(ptrType node, fstream &fil);
|
||||
private:
|
||||
int balance(ptrType &node);
|
||||
int maxHeight(ptrType &node);
|
||||
int size;
|
||||
void singleLeft(ptrType &node);
|
||||
void singleRight(ptrType &node);
|
||||
void doubleRL(ptrType &node);
|
||||
void doubleLR(ptrType &node);
|
||||
void delLeft(ptrType &node, nameType oneName, numberType oneNumber);
|
||||
void delRoot(ptrType &node);
|
||||
};
|
||||
#endif
|
||||
|
||||
|
||||
273
AVL_tree/huvud.cpp
Normal file
273
AVL_tree/huvud.cpp
Normal file
@@ -0,0 +1,273 @@
|
||||
//##################################################################
|
||||
// PROGRAMMERINGSUPPGIFT 2
|
||||
// DATASTRUKTURER OCH ALGORITMER
|
||||
// AVL TRÄD
|
||||
//==================================================================
|
||||
// HUVUD.CPP
|
||||
// Filen innehåller huvudprogrammet
|
||||
// Christian Ohlsson
|
||||
// Karlstad 980927
|
||||
//==================================================================
|
||||
|
||||
#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;
|
||||
}
|
||||
*/
|
||||
//##################################################################
|
||||
// SÄTTER IN EN NOD I TRÄD
|
||||
// calls: treeClass::insert, treeclass::seek, treeClass::setHeight
|
||||
// treeClass::rotation
|
||||
//==================================================================
|
||||
void _insert(treeClass &myTree)
|
||||
{
|
||||
nameType oneName;
|
||||
numberType number;
|
||||
int height=0;
|
||||
|
||||
cout <<"\n Ange namn: ";
|
||||
cin >> oneName;
|
||||
if(strlen(oneName) > NAMESIZE)
|
||||
cout << "\n Man kan högst ange namnet med " << NAMESIZE << " tecken";
|
||||
else {
|
||||
if(myTree.seek(myTree.node, oneName) != NULL)
|
||||
cout << "\n Du har redan satt in "
|
||||
<< oneName << " i katalogen";
|
||||
else {
|
||||
cout <<"\n Ange telefonnummer: ";
|
||||
cin >> number;
|
||||
if (strlen(number) > NUMBERSIZE)
|
||||
cout << "\n Man kan högst ange nummret med " << NUMBERSIZE << " tecken";
|
||||
else {
|
||||
myTree.insert(myTree.node,oneName,number,height);
|
||||
myTree.setHeight(myTree.node);
|
||||
myTree.rotation(myTree.node);
|
||||
myTree.setHeight(myTree.node);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
// getch();
|
||||
}
|
||||
//##################################################################
|
||||
// TAR BORT EN NOD UR TRÄD
|
||||
// calls: treeClass::del, treeClass::isEmpty, treeclass::seek
|
||||
// treeClass::setHeight, treeClass::rotation
|
||||
//==================================================================
|
||||
void _del(treeClass &myTree)
|
||||
{
|
||||
if(!myTree.isEmpty()) {
|
||||
nameType oneName;
|
||||
|
||||
cout << "\n Vem vill du ta bort: ";
|
||||
cin >> oneName;
|
||||
if(strlen(oneName) > NAMESIZE)
|
||||
cout << "\n Man kan högst ange namnet med " << NAMESIZE << " tecken";
|
||||
else {
|
||||
if(myTree.seek(myTree.node, oneName) == NULL)
|
||||
cerr << "\n " << oneName << " finns inte i katalogen. ";
|
||||
else {
|
||||
myTree.del(myTree.node, oneName);
|
||||
myTree.setHeight(myTree.node);
|
||||
myTree.rotation(myTree.node);
|
||||
myTree.setHeight(myTree.node);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
cerr << "\n Telefonkatalogen är tom... ";
|
||||
// getch();
|
||||
}
|
||||
//##################################################################
|
||||
// SKRIVER UT I INORDER
|
||||
// calls: treeClass::inOrder, treeClass::isEmpty
|
||||
//==================================================================
|
||||
void _inOrder(treeClass myTree)
|
||||
{
|
||||
if(!myTree.isEmpty()) {
|
||||
// clrscr();
|
||||
cout << setw(NAMESIZE)
|
||||
<< "Namn"
|
||||
<< setw(NAMESIZE)
|
||||
<< "Telefon"
|
||||
<< setw(NAMESIZE)
|
||||
<< "Höjd \n"
|
||||
<< setw(NAMESIZE)
|
||||
<< " ------------------------------------------------------------------ \n";
|
||||
myTree.inOrder(myTree.node);
|
||||
}
|
||||
else
|
||||
cerr << "\n Telefonkatalogen är tom... ";
|
||||
// getch();
|
||||
}
|
||||
//##################################################################
|
||||
// SÖKER I TRÄDET
|
||||
// calls: treeClass::seek, treeClass::isEmpty
|
||||
//==================================================================
|
||||
void _seek(treeClass myTree)
|
||||
{
|
||||
if(!myTree.isEmpty()) {
|
||||
nameType oneName;
|
||||
cout << "\n Mata in namn: ";
|
||||
cin >> oneName;
|
||||
ptrType tempNode = myTree.seek(myTree.node, oneName);
|
||||
if(tempNode != NULL)
|
||||
cout << "\n " << tempNode->name
|
||||
<< " har telefonnummer: "
|
||||
<< tempNode->number;
|
||||
else
|
||||
cout << "\n " << oneName << " fanns inte med i katalogen...";
|
||||
}
|
||||
else
|
||||
cerr << "\n Telefonkatalogen är tom... ";
|
||||
// getch();
|
||||
}
|
||||
//##################################################################
|
||||
// SPARAR TRÄDET PÅ FIL
|
||||
// calls: treeClass::save, treeClass::isEmpty
|
||||
//==================================================================
|
||||
void _save(treeClass myTree)
|
||||
{
|
||||
if(!myTree.isEmpty()) {
|
||||
fstream fil;
|
||||
char filnamn[FILENAMESIZE];
|
||||
cout << "\n Ange filnamn att spara: ";
|
||||
cin >> filnamn;
|
||||
fil.open(filnamn,ios::out|ios::binary);
|
||||
myTree.save(myTree.node, fil);
|
||||
fil.close();
|
||||
}
|
||||
else {
|
||||
cerr << "\n Telefonkatalogen är tom...";
|
||||
// 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, treeClass::isEmpty, treeClass::setHeight
|
||||
// treeClass::rotation
|
||||
//==================================================================
|
||||
void _load(treeClass &myTree)
|
||||
{
|
||||
if(myTree.isEmpty()) {
|
||||
fstream fil;
|
||||
numberType number;
|
||||
nameType oneName;
|
||||
char filnamn[FILENAMESIZE];
|
||||
|
||||
cout << "\n Ange filnamn att hämta: ";
|
||||
cin >> filnamn;
|
||||
fil.open(filnamn,ios::in|ios::binary);
|
||||
if(fil)
|
||||
while(fil.peek() != EOF) {
|
||||
fil.read((char*)&oneName,sizeof(oneName));
|
||||
fil.read((char*)&number,sizeof(number));
|
||||
myTree.insert(myTree.node, oneName,number,0);
|
||||
myTree.setHeight(myTree.node);
|
||||
myTree.rotation(myTree.node);
|
||||
myTree.setHeight(myTree.node);
|
||||
}
|
||||
else {
|
||||
cerr << "\n Filen finns inte...";
|
||||
// getch();
|
||||
}
|
||||
fil.close();
|
||||
}
|
||||
else {
|
||||
cerr << "\n Det finns redan personer i katalogen. \n"
|
||||
<< " Du måste ta bort samtliga personer \n"
|
||||
<< " genom att välja detta i menyn. \n";
|
||||
// getch();
|
||||
}
|
||||
}
|
||||
//##################################################################
|
||||
// DESTROYTREE
|
||||
// tar bort hela trädet
|
||||
// calls: treeClass::isEmpty, treeClass::destroyTree
|
||||
//==================================================================
|
||||
void _destroyTree(treeClass &myTree)
|
||||
{
|
||||
if(!myTree.isEmpty())
|
||||
myTree.destroyTree(myTree.node);
|
||||
else {
|
||||
cerr << "\n Telefonkatalogen är tom...";
|
||||
// getch();
|
||||
}
|
||||
}
|
||||
//##################################################################
|
||||
// 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 i bokstavsordning "
|
||||
<< " \n 5. Spara på fil "
|
||||
<< " \n 6. Hämta från fil "
|
||||
<< " \n 7. Radera hela trädet "
|
||||
<< " \n 0. Avsluta "
|
||||
<< " \n ";
|
||||
// gotoxy(2,12); //ställer markören under menyn
|
||||
}
|
||||
//##################################################################
|
||||
// MAIN FUNCTION
|
||||
// skapar trädet myTree av typen treeClass
|
||||
// calls: alla drivrutiner
|
||||
//==================================================================
|
||||
void main()
|
||||
{
|
||||
treeClass myTree;
|
||||
char val;
|
||||
do {
|
||||
meny();
|
||||
cin >> val;
|
||||
// val = mataInChar();;
|
||||
switch (val)
|
||||
{
|
||||
case '1' : _insert(myTree);break;
|
||||
case '2' : _del(myTree);break;
|
||||
case '3' : _seek(myTree);break;
|
||||
case '4' : _inOrder(myTree);break;
|
||||
case '5' : _save(myTree);break;
|
||||
case '6' : _load(myTree);break;
|
||||
case '7' : _destroyTree(myTree);break;
|
||||
case '0' : cout << "\n Programmet avslutat";break;
|
||||
default : cerr << "\n Felaktigt val";
|
||||
// getch();
|
||||
}
|
||||
}while(val != '0');
|
||||
}
|
||||
|
||||
|
||||
BIN
AVL_tree/run_me
Normal file
BIN
AVL_tree/run_me
Normal file
Binary file not shown.
344
AVL_tree/tree.cpp
Normal file
344
AVL_tree/tree.cpp
Normal file
@@ -0,0 +1,344 @@
|
||||
//##################################################################
|
||||
// PROGRAMMERINGSUPPGIFT 2
|
||||
// DATASTRUKTURER OCH ALGORITMER
|
||||
// AVL TRÄD
|
||||
//==================================================================
|
||||
// TREE.CPP
|
||||
// Filen innehåller funktioner för trädet
|
||||
// Christian Ohlsson
|
||||
// Karlstad 980927
|
||||
//==================================================================
|
||||
|
||||
#include "header.hpp"
|
||||
|
||||
//##################################################################
|
||||
// SKAPAR ETT TRÄD & SÄTTER NODE TILL NULL
|
||||
//==================================================================
|
||||
treeClass::treeClass():node(NULL)
|
||||
{
|
||||
}
|
||||
//##################################################################
|
||||
// DESTROYTREE
|
||||
// traverserar genom trädet rekursivt
|
||||
// och raderar hela trädet
|
||||
// pre: att det finns ett träd
|
||||
// post: samtliga noder i trädet är borttagna
|
||||
// calls: destroyTree (rekursivt)
|
||||
//==================================================================
|
||||
void treeClass::destroyTree(ptrType &node)
|
||||
{
|
||||
if(node->left != NULL)
|
||||
destroyTree(node->left);
|
||||
if(node->right != NULL)
|
||||
destroyTree(node->right);
|
||||
delete node;
|
||||
node = NULL;
|
||||
}
|
||||
//##################################################################
|
||||
// SKAPAR EN NOD
|
||||
// pre: TRUE
|
||||
// post: en ny nod har skapats
|
||||
//==================================================================
|
||||
treeNode::treeNode(nameType oneName,numberType oneNumber,
|
||||
ptrType L, ptrType R, int H) : left(L),right(R),height(H)
|
||||
{
|
||||
strcpy(name, oneName);
|
||||
strcpy(number,oneNumber);
|
||||
}
|
||||
//##################################################################
|
||||
// SÖKER EFTER ETT ELEMENT I TRÄDET
|
||||
// pre: att trädet inte är tomt
|
||||
// post: NULL om noden inte fanns
|
||||
// post: sökta noden om den fanns med
|
||||
// calls: seek (rekursivt)
|
||||
//==================================================================
|
||||
ptrType treeClass::seek(ptrType node, nameType oneName)
|
||||
{
|
||||
ptrType treeNodeFound;
|
||||
if(node == NULL)
|
||||
treeNodeFound = NULL;
|
||||
else if (strcmp(node->name, oneName) == 0)
|
||||
treeNodeFound = node;
|
||||
else if (strcmp(node->name, oneName) > 0)
|
||||
treeNodeFound = seek(node->left, oneName);
|
||||
else
|
||||
treeNodeFound = seek(node->right, oneName);
|
||||
return treeNodeFound;
|
||||
}
|
||||
//##################################################################
|
||||
// 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 (node==NULL)
|
||||
return TRUE;
|
||||
return FALSE;
|
||||
}
|
||||
//##################################################################
|
||||
// SKRIVER UT TRÄDET I INORDER
|
||||
// pre: att trädet inte är tomt
|
||||
// post: trädet har skrivits ut i bokstavsordning
|
||||
// calls: inOrder (rekursivt)
|
||||
//==================================================================
|
||||
void treeClass::inOrder(ptrType treeNode)
|
||||
{
|
||||
if(treeNode) {
|
||||
inOrder(treeNode->left);
|
||||
cout << setw(NAMESIZE)
|
||||
<< treeNode->name
|
||||
<< setw(NAMESIZE)
|
||||
<< treeNode->number
|
||||
<< setw(NAMESIZE)
|
||||
<< treeNode->height << endl;
|
||||
inOrder(treeNode->right);
|
||||
}
|
||||
}
|
||||
//##################################################################
|
||||
// SÄTTER IN EN NOD I TRÄDET
|
||||
// pre: att personen inte redan finns
|
||||
// post: trädet har fått en ny nod insatt
|
||||
// på rätt plats.
|
||||
// calls: insert (rekursivt)
|
||||
//==================================================================
|
||||
void treeClass::insert(ptrType &node,nameType oneName,numberType number, int height)
|
||||
{
|
||||
if(node==NULL)
|
||||
node=new treeNode(oneName,number,NULL,NULL,height);
|
||||
else if(strcmp(oneName, node->name) < 0)
|
||||
insert(node->left,oneName,number,height);
|
||||
else
|
||||
insert(node->right,oneName,number,height);
|
||||
}
|
||||
//##################################################################
|
||||
// SÖKER SIG FRAM TILL NODEN SOM SKALL TAS BORT
|
||||
// pre: att det finns ett träd
|
||||
// pre: att noden finns
|
||||
// post: noden har hittats
|
||||
// calls: delRoot, del (rekursivt)
|
||||
//==================================================================
|
||||
void treeClass::del(ptrType &node, nameType oneName)
|
||||
{
|
||||
if(strcmp(oneName,node->name) == 0)
|
||||
delRoot(node);
|
||||
else if(strcmp(oneName,node->name) < 0)
|
||||
del(node->left, oneName);
|
||||
else
|
||||
del(node->right,oneName);
|
||||
}
|
||||
//##################################################################
|
||||
// TAR BORT EN NODEN OM DEN INT HAR TVÅ BARN
|
||||
// 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
|
||||
//==================================================================
|
||||
void treeClass::delRoot(ptrType &node)
|
||||
{
|
||||
ptrType delPtr;
|
||||
nameType nyItem;
|
||||
numberType nyNumber;
|
||||
|
||||
if(node != NULL) {
|
||||
if((node->left == NULL) && (node->right == NULL)) {
|
||||
delete node;
|
||||
node = NULL;
|
||||
}
|
||||
else if(node->left == NULL) {
|
||||
delPtr = node;
|
||||
node = node->right;
|
||||
delPtr->right = NULL;
|
||||
delete delPtr;
|
||||
}
|
||||
else if(node->right == NULL) {
|
||||
delPtr = node;
|
||||
node = node->left;
|
||||
delPtr->left = NULL;
|
||||
delete delPtr;
|
||||
}
|
||||
else {
|
||||
delLeft(node->right, nyItem, nyNumber);
|
||||
strcpy(node->name, nyItem);
|
||||
strcpy(node->number, nyNumber);
|
||||
}
|
||||
}
|
||||
}
|
||||
//##################################################################
|
||||
// TAR BORT EN NOD 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 &node, nameType oneName, numberType oneNumber)
|
||||
{
|
||||
if((node != NULL) && (node->left == NULL)) {
|
||||
strcpy(oneName, node->name);
|
||||
strcpy(oneNumber, node->number);
|
||||
ptrType delPtr = node;
|
||||
node = node->right;
|
||||
delPtr->right = NULL;
|
||||
delete delPtr;
|
||||
}
|
||||
else
|
||||
delLeft(node->left, oneName, oneNumber);
|
||||
}
|
||||
//##################################################################
|
||||
// ROTATI0N
|
||||
// roterar trädet så att det blir ett AVL träd
|
||||
// pre: att det finns ett träd
|
||||
// post: trädets alla noder sitter balanserade
|
||||
// calls: rotation (rekursivt), balance,
|
||||
// singleLeft, singleRight, doubleRL, doubleLR
|
||||
//==================================================================
|
||||
void treeClass::rotation(ptrType &node)
|
||||
{
|
||||
if(node) {
|
||||
rotation(node->left);
|
||||
rotation(node->right);
|
||||
if(balance(node) == 2) {
|
||||
if(balance(node->right) >= 1)
|
||||
singleLeft(node);
|
||||
else if(balance(node->right) <= -1)
|
||||
doubleRL(node);
|
||||
}
|
||||
else if(balance(node) == -2) {
|
||||
if(balance(node->left) >= 1)
|
||||
doubleLR(node);
|
||||
else if(balance(node->left) <= -1)
|
||||
singleRight(node);
|
||||
}
|
||||
}
|
||||
}
|
||||
//##################################################################
|
||||
// BALANSERAR TRÄDET
|
||||
// returnerar högerbarnets höjd minus vänsterbarnets
|
||||
// pre: att trädet inte är tomt
|
||||
// post: höjddifferansen är returnerad
|
||||
// calls: none
|
||||
//==================================================================
|
||||
int treeClass::balance(ptrType &node) //eg root
|
||||
{
|
||||
int leftValue, rightValue;
|
||||
if(node->left == NULL)
|
||||
leftValue = -1;
|
||||
else
|
||||
leftValue = node->left->height;
|
||||
if(node->right == NULL)
|
||||
rightValue = -1;
|
||||
else
|
||||
rightValue = node->right->height;
|
||||
return (rightValue - leftValue);
|
||||
}
|
||||
//##################################################################
|
||||
// SINGLE LEFT ROTATION
|
||||
// roterar åt vänster
|
||||
// pre: att det finns ett träd
|
||||
// post: trädet är vänsterroterat
|
||||
// calls: none
|
||||
//==================================================================
|
||||
void treeClass::singleLeft(ptrType &node)
|
||||
{
|
||||
ptrType oldNode = node;
|
||||
node = node->right;
|
||||
oldNode->right = node->left;
|
||||
node->left = oldNode;
|
||||
}
|
||||
//##################################################################
|
||||
// SINGLE RIGHT ROTATION
|
||||
// roterar åt höger
|
||||
// pre: att det finns ett träd
|
||||
// post: trädet är högerroterat
|
||||
// calls: none
|
||||
//==================================================================
|
||||
void treeClass::singleRight(ptrType &node)
|
||||
{
|
||||
ptrType oldNode = node;
|
||||
node = node->left;
|
||||
oldNode->left = node->right;
|
||||
node->right = oldNode;
|
||||
}
|
||||
//##################################################################
|
||||
// DOUBLE RIGHT-LEFT ROTATION
|
||||
// Utför en dubbel höger-vänster rotation
|
||||
// pre: att det finns ett träd
|
||||
// post: trädet är höger-vänster roterat
|
||||
// calls: singleRight, singleLeft
|
||||
//==================================================================
|
||||
void treeClass::doubleRL(ptrType &node)
|
||||
{
|
||||
singleRight(node->right);
|
||||
singleLeft(node);
|
||||
}
|
||||
//##################################################################
|
||||
// DOUBLE LEFT-RIGHT ROTATION
|
||||
// Utför en dubbel vänster-höger rotation
|
||||
// pre: att det finns ett träd
|
||||
// post: trädet är vänster-höger roterat
|
||||
// calls: singleLeft, singleRight
|
||||
//==================================================================
|
||||
void treeClass::doubleLR(ptrType &node)
|
||||
{
|
||||
singleLeft(node->left);
|
||||
singleRight(node);
|
||||
}
|
||||
//##################################################################
|
||||
// SÄTTER ALLA HÖJDER I TRÄDET I POSTORDER
|
||||
// pre: att trädet inte är tomt
|
||||
// post: noderna i trädet har alla rätt höjd
|
||||
// calls: setHeight (rekursivt), maxHeight
|
||||
//==================================================================
|
||||
void treeClass::setHeight(ptrType &node)
|
||||
{
|
||||
if(node) {
|
||||
setHeight(node->left);
|
||||
setHeight(node->right);
|
||||
node->height = maxHeight(node) +1;
|
||||
}
|
||||
}
|
||||
//##################################################################
|
||||
// FINNER MAXIMAL HÖJD EN NOD BEFINNER SIG PÅ
|
||||
// pre: att trädet inte är tomt
|
||||
// post: maxhöjden har returnerats
|
||||
// calls: inget
|
||||
//==================================================================
|
||||
int treeClass::maxHeight(ptrType &node)
|
||||
{
|
||||
int max;
|
||||
if(node->left && node->right) {
|
||||
max = node->left->height;
|
||||
if(node->right->height > max)
|
||||
return (node->right->height);
|
||||
else
|
||||
return max;
|
||||
}
|
||||
else if(node->left)
|
||||
return (node->left->height);
|
||||
else if(node->right)
|
||||
return (node->right->height);
|
||||
else
|
||||
return (-1);
|
||||
}
|
||||
//##################################################################
|
||||
// SPARAR TRÄDET PÅ FIL
|
||||
// läser av nodens namn och nummer 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 node, fstream &fil)
|
||||
{
|
||||
if(node) {
|
||||
fil.write((char*)&node->name,sizeof(node->name));
|
||||
fil.write((char*)&node->number,sizeof(node->number));
|
||||
save(node->left,fil);
|
||||
save(node->right,fil);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user