Printf avec scanf demandant une entrée. Erreur de boucle avec BST

J’ai essayé de voir pourquoi printf ne casse pas la boucle après avoir imprimé l’entrée du fichier. Le fichier .c est BST et je suis en train de vérifier si une arborescence a été construite, mais ne semble pas pouvoir sortir de la boucle printf. J’ai besoin de la boucle printf pour la sortie correcte pour le code. Toute suggestion de pourquoi cette erreur se produit. Le code complet et la sortie sont affichés.

#include "bst.h" #include  #include  ///Author: Joe W //arbitrary list of temp nodes TreeNode *new_node, *root, *tmp, *parent; int elemArray[100], i1, i2, i0; /* Insert a new node into the tree by referencing the root and using recursion */ TreeNode* getN(int dataElem) { TreeNode* temp; temp = malloc(sizeof(TreeNode*)); temp-> left = NULL; temp-> right = NULL; temp->data = dataElem; return temp; } TreeNode* addNodeToTree(TreeNode *root, int data) { TreeNode* newNode = malloc(sizeof(TreeNode*)); if (root == NULL) { // thingy too. Creating a function too, // for you to look at. root = newNode; return root; } else { TreeNode* parent = malloc(sizeof(TreeNode*)); TreeNode* current = malloc(sizeof(TreeNode*)); parent = current = root; // This loop will actually help us, find the `parent`, // of the `newNode`(which is to be inserted) while (current != NULL) { parent = current; if (current->data > data) current = current->left; else if (current->data right; } // Now once, we have found, the node, under which the // newNode will be placed, now we have to check, whether // newNode will become a `left child/right child` of the // parent. newNode = getN(data); if (parent->data > data) parent->left = newNode; else if (parent->data right = newNode; return root; } } void build_Tree(TreeNode** root, const int elements[], const int count) { //TreeNode* node = malloc(sizeof(TreeNode*)); //node->left = node ->right = NULL; for ( i0 = 0; i0 < count; ++i0 ){ *root = addNodeToTree(*root, elements[count]); } } 

Cela comstack bien. L’erreur commence après la saisie du fichier par le fichier et commence à afficher le code. avec des déclarations printf.

 int main( int argc, char *argv[] ) { //Throw error is *Argv[] is not an integer //assuming it was an integer int cnt = atoi( argv[1] ); printf( "number is %d\n", cnt ); // printf("Enter %i integer values to place in tree:\n", cnt); for ( i1 = 0; i1 < cnt; ++i1) { scanf( "%d", &elemArray[i1] ); } //first ouput "INput Values" printf( " Input Values:\n " ); for ( i2 = 0; i2 data= 5; traverse( *root, PREORDER); //pass the pointer of root to traverse the tree //traverse a single node printf( "Inorder:\n "); printf( "Postorder:\n "); //Build tree with each element return 0; } void traverse( const TreeNode* root, const TraversalType type ) { if ( type == PREORDER) { if (root != NULL) { printf("%d", root->data); traverse( root->left, PREORDER); traverse( root-> right, PREORDER); } } } /** void insertNode(TreeNode** root, TreeNode* new_node) { if (new_node-> data  data) { if (*root-> left == NULL) *root-> left == new_node; else insert(*root->left, new_node); } if (new_node->data > *root->data) { if(*root-> right ==NULL) *root->right = new_node; else insert(*root->right, new_node); } } **/ //question1: what is the 

C’est là que je commence à exécuter le code

 jw8453@idaho:~/Courses/CS243/Homework/5$ make gcc -ggdb -c bst.c gcc -ggdb -o bst bst.o -lm jw8453@idaho:~/Courses/CS243/Homework/5$ ./bst 5 number is 5 Enter 5 integer values to place in tree: 1 2 3 4 5 Input Values: 1 building tree0 2 building tree0 3 building tree0 4 building tree0 5 building tree0 this isnt supposed to be in the printf loop 

Remarque: La question est une continuation des doubles pointeurs de l’arborescence de génération BST.

C’est faux:

 TreeNode* newNode = malloc(sizeof(TreeNode*)); 

au lieu

 TreeNode* newNode = malloc(sizeof(TreeNode)); 

ou

 TreeNode* newNode = malloc(sizeof(*newNode)); 

Ici:

  TreeNode* parent = malloc(sizeof(TreeNode*)); TreeNode* current = malloc(sizeof(TreeNode*)); parent = current = root; 

vous avez une fuite de mémoire, vous réservez de l’espace pour le parent et le current , puis vous affectez ces variables à une autre adresse, de même pour:

 TreeNode* newNode = malloc(sizeof(TreeNode*)); ... newNode = getN(data); 

je suggère

 void setN(TreeNode *node, int dataElem) { node->left = NULL; node->right = NULL; node->data = dataElem; } ... setN(newNode, data); 

au lieu de

 TreeNode* getN(int dataElem) { TreeNode* temp; temp = malloc(sizeof(TreeNode*)); temp-> left = NULL; temp-> right = NULL; temp->data = dataElem; return temp; } ... newNode = getN(data);