Beispiel #1
0
NodeT *createBinTree( int branch, NodeT *parent )
{
    NodeT *p;
    int id;
    /* read node id */
    if ( branch == 0 )
        printf( "Root identifier [0 to end] =" );
    else if ( branch == 1 )
        printf( "Left child of %d [0 to end] =",
                parent->id );
    else
        printf( "Right child of %d [0 to end] =",
                parent->id );
    scanf("%d", &id);
    if ( id == 0 )
        return NULL;
    else
    {
        /* build node pointed to by p */
        p = ( NodeT *)malloc(sizeof( NodeT ));
        if ( p == NULL )
            fatalError( "Out of space in createBinTree" );
        /* fill in node */
        p->id = id;
        p->left = createBinTree( 1, p );
        p->right = createBinTree( 2, p );
    }
    return p;
}
Beispiel #2
0
NodeT* createBinTree()
{
    NodeT *p;
    char *data=(char*)malloc(sizeof(char)*10);
    fscanf(input,"%s",data);
    if(strcmp(data,"*")==0)
        return NULL;
    else
    {
        p=createNODE(data);
        p->left=createBinTree();
        p->right=createBinTree();
    }
    return p;
}
Beispiel #3
0
NodeT *createBinTree()
{
    char *data=(char*) malloc(sizeof(char)*20);
    scanf("%s",data);
    if(strcmp(data,"*")==0)
    return NULL;
    else
    {
        NodeT *p=(NodeT*)malloc(sizeof (NodeT));
        p->data=data;
        p->left=createBinTree();
        p->right=createBinTree();
        return p;
    }
}
Beispiel #4
0
t_btree* createBinTree()
{
	t_btree *p;
	char *s;
	s = (char*)malloc(sizeof(char) * 100);
	fscanf(f, "%s",s);
	if (strcmp (s, "*") == 0)
		return (NULL);
	else
	{
		p = createNode(atoi(s));
		p->left = createBinTree();
		p->right = createBinTree();
	}
	return p;
}
Beispiel #5
0
nodeT* createBinTree()
{
    nodeT* p;
    char content[20];
    scanf("%s",content);
    if(strcmp(content,"*")==0)
        return NULL;

    p=(nodeT*)malloc(sizeof(nodeT));
    p->data=atoi(content);

    p->left=createBinTree();
    p->right=createBinTree();

    return p;
}
Beispiel #6
0
NodeT* createeBinTree()
{
    NodeT* p;
    char* data =(char*)malloc(sizeof(char)*100);
    scanf("%s",data);
    if(strcmp(data,"*")==0)
    {
        return NULL;
    }
    else
    {
        p=createNode(atoi(data));
        p->left=createBinTree();
        p->right=createBinTree();
    }
    return p;
}
Beispiel #7
0
int main()
{
    nodeT *root=createBinTree();
    nodeL *firstFromList=getListFromTree(root);
    traverseList(firstFromList);
    printf("\n");
    prettyPrint(root,0);
    return 0;
}
nodeT* createBinTree(FILE *f)
{
    nodeT *p;
    char *dat=( char* ) malloc(sizeof(char)*100);
    fscanf(f,"%s",dat);
    if (strcmp(dat,"*")==0)
    {
        return NULL;
    }
    else
    {
        p=createNode(atoi(dat));
        p->left=createBinTree(f);
        p->right=createBinTree(f);
    }
    p->height=max(p->left,p->right)+1;
    return p;
}
Beispiel #9
0
void exploitMemLeaks() {	

	// All data allocated and tracked, all will be freed
	int * low = calloc(1, sizeof(int));
	* low = 1;
	
	int * mid = calloc(1, sizeof(int));
	* mid = 2;
	
	int * hi = calloc(1, sizeof(int));
	* hi = 3;
	
	printf("Created the following data to add to a tree:\n");
	printf("Low: %d, Mid: %d, Hi: %d\n", * low, * mid, * hi);
	
	// Test inside a tree
	Tree * test = createBinTree(&compNum, &destructor);
	
	addToTree(test, mid);
	addToTree(test, low);
	addToTree(test, hi);
	
	printInOrder(test, &print);
	// Up to here, as long as destroyBinTree is called, no leaks are possible
	// Now lets look at some of the issues with the library
	
	// Left will contain Low (1), we know this. This function allocates memory
	// so it's return value must be freed
	Tree * left = getLeftSubtree(test);
	free(left);
	// All is well, no memory leaks here

	// Now let's get the right subtree, Hi (3), but before we free it, let's get
	// get one of it's subtrees too. We know it won't contain anything so
	// presumably we'll get some sort of error return value
	Tree * right = getRightSubtree(test);	

	Tree * empty = getRightSubtree(right);
	if (empty == NULL)
		printf("The call to an empty subtree returned NULL.\n");
		// Oh good, we did get some error handling, great now there's no problem

	// OOPS, no, there's a huge issue. The getSubtree functions are presumably 
	// doing the following: allocating memory to a temporary new tree pointer, 
	// checking what's in the subtree and returning NULL if nothing is in it.
	// So the temporary new tree pointer to allocated memory is completely lost
	// in all instances.
	
	// We can't even detect the error without a memory checker because the
	// following call of free(NULL) has no effect
	free(empty);
	
	free(right);
	
	destroyBinTree(test);	
}
Beispiel #10
0
int main()
{
    int i;
    i=0;
    NodeT* root=createBinTree();
    head=getListFromTree(root);
    root=getTreeFromList();
    prettyPrint(root,i);
    return 0;
}
Beispiel #11
0
BinTree* createBinTree(DLL** nodeL)
{
    char* c = (char*)(*nodeL)->data;
    BinTree* New = createBinTreeNode((*nodeL)->data);
    *nodeL = (*nodeL)->next;
    //If it is a operand, it will be a leaf, otherwise it is an internal node(2 more function calls)
    //the strlen condition is necessary since a negative number would be seen as an operator
    if((strlen(c) == 1)&&
       ((c[0] == '+')||(c[0] == '-')||(c[0] == '*')||(c[0] == '/')))
    {
        New->left = createBinTree(nodeL);
        New->right = createBinTree(nodeL);
        return New;
    }
    else
    {
        return New;
    }
}
Beispiel #12
0
int main()
{
 input=fopen("input.dat", "r");
 output=fopen("output.dat", "w");
 NODET *root=createBinTree();
 NODEL *firstFromList=getListFromTree(root);
 traverseList(firstFromList);
 root=getTreeFromList(&firstFromList);
 prettyPrint(root,0);
 return 0;
}
Beispiel #13
0
int main()
{
   root=createBinTree();
   head=getLfromT(root);
   printf("tree=>list: \n");
   printList();
   delTree(root);
   root=NULL;
   root=getTfromL(&head);
   printf("list=>tree: \n");
   prettyPrint(root,0);
   return 0;
}
Beispiel #14
0
int main(void)
{
	t_btree *root, *rootFromList;

	f = fopen("input.dat", "r");
	g = fopen("output.dat", "w");
	root = createBinTree();
	getListFromTree(root);
	traverseList(head);
	rootFromList = getTreeFromList();
	prettyPrint(root, 0);
	fprintf (g, "\n");
	return (0);
}
Beispiel #15
0
int main()
{
    NodeT *root;
    root = createBinTree( 0, NULL );
    show(root,0);
    printf("identifier of node to interchange:");
    int i=0;
    scanf("%d",&i);
    interchangeodes(find(root,i));
    show(root,0);
    printf("height:%d\n",detheight(root));
    printf("nr of leaves:%d\n",nmb_of_leaves(root));
    return 0;
}
binTree* addElement(binTree *root, int cur)
{
    if (root == NULL)
    {
        return createBinTree(cur);
    }
    else if (root->value > cur)
    {
        root->left = addElement(root->left, cur);
    }
    else if (root->value < cur)
    {
        root->right = addElement(root->right, cur);
    }
    return root;
}
Beispiel #17
0
int main()
{
    FILE *f=fopen("input.txt","r");
    if(f==NULL)
    {
        perror("Can't open file!\n");
        return -1;
    }
    NodeT *root=createBinTree(f);
    AVLTree(root);
    root=insertNode(root,11);
    root=deleteNode(root,11);
    prettyPrint(root,0);

    return 0;
}
Beispiel #18
0
int main(void)
{
    TreeT *root;
    FILE *f;

    f = fopen("input.txt", "r+");
    if (f == NULL)
    {
        perror("Cannot open file");
        return(-1);
    }
    root = createBinTree(f);
    printf("The tree made from the input is : \n");
    prettyPrint(root, 0);
    return 0;
}
Beispiel #19
0
int main(void)
{
    TreeT *root1;
    ListT *firstFromList;

    root1 = createBinTree();
    printf("The input tree is : \n");
    prettyPrint(root1, 0);
    firstFromList = getListFromTree(root1);
    printf("The list from the tree is : \n");
    traverseList(firstFromList);
    printf("\n");
    root1 = getTreeFromList(&firstFromList);
    printf("The tree from the list is : \n");
    prettyPrint(root1, 0);
    return 0;
}
Beispiel #20
0
int main()
{
    FILE *file, *fileOutput;
    file= fopen("input.dat", "r");

    if(file== NULL)
    {
        perror("Cannot open file");
        return -100;
    }
    fileOutput = fopen("output.dat", "w");

    getContent = &getStringContent;
    printElement = &printStringElement;

    NodeT *root = NULL;
    root = createBinTree(file);
    prettyPrint(root,0,fileOutput);

    return 0;
}