Пример #1
0
    static tpVertice* ObterOrigem (GRA_tppGrafo grafo, tpVertice* v) {
        tpVertice** us = NULL; //Vetor com componentes a iterar;
        tpVertice* u = NULL;
        LIS_tppLista origens = grafo->componentes;
        int i = 0;
        
        LIS_IrInicioLista(grafo->vertices);
        LIS_IrInicioLista(origens);
        if (LIS_ProcurarValor(origens, v) == LIS_CondRetOK) {
            return v; //é a origem da própria componente
        }
        if(LIS_NumeroDeElementos(origens) > 0) {
            us = (tpVertice**) calloc(LIS_NumeroDeElementos(origens), sizeof(tpVertice*));

            LIS_IrInicioLista(origens);
            do {
                u = (tpVertice *)LIS_ObterValor(origens);
                if(u == NULL) break;
                us[i] = u;
                i++;
            } while(LIS_AvancarElementoCorrente(origens, 1) == LIS_CondRetOK);


            for ( i;i; i--) {
                if (BFS(us[i-1],v) == 1) {
                    u =  us[i-1];
                }
            }
            free(us);
        }

        return u;
    }
Пример #2
0
    static int* converteListaParaVetorDeInteiros(LIS_tppLista lista, int* len) {
        int* vet;
        *len = 0;
        if (lista == NULL || LIS_NumeroDeElementos(lista) == 0) {
            return NULL;
        }
        vet = (int*)calloc(LIS_NumeroDeElementos(lista) ,sizeof(int));
        LIS_IrInicioLista(lista);
        do {
            vet[*len] = getInt(LIS_ObterValor(lista));
            *len = (*len)+1;
        } while(LIS_AvancarElementoCorrente(lista, 1) == LIS_CondRetOK);

        return vet;
    }
Пример #3
0
    GRA_tpCondRet GRA_BuscarVertice( GRA_tppGrafo pGrafo , int* idVertice , int predicado(void* pDado, void* _parametro), void* parametro )
    {
        LIS_tppLista vertices;
        tpVertice* vertice;
        vertices = pGrafo->vertices;

        if(LIS_NumeroDeElementos(vertices) == 0){
            *idVertice = -1;
            return GRA_CondRetGrafoVazio;
        }

        LIS_IrInicioLista(vertices);
        do
        {
            vertice = (tpVertice*)LIS_ObterValor(vertices);
            
            if (predicado(vertice->pNode->pValor, parametro))
            {
                *idVertice = vertice->id;
                return GRA_CondRetOK;
            }
        }
        while (LIS_AvancarElementoCorrente(vertices, 1) == LIS_CondRetOK);

        return GRA_CondRetNaoEhVertice;
    }
Пример #4
0
     GRA_tpCondRet GRA_InserirVertice (GRA_tppGrafo pGrafo, void* pValor, int id)
     {
        int i;
        tpVertice * pElem = NULL ;
        tpVertice * v = NULL ;
        #ifdef _DEBUG
             assert( pGrafo != NULL ) ;
        #endif

        /* Criar o Vertice antes */
        
        pElem = CriarVertice( pGrafo, pValor, id ) ;
        
        if ( pElem == NULL ) {
            return GRA_CondRetFaltouMemoria ;
        }
        
        if( LIS_InserirElementoApos (pGrafo->vertices, pElem) != LIS_CondRetOK) {
            free(pElem);
            return GRA_CondRetFaltouMemoria ;   
        }
       
        if(pGrafo->corrente == -1) { 
            pGrafo->corrente = id;
        }
        LIS_NumeroDeElementos(pElem->pNode->arestas);
        return GRA_CondRetOK ;
     } 
Пример #5
0
Файл: PILHA.C Проект: Rifeli/t4
PILHA_tpCondRet PILHA_VerificarPilha( PILHA_tppPilha pPilha, int * quantidadeErros){
	*quantidadeErros = 0;

	if(LIS_VerificaLiberaElemCorrente(pPilha->topo) != LIS_CondRetOK)
		*quantidadeErros += 1;
	if(LIS_VerificaSucessorNULL(pPilha->topo) != LIS_CondRetOK)
		*quantidadeErros += 1;
	if(LIS_VerificaPredecessorNULL(pPilha->topo) != LIS_CondRetOK)
		*quantidadeErros += 1;
	if(LIS_VerificaLixoSucessor(pPilha->topo) != LIS_CondRetOK)
		*quantidadeErros += 1;
	if(LIS_VerificaLixoPredecessor(pPilha->topo) != LIS_CondRetOK)
		*quantidadeErros += 1;
	if(LIS_VerificaConteudoNulo(pPilha->topo) != LIS_CondRetOK)
		*quantidadeErros += 1;
	if(LIS_VerificaTipoConteudo(pPilha->topo, "carta") != LIS_CondRetOK)
		*quantidadeErros += 1;
	if(LIS_VerificaCorrenteNulo(pPilha->topo) != LIS_CondRetOK)
		*quantidadeErros += 1;
	if(LIS_NumeroDeElementos(pPilha->topo) != LIS_CondRetOK)
		*quantidadeErros += 1;
	if(LIS_confereNumero(pPilha->topo) != LIS_CondRetOK)
		*quantidadeErros += 1;

	return PILHA_CondRetOK;
}
Пример #6
0
    static GRA_tpCondRet ExcluirVertice (GRA_tppGrafo pGrafo, tpVertice* pVertice) {
        tpAresta** vizinhos = NULL;
        tpNode* no = NULL;
        tpVertice * pVerticeVizinho = NULL;
        int i = 0;
        
        no = pVertice->pNode;
        LIS_IrInicioLista(pGrafo->componentes);
        LIS_ProcurarValor(pGrafo->componentes, pVertice);
        LIS_ExcluirElemento(pGrafo->componentes);

        if (LIS_NumeroDeElementos(no->arestas) > 0) {

            vizinhos = (tpAresta**)calloc(LIS_NumeroDeElementos(no->arestas), sizeof(tpAresta*));

            LIS_IrInicioLista(no->arestas);
            do {
                vizinhos[i] = (tpAresta *)LIS_ObterValor(no->arestas);
                i++;
            } while ( LIS_AvancarElementoCorrente(no->arestas,1) == LIS_CondRetOK);
            
            for (i; i; i--) {
                ExcluirAresta(pGrafo, pVertice, vizinhos[i-1]->pVizinho); 
            }
            
            if (pGrafo->ExcluirValor != NULL && no->pValor != NULL) {
                pGrafo->ExcluirValor(no->pValor);
                no->pValor = NULL;
            }
            free(vizinhos);
        }

        LIS_DestruirLista(no->arestas);
        no->arestas = NULL;

        pVertice->pNode = NULL;
        free(no);
        LIS_IrInicioLista(pGrafo->vertices);
        LIS_ProcurarValor(pGrafo->vertices, pVertice);
        LIS_ExcluirElemento(pGrafo->vertices);
        return GRA_CondRetOK;
    }
Пример #7
0
    static int BFS(tpVertice* v, tpVertice* u) {
        LIS_tppLista V = NULL; // LISTA VERTICE VISITADOS
        LIS_tppLista Q = NULL; //FILA
        LIS_tppLista arestas = NULL;
        tpVertice* t = NULL;
        tpVertice* s = NULL;
        tpAresta* a = NULL;
        int achou = 0;
        int achou_V = 0;

        V = LIS_CriarLista(NULL); // dados são referenciados por outros, não devem ser apagados
        Q = LIS_CriarLista(NULL); // dados são referenciados por outros, não devem ser apagados

        LIS_InserirElementoApos(V, v);
        LIS_InserirElementoApos(Q, v); //Usado como uma Fila.
        while (LIS_NumeroDeElementos(Q) > 0) {
            LIS_IrInicioLista(Q);
            t = (tpVertice *)LIS_ObterValor(Q);
            LIS_ExcluirElemento(Q);
            if (t == u) {
                achou = 1; 
                break;
            }
            arestas = t->pNode->arestas;
            LIS_IrInicioLista(arestas);
            do {
                a = (tpAresta *)LIS_ObterValor(arestas);
                if(a == NULL) continue;
                s = a->pVizinho;
                
                LIS_IrInicioLista(V);
                achou_V = 0;
                do {
                    tpVertice * re = (tpVertice *)LIS_ObterValor(V);
                    if (re == NULL) {
                        continue;
                    }
                    if(re == s) achou_V = 1;
                } while(LIS_AvancarElementoCorrente(V, 1) == LIS_CondRetOK);
            
                if (!achou_V) {
                    if(LIS_InserirElementoApos(V, s)!= LIS_CondRetOK){ achou = -1;break;}
                    if(LIS_InserirElementoApos(Q, s)!= LIS_CondRetOK){ achou = -1;break;}
                }
            } while(LIS_AvancarElementoCorrente(arestas, 1) == LIS_CondRetOK);
        }

        LIS_DestruirLista(V);
        LIS_DestruirLista(Q);

        return achou;
    }
Пример #8
0
/***********************************************************************
*
*  $FC Função: MEN GetMenuOpcoes
*
***********************************************************************/
    MEN_tpCondRet MEN_GetMenuOpcoes(MEN_tppMenus m,int id,char** l, int* tam){
        int n,x;
        MEN_tppMenu menu;
    	char* l1;
        n = 0;
        GRA_ObterValor(m->grafo,id,(void**)&menu);
        x = LIS_NumeroDeElementos(menu->opcoes);
        *l = (char*)malloc(x);
        l1 = (char*)malloc(x); 
    	LIS_IrInicioLista(menu->opcoes);
        do{
            MEN_tppOpcao o = (MEN_tppOpcao)LIS_ObterValor(menu->opcoes);
            l1[n] = o->cmd;
            n++;
        }
        while(LIS_AvancarElementoCorrente(menu->opcoes,1)==LIS_CondRetOK);
        *tam = n;
    	strcpy(*l,l1);
        return MEN_CondRetOK;
    }
Пример #9
0
    GRA_tpCondRet GRA_ObterVizinhos ( GRA_tppGrafo pGrafo, int idVertice, LIS_tppLista* pLista) {
        
        tpVertice * pVertice = get_by_id(pGrafo,idVertice);
        LIS_tppLista vizinhos = NULL;
        LIS_tppLista Ret_vizinhos = NULL;
        tpAresta* aresta = NULL;
        int* idVerticeVizinho = NULL;

        if (pVertice == NULL) 
            return GRA_CondRetNaoEhVertice; 

        Ret_vizinhos = LIS_CriarLista(free);
        if (Ret_vizinhos == NULL) {
            return GRA_CondRetFaltouMemoria;
        }

        vizinhos = pVertice->pNode->arestas;

        LIS_IrInicioLista(vizinhos);

        if (LIS_NumeroDeElementos(vizinhos) > 0) {
            do {
                idVerticeVizinho = (int*) calloc(1, sizeof(int));
                aresta = (tpAresta *)LIS_ObterValor(vizinhos);           
                (*idVerticeVizinho) = aresta->pVizinho->id;
                if (LIS_InserirElementoApos( Ret_vizinhos, idVerticeVizinho) != LIS_CondRetOK ) {
                    LIS_DestruirLista(Ret_vizinhos);
                    return GRA_CondRetFaltouMemoria;
                }
            }
            while(LIS_AvancarElementoCorrente(vizinhos, 1) == LIS_CondRetOK);
        }
        *pLista = Ret_vizinhos;

        return GRA_CondRetOK;
    }
Пример #10
0
    GRA_tpCondRet GRA_BuscarCaminho( GRA_tppGrafo pGrafo , int idVerticeOrigem, int idVerticeDestino, LIS_tppLista * pLista ) {
        tpVertice * v = NULL;
        tpVertice * u = NULL;         
        tpVertice * origem1 = NULL;
        tpVertice * origem2 = NULL;
        int lenV = 0;
        LIS_tppLista Q = NULL; //FILA
        LIS_tppLista arestas = NULL;
        LIS_tppLista retorno = NULL;
        int t;
        int len = 0;
        int achou = 0;
        int ok = 0;
        int i,j,in;
        int lenD;
        int alt = 0;
        int* visitados = NULL; // Vetor de vertices visitados
        int* vizinhos = NULL;
        int* idAux = NULL;
        Dist** dists = NULL;
        Dist* dist = NULL; //aux;
        Dist* currDist = NULL;

        lenD = 1;

        v = get_by_id(pGrafo, idVerticeOrigem);
        u = get_by_id(pGrafo, idVerticeDestino);
        if(v == NULL || u == NULL) {
            return GRA_CondRetNaoEhVertice; 
        }

        origem1 = ObterOrigem(pGrafo, v);
        origem2 = ObterOrigem(pGrafo, u);
        if (origem1 != origem2) {
            return GRA_CondRetNaoEhConexo;
        }//Else: É conexo, devia retornar Ok.
        

        for (;;) {
            dists = (Dist**)calloc(LIS_NumeroDeElementos(pGrafo->vertices)+1, sizeof(Dist*));
            if (dists == NULL) {break;}
            dists[0] = newDist(idVerticeOrigem, 0);

            retorno = LIS_CriarLista(free);
            if (retorno == NULL) { break; }
            else if (v == u) {
                if( LIS_InserirElementoApos(retorno, newInt(idVerticeOrigem)) == LIS_CondRetOK) {
                    *pLista = retorno;
                    return GRA_CondRetOK;
                } else {
                    break;
                }
            }

            visitados = (int*) calloc(LIS_NumeroDeElementos(pGrafo->vertices)+1,sizeof(int));
            if (visitados == NULL) { break; }

            Q = LIS_CriarLista(free);
            if (Q == NULL) { break; }

            visitados[0] = idVerticeOrigem;
            lenV = 1;
            if (LIS_InserirElementoApos(Q, newInt(idVerticeOrigem)) != LIS_CondRetOK) { break;} //enque

            ok = 1;
            break;
        }
        if (!ok) {
            free(dists);
            LIS_DestruirLista(retorno);
            free(visitados);
            LIS_DestruirLista(Q);
            return GRA_CondRetFaltouMemoria;
        }

        while (LIS_NumeroDeElementos(Q) > 0) {
            //dequeue
            LIS_IrInicioLista(Q);
            t = getInt(LIS_ObterValor(Q));
            LIS_ExcluirElemento(Q);

            //Iterar sobre vizinhos
            GRA_ObterVizinhos(pGrafo, t, &arestas);
            vizinhos = converteListaParaVetorDeInteiros(arestas, &len);
            LIS_DestruirLista(arestas);
            arestas = NULL;

            currDist = getDist(dists, t);
            if(!currDist) {
                return GRA_CondRetFaltouMemoria;
            } else {
            }
            alt = currDist->dist + 1;
            for (i=0; i < len; i++) {
                
                in = 0;
                for (j=0; j < lenV; j++) {
                    if (visitados[j] == vizinhos[i]) {
                        in = 1;
                    }
                }
                if (!in) {
                    dist = getDist(dists, vizinhos[i]);
                    if (dist == NULL) { //infinity
                        dists[lenD] = newDist(vizinhos[i], alt);
                        dists[lenD]->prev = currDist;
                        dist = dists[lenD];
                        lenD++;
                    } else if (alt < dist->dist) {
                        dist->dist = alt;
                        dist->prev = currDist;
                    }
                    if (idVerticeDestino == vizinhos[i]) {
                        currDist = dist;
                        achou = 1;
                    }
                    visitados[lenV] = vizinhos[i];
                    lenV++;
                    LIS_InserirElementoAntes(Q, newInt(vizinhos[i]));
                }
            }
            free(vizinhos);
            if (achou) {
                currDist = dist;
                break;
            }
            if(lenV == LIS_NumeroDeElementos(pGrafo->vertices)) {
                break;
            }
        }
        
        if (achou) {
            //printf("\n");
            // for(i=0; i < lenD; i++) {
            //     printf("endr: %p, id: %d, dist: %d, prev: %p \n", *(dists+i), dists[i]->id, dists[i]->dist, dists[i]->prev);
            // }
            while (currDist) {
                LIS_InserirElementoAntes(retorno, newInt(currDist->id));
                currDist  = currDist->prev;
            }

        }

        

        


        //Limpando a memória        
        for (i=0; i < lenD; i++) {
            free(dists[i]);
        }
        free(dists);
        free(visitados);
        LIS_DestruirLista(Q);
        *pLista = retorno;
        return GRA_CondRetOK;
    }