Binary Search Tree Iterator II - Problem

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

// --- Tree and Iterator structures remain the same ---
typedef struct TreeNode {
    int val;
    struct TreeNode *left, *right;
} TreeNode;

TreeNode* createNode(int val) {
    TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));
    node->val = val;
    node->left = node->right = NULL;
    return node;
}

typedef struct {
    int* values;
    int size;
    int index;
} BSTIterator;

void inorder(TreeNode* root, int** values, int* size, int* capacity) {
    if (!root) return;
    inorder(root->left, values, size, capacity);
    if (*size >= *capacity) {
        *capacity *= 2;
        *values = (int*)realloc(*values, sizeof(int) * (*capacity));
    }
    (*values)[(*size)++] = root->val;
    inorder(root->right, values, size, capacity);
}

BSTIterator* createIterator(TreeNode* root) {
    BSTIterator* it = (BSTIterator*)malloc(sizeof(BSTIterator));
    int capacity = 10;
    it->values = (int*)malloc(sizeof(int) * capacity);
    it->size = 0;
    it->index = -1;
    inorder(root, &(it->values), &(it->size), &capacity);
    return it;
}

// --- Helper to clean tokens (Removes brackets and commas) ---
void cleanToken(char* s) {
    char* src = s;
    char* dst = s;
    while (*src) {
        if (isdigit(*src) || *src == '-' || isalpha(*src)) {
            *dst++ = *src;
        }
        src++;
    }
    *dst = '\0';
}

TreeNode* buildTree(char** nodes, int count) {
    if (count == 0 || strcmp(nodes[0], "null") == 0 || strlen(nodes[0]) == 0) return NULL;

    TreeNode* root = createNode(atoi(nodes[0]));
    TreeNode** queue = (TreeNode**)malloc(sizeof(TreeNode*) * (count + 1));
    int head = 0, tail = 0;
    queue[tail++] = root;

    int i = 1;
    while (head < tail && i < count) {
        TreeNode* curr = queue[head++];

        // Left Child
        if (i < count && strcmp(nodes[i], "null") != 0 && strlen(nodes[i]) > 0) {
            curr->left = createNode(atoi(nodes[i]));
            queue[tail++] = curr->left;
        }
        i++;

        // Right Child
        if (i < count && strcmp(nodes[i], "null") != 0 && strlen(nodes[i]) > 0) {
            curr->right = createNode(atoi(nodes[i]));
            queue[tail++] = curr->right;
        }
        i++;
    }
    free(queue);
    return root;
}

int main() {
    char cmdLine[4096], inputLine[4096];
    if (!fgets(cmdLine, sizeof(cmdLine), stdin)) return 0;
    if (!fgets(inputLine, sizeof(inputLine), stdin)) return 0;

    // 1. Parse Commands
    char* commands[200];
    int cmdCount = 0;
    char* cmdToken = strtok(cmdLine, " \",[]\n");
    while (cmdToken) {
        commands[cmdCount++] = strdup(cmdToken);
        cmdToken = strtok(NULL, " \",[]\n");
    }

    // 2. Parse Tree Array (Targeting the first nested array)
    char* treeNodes[200];
    int nodeCount = 0;
    // Find the start of the actual tree values (after the third '[')
    char* start = strchr(inputLine, '[');
    if (start) start = strchr(start + 1, '[');
    if (start) start = strchr(start + 1, '[');

    if (start) {
        char* treePart = strdup(start);
        char* endOfArray = strchr(treePart, ']');
        if (endOfArray) *endOfArray = '\0';
        
        char* nodeToken = strtok(treePart, ", ");
        while (nodeToken) {
            cleanToken(nodeToken);
            if (strlen(nodeToken) > 0) {
                treeNodes[nodeCount++] = strdup(nodeToken);
            }
            nodeToken = strtok(NULL, ", ");
        }
        free(treePart);
    }

    // 3. Execution
    BSTIterator* it = NULL;
    printf("[");
    for (int i = 0; i < cmdCount; i++) {
        if (i > 0) printf(", ");
        
        if (strcmp(commands[i], "BSTIterator") == 0) {
            TreeNode* root = buildTree(treeNodes, nodeCount);
            it = createIterator(root);
            printf("null");
        } else if (strcmp(commands[i], "hasNext") == 0) {
            printf("%s", (it && it->index + 1 < it->size) ? "true" : "false");
        } else if (strcmp(commands[i], "next") == 0) {
            printf("%d", it->values[++it->index]);
        } else if (strcmp(commands[i], "hasPrev") == 0) {
            printf("%s", (it && it->index > 0) ? "true" : "false");
        } else if (strcmp(commands[i], "prev") == 0) {
            if (it->index > 0) printf("%d", it->values[--it->index]);
            else { it->index--; printf("null"); }
        }
    }
    printf("]\n");

    return 0;
}