All O`one Data Structure - Problem

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

#define MAX_KEYS 1000
#define MAX_FREQ_NODES 1000

typedef struct FreqNode {
    int count;
    char keys[MAX_KEYS][100];
    int keyCount;
    struct FreqNode* prev;
    struct FreqNode* next;
} FreqNode;

typedef struct {
    char keyToFreq[MAX_KEYS][100];
    FreqNode* keyToNode[MAX_KEYS];
    int keySize;
    FreqNode* head;
    FreqNode* tail;
} AllOne;

FreqNode* createFreqNode(int count) {
    FreqNode* node = (FreqNode*)malloc(sizeof(FreqNode));
    node->count = count;
    node->keyCount = 0;
    node->prev = NULL;
    node->next = NULL;
    return node;
}

AllOne* allOneCreate() {
    AllOne* obj = (AllOne*)malloc(sizeof(AllOne));
    obj->keySize = 0;
    obj->head = createFreqNode(0);
    obj->tail = createFreqNode(0);
    obj->head->next = obj->tail;
    obj->tail->prev = obj->head;
    return obj;
}

FreqNode* addNodeAfter(FreqNode* prevNode, int count) {
    FreqNode* newNode = createFreqNode(count);
    newNode->prev = prevNode;
    newNode->next = prevNode->next;
    prevNode->next->prev = newNode;
    prevNode->next = newNode;
    return newNode;
}

void removeNode(FreqNode* node) {
    node->prev->next = node->next;
    node->next->prev = node->prev;
    free(node);
}

int findKeyIndex(AllOne* obj, char* key) {
    for (int i = 0; i < obj->keySize; i++) {
        if (strcmp(obj->keyToFreq[i], key) == 0) {
            return i;
        }
    }
    return -1;
}

void addKeyToNode(FreqNode* node, char* key) {
    strcpy(node->keys[node->keyCount], key);
    node->keyCount++;
}

void removeKeyFromNode(FreqNode* node, char* key) {
    for (int i = 0; i < node->keyCount; i++) {
        if (strcmp(node->keys[i], key) == 0) {
            for (int j = i; j < node->keyCount - 1; j++) {
                strcpy(node->keys[j], node->keys[j + 1]);
            }
            node->keyCount--;
            return;
        }
    }
}

void allOneInc(AllOne* obj, char* key) {
    int keyIndex = findKeyIndex(obj, key);
    
    if (keyIndex != -1) {
        FreqNode* node = obj->keyToNode[keyIndex];
        removeKeyFromNode(node, key);
        int nextCount = node->count + 1;
        
        FreqNode* nextNode;
        if (node->next->count != nextCount) {
            nextNode = addNodeAfter(node, nextCount);
        } else {
            nextNode = node->next;
        }
        
        addKeyToNode(nextNode, key);
        obj->keyToNode[keyIndex] = nextNode;
        
        if (node->keyCount == 0) {
            removeNode(node);
        }
    } else {
        FreqNode* firstNode;
        if (obj->head->next->count != 1) {
            firstNode = addNodeAfter(obj->head, 1);
        } else {
            firstNode = obj->head->next;
        }
        
        strcpy(obj->keyToFreq[obj->keySize], key);
        obj->keyToNode[obj->keySize] = firstNode;
        obj->keySize++;
        addKeyToNode(firstNode, key);
    }
}

void allOneDec(AllOne* obj, char* key) {
    int keyIndex = findKeyIndex(obj, key);
    FreqNode* node = obj->keyToNode[keyIndex];
    removeKeyFromNode(node, key);
    
    if (node->count == 1) {
        for (int i = keyIndex; i < obj->keySize - 1; i++) {
            strcpy(obj->keyToFreq[i], obj->keyToFreq[i + 1]);
            obj->keyToNode[i] = obj->keyToNode[i + 1];
        }
        obj->keySize--;
    } else {
        int prevCount = node->count - 1;
        FreqNode* prevNode;
        if (node->prev->count != prevCount) {
            prevNode = addNodeAfter(node->prev, prevCount);
        } else {
            prevNode = node->prev;
        }
        
        addKeyToNode(prevNode, key);
        obj->keyToNode[keyIndex] = prevNode;
    }
    
    if (node->keyCount == 0) {
        removeNode(node);
    }
}

char* allOneGetMaxKey(AllOne* obj) {
    if (obj->tail->prev == obj->head) return "";
    return obj->tail->prev->keys[0];
}

char* allOneGetMinKey(AllOne* obj) {
    if (obj->head->next == obj->tail) return "";
    return obj->head->next->keys[0];
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char operations[1000];
    char params[2000];
    
    fgets(operations, sizeof(operations), stdin);
    fgets(params, sizeof(params), stdin);
    
    // Remove newlines
    operations[strcspn(operations, "\n")] = 0;
    params[strcspn(params, "\n")] = 0;
    
    // Parse operations
    char* opArray[100];
    int opCount = 0;
    char* token = strtok(operations, ",");
    while (token != NULL) {
        opArray[opCount++] = token;
        token = strtok(NULL, ",");
    }
    
    // Parse parameters (simple parsing for this format)
    char paramArray[100][100];
    int paramCount = 0;
    char* p = params + 1; // Skip first '['
    while (*p) {
        if (*p == '[') {
            p++;
            if (*p == ']') {
                strcpy(paramArray[paramCount], "");
                paramCount++;
                p++;
            } else if (*p == '\"') {
                p++;
                int start = 0;
                while (*p && *p != '\"') {
                    paramArray[paramCount][start++] = *p;
                    p++;
                }
                paramArray[paramCount][start] = '\0';
                paramCount++;
                if (*p == '\"') p++;
                if (*p == ']') p++;
            }
        }
        if (*p == ',' || *p == ']') p++;
    }
    
    printf("[");
    AllOne* obj = NULL;
    
    for (int i = 0; i < opCount; i++) {
        if (i > 0) printf(",");
        
        if (strcmp(opArray[i], "AllOne") == 0) {
            obj = allOneCreate();
            printf("null");
        } else if (strcmp(opArray[i], "inc") == 0) {
            allOneInc(obj, paramArray[i]);
            printf("null");
        } else if (strcmp(opArray[i], "dec") == 0) {
            allOneDec(obj, paramArray[i]);
            printf("null");
        } else if (strcmp(opArray[i], "getMaxKey") == 0) {
            char* key = allOneGetMaxKey(obj);
            if (strlen(key) == 0) {
                printf("\"\"");
            } else {
                printf("\"%s\"", key);
            }
        } else if (strcmp(opArray[i], "getMinKey") == 0) {
            char* key = allOneGetMinKey(obj);
            if (strlen(key) == 0) {
                printf("\"\"");
            } else {
                printf("\"%s\"", key);
            }
        }
    }
    printf("]\n");
    
    return 0;
}