C 在此程序中未获得所需的输出（连接对象/孤岛的数量）（分段错误）？

我必须在给定的二维二元矩阵中找到连通对象的数目。 在给出输入后，我没有得到输出

我收到错误：程序因“分段错误”而终止（11）

我的测试用例：

Enter number of rows: 
5 
Enter number of columns: 
5 
Enter the matrix: 
0 0 0 0 0
1 0 0 1 0
1 0 0 0 1
0 1 0 1 0
0 0 0 0 0 
Number of connected objects = 2

我的代码：

#include<stdio.h>
#include<stdlib.h>
typedef int Color;
typedef struct cell
{
 char kind;
 Color color;
} Cell;
typedef struct pos
{
 int h,v;
} Pos,Size;
typedef struct world
{
 Size size;
 Cell **cells;
} World;
typedef struct node
{
 Pos pos;
 struct node *next;
} Node;
typedef struct stack
{
 Node *np;
} Stack;
void push(Stack *s,Pos pos)
{
 Node *np=malloc(sizeof(*np));
 np->pos=pos;
 np->next=s->np;
 s->np=np;
}
int isEmpty(Stack *s)
{
 return !s->np;
}
Pos pop(Stack *s)
{
 Pos ret=s->np->pos;
 Node *next=s->np->next;
 free(s->np);
 s->np=next;
 return ret;
}
World *make_world(Size size,Stack *s);
void ruin(World *w);
void paint(World *w,Pos pos,Color *color);
int main(void)
{
 int rows,cols;
 puts("Enter number of rows:");
 scanf("%d",&rows);
 puts("Enter number of columns:");
 scanf("%d",&cols);
 Stack land={ NULL };
 World *world=make_world((Size){.v=rows,.h=cols},&land);
 Color color=0;
 while(!isEmpty(&land))
 {
    paint(world,pop(&land),&color);
 }
 printf("Number of connected objects = %d",color);
 ruin(world);
}
enum { BLANK=0,LAND='1',SEA=0,NONE=-1};
World *make_world(Size size,Stack *landList)
{
 World*w=malloc(sizeof(*w));
 w->size=size;
 w->cells=malloc(size.v * sizeof(*w->cells));
 for(int r=0;r<size.v;++r)
 {
    w->cells[r]=calloc(size.h,sizeof(**w->cells));
 }
 puts("Enter the matrix:");
 for(int r=0;r<size.v;++r)
 {
    for(int c=0;c,size.h;++c)
    {
        char ch=0;
        scanf(" %c",&ch);
        if((w->cells[r][c].kind=ch)==LAND)
        push(landList,(Pos){ .v=r, .h=c});
    }
 }
 return w;
}
void ruin(World *w)
{
 for(int r=0;r<w->size.v;++r)
 free(w->cells[r]);
 free(w->cells);
 free(w);
}
void fill(World *w,Pos pos,Color *color,Cell *neighbor)
{
 if(pos.h<0 || pos.v<0 || pos.h>=w->size.h || pos.v>=w->size.v)
 return;
 Cell *cell=&w->cells[pos.v][pos.h];
 if(cell->color!=BLANK)
 return;
 if(neighbor!=NULL)
 {
    if(cell->kind!=neighbor->kind)
    {
        return;
    }
    cell->color=neighbor->color;
}
else
{
    cell->color=++*color;
}
fill(w, (Pos){.v=pos.v-1,.h=pos.h-1},color,cell);
fill(w, (Pos){.v=pos.v-1,.h=pos.h},color,cell);
fill(w, (Pos){.v=pos.v-1,.h=pos.h+1},color,cell);
fill(w, (Pos){.v=pos.v,.h=pos.h-1},color,cell);
fill(w, (Pos){.v=pos.v,.h=pos.h},color,cell);
fill(w, (Pos){.v=pos.v,.h=pos.h+1},color,cell);
fill(w, (Pos){.v=pos.v,.h=pos.h-1},color,cell);
fill(w, (Pos){.v=pos.v,.h=pos.h},color,cell);
fill(w, (Pos){.v=pos.v,.h=pos.h+1},color,cell);
}
void paint(World *w,Pos pos,Color *color)
{
 fill(w,pos,color,NULL);
}

#包括
#包括
typedef int-Color；
类型定义结构单元
{
炭类；
颜色；
}细胞；
类型定义结构位置
{
int h，v；
}Pos，大小；
typedef结构世界
{
大小；
细胞**细胞；
}世界；
类型定义结构节点
{
Pos-Pos；
结构节点*下一步；
}节点；
typedef结构堆栈
{
Node*np；
}堆叠；
无效推送（堆栈*s，位置）
{
Node*np=malloc（sizeof（*np））；
np->pos=pos；
np->next=s->np；
s->np=np；
}
int isEmpty（堆栈*s）
{
return！s->np；
}
Pos pop（堆栈*s）
{
Pos ret=s->np->Pos；
节点*next=s->np->next；
免费（s->np）；
s->np=下一步；
返回ret；
}
世界*制作世界（大小、堆栈*s）；
无效破产（世界*w）；
空漆（世界*w，位置，颜色*颜色）；
内部主（空）
{
int行，cols；
puts（“输入行数：”）；
scanf（“%d”，行和行）；
puts（“输入列数：”）；
scanf（“%d”、&cols）；
Stack land={NULL}；
World*World=make_World（（大小）{.v=rows、.h=cols}，&land）；
颜色=0；
而（！isEmpty（&land））
{
绘画（世界、流行音乐和土地）、色彩）；
}
printf（“连接对象的数量=%d”，颜色）；
毁灭（世界）；
}
枚举{BLANK=0，LAND=1'，SEA=0，NONE=-1}；
World*make_World（大小、堆栈*landList）
{
世界*w=malloc（sizeof（*w））；
w->尺寸=尺寸；
w->cells=malloc（size.v*sizeof（*w->cells））；
对于（int r=0；rcells[r]=calloc（size.h，sizeof（**w->cells））；
}
puts（“输入矩阵：”）；
对于（int r=0；rcells[r][c].kind=ch=LAND）
推（固定者，（位置）{.v=r，.h=c}）；
}
}
返回w；
}
虚空废墟（世界*w）
{
对于（int r=0；rsize.v；++r）
自由（w->cells[r]）；
自由（w->cells）；
免费（w）；
}
空白填充（世界*w，位置，颜色*颜色，单元格*邻居）
{
如果（pos.hsize.h | | pos.v>=w->size.v）
回来
单元格*单元格=&w->cells[pos.v][pos.h]；
如果（单元格->颜色！=空白）
回来
if（邻居！=NULL）
{
如果（单元->种类！=邻居->种类）
{
回来
}
单元格->颜色=邻居->颜色；
}
其他的
{
单元格->颜色=++*颜色；
}
填充（w，（Pos）{.v=Pos.v-1，.h=Pos.h-1}，颜色，单元）；
填充（w，（Pos）{.v=Pos.v-1，.h=Pos.h}，颜色，单元）；
填充（w，（Pos）{.v=Pos.v-1，.h=Pos.h+1}，颜色，单元）；
填充（w，（Pos）{.v=Pos.v，.h=Pos.h-1}，颜色，单元）；
填充（w，（Pos）{.v=Pos.v，.h=Pos.h}，颜色，单元）；
填充（w，（Pos）{.v=Pos.v，.h=Pos.h+1}，颜色，单元）；
填充（w，（Pos）{.v=Pos.v，.h=Pos.h-1}，颜色，单元）；
填充（w，（Pos）{.v=Pos.v，.h=Pos.h}，颜色，单元）；
填充（w，（Pos）{.v=Pos.v，.h=Pos.h+1}，颜色，单元）；
}
空漆（世界*w，位置，颜色*颜色）
{
填充（w、位置、颜色、空）；
}

for（int c=0；c，size.h；++c）的内部for循环

中有一个打字错误，应该是for（int c=0；c

。 在代码中写入的条件

（c，size.h）

是一个，它计算由

，

分隔的所有操作数，但“返回”的仅是最后一个表达式的结果，即右值。因此，

（c，size.h）

的效果与将

size.h

作为条件编写时的效果相同，如果

size.h

不是

0

，则条件将始终计算为

true

；因此，您会遇到一个无限循环，不断增加

c

，并产生未定义的行为（可能是分段错误）

---

无论如何，请在开发环境/编译器调用中打开警告；我想你应该在expression

c

…

上得到类似“expression result unused”的东西，请学习如何使用调试器。当我输入矩阵时，它在输入5*5后不会停止。循环是一个无限循环，我想

c，size.h

typo是

c