如何测量基于邻接法的队列方法的时间和复杂性广度优先搜索

Question

宽度优先搜索（BFS）是一种用于遍历或搜索树或图形数据结构的算法。它从树的根部（或图的某个任意节点，有时称为“搜索关键字”）开始，并在移至下一个深度级别的节点之前先探索当前深度的所有邻居节点。

这是我的基于邻接矩阵的队列方法的广度优先搜索（BFS）C代码。我使用clock_t来测量花费的时间，但是时间很短。如何计算这段代码花费的时间？谁能帮我吗？

  #include <stdio.h>
    #include <time.h>

    #define QUEUE_SIZE 20
    #define MAX 20

    //queue
    int queue[QUEUE_SIZE];
    int queue_front, queue_end;
    void enqueue(int v);
    int dequeue();

    void bfs(int Adj[][MAX], int n, int source);

   int main(void) {
       clock_t t;
       t = clock();
    //Adj matrix
    int Adj[][MAX] = {
        {0,0,1,1,0,0,0,0},
        {0,0,0,0,0,1,0,0},
        {1,0,0,0,0,0,1,0},
        {1,0,0,0,0,1,0,0},
        {0,0,0,0,0,0,1,1},
        {0,1,0,1,0,0,0,1},
        {0,0,1,0,1,0,0,0},
        {0,0,0,0,1,1,0,0},
    };

    int n = 8;  //no. of vertex
    int starting_vertex = 0;

    bfs(Adj, n, starting_vertex);

double time_taken = ((double)t)/(CLOCKS_PER_SEC/(1000));

    printf("\n%f miliseconds to execute \n", time_taken);
    return 0;
}

void bfs(int Adj[][MAX], int n, int source) {
    //variables
    int i, j;

    //visited array to flag the vertex that
    //were visited
    int visited[MAX];

    //queue
    queue_front = 0;
    queue_end = 0;

    //set visited for all vertex to 0 (means unvisited)
    for(i = 0; i < MAX; i++) {
        visited[i] = 0;
    }

    //mark the visited source
    visited[source] = 1;

    //enqueue visited vertex
    enqueue(source);

    //print the vertex as result
    printf("%d ", source);

    //continue till queue is not empty
    while(queue_front <= queue_end) {
        //dequeue first element from the queue
        i = dequeue();

        for(j = 0; j < n; j++) {
            if(visited[j] == 0 && Adj[i][j] == 1) {
                //mark vertex as visited
                visited[j] = 1;

                //push vertex into stack
                enqueue(j);

                //print the vertex as result
                printf("%d ", j);
            }
        }
    }
    printf("\n");
}

void enqueue(int v) {
    queue[queue_end] = v;
    queue_end++;
}

int dequeue() {
    int index = queue_front;
    queue_front++;
    return queue[index];
}