рабочий нерекурсивный алгоритм заполнения, написанный на C?

просто реализуйте стек пар int с массивом некоторого фиксированного размера (например, размер изображения в пикселях или квадратный корень из него) для стека и отслеживайте верхнюю часть с помощью int.

вот некоторый код C#, который реализует floodfill нерекурсивно:

private static void Floodfill(byte[,] vals, Point q, byte SEED_COLOR, byte COLOR)
{
    int h = vals.GetLength(0);
    int w = vals.GetLength(1);

    if (q.Y < 0 || q.Y > h - 1 || q.X < 0 || q.X > w - 1)
        return;

    Stack<Point> stack = new Stack<Point>();
    stack.Push(q);
    while (stack.Count > 0)
    {
        Point p = stack.Pop();
        int x = p.X;
        int y = p.Y;
        if (y < 0 || y > h - 1 || x < 0 || x > w - 1)
            continue;
        byte val = vals[y, x];
        if (val == SEED_COLOR)
        {
            vals[y, x] = COLOR;
            stack.Push(new Point(x + 1, y));
            stack.Push(new Point(x - 1, y));
            stack.Push(new Point(x, y + 1));
            stack.Push(new Point(x, y - 1));
        }
    }
}

быстрый поиск в гугле вызывает статья Википедии о заливке, которая включает реализации псевдокода, которые не являются рекурсивными. Ниже приведен код, который может помочь вам начать работу, базовая реализация очереди в C:

typedef struct queue_ { struct queue_ *next; } queue_t;
typedef struct ffnode_ { queue_t node; int x, y; } ffnode_t;

/* returns the new head of the queue after adding node to the queue */
queue_t* enqueue(queue_t *queue, queue_t *node) {
    if (node) {
        node->next = queue;
        return node;
    }
    return NULL;
}

/* returns the head of the queue and modifies queue to be the new head */
queue_t* dequeue(queue_t **queue) {
    if (queue) {
        queue_t *node = (*queue);
        (*queue) = node->next;
        node->next = NULL;
        return node;
    }
    return NULL;
}

ffnode_t* new_ffnode(int x, int y) {
    ffnode_t *node = (ffnode_t*)malloc(sizeof(ffnode_t));
    node->x = x; node->y = y;
    node->node.next = NULL;
    return node;
}

void flood_fill(image_t *image, int startx, int starty, 
                color_t target, color_t replacement) {
    queue_t *head = NULL;
    ffnode_t *node = NULL;

    if (!is_color(image, startx, starty, target)) return;

    node = new_ffnode(startx, starty);
    for ( ; node != NULL; node = (ffnode_t*)dequeue(&head)) {
        if (is_color(image, node->x, node->y, target)) {
            ffnode_t *west = node, *east = node;

            recolor(image, node->x, node->y, replacement);
            /* 1. move w to the west until the color of the node to the west
               no longer matches target */
            ...
        }
    }
}

разве нет доказательства, что все рекурсивные функции могут быть реализованы как итеративная функция, используя локальные данные для имитации стека? Вероятно, вы можете использовать std::vector для создания стекового поведения алгоритма, не раздувая стек, так как он будет использовать кучу.

EDIT: я заметил, что вы используете C, поэтому вместо std:: vector вы можете просто реализовать подобное поведение через realloc, поскольку вам нужно добавить больше элементов в свой локальный "стек" любых данных структура, которую вы бы использовали.

вы можете преобразовать любой рекурсивный алгоритм в итеративный, создав явный стек или очередь и загрузив на него/вытащив его.

все, что вам нужно-это выбрать хороший, компактное представление работы. В худшем случае: создайте struct удерживая аргументы, которые вы обычно передаете рекурсивной версии...

мы заметили, что наша реализация floodfill на 3d-томах потребляла много памяти; поэтому мы изменили код следующим образом (было значительное улучшение):

1. создайте сферу радиуса = 10 воксов вокруг начальной точки и отметьте все воксели в пределах этого радиуса как "посещаемые"

2. Если текущий воксель > порог, вставить 1.

3. пойти к соседям [+1, -1, 0] (Также проверьте, что один не пересматривает никакой воксел), если сосед.getVoxVal = 0 (значение инициализации для целевого объема), затем он попадает на границу сферы, вставляет координаты в другой стек. (это будет отправной точкой для нашей следующей сферы)

4. radius = radius + 10 (воксели)

таким образом, в то время, наш поток работает над концентрической сферой и заполняет вещи, которые являются частью всего объема, и, как я сказал, это имеет резко сократил потребление памяти, но я все еще ищу реализацию/идею, которая была бы лучше.

У меня есть нерекурсивная заливка, но я не буду публиковать ее, потому что это решение домашнего задания. Но вот подсказка: глубинный поиск, который является естественным алгоритмом, использует далеко больше вспомогательного пространства, чем поиск по ширине. Вот что я написал в то время (соответствующим образом вычеркнуто):

Я не смею пытаться искать глубину сначала простой рекурсией; глубина рекурсии ограничена только отредактированным, и мои эксперименты показывают, что проблема Тем не менее для редактирования может потребоваться глубина стека более миллиона. Поэтому я поместил стек во вспомогательную структуру данных. Использование явного стека на самом деле упрощает поиск по ширине, и оказывается, что поиск по ширине может использовать в сорок раз меньше пространства, чем поиск по глубине.

для моей структуры данных я использовал Seq_T от Дэйва Хэнсона C интерфейсы и реализации; изменение от глубины к ширине не требует изменение только одного вызова функции.

Я не знаю, имеет ли мой ответ полное отношение к поставленному вами вопросу, но в дальнейшем я предлагаю свою версию алгоритма заполнения потока C, которая не использует рекурсивные вызовы.

1-11-2017: НОВАЯ ВЕРСИЯ; УСПЕШНО ПРОТЕСТИРОВАНО С ДВУМЯ РАСТРОВЫМИ ИЗОБРАЖЕНИЯМИ.

он использует только очередь смещений новых точек, он работает на окне: WinnOffs-(WinDimX,WinDimY) двойного буфера: * VBuffer (копия экрана или изображения) и, необязательно, он пишет маску результат заливки (*ExtraVBuff). ExtraVBuff должен быть заполнен 0 перед вызовом (если вам не нужна маска, Вы можете установить ExtraVBuff= NULL); используя его после вызова, вы можете сделать градиентную заливку или другие эффекты рисования. NewFloodFill работает с 32 бит на пиксель,и это функция C. Я изобрел этот алгоритм в 1991 году (я написал его в Pascal), но теперь он работает в C с 32 бит на пиксель; также не использует никаких вызовов функций, делает только деление после каждого " pop " из очереди и никогда переполняет очередь, которая, если она имеет правильный размер (около 1/4 пикселей изображения), всегда позволяет правильно заполнить любую область; я показываю перед c-функцией (FFILL.C), после программы испытания (испытания.C):

#define IMAGE_WIDTH 1024
#define IMAGE_HEIGHT 768
#define IMAGE_SIZE IMAGE_WIDTH*IMAGE_HEIGHT
#define QUEUE_MAX IMAGE_SIZE/4

typedef int T_Queue[QUEUE_MAX];
typedef int T_Image[IMAGE_SIZE];

void NewFloodFill(int X,
                  int Y,
                  int Color,
                  int BuffDimX,
                  int WinOffS,
                  int WinDimX,
                  int WinDimY,
                  T_Image VBuffer,
                  T_Image ExtraVBuff,
                  T_Queue MyQueue)

/* Replaces all pixels adjacent to the first pixel and equal to this;   */
/* if ExtraVBuff == NULL writes to *VBuffer (eg BUFFER of 786432 Pixel),*/
/* otherwise prepare a mask by writing on *ExtraVBuff (such BUFFER must */
/* always have the same size as *VBuffer (it must be initialized to 0)).*/

/*         X,Y: Point coordinates' of origin of the flood-fill.         */
/*     WinOffS: Writing start offset on *VBuffer and *ExtraVBuff.       */
/*    BuffDimX: Width, in number of Pixel (int), of each buffer.        */
/*     WinDimX: Width, in number of Pixel (int), of the window.         */
/*       Color: New color that replace all_Pixel == origin's_point.     */
/*     WinDimY: Height, in number of Pixel (int), of the window.        */
/*     VBuffer: Pointer to the primary buffer.                          */
/*  ExtraVBuff: Pointer to the mask buffer (can be = NULL).             */
/*     MyQueue: Pointer to the queue, containing the new-points' offsets*/

{
 int VBuffCurrOffs=WinOffS+X+Y*BuffDimX;
 int PixelIn=VBuffer[VBuffCurrOffs];
 int QueuePnt=0;
 int *TempAddr=((ExtraVBuff) ? ExtraVBuff : VBuffer);
 int TempOffs1;
 int TempX1;
 int TempX2;
 char FLAG;

 if (0<=X && X<WinDimX && 0<=Y && Y<WinDimY) do
  {
   /* Fill to left the current line */
   TempX2=X;
   while (X>=0 && PixelIn==VBuffer[VBuffCurrOffs])
    {
     TempAddr[VBuffCurrOffs--]=Color;
     --X;
    }
   TempOffs1=VBuffCurrOffs+1;
   TempX1=X+1;

   /* Fill to right the current line */
   VBuffCurrOffs+=TempX2-X;
   X=TempX2;
   while (X+1<WinDimX && PixelIn==VBuffer[VBuffCurrOffs+1])
    {
     ++X;
     TempAddr[++VBuffCurrOffs]=Color;
    }
   TempX2=X;

   /* Backward scan of the previous line; puts new points offset in Queue[] */
   if (Y>0)
    {
     FLAG=1;
     VBuffCurrOffs-=BuffDimX;
     while (X-->=TempX1)
      {
       if (PixelIn!=VBuffer[VBuffCurrOffs] ||
           ExtraVBuff && Color==ExtraVBuff[VBuffCurrOffs])
        FLAG=1;
       else
       if (FLAG)
        {
         FLAG=0;
         if (QueuePnt<QUEUE_MAX)
          MyQueue[QueuePnt++]=VBuffCurrOffs;
        } 
       --VBuffCurrOffs;
      }
    }

   /* Forward scan of the next line; puts new points offset in Queue[] */
   if (Y<WinDimY-1)
    {
     FLAG=1;
     VBuffCurrOffs=TempOffs1+BuffDimX;
     X=TempX1;
     while (X++<=TempX2)
      {
       if (PixelIn!=VBuffer[VBuffCurrOffs] ||
           ExtraVBuff && Color==ExtraVBuff[VBuffCurrOffs])
        FLAG=1;
       else
       if (FLAG)
        {
         FLAG=0;
         if (QueuePnt<QUEUE_MAX)
          MyQueue[QueuePnt++]=VBuffCurrOffs;
        }
       ++VBuffCurrOffs;
      }
    }

   /* Gets a new point offset from Queue[] */ 
   if (--QueuePnt>=0)
    {
     VBuffCurrOffs=MyQueue[QueuePnt];
     TempOffs1=VBuffCurrOffs-WinOffS;
     X=TempOffs1%BuffDimX;
     Y=TempOffs1/BuffDimX;
    }

  /* Repeat the main cycle until the Queue[] is not empty */
  } while (QueuePnt>=0);
}

здесь есть тестовая программа:

#include <stdio.h>
#include <malloc.h>
#include "ffill.c"

#define RED_COL 0xFFFF0000
#define WIN_LEFT 52
#define WIN_TOP 48
#define WIN_WIDTH 920
#define WIN_HEIGHT 672
#define START_LEFT 0
#define START_TOP 671

#define BMP_HEADER_SIZE 54

typedef char T_Image_Header[BMP_HEADER_SIZE];
void main(void)
{

 T_Image_Header bmpheader;
 T_Image *image;
 T_Image *mask;
 T_Queue *MyQueue;

 FILE *stream;
 char *filename1="ffill1.bmp";
 char *filename2="ffill2.bmp";
 char *filename3="ffill3.bmp";
 int bwritten;
 int bread;

 image=malloc(sizeof(*image));
 mask=malloc(sizeof(*mask));
 MyQueue=malloc(sizeof(*MyQueue));

 stream=fopen(filename1,"rb");
 bread=fread(&bmpheader, 1, BMP_HEADER_SIZE, stream);
 bread=fread((char *)image, 1, IMAGE_SIZE<<2, stream);
 fclose(stream);

 memset(mask,0,IMAGE_SIZE<<2);

 NewFloodFill(START_LEFT,
              START_TOP,
              RED_COL,
              IMAGE_WIDTH,
              IMAGE_WIDTH*WIN_TOP+WIN_LEFT,
              WIN_WIDTH,
              WIN_HEIGHT,
              *image,
              NULL,
              *MyQueue);

 stream=fopen(filename2,"wb+");
 bwritten=fwrite(&bmpheader, 1, BMP_HEADER_SIZE, stream);
 bwritten=fwrite((char *)image, 1, IMAGE_SIZE<<2, stream);
 fclose(stream);

 stream=fopen(filename3,"wb+");
 bwritten=fwrite(&bmpheader, 1, BMP_HEADER_SIZE, stream);
 bwritten=fwrite((char *)mask, 1, IMAGE_SIZE<<2, stream);
 fclose(stream);

 free(MyQueue);
 free(mask);
 free(image);
}

я использовал, для ввода показанной тестовой программы, следующие окна несжатые .Изображения в формате BMP (ffill1.bmp):

заполнил, тест программа показана следующим образом (ffill2.bmp):

используя "маску" вместо NULL, выходное растровое изображение (ffill3.bmp):

Ниже приведен мой итерационный метод C++ на основе BFS для проблемы заливки потока:

// M is the input matrix, with every entry(pixel) have a color
// represented with an integer value.
// (x, y) row and column of seed point respectively
// k: The new color to fill the seed and its adjacent pixels
void floodFill(vector<vector<int>> &M, int x, int y, int k) {
    queue<pair<int, int>> nodeQ;
    nodeQ.push({x, y});
    int oldCol = M[x][y];
    while(!nodeQ.empty()) {
        pair<int, int> currNode = nodeQ.front();
        nodeQ.pop();
        if(M[currNode.first][currNode.second] == oldCol) {
            M[currNode.first][currNode.second] = k;
            if(currNode.first > 0) nodeQ.push({currNode.first-1, currNode.second});
            if(currNode.first < (M.size()-1)) nodeQ.push({currNode.first+1, currNode.second});
            if(currNode.second > 0) nodeQ.push({currNode.first, currNode.second-1});
            if(currNode.second < (M[0].size()-1)) nodeQ.push({currNode.first, currNode.second+1});
        }
    }
}

вы можете быстро преобразовать рекурсивную заливку потока в ультра-исполнительную псевдо-рекурсивную... Не редактируйте строки, просто добавьте новые строки: поместите рекурсивную функцию в цикл XY для добавленной структуры. запись нашли соседи "нашли такие соседи " вместо памяти, поэтому вы начнете паковать дерево стилей 4-16-64 рекурсии в массив XY. использование памяти идет от 1 гигабайта до 2 мегабайт. Также используйте 2D-массив, называемый "заполненный массив соседей"... прервать функцию для любого пиксели, отмеченные как заполненные в "заполненном массиве соседей", это использует 2 инструкции для каждого дубликата, 20 инструкций для каждой операции заполнения, и он итеративно заполняет влево и вверх, как домино, безумно быстро.

1024x1024 использует около 1million * 20 инструкций, что составляет 0,1 секунды для одного ядра.

Я достигаю 9 миллионов заполненных пикселей в секунду на i7 таким образом, у меня есть видео в качестве доказательства и страница блога с объяснениями кода и теории:

www.youtube.com/watch?v=4hQ1wA4Sl4c

и вот страница, на которой я попытался объяснить, как это работает. http://unity3dmc.blogspot.com/2017/02/ultimate-3d-floodfill-scanline.html?m=1

и код.

рекурсии были бы самыми быстрыми, если бы они могли оставаться организованными.

Если вы рекурсируете через сетку данных (изображение), вы можете сохранить обработку рекурсий в формате сетки, потому что обработанные шаги представляют пиксели из сетки, а не разнесут результаты в формат дерева.