Getting the count of each word in a sorted array

Question

The goal of the following code segment is to take a sorted array of strings, and count how many of each word there is.

That information is then put into a struct called reduceNode that holds a string and a count for the given string.

The reduceNode structs are put into another array.

Once all of the words and their counts are found and put into the intermediate array, they are inserted into a global array of reduceNode structs.

This method is called by threads, which is why I am storing the results into a global array.

Anytime I run this part of the program, I am getting a segfault.

I assume I am accessing an array out of bounds, but I am having trouble narrowing down where I am doing so.

void* reduce(void* num) //Reduce function 
{
    int index = *(int*)num;
    int curSize = 0; //Size of the current linked list
    struct HashNode *head = HashTable[index]; //Get the head of the linked list from the hashtable
    struct HashNode *linkedList = head; //Pointer to the head to traverse the linked list
    while(linkedList != NULL) //Gets the size of the current linked list 
    {
        curSize++;
        linkedList = linkedList->next;
    }
    linkedList = head;
    int linkedListTraverse = 0; //Array index for each linked list node
    int numSort[curSize];
    char* wordSort[curSize];
    while(linkedList != NULL)
    {
        if(app == 1)
            numSort[linkedListTraverse] = linkedList->num; //Copy the data from the linked list into an array 
        else
        {
            wordSort[linkedListTraverse] = (char*) malloc(sizeof(linkedList->string));
            strcpy(wordSort[linkedListTraverse],linkedList->string); //Copy the data from the linked list into an array 
        }
        linkedList = linkedList->next;
        linkedListTraverse++;
    }
    if(app == 1)
    {
        qsort(numSort, curSize, sizeof(int), numCmpFunc); //Sort the current node
        int i, j = 0;
        reduceNode* numSortArray[curSize];
        reduceNode* curNum;
        for(i = 0; i < curSize; i++)
        {
            curNum = (reduceNode*) malloc(sizeof(reduceNode));
            curNum->num = numSort[i];
            numSortArray[i] = curNum;
        }
        i = 0;
        while(sortedArray[i] != NULL)
        {
            i++;
        }
        for(j = 0; j < curSize; j++, i++)
        {  
            sortedArray[i] = numSortArray[j];
        }
        return (void*) 0;
    }
    else
    {
        int i = 0;
        while(i < curSize) //Convert all of the words to lowercase
        {
            char* str = wordSort[i];
            char *p;
            for (p = str; *p != '\0'; p++)
                *p = (char)tolower(*p);
            i++;
        }
        qsort(wordSort, curSize, sizeof(char*), stringCmpFunc); //Sort the current node 
    }
    int curWordIndex = 0; //Exclusively for wordcount
    int checkWordIndex = 1;
    int curArrayIndex = 0;
    reduceNode *curWord;
    reduceNode* wordCountArray[curSize];
    while(curWordIndex < curSize)
    {
        curWord = malloc(sizeof(reduceNode));
        curWord->word = wordSort[curWordIndex]; //Set the word
        curWord->count = 1; //Start the count out at 1
        while(strcmp(wordSort[curWordIndex], wordSort[checkWordIndex]) == 0) //While the two words are equal
        {
            checkWordIndex++; //Advance the leading index check
            curWord->count++;
            if(checkWordIndex >= curSize) //If the leading index goes beyond the array bounds
            {
                break;
            }
        }
        if(checkWordIndex <= curSize)
        {
            curWordIndex = checkWordIndex;
            checkWordIndex = curWordIndex + 1;
        }
        else if(checkWordIndex >= curSize) //If the leading index goes beyond the array bounds
        {
            if(strcmp(curWord->word, wordSort[curWordIndex]) != 0)
            {
                curWord->word = wordSort[curWordIndex]; //Set the word
                curWord->count = 1; //Start the count out at 1
                curArrayIndex++;
                wordCountArray[curArrayIndex] = curWord;
            }
            else
            {
                wordCountArray[curArrayIndex] = curWord;
                curArrayIndex++;
            }
            break;
        }
        wordCountArray[curArrayIndex] = curWord;
        curWord = NULL;
        curArrayIndex++;
    }
    int i,j  = 0;
    while(sortedArray[i] != NULL)
    {       
        i++;
    }
    for(j = 0; j < curSize; j++, i++)
    {  
        sortedArray[i] = wordCountArray[j];
    }
    return (void*) 0;

}

reduceNode is defined as

typedef struct reduceNode
{
    int count;
    char *word;
    int num;
} reduceNode;

sortedArray is declared globally as

reduceNode **sortedArray;

and later initialized as

sortedArray = (reduceNode **)calloc(1,sizeof(reduceNode*)*inputCount);

Input count is the number of words that are read into the program

An example input would be an array: [alpha, alpha, bravo, charlie, charlie, charlie, delta]. The expected result would be [alpha 2, bravo 1, charlie 3, delta 1].

Answer 1

1. You checkWordIndex reaches exactly curSize and strcmp(wordSort[curWordIndex], wordSort[checkWordIndex] will go out of bounds. I recomment printing the indicies for debugging.

if(checkWordIndex < curSize)
{
    curWordIndex = checkWordIndex;
    checkWordIndex = curWordIndex + 1;
}

this code will still lead to checkWordIndex == curSize

2. You allocate new memory, remember to free it.

3. For thread safety lookup mutex in C.

I recommend using only one indicie and iterating like

while(index < cursize-1)
{
    ...
    ++index;
}

your fist indicie is index and your second is index+1.