PROJETO: Algoritmo de preenchimento - Estrutura de Dados

PROJETO: Algoritmo de preenchimento - Estrutura de Dados

Algoritmo de preenchimento - Estrutura de Dados

==========
main.c
==========
/*  Algoritmo de preenchimento - Estrutura de Dados
    | Kássio Rômulo Lima SOusa CP09126-81 | Núbia Cristine Silveira dos Santos CP09142-81 |
*/

#define TRUE 1
#define FALSE 0
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>
#include "stack.h"

int n, m, cont;

void pintar(int k, int cor, stack *pilha, int *matriz){
 int cor_antiga;
 int ponto;
 int ponto_p;
 int teste;

if((k == (n*m)-1) && (cont == 1)){
    k = 0;
    cont++;
}
 ponto = k;
 stkpush(pilha, (void*) ponto);
 cor_antiga = matriz[ponto];

while(stkisempty(pilha) == FALSE){
   ponto_p = (int) stkpop(pilha);
     if(matriz[ponto_p] == cor_antiga){
      
       stkpush(pilha, (void *) k-m);   
       stkpush(pilha, (void *) k-1);   
       stkpush(pilha, (void *) k+m);
       stkpush(pilha, (void *) k+1);
       matriz[ponto_p] = cor;
       k++;
      }            
     }
}

int main(){
    int i, j, k, x, y, regiao, cor_escolhida;
    int *matriz;
    stack *pilha;

    printf("Entre com o tamanho da matriz x e y: ");
    scanf("%d %d", &n, &m);
    matriz = (int *) calloc(sizeof(int), n*m);
    pilha = stkCreate(n*m);

    for(i=0; i<n; i++){
        for(j=0; j<m; j++){
            k = i*m +j;
            printf("Insira a cor da posicao [%d]: ", k);                
            scanf("%d", &matriz[k]);   
        }    
    }

    printf("Entre com as coordenadas que deseja pintar: ");                
    scanf("%d%d", &x, &y);
    printf("Entre com a cor desejeda: ");                
    scanf("%d", &cor_escolhida);
    pintar(x*m+y, cor_escolhida, pilha, matriz);
    printf("\n\nMatriz pintada: \n\n");                
           
    for(i=0; i<n; i++){
        for(j=0; j<m; j++){
            k = i*m+j;
            printf("%d ", matriz[k]);   
        }    
        printf("\n");
    }
  system("PAUSE");   
}

=============
stack.c
=============

/*  Algoritmo de preenchimento - Estrutura de Dados
    | Kássio Rômulo Lima SOusa CP09126-81 | Núbia Cristine Silveira dos Santos CP09142-81 |
*/

#define _STACK_H_
#define TRUE 1
#define FALSE 0
#include<stdio.h>
#include<assert.h>
#include "stack.h"

stack *stkCreate(int max){
      stack *s;
            if(max>0){
            s = (stack *) malloc(sizeof(stack));
              if(s!=NULL){
                 s->item = (void **) malloc(max*sizeof(void *));           
                   if(s->item!=NULL){
                      s->maxitens = max;
                      s->topo = -1;
                      return s;
                  }
                  free(s);
              }         
            }
      return NULL;
}

int stkdestroy(stack *s){
       if(s!=NULL){
          free(s->item);
          free(s);
          return TRUE;           
       }
    return FALSE;
}

int stkpush(stack *s, void *item){
    if(s!=NULL){
      if(s->topo < s->maxitens-1){
        s->topo++;
        s->item[s->topo] = item;
        return TRUE;        
        }
    }
    return FALSE;
}

void *stkpop(stack *s){
     void *aux;
     if(s!=NULL){
       if(s->topo>-1){
         aux = s->item[s->topo];
         s->topo--;
         return aux;
         }
       }
     return NULL;
}

void *stktop(stack *s){
     if(s!=NULL){
        if(s->topo>-1){
           return s->item[s->topo];
        }
     }
return NULL;
}

int stkisempty(stack *s){
    if(s!=NULL){
      if(s->topo<0){
        return TRUE;
        }
      }
    return FALSE;
}

==============
stack.h
==============
#ifndef __STACK_H_
#define __STACK_H_

/* Estrutura */
typedef struct _stack_{
        int maxitens;
        int topo;
        void ** item;
}stack;

/*Funcao criar pilha:
pré-condições: ; maxItens > 0
               ; pós-condição1: retorna a pilha
               ; pós-condição2: retorna null em caso de maxitens>0 ou nao houver espaço para alocar
*/

stack *stkCreate(int max);

/*Funcao Destruir pilha
pré-condições:  ; s nao ser null
                ; retorna TRUE se a pilha for eliminada
                ; retorna FALSE caso nao satisfaça as pré-condições
*/

int stkdestroy(stack *s);

/*Funcao Insere elemento da pilha:
pré-condições:  ; s nao ser null e s->topo tem que ser menor que s->maxitens-1
                ; retorna TRUE se o elemento for inserido
*/

int stkpush(stack *s, void *item);

/*Funcao Remove elemento da pilha:
pré-condições: ; c nao ser null e c->item nao pode ser null
               ; retorna o elemento se o elemento for removido
               ; retorna NULL caso nao satisfaça as pré-condições
*/

void *stkpop(stack *s);

/*Funcao Retorna elemento do topo:
pré-condições: ; s nao ser null e s->topo te que ser maior que -1
               ; pós-condição1: retorna elemento do topo
*/

void *stktop(stack *s);

/*Funcao Confere se pilha vazia:
pré-condições:  ; s nao ser null e s->topo te que ser menor que 0
                ; retorna TRUE se pilha for vazia
                ; pós-condição2: retorna FALSE se pilha nao for vazia
*/
 
int stkisempty(stack *s);

#endif