//------------------------------------------- void Constroi(arvore **eainicio) { char c; c = getc (arq); if (c == '.') *eainicio = NULL; else { *eainicio = malloc (sizeof (arvore)); (*eainicio)->dado = c; Constroi (&((*eainicio)->esq)); Constroi (&((*eainicio)->dir)); } }
TipoPeso * Dijkstra(TipoGrafo *Grafo, TipoValorVertice *Raiz) { TipoValorVertice * Pos = (TipoValorVertice *) malloc((Grafo->NumVertices+1) * sizeof(TipoValorVertice)); TipoPeso P[Grafo->NumVertices+1]; long * Antecessor = (long *) malloc((Grafo->NumVertices+1) * sizeof(long)); short * Itensheap = (short *) malloc((Grafo->NumVertices+1) * sizeof(short)); int soma = 0; TipoVetor A[Grafo->NumVertices+1]; TipoValorVertice u, v; TipoItem temp; TipoApontador Aux; short FimListaAdj; TipoPeso Peso; for (u = 0; u <= Grafo->NumVertices; u++) { /*Constroi o heap com todos os valores igual a INFINITO*/ Antecessor[u] = -1; P[u] = INFINITO; /*Heap a ser construido*/ A[u+1].Chave = u; Itensheap[u] = TRUE; Pos[u] = u + 1; } n = Grafo->NumVertices; P[*(Raiz)] = 0; Constroi(A, P, Pos); while (n >= 1) { /*enquanto heap nao vazio*/ temp = RetiraMinInd(A, P, Pos); u = temp.Chave; Itensheap[u] = FALSE; if (!ListaAdjVazia(&u, Grafo)) { Aux = PrimeiroListaAdj(&u, Grafo); FimListaAdj = FALSE; while (!FimListaAdj) { ProxAdj(&u, Grafo, &v, &Peso, &Aux, &FimListaAdj); if (P[v] > (P[u] + Peso)) { P[v] = P[u] + Peso; Antecessor[v] = u; DiminuiChaveInd(Pos[v], P[v], A, P, Pos); } } } } free(Pos); free(Antecessor); free(Itensheap); return P; }
//-------------------------------------------- main (){ arq = fopen ("a1.txt", "r"); Constroi (&aini); fclose (arq); LeArv(aini); printf("\n\n"); system("pause"); }
void Prim(int **matriz, int numVertice, int numAresta, int teste) { //localidade e referencia Pilha *pilha = PilhaNova(numVertice); int distancia[numVertice]; int quantidadeAcesso[numVertice]; IniciaVetorComZero(distancia, numVertice); IniciaVetorComZero(quantidadeAcesso, numVertice); int tamanhoPilha = 0; int verticeAntecessor[numVertice + 1]; short arrayBooleano[numVertice + 1]; //Simula um vetor de booleanos com 0=falso e 1=verdadeiro int heap[numVertice]; int tamanhoDoHeap; int proximoVertice; int finalListaAdj; int peso; int verticeInicial = 0; int pesoAresta[numVertice + 1]; int posicaoVerticeHeap[numVertice + 1]; int u, v; //Vértices que compõe uma aresta qualquer int guarda; for (u = 0; u <= numVertice; u++) { /*Constroi o heap com todos os valores igual a INFINITO*/ verticeAntecessor[u] = -1; pesoAresta[u] = MaiorPesoDeAresta(matriz, numVertice) +1; heap[u+1] = u; /*Heap a ser construido*/ arrayBooleano[u] = VERDADEIRO; posicaoVerticeHeap[u] = u + 1; } tamanhoDoHeap = numVertice; pesoAresta[verticeInicial] = 0; Constroi(heap, pesoAresta, posicaoVerticeHeap, &tamanhoDoHeap); while (tamanhoDoHeap >= 1) /*enquanto heap nao vazio*/ { guarda = RetiraIndiceMinimo(heap, pesoAresta, posicaoVerticeHeap, &tamanhoDoHeap); u = guarda; arrayBooleano[u] = FALSO; if (u != verticeInicial) { printf("%d %d %d\n", verticeAntecessor[u], u, matriz[verticeAntecessor[u]][u]); } if (!ListaAdjacenciaVazia(&u, matriz, numVertice)) { proximoVertice = PrimeiroListaAdjacente(&u, matriz, numVertice); finalListaAdj = FALSO; while (!finalListaAdj) { if(proximoVertice < numVertice) PilhaEmpilha(pilha, &tamanhoPilha, proximoVertice, distancia, quantidadeAcesso); ProxAdjacente(&u, matriz, numVertice, &v, &peso, &proximoVertice, &finalListaAdj); if (arrayBooleano[v] && peso < pesoAresta[v]) { verticeAntecessor[v] = u; DiminuiChaveIndice(posicaoVerticeHeap[v], peso, heap, pesoAresta, posicaoVerticeHeap); } } } } GeraDistribuicaoEspacial("DistriEspaPrim", teste, distancia, quantidadeAcesso, numVertice); printf("\n"); }