tree consTree( element e, tree leftTree, tree rightTree )
{
tree root = EMPTYTREE;
/* If there's no left and right three, make a new tree. */
if ( emptyTree( leftTree ) && emptyTree( rightTree ) ) {
/* After this call a new graph will be initialized. */
root =
newVertex( e, globalPointerToVertexHead,
globalPointerToEdgeHead );
} else if ( emptyTree( rightTree ) ) {
root =
newVertex( e, globalPointerToVertexHead,
globalPointerToEdgeHead );
connectVertex( globalPointerToEdgeHead, root, leftTree, 'l' );
} else if ( emptyTree( leftTree ) ) {
root =
newVertex( e, globalPointerToVertexHead,
globalPointerToEdgeHead );
connectVertex( globalPointerToEdgeHead, root, rightTree, 'r' );
}
/* otherwise make new vertex as root and two trees as son */
else {
root =
newVertex( e, globalPointerToVertexHead,
globalPointerToEdgeHead );
connectVertex( globalPointerToEdgeHead, root, leftTree, 'l' );
connectVertex( globalPointerToEdgeHead, root, rightTree, 'r' );
}
return root;
}
void emptyTree(Tree t) {
if(!t)
return;
emptyTree(t->left);
emptyTree(t->right);
free(t);
}
void emptyTree(Arbol *p)//en posOrden
{
if(*p)
{
emptyTree(&(*p)->left);
emptyTree(&(*p)->rigth);
free(*p);
}
}
void emptyTree(Tree* tree, Node* node)
{
if (node->left != NULL)
emptyTree(tree, node->left);
if (node->right != NULL)
emptyTree(tree, node->right);
removeNode(tree, node->value);
}
int main()
{
Tree* tree;
printf("välkommen till skagettikåd\n\n");
printf("No.items, Sekvential, BinaryST, HashTable\n");
//loop
for (int numberOfitems = 50000; numberOfitems <= 5000000; numberOfitems = numberOfitems * 10)
{
int* arr = (int*)calloc(numberOfitems, sizeof(int));
FILE* fp;
fp = fopen("5 000 000 unika slumpade tal.txt", "r");
for (int i = 0; i < numberOfitems; i++)
{
fscanf(fp, "%d", &arr[i]);
}
fclose(fp);
//stuff
makeHashTable(arr, numberOfitems);
tree = makeBST(arr, numberOfitems);
//time variables
double timeSekventiall = 0;
double timeBST = 0;
double timeHash = 0;
//Genomför sköningen 100 gånger
for (int i = 0; i < 100; i++)
{
int searchfor = 1;
timeSekventiall += sekventiell(arr, searchfor, numberOfitems);
timeBST += searchBST(tree, searchfor, numberOfitems);
timeHash += searchHashTable(arr, searchfor, numberOfitems);
}
//dela på 100 för att få genomsnitt
timeSekventiall = timeSekventiall / 100;
timeBST = timeBST / 100;
timeHash = timeHash / 100;
//Print it!
printf("%8d%10Lf%12Lf%10Lf\n", numberOfitems, timeSekventiall, timeBST, timeHash);
//free
free(arr);
emptyTree(tree, tree->root);
}
system("pause");
return 0;
}
void balance(Tree* tree)
{
int nodes = numberOfNodes(tree);
//1 eftersom ett träd med två noder alltid kommer vara balanserat.
if (nodes > 1)
{
if (actualDepth(tree->root, 0, 0) > theoreticalDepth(tree))
{
int *arr = (int*)calloc(numberOfNodes(tree), sizeof(int));
moveToArr(tree->root, arr, 0);
emptyTree(tree, tree->root);
buildBalanced(tree, arr, nodes);
free(arr);
//vill inte skriva ut :(
//printf("Your tree is now balanced!\n");
}
else
{
printf("Your tree is already balanced!\n");
}
}
else
{
printf("Your tree has to have more than one node!\n");
}
}
boolean isBST (tree t, element minKey, element maxKey)
{
if (emptyTree (t)) {
return true;
}
if (lessThan (root (t), minKey) || greaterThan (root(t), maxKey)) {
return false;
}
return ( isBST(left(t), minKey, root (t)) && isBST(right (t), root (t), maxKey));
}
/* Visit root, left and right. */
int preOrder( tree root, int number )
{
int leftKids, rightKids;
assert( !emptyTree( root ) );
printf( "Visiting %s\n", root->name );
/* givenNo = weight w. */
root->w = number;
leftKids =
( !emptyTree( left( root ) ) ? preOrder( left( root ), number + 1 )
: 0 );
rightKids =
( !emptyTree( right( root ) ) ?
preOrder( right( root ), number + 1 + leftKids ) : 0 );
root->size = leftKids + rightKids + 1;
return root->size;
}
/* In-order insert */
tree insOrd( element el, tree t )
{
/* P = { el ∉ t } */
if ( emptyTree( t ) ) {
return consTree( el, EMPTYTREE, EMPTYTREE );
}
else if ( lessThan( el, root( t ) ) ) {
return consTree( root( t ), insOrd( el, left( t ) ), right( t ) );
}
/* greaterThan(el, root(t)) */
else {
return consTree( root( t ), left( t ), insOrd( el, right( t ) ) );
}
}
/* Recirsive version.
* NULL is returned if element with corresponding key is not found.
*/
tree searchBST ( tree t, element key )
{
if (emptyTree (t)) {
return EMPTYTREE;
}
else if (root (t) == key) {
return t;
}
else if (lessThan( key, root( t ))) {
return (searchBST (left (t), key));
}
else {
return (searchBST (right (t), key));
}
}
/* return left subtree, it assumes that left node is the first edge in list */
tree left( tree t )
{
nodePointer dummy;
nodePointer thisEdge;
assert( !emptyTree( t ) );
dummy = ( *( t->edgeListOut ) );
thisEdge = dummy->next;
while ( thisEdge != dummy ) {
if ( thisEdge->edgeAddr->w == 'l' ) {
return ( ( thisEdge->edgeAddr )->toNode );
}
thisEdge = thisEdge->next;
}
return EMPTYTREE;
}
void ptree_EmptyTable(pwr_tStatus *sts, ptree_sTable *tp)
{
emptyTree( sts, tp);
}
/// Construct a PropertyTreeArra7 referencing an empty property tree
/// singleton.
PropertyTreeArray()
: array(emptyTree()) { }
/// Construct a wrapper for an empty property tree
PropertyTreeValue()
: object(emptyTree()) { }
/// Construct a PropertyTreeObject referencing an empty property tree.
PropertyTreeObject()
: object(emptyTree()) { }
/* this is the equivalent function to car, as view inside lists */
element root( tree t )
{
assert( !emptyTree( t ) );
return t->name;
}
int main()
{
char programName[] = "trees";
int data;
int chosenOperation;
printf ( "Welcome to %s\n", programName );
BinaryTree *theTree = NULL;
initializeTree ( theTree );
do
{
printf ( "%s", mainMenuString );
chosenOperation = fetchINT ( stdin );
switch ( chosenOperation )
{
case AddToTree:
if ( isTreeFull ( *theTree ) )
{
printf ( "sorry the queue is full\n" );
}
else
{
printf ( "Enter a number: " );
data = fetchINT ( stdin );
addToTree ( theTree, data );
}
break;
case 2:
if ( isTreeEmpty ( *theTree ) )
{
printf ( "sorry the queue is empty\n" );
}
else
{
printf ( "The number is %d\n", takeFromTree ( theTree, data ) );
}
break;
case 3:
if ( isTreeEmpty ( *theTree ) )
{
printf ( "sorry the queue is empty\n" );
}
else
{
printTree ( theTree );
}
break;
case 4:
printf ( "bye\n" );
break;
default:
printf ( "Oops Wrong input\n" );
chosenOperation = AddToTree;
}
}
while ( ! ( ( chosenOperation < AddToTree )
|| ( chosenOperation >= Quit ) ) );
emptyTree ( theTree );
free ( theTree );
return EXIT_SUCCESS;
}
void *largestPalindrome(node *T, char *word, int size, node *P){
int i, j, k, pos, test;
char *largest, *aux_largest, *aux_word;
node *pointer, *aux;
P = Trie();
if (!(largest = malloc(sizeof(char)*size))){
printf("Falta de memória");
exit(1);
}
if (!(aux_largest = malloc(sizeof(char)*size))){
printf("Falta de memória");
exit(1);
}
if (!(aux_word = malloc(sizeof(char)*size))){
printf("Falta de memória");
exit(1);
}
largest[0] = '\0';
pointer = T;
for (i = 0; i < size; i++){
aux = T;
pos = position(word[i]);
j = 0;
k = i;
while(aux->key[pos]){
aux_largest[j] = word[k];
j++;
k++;
aux = aux->key[pos];
pos = position(word[k]);
}
aux_largest[j] = '\0';
while (j > 0){
if (!palindrome(aux_largest)){
j--;
aux_largest[j] = '\0';
} else {
break;
}
}
if (lenght(aux_largest) > lenght(largest)){
copy(largest, aux_largest); // largest = aux_largest
/* Caso tenha uma palavra maior que anterior
* limpar a trie para conter somente as maiores palíndromas */
emptyTree(P);
}
copy(aux_word, aux_largest);
insert(P, aux_word);
}
printf("-- Maiores palindormas:");
printTree(P, lenght(largest));
}
/* Returns the number of nodes inside a tree */
int findWeight( tree t )
{
return ( emptyTree( t ) ? 0
: 1 + findWeight( left( t ) ) + findWeight( right( t ) ) );
}
int main()
{
FILE *fp;
tInfo info;
Arbol tree;
int cont = 0;
char op;
printf("Ejercicio 2 Arbol Binario\n");
if(!openFile(&fp,"r+b",nameFile,!CON_SIN_MSJ))
{
createFile();
if(!openFile(&fp,"r+b",nameFile,CON_SIN_MSJ))
return 0;
}
showFile(&fp);
createTree(&tree);
fread(&info,1,sizeof(tInfo),fp);
while(!feof(fp) && !isTreeFull(&tree))
{
putInTree(&tree,&info,&cont,compear);
fread(&info,1,sizeof(tInfo),fp);
}
op = menuOption(MSJ,OPTION);
while(op != 'L')
{
switch(op)
{
case 'A':
{
newInfo(&info);
if(!isTreeFull(&tree))
{ if(putInTree(&tree,&info,&cont,compear) == CLAV_DUP)
puts("Informacion duplicada, no se pudo completar la accion");
else
putAtTheEnd(&fp,&info);
}
break;
}
case 'B':
{
printf("Ingrese clave:");
fflush(stdin);
scanf("%ld",&info.dni);
showInfoByKey(&fp,searchInTree(&tree,&info,compear));
break;
}
case 'C':
{
puts("Informacion en orden");
order(&tree,&fp);
break;
}
case 'D':
{
puts("Informacion en posOrden");
posOrder(&tree,&fp);
break;
}
case 'E':
{
puts("Informacion en preOrden");
preOrder(&tree,&fp);
break;
}
case 'F':
{
printf("Hojas: %d",sheetsCounting(&tree));
break;
}
case 'G':
{
printf("Nodos: %d",countingNodes(&tree));
break;
}
case 'H':
{
if(completeTree(&tree))
puts("Arbol completo");
else
puts("Arbol no completo");
break;
}
case 'I':
{
if(isAVL(&tree))
puts("Arbol es AVL");
else
puts("Arbol no es AVL");
break;
}
case 'J':
{
if(balancedTree(&tree))
puts("Arbol es balanceado");
else
puts("Arbol no es balanceado");
break;
}
}
op = menuOption(MSJ,OPTION);
}
fclose(fp);
emptyTree(&tree);
return 0;
}
