Structure Array as a parameter and it's member access

Question

This code is written in C. The first line of Node_reset() function occurs an error. (Structure array is allocated dynamically in main function.) I think there's something wrong in member-access of Node_reset(), also Create() might occur same kind of error. Input.txt, the following format is provided:

2
3 dfs(3)
786 368 603
5 bfs(4)
825 162 768 724 635

The number in the first line (i.e., 2) shows the number of test cases to be processed. From the second line, test cases are given, and the information for each case is provided over two lines.

In the first line (line number 2 in the example above), the first number (i.e., 3) indicates the number of integers in that case, and the next string (i.e., dfs(3)) shows the location of the target number that you need to look for. In this example, the target number is on the third node of DFS.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_QUEUE_SIZE 100
#define FALSE 1;
#define TRUE 0;

typedef struct BST_node{
    int data;
    int visited;
    struct BST_node * leftChild;
    struct BST_node * rightChild;
}node;

typedef node* TreeNode;
typedef struct {
    TreeNode data[MAX_QUEUE_SIZE];
    int front;
    int rear;
}Queue;

void Node_reset(TreeNode* input_tree, int BST_size)
{
    for(int i=0;i<BST_size;i++)
    {
        input_tree[i]->data = 0;  //"Thread 1: EXC_BAD_ACCESS (code=1, address=0x0)"occurs
        input_tree[i]->leftChild=NULL;
        input_tree[i]->rightChild=NULL;
        input_tree[i]->visited=FALSE;
    }
}

void Create(TreeNode* input_tree, int data[], int BST_size)
{
    for(int i=0;i<BST_size;i++)
    {
        input_tree[i]->data=data[i];
    }
    for(int i=0;i<BST_size-1;i++)
    {
        if(input_tree[i]->data > input_tree[i+1]->data) input_tree[i]->leftChild=input_tree[i+1];
        else input_tree[i]->rightChild=input_tree[i+1];
    }
}

void init_Q(Queue* q)
{
    q->front = q->rear =0;
}

int IsEmpty(Queue* q)
{
    return (q->front == q->rear);
}

int IsFull(Queue* q)
{
    return ((q->rear+1)%MAX_QUEUE_SIZE==q->front);
}

void enqueue(Queue* q,TreeNode data)
{
    if(IsFull(q))
    {
        printf("Queue is Full");
    }
    q->rear = (q->rear+1)%MAX_QUEUE_SIZE;
    q->data[q->rear]=data;
}

TreeNode dequeue(Queue* q)
{
    if(IsEmpty(q))
    {
        printf("Queue is empty");
        return NULL;
    }
    q->front = (q->front+1)%MAX_QUEUE_SIZE;
    return q->data[q->front];
}
int DFS_search(TreeNode Node, int *searching_times)
{
    while(*searching_times==0){
        *searching_times--;
        if(Node->leftChild!=NULL)   DFS_search(Node->leftChild, searching_times);
        if(Node->rightChild!=NULL)  DFS_search(Node->rightChild, searching_times);
    }
    return Node->data;
}
int BFS_search(TreeNode* Node, int searching_times)
{
    Queue q;
    init_Q(&q);
    for(int i=0;i<searching_times;i++)
    {
        enqueue(&q, Node[i]);
        if(Node[i]->leftChild)
            enqueue(&q, Node[i]->leftChild);
        if(Node[i]->rightChild)
            enqueue(&q, Node[i]->rightChild);
    }
    for(int i=0;i<searching_times;i++)
    {
        if(i==searching_times-1) return dequeue(&q)->data;
        else dequeue(&q);
    }
    return 0;
}

void pass_result(int result_num,int *result,int result_arr[])
{
    result_arr[result_num]=(*result);
}

void return_result(int result_arr[],int how_many)
{
    FILE *of = fopen("output.txt","w");
    for(int i=0;i<how_many;i++)
    {
    fprintf(of, "%d\n",result_arr[i]);
    }
    fclose(of);
}

int main()
{
    int how_many_times;      //the number of input expression
    int BST_size;            //input the number of element here
    char string[7]={0};      //input string data here
    char temp[2]={0};        //input searching num
    int searching_times;     //the number of input expression
    int result;              //result of expression


    FILE *fp = fopen("input.txt","r");
    fscanf(fp, "%d", &how_many_times);
    int *result_arr=(int*)malloc(sizeof(int)*how_many_times);
    
        for(int i=0;i<how_many_times;i++)
        {
            memset(string, 0, sizeof(char)*7);          //reset string[]
            memset(temp, 0, sizeof(char)*2);            //reset temp[]
            fscanf(fp, "%d", &BST_size);                //pass BST size
            int* input=(int*)malloc(sizeof(int)*BST_size);    //allocate heep memory as long as input BST size
            fscanf(fp, "%s", string);                   //pass string input data to string[]
            TreeNode* tree=(TreeNode*)malloc(sizeof(TreeNode)*BST_size);
            Node_reset(tree, BST_size);
            for(int i=0;i<BST_size;i++)                 //input elements in array
            {
                fscanf(fp, "%d",&input[i]);
            }
            Create(tree, input, BST_size);
            for(int i=0;i<2;i++)
            {
                temp[i]=string[i+4];
            }
            searching_times=atoi(temp);                 //input data about searching times becomes integer type
            if(strcmp(&string[0],"d")) result=DFS_search(tree[0], &searching_times);
            if(strcmp(&string[0],"b")) result=BFS_search(tree, searching_times);
            pass_result(i, &result, result_arr);        //pass the result
            free(input);
        }
    return_result(result_arr, how_many_times);          //return result in txt file
    free(result_arr);                                   //free result heep data
}

This is the part that occurs error. If needed please refer full code or tell me what I could do more.

#define MAX_QUEUE_SIZE 100
#define FALSE 1;
#define TRUE 0;

typedef struct BST_node{
    int data;
    int visited;
    struct BST_node * leftChild;
    struct BST_node * rightChild;
}node;

typedef node* TreeNode;
typedef struct {
    TreeNode data[MAX_QUEUE_SIZE];
    int front;
    int rear;
}Queue;

void Node_reset(TreeNode* input_tree, int BST_size)
{
    for(int i=0;i<BST_size;i++)
    {
        input_tree[i]->data = 0;
        input_tree[i]->leftChild=NULL;
        input_tree[i]->rightChild=NULL;
        input_tree[i]->visited=FALSE;
    }
}

void Create(TreeNode* input_tree, int data[], int BST_size)
{
    for(int i=0;i<BST_size;i++)
    {
        input_tree[i]->data=data[i];
    }
    for(int i=0;i<BST_size-1;i++)
    {
        if(input_tree[i]->data > input_tree[i+1]->data) input_tree[i]->leftChild=input_tree[i+1];
        else input_tree[i]->rightChild=input_tree[i+1];
    }
}

int main()
{
    int how_many_times;      //the number of input expression
    int BST_size;            //input the number of element here
    char string[7]={0};      //input string data here
    char temp[2]={0};        //input searching num
    int searching_times;     //the number of input expression
    int result;              //result of expression

    FILE *fp = fopen("input.txt","r");
    fscanf(fp, "%d", &how_many_times);
    int *result_arr=(int*)malloc(sizeof(int)*how_many_times);
    
        for(int i=0;i<how_many_times;i++)
        {
            fscanf(fp, "%d", &BST_size);                    //pass BST size
            int* input=(int*)malloc(sizeof(int)*BST_size);  //allocate heep memory as long as input BST size
            fscanf(fp, "%s", string);                       //pass string input data to string[]
            TreeNode* tree=(TreeNode*)malloc(sizeof(TreeNode)*BST_size);
            Node_reset(tree, BST_size);
            for(int i=0;i<BST_size;i++)                 //input elements in array
            {
                fscanf(fp, "%d",&input[i]);
            }
            Create(tree, input, BST_size);
        }
}