Error while passing linked list as an argument - c

Question

Here is the code for a bucket sort program.
typedef struct node_struct {
double d;
struct node_struct *next;
} node;
I'm using insertion sort to sort the values
void insert(double value, int index, node *B[]) {
node *t;
if (B[index] == NULL) {
t = (node *)malloc(sizeof(node));
t->d = value;
t->next = NULL;
B[index] = t;
} else {
node *p0, *p1;
p0 = B[index];
p1 = p0 -> next;
while(p1 != NULL) {
if (p1 -> d > value) {
break;
}
p1 = p1->next;
p0 = p0->next;
}
t = (node *)malloc(sizeof(node));
t->d = value;
t->next = p1;
p0->next = t;
}
void Bucket_Sort(double A[], int n) {
int j, index;
double B[n];
node *B1;
B1 = (node *)malloc(sizeof(node));
for (int i = 0; i < n; i++) {
B[i] = 0;
}
B1->d = A[0];
B1->next = NULL;
for (int i = 1; i <= n; i++) {
index = (int) floor(n * A[i]);
insert(A[i], index, B1); // This part of the program is where I'm going wrong
}
for (int = 0; i < n; i++) {
printf("%f \n", B[i]);
}
}
When I try calling the insert function, an error occurs saying "expecting struct node ** but the argument is of type struct node *"
But if I call insert function as follows:
insert(A[i],index,&B1);
Then no error is given while compiling but when I run the program it leads to a segmentation fault. Can someone help me with the confusion?

Answer 1

Your insert function is indicating b is an array of pointers to node objects.
But you're not passing in an array of pointers, you're calling it with &b1, which is a pointer to a single node (not an array). And when you uses arrays like that generally you need to pass a count of elements, whereas with pointers to linked list elements you usually use null to indicate the end of the list.
If I were you I would just pass pointers around to deal with everything, and get rid of the [] since you're really not passing things properly for an array. E.g. Rather than passing in an index, just pass a pointer to the object of interest. In more tricky cases you can use ** pointer to pointer but that requires a very solid understand of what you're doing.
Google linked-list example to get ideas how to deal with that properly with pointers. You'll get the idea.
Otherwise be consistent in the way you pass an interpret arrays and pass a count in, and use the count variable in your loops. I'd advise not to try to mix the [] form and * or ** paradigms until you get really comfortable with each separately.
typedef struct node_struct {
double d;
struct node_struct *next;
} node;
void insert(double value, int index, node *b[]) {
node *t;
if (b[index] == NULL) {
t = (node *)malloc(sizeof(node));
t->d = value;
t->next = NULL;
b[index] = t;
} else {
node *p0, *p1;
p0 = b[index];
p1 = p0 -> next;
while (p1 != NULL) {
if (p1 -> d > value) {
break;
}
p1 = p1->next;
p0 = p0->next;
}
t = (node *)calloc(sizeof(node), 1);
t->d = value;
t->next = p1;
p0->next = t;
}
void Bucket_Sort(double a[], int n) {
int j, index;
double b[n];
node *b1 = (node *)calloc(sizeof(node), 1);
a1->d = a[0];
b1->next = NULL;
for (int i = 1; i <= n; i++) {
index = (int) floor(n * a[i]);
insert(a[i], index, b1);
}
for (int = 0; i < n; i++) {
printf("%f \n", b[i]);
}
}
I formatted the program in your question, and went further below. This is more how I see code written in professional code bases and when I do peer code reviews, etc...
Some notes:
• If you use calloc() instead of malloc, and your buffer is automatically zeroed. People usually use bzero(), or memset() to zero arrays rather than a for() loop.
• You can declare an assign a variable such as B1 at the same time and save space/clutter;
• You can declare the variable type inside a for-loop and it will be scoped to just that for-loop. Makes it clear and saves vertical space.
• Don't get too idiosyncratic with your formatting. The programming community is just frustrated by it. There are coding standards at just about any respectable C coding place, and very strict so the code looks clean, readable, easy to understand and maintain, and consistent. If everyone applies their own twist a large coding base becomes an ugly maintenance nightmare.
• Don't add spaces before and after pointers -> no one does it and it's harder to read by experienced programmers. Leave spaces after commas, for the same reason you do when writing - separates items visually better - easier to debug, etc...
• Capitals are used for constants. Camel-case (first letter lower-case and subsequent words first letter capital for example thisIsMyVariable), for variables, or underscores this_is_my_variable, in C. Naming arrays with capital letters is tacky and you almost never see it in professional code.