commit c4d164d8c33022f4a2b8e04486f2b3dbc4672169 Author: Christian Ohlsson Date: Thu Mar 5 13:39:39 2026 +0100 Startpunkten diff --git a/AVL_tree/header.hpp b/AVL_tree/header.hpp new file mode 100644 index 0000000..dd5a123 --- /dev/null +++ b/AVL_tree/header.hpp @@ -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 +#include +#include +#include +#include +//#include +#include + +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 + + diff --git a/AVL_tree/huvud.cpp b/AVL_tree/huvud.cpp new file mode 100644 index 0000000..45739d9 --- /dev/null +++ b/AVL_tree/huvud.cpp @@ -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'); +} + + diff --git a/AVL_tree/run_me b/AVL_tree/run_me new file mode 100644 index 0000000..eb95391 Binary files /dev/null and b/AVL_tree/run_me differ diff --git a/AVL_tree/tree.cpp b/AVL_tree/tree.cpp new file mode 100644 index 0000000..a9df706 --- /dev/null +++ b/AVL_tree/tree.cpp @@ -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); + } +} + + diff --git a/Dijkstra/NeverNeverLand.doc b/Dijkstra/NeverNeverLand.doc new file mode 100644 index 0000000..3d80696 Binary files /dev/null and b/Dijkstra/NeverNeverLand.doc differ diff --git a/Dijkstra/dijkstra.exe b/Dijkstra/dijkstra.exe new file mode 100644 index 0000000..89e3f0a Binary files /dev/null and b/Dijkstra/dijkstra.exe differ diff --git a/Dijkstra/graf.cpp b/Dijkstra/graf.cpp new file mode 100644 index 0000000..f732c0e --- /dev/null +++ b/Dijkstra/graf.cpp @@ -0,0 +1,285 @@ +/************************************************ +* Laboration 4 i +* Datastrukturer och Algoritmer +* Dijkstras Shortest Path +************************************************* +* Christian Ohlsson +* Karlstads universitet, 1999 +* +* graf.cpp +* Innehåller de funktioner programmet +* använder sig av för att beräkna +* den kortaste vägen +*************************************************/ + +#include "header.h" +/*=============================================== +* graphNode +* Construktor. +* Skapar en graphNode +-------------------------------------------------*/ +graphNode::graphNode() { + startCity = -1; + endCity = -1; + Start = 0; + End = 0; +} + +/*=============================================== +* Operator == +* Operatoröverlagring +-------------------------------------------------*/ + +int graphNode::operator==(graphNode node) { + if(Start != node.Start || End != node.End || + startCity != node.startCity || endCity != node.endCity) + return false; + return true; +} + +/*=============================================== +* Operator = +* Operatoröverlagring +-------------------------------------------------*/ +void graphNode::operator=(graphNode node) { + startCity = node.startCity; + endCity = node.endCity; + Start = node.Start; + End = node.End; +} + +/*=============================================== +* Operator > +* Operatoröverlagring +-------------------------------------------------*/ +int graphNode::operator>(graphNode node) { + if(Start <= node.Start) + return false; + return true; +} + +/*=============================================== +* dijkstraNode +* Construktor. +* Skapar en Dijkstra node +-------------------------------------------------*/ +dijkstraNode::dijkstraNode() { + deleted = false; + lastCity = 0; + Totaltime = MAXINT; //Tiden sätts till max +} + +/*=============================================== +* ~dijkstraNode +* Destruktor. +* Tar bort en nod +-------------------------------------------------*/ +dijkstraNode::~dijkstraNode() {} + +/*=============================================== +* graph +* Construktor +* Skapar en graph +-------------------------------------------------*/ +graph::graph() { + visitedCities = 0; + table = NULL; + lastPath = NULL; + prevSize = 0; + lastTime = 0; +} + +/*=============================================== +* ~graph +* Destruktor +* Anropar deleteGraph +-------------------------------------------------*/ +graph::~graph() { deleteGraph(); } + +/*=============================================== +* deleteGraph +* Tömmer grafen på info +-------------------------------------------------*/ +void graph::deleteGraph() { + if(table != NULL) + delete[] table; + if(lastPath != NULL) + delete[] lastPath; + table = NULL; + lastPath = NULL; + visitedCities = 0; + prevSize = 0; + lastTime = 0; +} + +/*=============================================== +* makeGraph +* Skapar en graf med size stycken städer. +* Tar först bort eventuell gammal graf. +* Returnerar true om allt gick bra +-------------------------------------------------*/ +int graph::makeGraph(int size) { + deleteGraph(); + table = new list*[size]; + if(table == NULL) + return false; + for(int index = 0; index < size; index++) + table[index] = new list[size]; + if(table == NULL) + return false; + visitedCities = size; + return true; +} + +/*=============================================== +* connect +* Skapar förbindelse mellan noderna i grafen +-------------------------------------------------*/ +void graph::connect(int startvertex, int endvertex, graphNode node) { + if(startvertex < 0 || startvertex > visitedCities-1 || + endvertex < 0 || endvertex > visitedCities-1) + return; + node.startCity = startvertex; + node.endCity = endvertex; + table[startvertex][endvertex].insert(node); +} + +/*=============================================== +* shortestPath +* Letar reda på den kortaste +* vägen mellan två noder +-------------------------------------------------*/ +graphNode graph::shortestPath(int startvertex, int endvertex, int time) { + int index, time1, time2; + graphNode node1, node2; + if(startvertex < 0 || startvertex > visitedCities-1 || + endvertex < 0 || endvertex > visitedCities-1) + return node1; + int connections = table[startvertex][endvertex].listLength(); + if(connections == 0) return node1; + node1 = table[startvertex][endvertex].printElement(1); + time1 = getTime(node1, time); + for(index = 2; index <= connections; index++) { + node2 = table[startvertex][endvertex].printElement(index); + time2 = getTime(node2, time); + if(time1 > time2) { + node1 = node2; + time1 = time2; + } + } + return node1; +} + +/*=============================================== +* getTime +* Returnerar antalet timmar mellan tiden +* time och tiden som finns i noden +-------------------------------------------------*/ +int graph::getTime(graphNode node, int time) { + int total; + if(node.Start >= time && node.End > time && node.Start < node.End) + total = node.End - time; + else if(node.Start > node.End) + total = ( (24 - time + node.Start) + (24 - node.Start + node.End) ); + else + total = (24 - time + node.End); + return total; +} + +/*=============================================== +* dijkstra +* Beräknar den kortaste sträckan dvs. tiden +* mellan två städer i NeverNeverLand +-------------------------------------------------*/ +void graph::dijkstra(int startvertex, int endvertex, int time) { + delPath(); + if(startvertex == endvertex || startvertex < 0 || + startvertex > visitedCities-1 || endvertex < 0 || + endvertex > visitedCities-1) + return; + + dijkstraNode *temparray = new dijkstraNode[visitedCities]; + if(temparray == NULL) return; + int min, index, parent = 0, temptime; + graphNode tempnode; + temparray[startvertex].Totaltime = 0; + temparray[startvertex].deleted = true; + min = startvertex; + while(min != endvertex) { + for(index = 0; index < visitedCities; index++) { + if(!temparray[index].deleted) { + tempnode = shortestPath(min, index, time); + if(tempnode.startCity != -1) { + temptime = getTime(tempnode, time); + if((temptime + temparray[min].Totaltime) + < temparray[index].Totaltime) { + temparray[index].Totaltime = + temptime + temparray[min].Totaltime; + if(parent == 0) + temparray[index].lastCity = 0; + else + temparray[index].lastCity = min; + temparray[index].Node = tempnode; + } + } + } + } + min = getMinTime(temparray); + temparray[min].deleted = true; + time = temparray[min].Node.End; + parent++; + } + calcPath(temparray, min); +} + +/*=============================================== +* calcPath +* Skapar en array med information +* om den kortaste vägen. +-------------------------------------------------*/ +void graph::calcPath(dijkstraNode *array, int start) { + graphNode *path = new graphNode[visitedCities]; + if(path == NULL) + return; + int temp = 1, index = start; + while(array[index].lastCity > 0) { + temp++; + index = array[index].lastCity; + } + prevSize = temp; + lastTime = array[start].Totaltime; + for(index = temp-1; index >= 0; index--) { + path[index] = array[start].Node; + start = array[start].lastCity; + } + lastPath = path; +} + +/*=============================================== +* getMinIndex +* Hittar den minsta noden i en array och +* returnerar dess index i arrayen +-------------------------------------------------*/ +int graph::getMinTime(dijkstraNode *temptable) { + int temp = 0, index; + while(temptable[temp].deleted) + temp++; + for(index = temp+1; index < visitedCities; index++) { + if(!temptable[index].deleted) { + if(temptable[temp].Totaltime > temptable[index].Totaltime) + temp = index; + } + } + return temp; +} + +/*=============================================== +* delPath +* Tar bort det som lastpath pekar på +-------------------------------------------------*/ +void graph::delPath() { + if(lastPath != NULL) + delete[] lastPath; + lastPath = NULL; + prevSize = 0; +} diff --git a/Dijkstra/graf.h b/Dijkstra/graf.h new file mode 100644 index 0000000..6250c81 --- /dev/null +++ b/Dijkstra/graf.h @@ -0,0 +1,75 @@ +/************************************************ +* Laboration 4 i +* Datastrukturer och Algoritmer +* Dijkstras Shortest Path +************************************************* +* Christian Ohlsson +* Karlstads universitet, 1999 +* +* Graph.h +* Innehåller de definitioner och klasser +* som används för att beräkna kortaste +* vägen mellan två städer +*************************************************/ + +#ifndef _GRAPH_H_ +#define _GRAPH_H_ +#include "list.h" + +/*=============================================== +* graphNode +* Nod mellan två städer +-------------------------------------------------*/ +class graphNode { + public: + graphNode(); //Construktor + ~graphNode() {}; //Destruktor + int startCity; //Stad man åker ifrån + int endCity; //Stad man kommer till + int Start; //Starttid + int End; //Ankomsttid + void operator=(graphNode node); //Operator-överlagring + int operator>(graphNode node); //för noder + int operator==(graphNode node); //... +}; + +/*=============================================== +* dijkstraNode +* Speciell nod för Dijkstra +-------------------------------------------------*/ +class dijkstraNode { + public: + int deleted; //Märkning för noden + int lastCity; //Föregående besökt stad + int Totaltime; //TotaL restid + dijkstraNode(); //Construktor + ~dijkstraNode(); //Destruktor + graphNode Node; //En nod +}; + +/*=============================================== +* graph +* Skapar en graf och sköter uträkningen +-------------------------------------------------*/ +class graph { + private: + int visitedCities; //Antalet traverserade städer + list **table; //Resväg + graphNode shortestPath(int startvertex, int endvertex, int time); + void delPath(); + int getTime(graphNode node, int time); + int getMinTime(dijkstraNode *temptable); + void calcPath(dijkstraNode *array, int start); + public: + int lastTime; //Tid som ökas när vi reser + int prevSize; //Antalet städer i arrayen + graphNode *lastPath; //Traverserad väg + graph(); //Construktor + ~graph(); //Destruktor + void deleteGraph(); + void connect(int startvertex, int endvertex, graphNode node); + int makeGraph(int size); + void dijkstra(int startvertex, int endvertex, int time); +}; +#endif + diff --git a/Dijkstra/header.h b/Dijkstra/header.h new file mode 100644 index 0000000..fb3bdfa --- /dev/null +++ b/Dijkstra/header.h @@ -0,0 +1,36 @@ +/************************************************ +* Laboration 4 i +* Datastrukturer och Algoritmer +* Dijkstras Shortest Path +************************************************* +* Christian Ohlsson +* Karlstads universitet, 1999 +* +* Header.h +* Innehåller definitioner och includes +* som används i programmet. +*************************************************/ + +#ifndef ___HEADER___ +#define ___HEADER___ + +#include +#include +#include +#include +#include +#include + +#include "graf.h" +#include "list.h" + +const int false=0; //boolsk variabel +const int true=!false; //boolsk variabel +const int citySize=25; //Max antal tecken i en stad +const int numOfCities=13; //Antalet städer +const int FORWARD=2; //För inläsning +const int MAXTIME = 6; //Max antal tkn +const int BASE=10; //Talbas +const int BUFFERSIZE=20; //Buffer för säker inmatning + +#endif diff --git a/Dijkstra/list.h b/Dijkstra/list.h new file mode 100644 index 0000000..911eb7c --- /dev/null +++ b/Dijkstra/list.h @@ -0,0 +1,240 @@ +/************************************************ +* Laboration 4 i +* Datastrukturer och Algoritmer +* Dijkstras Shortest Path +************************************************* +* Christian Ohlsson +* Karlstads universitet, 1999 +* +* list.h +* Innehåller definitioner och funktioner +* för en templatelista. +*************************************************/ + +#ifndef _LISTA_H_ +#define _LISTA_H_ + +#include "header.h" + +/*=============================================== +* list +* Denna klass skapar en templatelista. +* Varje nod innehåller ett godtyckligt data- +* fält och en pekare till nästa nod. +-------------------------------------------------*/ +template +class list { + private: + struct nod { // En template nod + T data; + nod *next; + }; + int size; // Storleken på listan. + nod *head; // Pekar på första elementet i listan. + public: + list(); + ~list(); + int listLength(); //Storleken på listan + void insert(T data); //Sätter in en nod + void del(int place); //Tar bort en nod + void sort(void); //Sorterar listan + int seek(T data); //Söker i listan + int isFree(void); //Kollar om det finns element i listan + void delAll(void); //Tar bort allt i listan + int occupiedExist(T data); //Kollar om inmatat värde existerar + int occupied(int place); //Testar om det finns plats + void setNode(nod *dat, T data); //Mata in data i den nya noden + T printElement(int place); //Visar Innehållet på bestämd plats. + T *getPtr(int place); //Returnera platsen på place position +}; + + +/*=============================================== +* list +* Construktor, skapar en lista +-------------------------------------------------*/ +template +list::list() { + head = NULL; + size = 0; +} + +/*=============================================== +* ~list +* Destruktor. Anropar delAll +-------------------------------------------------*/ +template +list::~list() { delAll(); } + +/*=============================================== +* insert +* Sätter in en ny nod i listan +-------------------------------------------------*/ +template +void list::insert(T data) { + nod *newNode = new nod; + newNode->next = head; + head = newNode; + size++; + newNode->data = data; +} + +/*=============================================== +* del +* Tar bort ett element på en viss +* position i listan +-------------------------------------------------*/ +template +void list::del(int place) { + int i = 1; + nod *temp1; + temp1 = head; + nod *temp2; + temp2 = head->next; + if(temp2 == NULL || place == 1) { //Bara ett element i listan + head = temp1->next; + delete temp1; + size--; + } + else { //Flera element i listan + temp2 = head; + while(i < place) { + temp1 = temp2; + temp2 = temp1->next; + i++; + } + temp1->next = temp2->next; + delete temp2; + size--; + } +} + +/*=============================================== +* isFree +* Kollar om listan är tom. Returnerar +* true om listan är tom +-------------------------------------------------*/ +template +int list::isFree() { + if(size == 0) return true; + else return false; +} + +/*=============================================== +* occupied +* Kollar om plats finns på en angiven +* position. +-------------------------------------------------*/ +template +int list::occupied(int place) { + if( (place < 1) || (place > size) ) return false; + else return true; +} + +/*=============================================== +* listLength +* Returnerar antalet element i listan +-------------------------------------------------*/ +template +int list::listLength() { return size; } + +/*=============================================== +* sort +* Sorterar elementen i listan +-------------------------------------------------*/ +template +void list::sort() { + nod *temp; + T sop; + int changed; + do { + changed = 0; + for(temp = head; temp != NULL; temp = temp->next) + if(temp->data > temp->next->data) { + sop = temp->data; + temp->data = temp->next->data; + temp->next->data = sop; + changed = 1; + } + }while(changed); +} + +/*=============================================== +* delAll +* Tar bort alla element i listan. +* Sätter sedan storleken till 0 +-------------------------------------------------*/ +template +void list::delAll() { + nod *temp1 = head; + nod *temp2; + head = NULL; + while(temp1 != NULL) { + temp2 = temp1; + temp1 = temp1->next; + delete temp2; + } + size = 0; +} + +/*=============================================== +* +* +-------------------------------------------------*/ +template +int list::occupiedExist(T data) { //Kollar om inmatat värde existerar + nod *temp; + for(temp = head; temp != NULL; temp = temp->next) + if(temp->data == data) + return true; + return false; +} + +/*=============================================== +* +* +-------------------------------------------------*/ +template +int list::seek(T data) { //Söker efter ett element i listan + nod *temp; + int position = 0; + for(temp = head; temp != NULL; temp = temp->next) { + position++; + if(temp->data == data) + return position; //Funnet! Returnera positionen + } + position = 0; + return position; //Inget hittades, returnera 0 +} + +/*=============================================== +* printElement +* Hämtar element på en angiven plats +-------------------------------------------------*/ +template +T list::printElement(int place) { + nod *temp1 = head; + int i = 1; + while(i < place && i < size) { + temp1 = temp1->next; + i++; + } + return temp1->data; +} + +/*=============================================== +* getPtr +* Returnera adressen till ett element +* på en angiven plats +-------------------------------------------------*/ +template +T *list::getPtr(int place) { + nod *temp1 = head; + int i = 1; + while(i < place && i < size) { + temp1 = temp1->next; + i++; + } + return &(temp1->data); +} +#endif \ No newline at end of file diff --git a/Dijkstra/main.cpp b/Dijkstra/main.cpp new file mode 100644 index 0000000..31d5b6d --- /dev/null +++ b/Dijkstra/main.cpp @@ -0,0 +1,191 @@ +/************************************************ +* Laboration 4 i +* Datastrukturer och Algoritmer +* Dijkstras Shortest Path +************************************************* +* Christian Ohlsson +* Karlstads universitet, 1999 +* +* main.cpp +* Innehåller drivrutiner för +* Dijkstra labben. +* Skapat med Borland C++ 4.0 +* Låt main.cpp och graph.cpp +* finnas i projektet. +* Kompilera för Easywin, Windows 3.x +* 16-bitar, target: Small +* Se till att filen network.txt finns +* i samma katalog som dijkstra.exe +*************************************************/ + +#include "header.h" + +/*=============================================== +* cities +* Alla städer i NeverNeverLand +-------------------------------------------------*/ +const char cities[numOfCities][citySize] = { + {"Wonderland"}, + {"Sanctuary"}, + {"Battlefield"}, + {"Octopus's Garden"}, + {"Paradise City"}, + {"Strawberry Fields"}, + {"Chaos"}, + {"El Dorado"}, + {"Kozmic Place"}, + {"Oz"}, + {"Nowhereland"}, + {"Shangrila"}, + {"Southbound"} +}; + +graph myGraph; //Global klass för grafen + +/*=============================================== +* mataIn +* Ser till att bara tal matas in +-------------------------------------------------*/ +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 <<"NAN, try again: "; + } + }while (!f); + return 0; +} + +/*=============================================== +* getName +* Hämtar namn på stad, dvs det nummer staden +* motsvarar +-------------------------------------------------*/ +int getName(char *text) { + int i = 0; + while(strcmp(text, cities[i]) !=0 && i < numOfCities) + i++; + if(i >= numOfCities) return -1; + else return i; +} + +/*=============================================== +* readGraph +* Läser in alla städer och tider från fil. +-------------------------------------------------*/ +void readGraph() +{ + graphNode node; + ifstream myFile; + char temp[citySize]; + if(!myGraph.makeGraph(numOfCities)) { //Skapar en graf + cout<<"Could not make graph";getch(); + return; + } + myFile.open("network.txt"); //Öppnar filen + do { + myFile.get(temp, citySize); + node.startCity = getName(temp); //Hämtar startstad + myFile.seekg(FORWARD, ios::cur); + myFile.get(temp, citySize); + node.endCity = getName(temp); //Hämtar slutstad + myFile.seekg(FORWARD, ios::cur); + myFile.get(temp, citySize); + node.Start = atoi(temp); //Hämtar starttid + myFile.seekg(FORWARD, ios::cur); + myFile.get(temp, citySize); + node.End = atoi(temp); //Hämtar sluttid + myFile.seekg(FORWARD, ios::cur); + myGraph.connect(node.startCity, node.endCity, node); //Sätter in noden + } while(myFile.peek() != EOF); +} + +/*=============================================== +* printPath +* Skriver ut kortaste vägen +-------------------------------------------------*/ +void printPath() { + int index; + char text[citySize * 4], time[MAXTIME]; + cout << "The shortest path is:" + << "\n________________________________________________________"; + for(index = 0; index < myGraph.prevSize; index++) { + text[0] = 0; + time[0] = 0; + cout << "\nFrom " << cities[myGraph.lastPath[index].startCity]; + itoa(myGraph.lastPath[index].Start, time, BASE); + cout << " "<< time << ":00\t"; + time[0] = 0; + + cout << "to "; + cout << cities[myGraph.lastPath[index].endCity]; + itoa(myGraph.lastPath[index].End, time, BASE); + cout << " " << time << ":00\t"; + } + text[0] = 0; time[0] = 0; + itoa(myGraph.lastTime, time, BASE); + cout << "\n________________________________________________________"; + cout << "\nThe total travelling time is "<" + << "\n Welcome to the RailWay Company" + << "\n in the NeverNeverLand..." + << "\n ____________________________________________________" + << "\n | 0. Wonderland 7. El Dorado |" + << "\n | 1. Sanctuary 8. Kozmic Place |" + << "\n | 2. Battlefield 9. Oz |" + << "\n | 3. Octopus's Garden 10. Nowhereland |" + << "\n | 4. Paradise City 11. Shangrila |" + << "\n | 5. Strawberry Fields 12. Southbound |" + << "\n | 6. Chaos |" + << "\n |__________________________________________________|" + << "\n"; +} + +/*=============================================== +* main +* Huvudfunktionen för programmet. +* Läser in grafen och ber användaren +* mata in mellan vilka städer han skall resa +-------------------------------------------------*/ +void main() { + int start, end, time; + char playAgain; + readGraph(); //Läs in filen + do{ + printTowns(); //Skriv ut städerna + do { + cout <<"\nFrom wich town (0-"<<(numOfCities-1)<<"): "; + start=mataIn(); + }while(start<0 || start>numOfCities-1); + do { + cout <<"To wich town (0-"<<(numOfCities-1)<<"): "; + end=mataIn(); + }while(end<0 || end>numOfCities-1); + do { + cout <<"Time of departure (0-24): "; + time=mataIn(); + }while(time<0 || time>24); + myGraph.dijkstra(start, end, time); //Beräkna kortaste väg + if(myGraph.prevSize > 0) + printPath(); //Skriv ut vägen + else + cout <<"\nStarttown and arrivaltown are the same! Are you stupid?"; + cout <<"\n\nPlay Again (Y/N)? "; + cin >> playAgain; + }while(playAgain == 'y' || playAgain == 'Y'); +} + + diff --git a/Dijkstra/map.gif b/Dijkstra/map.gif new file mode 100644 index 0000000..daf8121 Binary files /dev/null and b/Dijkstra/map.gif differ diff --git a/Dijkstra/network.txt b/Dijkstra/network.txt new file mode 100644 index 0000000..09d4d51 --- /dev/null +++ b/Dijkstra/network.txt @@ -0,0 +1,1068 @@ +Wonderland +Sanctuary +6 +11 +Wonderland +Sanctuary +10 +15 +Wonderland +Sanctuary +14 +19 +Wonderland +Battlefield +7 +14 +Wonderland +Battlefield +9 +16 +Wonderland +Battlefield +14 +21 +Wonderland +Octopus's Garden +9 +15 +Wonderland +Octopus's Garden +12 +18 +Wonderland +Octopus's Garden +15 +21 +Sanctuary +Wonderland +7 +12 +Sanctuary +Wonderland +11 +16 +Sanctuary +Wonderland +15 +20 +Sanctuary +Octopus's Garden +6 +9 +Sanctuary +Octopus's Garden +8 +11 +Sanctuary +Octopus's Garden +10 +13 +Sanctuary +Octopus's Garden +12 +15 +Sanctuary +Octopus's Garden +14 +17 +Sanctuary +Octopus's Garden +16 +19 +Sanctuary +Octopus's Garden +18 +21 +Sanctuary +Octopus's Garden +20 +23 +Battlefield +Wonderland +5 +11 +Battlefield +Wonderland +10 +15 +Battlefield +Wonderland +15 +22 +Battlefield +Octopus's Garden +7 +12 +Battlefield +Octopus's Garden +10 +15 +Battlefield +Octopus's Garden +13 +18 +Battlefield +Octopus's Garden +16 +21 +Battlefield +Octopus's Garden +19 +24 +Battlefield +Octopus's Garden +24 +5 +Battlefield +Paradise City +6 +9 +Battlefield +Paradise City +7 +9 +Battlefield +Paradise City +8 +11 +Battlefield +Paradise City +10 +13 +Battlefield +Paradise City +12 +15 +Battlefield +Paradise City +14 +17 +Battlefield +Paradise City +15 +17 +Battlefield +Paradise City +16 +19 +Battlefield +Paradise City +18 +21 +Battlefield +Paradise City +20 +23 +Battlefield +Paradise City +21 +23 +Battlefield +Paradise City +22 +1 +Battlefield +Strawberry Fields +5 +11 +Battlefield +Strawberry Fields +9 +15 +Battlefield +Strawberry Fields +12 +16 +Battlefield +Strawberry Fields +13 +19 +Battlefield +Strawberry Fields +17 +23 +Battlefield +Strawberry Fields +20 +24 +Battlefield +Strawberry Fields +21 +3 +Battlefield +Chaos +23 +7 +Octopus's Garden +Wonderland +8 +14 +Octopus's Garden +Wonderland +11 +17 +Octopus's Garden +Wonderland +14 +20 +Octopus's Garden +Sanctuary +5 +8 +Octopus's Garden +Sanctuary +7 +10 +Octopus's Garden +Sanctuary +9 +12 +Octopus's Garden +Sanctuary +11 +14 +Octopus's Garden +Sanctuary +13 +16 +Octopus's Garden +Sanctuary +15 +18 +Octopus's Garden +Sanctuary +17 +20 +Octopus's Garden +Sanctuary +19 +22 +Octopus's Garden +Sanctuary +21 +24 +Octopus's Garden +Battlefield +6 +13 +Octopus's Garden +Battlefield +9 +14 +Octopus's Garden +Battlefield +12 +17 +Octopus's Garden +Battlefield +15 +20 +Octopus's Garden +Battlefield +18 +23 +Octopus's Garden +Battlefield +24 +5 +Octopus's Garden +Strawberry Fields +8 +12 +Octopus's Garden +Strawberry Fields +10 +14 +Octopus's Garden +Strawberry Fields +12 +16 +Octopus's Garden +Strawberry Fields +14 +18 +Octopus's Garden +Strawberry Fields +16 +20 +Octopus's Garden +Strawberry Fields +18 +22 +Octopus's Garden +Strawberry Fields +20 +24 +Octopus's Garden +Chaos +9 +14 +Octopus's Garden +Chaos +15 +20 +Octopus's Garden +Chaos +19 +24 +Octopus's Garden +Chaos +24 +5 +Paradise City +Battlefield +5 +8 +Paradise City +Battlefield +7 +10 +Paradise City +Battlefield +8 +10 +Paradise City +Battlefield +9 +12 +Paradise City +Battlefield +11 +14 +Paradise City +Battlefield +13 +16 +Paradise City +Battlefield +15 +18 +Paradise City +Battlefield +16 +18 +Paradise City +Battlefield +17 +20 +Paradise City +Battlefield +19 +22 +Paradise City +Battlefield +21 +24 +Paradise City +Battlefield +22 +24 +Paradise City +Strawberry Fields +6 +11 +Paradise City +Strawberry Fields +9 +14 +Paradise City +Strawberry Fields +12 +17 +Paradise City +Strawberry Fields +15 +20 +Paradise City +Strawberry Fields +18 +23 +Paradise City +Strawberry Fields +21 +2 +Paradise City +Strawberry Fields +24 +5 +Paradise City +Chaos +7 +13 +Paradise City +Chaos +13 +17 +Paradise City +Chaos +24 +6 +Paradise City +El Dorado +7 +11 +Paradise City +El Dorado +10 +14 +Paradise City +El Dorado +13 +17 +Paradise City +El Dorado +16 +20 +Paradise City +El Dorado +19 +23 +Paradise City +Kozmic Place +9 +14 +Paradise City +Kozmic Place +15 +20 +Strawberry Fields +Battlefield +6 +12 +Strawberry Fields +Battlefield +10 +16 +Strawberry Fields +Battlefield +11 +15 +Strawberry Fields +Battlefield +14 +20 +Strawberry Fields +Battlefield +18 +24 +Strawberry Fields +Battlefield +19 +23 +Strawberry Fields +Battlefield +22 +4 +Strawberry Fields +Octopus's Garden +7 +11 +Strawberry Fields +Octopus's Garden +9 +13 +Strawberry Fields +Octopus's Garden +11 +15 +Strawberry Fields +Octopus's Garden +13 +17 +Strawberry Fields +Octopus's Garden +15 +19 +Strawberry Fields +Octopus's Garden +17 +21 +Strawberry Fields +Octopus's Garden +19 +23 +Strawberry Fields +Paradise City +5 +10 +Strawberry Fields +Paradise City +8 +13 +Strawberry Fields +Paradise City +11 +14 +Strawberry Fields +Paradise City +14 +19 +Strawberry Fields +Paradise City +17 +22 +Strawberry Fields +Paradise City +20 +1 +Strawberry Fields +Paradise City +23 +4 +Strawberry Fields +Chaos +7 +11 +Strawberry Fields +Chaos +10 +14 +Strawberry Fields +Chaos +13 +17 +Strawberry Fields +Chaos +16 +20 +Strawberry Fields +Chaos +19 +23 +Strawberry Fields +El Dorado +6 +9 +Strawberry Fields +El Dorado +8 +11 +Strawberry Fields +El Dorado +10 +13 +Strawberry Fields +El Dorado +12 +15 +Strawberry Fields +El Dorado +14 +17 +Strawberry Fields +El Dorado +16 +19 +Strawberry Fields +El Dorado +18 +21 +Strawberry Fields +El Dorado +20 +23 +Strawberry Fields +El Dorado +22 +1 +Strawberry Fields +Oz +8 +12 +Strawberry Fields +Oz +11 +15 +Strawberry Fields +Oz +14 +18 +Strawberry Fields +Oz +17 +21 +Strawberry Fields +Oz +20 +24 +Chaos +Battlefield +24 +8 +Chaos +Octopus's Garden +10 +15 +Chaos +Octopus's Garden +16 +21 +Chaos +Octopus's Garden +20 +1 +Chaos +Octopus's Garden +24 +5 +Chaos +Paradise City +7 +13 +Chaos +Paradise City +13 +17 +Chaos +Paradise City +24 +6 +Chaos +Strawberry Fields +8 +12 +Chaos +Strawberry Fields +11 +15 +Chaos +Strawberry Fields +14 +18 +Chaos +Strawberry Fields +17 +21 +Chaos +Strawberry Fields +20 +24 +Chaos +Nowhereland +6 +11 +Chaos +Nowhereland +10 +15 +Chaos +Nowhereland +14 +19 +Oz +Strawberry Fields +8 +12 +Oz +Strawberry Fields +11 +15 +Oz +Strawberry Fields +14 +18 +Oz +Strawberry Fields +17 +21 +Oz +Strawberry Fields +20 +24 +Oz +Nowhereland +7 +12 +Oz +Nowhereland +10 +15 +Oz +Nowhereland +13 +18 +Oz +Nowhereland +16 +21 +Oz +Nowhereland +19 +24 +Oz +Nowhereland +24 +5 +Oz +Shangrila +8 +10 +Oz +Shangrila +12 +14 +Oz +Shangrila +15 +17 +Oz +Shangrila +18 +20 +Oz +Shangrila +21 +23 +Nowhereland +Chaos +7 +12 +Nowhereland +Chaos +11 +16 +Nowhereland +Chaos +15 +20 +Nowhereland +Oz +7 +12 +Nowhereland +Oz +10 +15 +Nowhereland +Oz +13 +18 +Nowhereland +Oz +16 +21 +Nowhereland +Oz +19 +24 +Nowhereland +Oz +24 +5 +El Dorado +Paradise City +8 +12 +El Dorado +Paradise City +11 +15 +El Dorado +Paradise City +14 +18 +El Dorado +Paradise City +17 +21 +El Dorado +Paradise City +20 +24 +El Dorado +Strawberry Fields +5 +8 +El Dorado +Strawberry Fields +7 +10 +El Dorado +Strawberry Fields +9 +12 +El Dorado +Strawberry Fields +11 +14 +El Dorado +Strawberry Fields +13 +16 +El Dorado +Strawberry Fields +15 +18 +El Dorado +Strawberry Fields +17 +20 +El Dorado +Strawberry Fields +19 +22 +El Dorado +Strawberry Fields +21 +24 +El Dorado +Shangrila +7 +11 +El Dorado +Shangrila +9 +13 +El Dorado +Shangrila +11 +15 +El Dorado +Shangrila +13 +17 +El Dorado +Shangrila +15 +19 +El Dorado +Shangrila +17 +21 +El Dorado +Shangrila +19 +23 +El Dorado +Kozmic Place +5 +8 +El Dorado +Kozmic Place +7 +10 +El Dorado +Kozmic Place +9 +12 +El Dorado +Kozmic Place +11 +14 +El Dorado +Kozmic Place +13 +16 +El Dorado +Kozmic Place +15 +18 +El Dorado +Kozmic Place +17 +20 +El Dorado +Kozmic Place +19 +22 +El Dorado +Kozmic Place +21 +24 +Shangrila +Oz +6 +8 +Shangrila +Oz +9 +11 +Shangrila +Oz +12 +14 +Shangrila +Oz +15 +17 +Shangrila +Oz +18 +20 +Shangrila +El Dorado +8 +12 +Shangrila +El Dorado +10 +14 +Shangrila +El Dorado +12 +16 +Shangrila +El Dorado +14 +18 +Shangrila +El Dorado +16 +20 +Shangrila +El Dorado +18 +22 +Shangrila +El Dorado +20 +24 +Shangrila +Southbound +7 +11 +Shangrila +Southbound +9 +13 +Shangrila +Southbound +11 +15 +Shangrila +Southbound +13 +17 +Shangrila +Southbound +15 +19 +Shangrila +Southbound +17 +21 +Shangrila +Southbound +19 +23 +Kozmic Place +Paradise City +9 +14 +Kozmic Place +Paradise City +15 +20 +Kozmic Place +El Dorado +6 +9 +Kozmic Place +El Dorado +8 +11 +Kozmic Place +El Dorado +10 +13 +Kozmic Place +El Dorado +12 +15 +Kozmic Place +El Dorado +14 +17 +Kozmic Place +El Dorado +16 +19 +Kozmic Place +El Dorado +18 +21 +Kozmic Place +El Dorado +20 +23 +Kozmic Place +El Dorado +22 +1 +Kozmic Place +Southbound +7 +12 +Kozmic Place +Southbound +10 +15 +Kozmic Place +Southbound +13 +18 +Kozmic Place +Southbound +16 +21 +Kozmic Place +Southbound +19 +24 +Kozmic Place +Southbound +24 +5 +Southbound +Shangrila +8 +12 +Southbound +Shangrila +10 +14 +Southbound +Shangrila +12 +16 +Southbound +Shangrila +14 +18 +Southbound +Shangrila +16 +20 +Southbound +Shangrila +18 +22 +Southbound +Shangrila +20 +24 +Southbound +Kozmic Place +6 +11 +Southbound +Kozmic Place +9 +14 +Southbound +Kozmic Place +12 +17 +Southbound +Kozmic Place +15 +20 +Southbound +Kozmic Place +18 +23 +Southbound +Kozmic Place +24 +5 diff --git a/Dijkstra/read_me b/Dijkstra/read_me new file mode 100644 index 0000000..89edf22 --- /dev/null +++ b/Dijkstra/read_me @@ -0,0 +1,17 @@ +Laboration 4 i +Datastrukturer och Algoritmer +Dijkstra's shortest path +------------------------------------------------ +Stort OBS! +Denna lab är utvecklad under windows +med Borland C++ 5.0 +Kompilering under Linux kommer ej +att fungera utan lite trix. +Tex finns inte funktioner som clrscr() +i Linux. +Exe-filen borde gå att köra på en windows- +dator. Se till att network.txt finns i samma +katalog som exe-filen. +Labben är provkörd och klar. +------------------------------------------------ +Christian Ohlsson, di7chro@cse.kau.se, 1999 diff --git a/Hashing/hash.cpp b/Hashing/hash.cpp new file mode 100644 index 0000000..f694fcd --- /dev/null +++ b/Hashing/hash.cpp @@ -0,0 +1,292 @@ +//################################################################## +// PROGRAMMERINGSUPPGIFT 3 +// DATASTRUKTURER OCH ALGORITMER +// HASH TABELL +//================================================================== +// HASH.HPP +// Filen innehåller hashfunktionerna +// Christian Ohlsson +// Ingela Johansson +// Anna-Maria Haglund +// Karlstad 981007 +//================================================================== + +#include "header.hpp" +//################################################################## +//Function: hashClass() +//Task: constuctorn +//Calls: nothing +//================================================================== +hashClass::hashClass() +{ + prime(); + PRIMENUMBER=0; + ARRAYSIZE = DEFAULTSIZE; + hashPtr = new hashNode[ARRAYSIZE]; + for(int i=0; i ARRAYSIZE) + location = location - ARRAYSIZE; + if(strcmp(hashPtr[location].name, name) == 0) + return TRUE; + } + return FALSE; +} +//################################################################## +//Function: getNode() +//Task: hämtar en nod ur tabellen, d.v.s. namn telefonnummer och +// "deleted-flaggan" +//Calls: hash1() och hash2() +//================================================================== +hashNode hashClass::getNode(nameType &oneName) +{ + int location = hash1(oneName); + if(strcmp(hashPtr[location].name, oneName) == 0) + return (hashPtr[location]); + else + do { + location = location + hash2(hash1(oneName)); + if(location>ARRAYSIZE) { + location = (location-ARRAYSIZE); + if(strcmp(hashPtr[location].name, oneName) == 0) + return hashPtr[location]; + } + }while(hashPtr[location].exist == FALSE); +} +//################################################################## +//Function: biggerHash() +//Task: kollar om en större tabell behövs (om 80% av positionerna +// är upptagna) +//Calls: checkOccupied() +//================================================================== +bool hashClass::biggerHash() +{ + float siz = INSERTFACTOR*getSize(); + int occ = checkOccupied(); + if(occ>=siz) + return TRUE; + return FALSE; +} +//################################################################## +//Function: newHashArray() +//Task: +//Calls: reHash() +//================================================================== +void hashClass::newHashArray() +{ + int oldSize = ARRAYSIZE; + ARRAYSIZE = nextPrime(); + reHash(oldSize); +} +//################################################################## +//Function: +//Task: +//Calls: +//================================================================== +bool hashClass::anotherHash() +{ + int del=0; + float siz = DELETEFACTOR*getSize(); + for(int i=0; i=siz) + return TRUE; + return FALSE; +} +//################################################################## +//Function: +//Task: +//Calls: +//================================================================== +void hashClass::reHash(int oldSize) +{ + int location; + hashNode *tempPtr = new hashNode[ARRAYSIZE]; + for(int j=0; j ARRAYSIZE) + location = location - ARRAYSIZE; + if(hashPtr[location].exist == FALSE) + insert(location, tempPtr[i]); + } + } + delete tempPtr; +} +//################################################################## +//Function: +//Task: +//Calls: +//================================================================== +int hashClass::hash1(nameType name) +{ + int sum = 0; + for(int i=0 ; i //för in och utmatning +#include //för filhantering +#include //för textmanipulation +#include //för strängmanipulation +#include //för getch() +#include //för isalnum +#include //för en massa saker + +const int FALSE = 0; //boolsk variabel +const int TRUE = !FALSE //boolsk variabel +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 +const int PRIMEARRAYSIZE = 30; //storlek på primtalsarrayen +const int DEFAULTSIZE = 11; //hasharrayens defaultstorlek +const int TABSIZE = 20; //antal steg som motsvarar TAB +const int STEPSIZE = 7; //antal steg hash2 max stegar fram +const int DEFAULTPRIMENUMBER = 4; //minsta primtalet i arrayen +const int FIRSTPRIME = 3; //första talet som man jämför med +const int STARTPRIME = 2; //första primtalet i arrayen +const int PRIMESTEP = 2; //antal steg som man hoppar fram +const float INSERTFACTOR = 0.8; //ger en omhashning när 80% är upptaget +const float DELETEFACTOR = 0.3; //ger en omhashning när 30% är märkta deleted + +typedef int bool; //definierar boolesk variabel +typedef char nameType[NAMESIZE]; //sätter nametypen till char +typedef char numberType[NUMBERSIZE]; //sätter numberTypen till char + +struct hashNode{ //en nod + nameType name; + numberType number; + bool exist; +}; + +class hashClass +{ +public: + hashClass(); + ~hashClass(); + bool search(nameType name); + hashNode getNode(nameType &oneName); + int hash1(nameType name); + int hash2(int key); + int getSize(); + void newHashArray(); + void reHash(int oldSize); + void print(); + void prime(); + int checkOccupied(); + void destroyHash(int oldSize); + bool biggerHash(); + bool anotherHash(); + void del(int location); + void insert(int location, hashNode &newNode); + void save(fstream &fil); + hashNode *hashPtr; + int nextPrime(); +private: + void delHash(int location); + bool isPrime(int nummer, int antal, int primeArray[PRIMEARRAYSIZE]); + int ARRAYSIZE; + int primeArray[]; + int PRIMENUMBER; +}; +#endif + diff --git a/Hashing/huvud.cpp b/Hashing/huvud.cpp new file mode 100644 index 0000000..3cae551 --- /dev/null +++ b/Hashing/huvud.cpp @@ -0,0 +1,294 @@ +//################################################################## +// 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); +} diff --git a/Simulering/lab1.cpp b/Simulering/lab1.cpp new file mode 100644 index 0000000..82e16f6 --- /dev/null +++ b/Simulering/lab1.cpp @@ -0,0 +1,144 @@ +/* *********************************************************************** */ +/* lab1.cpp 980910 */ +/* Innehåller köhantering */ +/* *********************************************************************** */ +/* Daniel Westerberg */ +/* Christian Ohlsson */ +/* Anna-Maria Haglund */ +/* Ingela Johansson */ +/* Charlotta Lagerkvist */ +/* *********************************************************************** */ +#include "lab1.hpp" + +/* *********************************************************************** */ +/* constructorn */ +/* Nollställer variabler */ +/* INPUT: inget */ +/* OUTPUT: inget */ +/* *********************************************************************** */ +queue::queue() +{ + first = NULL; + last = NULL; + cur = NULL; + r = 0; +} + +/* *********************************************************************** */ +/* destructorn */ +/* Tömmer listan */ +/* INPUT: inget */ +/* OUTPUT: inget */ +/* *********************************************************************** */ +queue::~queue() +{ + cur = first; + while (cur) + { + first = cur; + cur = cur->next; + delete first; + } + first = NULL; + last = NULL; + cur = NULL; + r = 0; +} + +/* *********************************************************************** */ +/* enqueue() */ +/* ställer en person med ett antal varor i kön */ +/* INPUT: antal varor */ +/* OUTPUT: bool */ +/* *********************************************************************** */ +bool queue::enqueue(int v) +{ + if (cur = new kund) + { + cur->next=NULL; + cur->varor = v; + if (first == NULL) + first = cur; + else + last->next = cur; + last = cur; + return TRUE; + } + return FALSE; +} + +/* *********************************************************************** */ +/* dequeue() */ +/* tar bort en person ur kön */ +/* INPUT: inget */ +/* OUTPUT: bool */ +/* *********************************************************************** */ +bool queue::dequeue() +{ + if (cur = first) + { + if ((first = first->next) == NULL) + last=NULL; + delete cur; + return TRUE; + } + return FALSE; +} + +/* *********************************************************************** */ +/* warez() */ +/* kollar hur lång varje kö är, tidsmässigt! */ +/* INPUT: inget */ +/* OUTPUT: tiden för varje kund baserad på antal varor */ +/* *********************************************************************** */ +int queue::warez() +{ + int x=0; + cur = first; + while (cur) + { + x += cur->varor*R + B; // räknar ut tiden för varje kund + 'x' + cur = cur->next; + } + return x; +} + +/* *********************************************************************** */ +/* pay() */ +/* betalningsfunktion, returnerar antalet varor kvar att betala */ +/* INPUT: antal varor att läggas till */ +/* OUTPUT: antal varor för första kunden i kön */ +/* *********************************************************************** */ +int queue::pay(int v) +{ + if (first) + return (first->varor += v); // lägger till 'v' och returnerar + else + return 0; +} + +/* *********************************************************************** */ +/* queueSize() */ +/* returnerar antalet kunder i kön */ +/* INPUT: inget */ +/* OUTPUT: Antal kunder i kön */ +/* *********************************************************************** */ +int queue::queueSize() +{ + int x=0; + cur = first; + while (cur) + { + cur = cur->next; + x++; + } + return x; +} + +/* *********************************************************************** */ +/* isEmpty() */ +/* kollar om en kö är tom */ +/* INPUT: inget */ +/* OUTPUT: TRUE om listan är tom */ +/* *********************************************************************** */ +bool queue::isEmpty() { return (first == NULL) ; } diff --git a/Simulering/lab1.hpp b/Simulering/lab1.hpp new file mode 100644 index 0000000..8bda024 --- /dev/null +++ b/Simulering/lab1.hpp @@ -0,0 +1,57 @@ +/* *********************************************************************** */ +/* lab1.hpp 980910 */ +/* Headerfil för lab1 */ +/* *********************************************************************** */ +/* Daniel Westerberg */ +/* Christian Ohlsson */ +/* Anna-Maria Haglund */ +/* Ingela Johansson */ +/* Charlotta Lagerkvist */ +/* *********************************************************************** */ + +#include +#include +#include +#include + +typedef int bool; +const bool TRUE=-1, FALSE=0; + +const int K=6; //Konstant för antal kassor +const int R=8; //Konstant för antal sekunder per vara +const int B=20; //Konstant för betalning +const int T=100; //Konstant för hur mycket snabbare än real-time det går +const int MS=1000; //Konstant för antal ms på en sekund +const int SPM=60; //Antal sekunder per minut +const int STARTTID=9*SPM*SPM+SPM; //Gör att programmet startar 9.01 +const int MOVEX=5; //Antal steg att flytta i X-led +const int CENT=100; //Ger 100% att starta med +const int FALL1=10; //Ger 10% chans +const int FALL2=40; //Ger 30% chans +const int FALL3=90; //Ger 50% chans +const int MAV=40; //Ger slumptal mellan 1 - 40 + +class queue +{ + private: + typedef struct kund + { + struct kund *next; + int varor; + } kund; + + kund *first; + kund *last; + kund *cur; + + public: + char r; + queue(); + ~queue(); + bool enqueue(int); + bool dequeue(); + int warez(); + int pay(int); + int queueSize(); + bool isEmpty(); +}; diff --git a/Simulering/main.cpp b/Simulering/main.cpp new file mode 100644 index 0000000..5378243 --- /dev/null +++ b/Simulering/main.cpp @@ -0,0 +1,123 @@ +/* *********************************************************************** */ +/* main.cpp 980910 */ +/* Innehåller huvudprogram för köhantering */ +/* *********************************************************************** */ +/* Daniel Westerberg */ +/* Christian Ohlsson */ +/* Anna-Maria Haglund */ +/* Ingela Johansson */ +/* Charlotta Lagerkvist */ +/* *********************************************************************** */ +#include "lab1.hpp" + +/* *********************************************************************** */ +/* Klassarray */ +/* *********************************************************************** */ +class queue q[K]; + +/* *********************************************************************** */ +/* funktionsprototyper som denna fil innehåller */ +/* *********************************************************************** */ +void betala(int); +void print(long); +void addkund(void); + +/* *********************************************************************** */ +/* main med huvud-loop och delay */ +/* *********************************************************************** */ +void main() +{ + long clock=STARTTID; + int kund=0; + + while(!kbhit()) + { + print(clock++); + if (++kund == SPM) + { + addkund(); + kund=0; + } + for(int x=0; x0) + q[pos].r--; + else + q[pos].dequeue(); +} + +/* *********************************************************************** */ +/* addkund() */ +/* lägger till en kund med ett slumpmässigt antal varor i den minsta kön */ +/* INPUT: inget */ +/* OUTPUT: inget */ +/* *********************************************************************** */ +void addkund() +{ + int in, x, min, pos=0; + unsigned int slumptal; + srand((unsigned) time(NULL)); + slumptal = rand()%CENT; + if (slumptal < FALL1) + in=0; + else if (slumptal < FALL2) + in=1; + else if (slumptal < FALL3) + in=2; + else + in=3; + while(in) + { + min=q[0].warez(); + for(x=1; xq[x].warez()) + { + min=q[x].warez(); + pos=x; + } + q[pos].enqueue(rand()%MAV+1); + in--; + } +}