//-------------------------------------------
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");
}
