二叉树中的有序遍历

Question

I tried to write a function to traverse a binary tree in-order and to put its items to an array of integers, in-order.I know this piece of code includes some bad practices but what I wonder is actually why my function does not create aimed integer array.For example even if my function can find the size needed to keep all the items of bst, it cannot put these items properly.Sometimes it puts only 2 nodes and sometimes only the root.

I do not see any reason put any main function here since I would use it only for printing elements of that array.

My function, global variabless and typedef block for a TreeNode ;

typedef struct TreeNode{
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
} TreeNode;

    int ctr = 0;
    int size = 0;

    int* inorder(TreeNode *root, int* arr){

        if(ctr==0) /*if first call to this function*/
            arr = malloc(size*sizeof(int)) ;

        ctr++ ; 

        if(root){

            if(!root->left && !root->right){        
                arr = realloc(arr, ++size*sizeof(int)) ;
                arr[size-1] = root->val ;
            }

            else if(!root->left&&root->right){
                arr = realloc(arr, ++size*sizeof(int)) ;
                arr[size-1] = root->val ;
                arr=inorder(root->right,arr) ;  
            }
            else if(!root->right&&root->left){
                arr=inorder(root->left,arr) ;
                arr = realloc(arr, ++size*sizeof(int)) ;
                arr[size-1] = root->val ;
            }
            else{
                arr=inorder(root->left,arr) ;
                arr = realloc(arr, ++size*sizeof(int)) ;
                arr[size-1] = root->val ;
                arr=inorder(root->right,arr) ;

            }

            return arr ;
        }
        else
            return arr ;
    }

Answer 1

Ouch, you're doing a realloc() at each function call. A realloc() is costly, and should be used as little as possible. You should keep the size of the tree somewhere. If you can't, you can traverse it a first time to count the number of elements.

Another thing: your if/elseif/elseif/else is useless: you can always apply the same treatment. Pseudocode, assuming that for any node left->val < node->val < right->val :

1. getting the size of the tree (if you don't already have it)
2. malloc() an array of size size*sizeof(int) (that's the only allocation you'll need), initialize an index to 0

Then you can do a simple recursion:

void inorder(Treenode *root, int *array, int *index) {
    if (!root)
        return;

    inorder(root->left, array, index);
    array[*index] = root->val;
    (*index)++;
    inorder(root->right, array, index);
}

And that's it!