Question

我试图将2 ^ n乘2 ^ n 2D阵列分成4个象限。然后我想搜索这些象限以获取信息。如果所有象限数组元素= 1或0，那么该象限可以保持不变。如果象限混合了1和0，那么我想继续拆分数组，直到我留下只有1或0或0的象限（偶数）如果那是一个单一的数组元素）。我知道我必须实现一个递归函数，但我似乎无法弄清楚......到目前为止我所拥有的是什么。非常感谢任何帮助！

node* split(int **image_array, int width){
 node* root = NULL;
 int i, j;
 int black_pixel_NW = 0, black_pixel_NE = 0, black_pixel_SE = 0, black_pixel_SW = 0;


 if (width >= 2){


     for (i = 0; i < width/2; i++)   {
         for (j = 0; j < width/2; j++){
             printf("(%d,%d) = %d\n", i, j, image_array[i][j]);
             if (image_array[i][j] == 0){
                 black_pixel_NW = ++black_pixel_NW;
             }
         }
     }
     printf("\nBlack pixels NW = %d\n", black_pixel_NW);


     for (i = width/2; i < width; i++)   {
         for (j = 0; j < width/2; j++){
             printf("(%d,%d) = %d\n", i, j, image_array[i][j]);
             if (image_array[i][j] == 0){
                 black_pixel_NE = ++black_pixel_NE;
             }
         }
     }
     printf("\nBlack pixels NE = %d\n", black_pixel_NE);


             for (i = width/2; i < width; i++)   {
         for (j = width/2; j < width; j++){
             printf("(%d,%d) = %d\n", i, j, image_array[i][j]);
             if (image_array[i][j] == 0){
                 black_pixel_SE = ++black_pixel_SE;
             }
         }
     }
    printf("\nBlack pixels SE = %d\n", black_pixel_SE);


     for (i = 0; i < width/2; i++)   {
         for (j = width/2; j < width; j++){
             printf("(%d,%d) = %d\n", i, j, image_array[i][j]);
             if (image_array[i][j] == 0){
                 black_pixel_SW = ++black_pixel_SW;
             }
         }
     }
     printf("\nBlack pixels SW = %d\n", black_pixel_SW);

     width = width / 2;

 }

 return root;}

代码用于读取二进制图像文件，因此是black_pixel变量。 black_pixel_NW表示左上象限中的黑色像素数。我在函数中有指针内容，因为这些信息最终将存储在四叉树中。

Answer 1

将函数分解为绝对最基本状态时，最容易理解递归。你实际上写了4次逻辑。

最明显的解决方案（对我来说！）会稍微扩展一下函数参数。类似的东西：

split(int **img, int x, int y, int width, int height);

将逻辑仅用于单个象限，然后通过四个象限中的每一个递归。像：

if (all_pixels_same_color) return; // or do something
else {
 split(img, x, y, width/2, height/2); // Top left Quadrant
 split(img, x + width/2, y, width/2, height/2); // Top right Q.
 split(img, x, y + height/2, width/2, height/2); // Bottom left Q.
 split(img, x + width/2, y + height/2, width/2, height/2); // Bottom right Q.
}

现在，要查看图像的每个像素，只需从图像的完整尺寸开始

split(img, 0, 0, 256, 256);

该功能会将此视为一个象限，并且最有可能分成四个象限（用四个新的起始象限位置自称四次）。

编辑：以及检查象限中所有像素的相同值的示例：

if (width == 1 || height == 1)
 return; // or something else

int i, j;
int cmp = img[x][y]; // top-left pixel

for (j = y; j < height; j++)
 for (i = x; i < width; i++)
   if (img[i][j * IMG_WIDTH] != cmp)
    goto split_to_quads; // or whatever

如何重复将2D阵列细分或拆分成较小的象限？

1 个答案: