Measuring time in C

Question

I'm writing a lab assignment for programming classes. I need to do it in C :). The task I choose looks as follows: I created three kinds of data types in C: linked list, binary tree and avl tree. All the data handle 5,000,000 elements. I need to measure how long it takes to find and not find element in certain step. I have fixed values for positive and negative findings.

Here is some of my code that contains function for creating array of 5,000,000 numbers and two function for binary tree adding and finding node. I hope that the code is quite clear.

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

#define SIZE 5000000

typedef struct Node {

    int data;
    struct Node *left, *right;
} Node;

void evenArrayGen(int num, int even_nums[]);
void shuffle(int numbers[]);
void addNode(Node **root, int value);
Node* findNode(Node *root, int value);



/** Recursively adds given value to the tree
 *
 * @param root
 * @param value
 *
 */

void addNode(Node **root, int value) {

    Node *temp;
    ///check statement to avoid infinite loop in adding
    if(*root == NULL) {
        temp = (Node*)malloc(sizeof(Node));
        temp->data = value;
        temp->left = temp->right = NULL;
        *root = temp;
        return;
    }
    ///recursively check where to add node
    ///if smaller than the root add to the left
    ///if bigger than the root add to the right
    else {
        temp = *root;
        if(value < temp->data) {
            addNode(&(temp->left), value);
        } else {
            addNode(&(temp->right), value);
        }
        return;
    }
}


/** Recursively searches for Node with given value
 *
 * @param root
 * @param value
 * @return Node or NULL (if Node was not found)
 *
 */

Node* findNode(Node *root, int value) {

    Node *temp;
    ///check statement to avoid infinite loop in searching
    ///if it reachese that point given value is not in the tree
    if(root == NULL) {
       // printf("Given value is not in the tree\n");
        return NULL;
    }
    temp = root;
    if(temp->data == value) {
       // printf("Searched value is: %i\n", temp->data);
        return temp;
    } else if(value < temp->data) {
        findNode(temp->left, value);
    } else {
        findNode(temp->right, value);
    }
}


/** Generates array of ordered even numbers from 2
 *
 * @param num number of uniqe even digits
 * @param array of size equal to the number
 *
 */

void evenArrayGen(int num, int even_nums[]) {

    int i, current;
    i = current = 0;
    for(; i<num; i++) {
        even_nums[i] = current += 2;
    }
    return;
}


/** Shuffle the array in random order. Radomly gets the index between 0 and
 *  current last index. Swaps number at random index with last one and
 *  decreses the current_last index by 1.
 *
 * @param array of numbers to be shuffled
 *
 */

void shuffle(int nums[]) {

    int i, len, current_last, index, temp;
    ///set the current_last to length of the array to track index for
    ///swaping nums
    current_last = len = SIZE;
    for (i=0; i<len; i++) {
        srand(time(NULL));
        index = rand()%(current_last);
        temp = nums[index];
        nums[index] = nums[current_last];
        nums[current_last] = temp;
        current_last--;
    }
    return;

}

int main() {

    //initialize root for the tree
    Node *root;
    //intilialize array of 5,000,000 elements, and scores
    static int nums[SIZE];
    int i; //iterator
    //initialize positive and negative numbers for find method
    int positive_num, negative_num;
    //initilaize timer
    clock_t start_for_adding, start_for_finding;


    //add elements to the array
    evenArrayGen(SIZE, nums);
    shuffle(nums);
    //set positive number to one of the first 5000 elements
    positive_num = nums[3222];
    negative_num = 345; //all numbers in num are even so negative need to be odd

    root = NULL; //set the root Node to NULL
    start_for_adding = clock(); //zero the timer

    //now iterate trough all elements in nums array and add each to
    //the binary tree
    for(i=0; i<SIZE; i++) {

        //check if i reached proper value
        if (i == 5000 || i == 50000 || i == 500000 || i == (5000000-1)) {
            //add the adding time
            printf("\nIndex: %d\n", i);
            printf("Adding: %.5f\n", (double) clock() - start_for_adding);
            start_for_finding = clock(); //zero the timer
            //search for positive num
            findNode(root, positive_num);
            printf("Finding positive: %.5f\n", 
                   (double) clock() - start_for_finding);
            start_for_finding = clock(); //zero the timer
            //search for negative num
            findNode(root, negative_num);
            printf("Finding negative: %.5f\n", 
                   (double) clock() - start_for_finding);
            start_for_adding = clock(); //reset the timer for adding
        }
        addNode(&root, nums[i]);
    }
    return;

}

The times for finding elements are pointing to zero (in both cases)

I'm pretty lost, have no idea where to follow now (the easiest part for my task shows that is the hardest one...)

Answer 1

The resolution of clock is most likely to coarse to measure the time taken by individual calls to your findNode function. Typically the time is measured to perform such a call lots of times and then divide this time by the number of times the call was performed.