breadth-first search in C language - c

Question

I have two integer lists say list_a and list_b.
I have a function say func(), and func(list_a) would produce n lists say:
list_a_1 list_a_2 list_a_3 list_a_4 ........... list_a_n
I have to run func() on all lists as produced above until I find one of those lists = list_b.
So below could be the possible representation of how the list grows:
list_a
============================================================================
list_a_1 list_a_2 list_a_3 list_a_4 ........... list_a_n LEVEL 1
============================================================================
list_a_1_1.... list_a_1_n list_a_2_1... list_a_2_n..... LEVEL 2
============================================================================
Suppose say we find list_a_1_n == list_b, then stop the function and return the LEVEL, which in our case is 2 (Level2).
I am not being able to do it :(
How to do it in C?
Please note, this is not a homework question.
I am trying to find Cyclic Kendal Tau distance between two inputs as I think I found a solution in terms of algorithm for this question. I want to check whether my algorithm is correct.
below is the code in Python:
import collections
def Transpose(alist):
leveloutput = []
n = len(alist)
for i in range(n):
x=alist[:]
x[i],x[(i+1)%n] = x[(i+1)%n],x[i]
leveloutput.append(x)
return leveloutput
def Cyc_Ken_Tau(start, goal):
queue = collections.deque([(start, 0)])
while True:
element, level = queue.popleft()
if element == goal:
return level
for new_list in Transpose(element):
queue.append((new_list, level + 1))
if __name__ == '__main__':
print "***********************************************************"
u = [2, 3, 4, 1]
v = [1, 2, 4, 3]
print "***********************************************************"
m = Cyc_Ken_Tau(u,v)
print "Cyclic Kendal Tau:",m
Also the partial code in C is as follows:
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void print_array(int **a, int num_elements);
int **transpose(int n, int arr[n]);
int main(){
int a[] = {2, 3, 4, 1};
int **c;
int n = sizeof(a)/sizeof(*a);
int i;
printf("original\n");
print_array2(a,4);
printf("\n*****************************\n");
c= transpose(n, a);
print_array(c, n);
//deallocate
for(i=0;i<n;++i)
free(c[i]);
free(c);
return 0;
}
int **transpose(int n, int arr[n]){
int l = n;
int **b = malloc(l * sizeof(*b));//sizeof(*b) : sizeof(int *)
int i, j, k;
for (i = 0; i < l; i++) {
j = (i + 1) % l;
int *copy = malloc(l * sizeof(*copy));//sizeof(int)
for (k = 0; k < l; k++)
copy[k] = arr[k];
int t = copy[i];
copy[i] = copy[j];
copy[j] = t;
//printf("{%d, %d, %d, %d}\n", copy[0], copy[1], copy[2], copy[3]);
b[i] = copy;
}
return b;
}
void print_array(int **a, int num_elements){
int i, j;
for(i=0; i<num_elements; i++){
for(j=0; j<num_elements; j++)
printf("%d ", a[i][j]);
printf("\n");
}
}
void print_array2(int a[], int num_elements)
{
int i;
for(i=0; i<num_elements; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}
But I am struggling with the Cyc_Ken_Tau function in C. Any help will be much much appreciated.