Arv* arv_reconstroi (Arv* arv, Fila* preordem, infotype *vetDFS, infotype inicio, infotype tamanho){
infotype pivo, x = 0;
/* Enquanto houver elementos na fila do percorrimento preordem significa que ainda temos que
percorrer a árvore e reconstrui-la */
while (!fila_vazia(preordem)){
x = fila_remove (preordem);
arv = arv_insere (arv, x, arv);
/* Encontramos o pivô do vetor DFS que representa a raiz da árvore */
pivo = particiona (preordem, vetDFS, inicio, tamanho, x);
/* Constrói subárvore esquerda recursivamente com a raiz da árvore sendo
a raiz da subárvore esquerda */
arv = arv_reconstroi (arv, preordem, vetDFS, inicio, pivo - 1);
/* Constrói subárvore direita recursivamente com a raiz da árvore sendo
a raiz da subárvore direita */
arv = arv_reconstroi (arv, preordem, vetDFS, pivo + 1, tamanho);
}
return arv;
}
//---------------------------------------------------
main()
{
tipo_fila *fila;
int i, numero, maior;
fila = (tipo_fila *) malloc (sizeof(tipo_fila));
inicializar_fila(fila);
for (i = 0; i < 5; i++)
{
printf("\nLeitura do valor (%d) : ", i + 1);
scanf("%d", &numero);
enqueue(numero, fila);
//printf("Enfileirou: %d \n", numero);
}
if (fila_vazia(fila)) printf("Fila vazia");
else mmm(&maior,fila);
printf ("\nO maior valor da fila é : %d\n",maior);
for (i = 0; i < 5; i++)
{
numero = dequeue(fila);
}
getch ();
}
void inserir_ordenado(int p_valor, tipo_fila *fila)
{
tipo_no *atual, *anterior, *aux;
if (fila_vazia(fila)) enqueue(p_valor, fila);
else
{
if (p_valor < fila -> inicio -> valor)
{
aux = (tipo_no *) malloc(sizeof(tipo_no));
aux -> valor = p_valor;
aux -> prox = fila -> inicio;
fila -> inicio = aux;
}
else
{
atual = fila -> inicio;
anterior = atual;
while ((atual -> valor < p_valor) & (atual != NULL))
{
anterior = atual;
atual = atual -> prox;
}
aux = (tipo_no *) malloc(sizeof(tipo_no));
aux -> valor = p_valor;
anterior -> prox = aux;
aux -> prox = atual;
}
fila -> tamanho++;
}
}
Val apaga_fila(fila* f){
Val total=criaValor(0);
Chq Cheque;
while (!fila_vazia(f)){
Cheque = tira_first(f);
total += valorCheque(Cheque);
libertaCheque(Cheque);
}
free(f);
return total;
}
int remover(Fila *f, void *y)
{
if(fila_vazia(*f))
return ERRO_FILA_VAZIA;
memcpy(y, f->dados[f->inicio], f->tamInfo);
free(f->dados[f->inicio]);
f->inicio++;
f->num_ele--;
if(f->inicio == f->capacidade)
f->inicio = 0;
return 0;
}
Arv* remover_fila(Fila *f)
{
Arv *aux = NULL;
if(fila_vazia(f) == 0)
{
aux = f->v[f->ini];
f->ini = (f->ini+1)%MAX;
f->qtde--;
}
return aux; // se fila vazia
}
void partida (char *x, fila *f)
{
if (fila_vazia(f))
{
printf("\n A fila esta vazia");
return;
}
f -> tam = (( f -> tam) - 1 );
*x = f -> entradas[ f -> front ] ;
f -> front = ( ( f -> front ) + 1) % MAX_VETOR ;
return;
}
void mostra_fila(Fila f, void (*mostra_info)(void *))
{
if(fila_vazia(f))
return ERRO_FILA_VAZIA;
int i = f.inicio;
int n = f.num_ele;
while(n--)
{
mostra_info(f.dados[i]);
i++;
if (i == f.capacidade)
i = 0;
}
}
//retira elemento da fila
Mala* fila_retira(Fila* f){
Lista* t;
Mala* m;
if(fila_vazia(f)){
printf("Fila Vazia!\n");
exit(1);
}
t = f->ini;
m = t->info;
f->ini = t->prox;
if(f->ini == NULL)
f->fim = NULL;
free(t);
return m;
}
int dequeue(tipo_fila *fila)
{
tipo_no *q; int v;
if (fila_vazia(fila))
{
printf("fila esta vazia\n");
return 0;
}
q = fila -> inicio;
v = fila -> inicio -> valor;
fila -> inicio = fila -> inicio -> prox;
free(q);
fila -> tamanho--;
return v;
}
void fila_pop(fila *f)
{
filaItem *cabeca;
if (f == NULL || fila_vazia(f))
return;
cabeca = f->cabeca;
f->cabeca = cabeca->proximo;
if (f->cabeca == NULL)
f->cauda = NULL;
free(cabeca->string);
free(cabeca);
}
float fila_retira (Fila* f)
{
Lista* t;
float v;
if (fila_vazia(f)) {
printf("Fila vazia.\n");
exit(1); } /* aborta programa */
t = f->ini;
v = t->info;
f->ini = t->prox;
if (f->ini == NULL) /* verifica se fila ficou vazia */
f->fim = NULL;
free(t);
return v;
}
void enqueue(int x, tipo_fila *fila)
{
tipo_no *aux;
aux = (tipo_no *) malloc(sizeof(tipo_no));
aux -> valor = x;
aux -> prox = NULL;
if (fila_vazia(fila))
{
fila -> inicio = aux;
fila -> fim = aux;
}
else
{
fila -> fim -> prox = aux;
fila -> fim = aux;
}
fila -> tamanho++;
}
void copia (tipo_fila *fila, tipo_fila *fila2){
tipo_no *aux,*aux2;
aux2 = (tipo_no *) malloc(sizeof(tipo_no));
aux = fila -> inicio;
while (aux != NULL){
aux2 -> valor = aux -> valor;
aux2 -> prox = NULL;
if (fila_vazia(fila2)){
fila2 -> inicio = aux2;
fila2 -> fim = aux2;
}else{
fila2 -> fim -> prox = aux2;
fila2 -> fim = aux2;
}
fila2->tamanho++;
aux = aux -> prox;
}
}
void imprime_largura(Arv *raiz){
Arv* aux;
Fila fila;
iniciar(&fila);
if (raiz!=NULL){
inserir_fila(&fila, raiz);
while(fila_vazia(&fila)==0){
aux = remover_fila(&fila);
printf("%d.", aux->elem);
if(aux->esq!=NULL)
inserir_fila(&fila, aux->esq);
if(aux->dir!=NULL)
inserir_fila(&fila, aux->dir);
}
}
else
printf("Arvore vazia!\n");
}
void ConferePercorrimentos (infotype *vetDFS, Fila* fila_preordem, infotype tamDFS, infotype tamPreordem){
infotype i, x = 0;
if (tamDFS != tamPreordem){
printf("\nOs percorrimentos são diferentes.");
exit(1);
}
printf("\nConferindo os dois percorrimentos...\n");
while (!fila_vazia (fila_preordem)) {
i = 0;
x = fila_remove (fila_preordem);
while (i <= tamDFS){
if (vetDFS[i] != x){
i++;
}
else
break;
}
if (i > tamDFS){
printf("\nOs percorrimentos são diferentes.\n");
exit(1);
}
}
printf("\nOs percorrimentos são iguais, continuando...\n");
}
void separa_filas (Fila* f, Fila* f_prioridade, Fila* f_convencional)
{
Lista* l = f->ini;
if (!fila_vazia(f))
{
while (l != NULL)
{
if ((2015 - l->info) >= 65)
{
fila_insere(f_prioridade, l->info);
}
else
{
fila_insere(f_convencional, l->info);
}
l = l->prox;
}
}
}
main()
{
tipo_fila *fila;
int numero;
fila = (tipo_fila *) malloc (sizeof(tipo_fila));
inicilizar_fila(fila);
printf("\n\nDigite uma sequencia de numeros (0 finaliza)\n");
scanf("%d", &numero);
while (numero != 0)
{
inserir_ordenado(numero, fila);
scanf("%d", &numero);
}
printf("\n");
if (fila_vazia(fila)) printf("Fila Vazia");
else imprimir_fila(fila);
getch();
}
void* requester(void* thr_data) {
signal(SIGINT, ctrlHandler);
int rc;
rc = pthread_mutex_lock(&mutex);
#ifdef DEBUG
printf("Thread %lu created!\n", pthread_self());
#endif
int found, i;
char dig[30];
char awk[30];
FILE* file;
char* ip;
struct thread_data t_d;
t_d = *((struct thread_data*)thr_data);
Local head_local = t_d.domains;
Fila head_normal = t_d.normal;
Fila aux_normal;
Fila head_prior = t_d.prioridade;
Fila aux_prior;
while(1) {
rc = pthread_cond_wait(&cond, &mutex);
#ifdef DEBUG
printf("Thread working ID = %lu\n", pthread_self());
#endif
if(fila_vazia(head_prior) == 0) { // Lista local nao vazia
#ifdef DEBUG
imprimir_fila(t_d.prioridade);
#endif
#ifdef DEBUG
printf("LOCAL thread...\n");
#endif
aux_prior = head_prior->next;
Local local = head_local->next;
#ifdef DEBUG
printf("Dominio = %s\n", aux_prior->query);
#endif
i = 0;
found = 0;
while(i<n_linhas && local != NULL){
if(strcmp(aux_prior->query, local->addr) == 0) {
ip = local->ip;
found = 1;
break;
}
local = local->next;
i++;
}
if(found != 0) {
sendReply(aux_prior->dns_id, aux_prior->query, inet_addr(local->ip), aux_prior->socket, aux_prior->origem);
} else {
printf("IP de endereco local pedido nao encontrado!\n.");
sendReply(aux_prior->dns_id, aux_prior->query, inet_addr("0.0.0.0"), aux_prior->socket, aux_prior->origem);
}
eliminar_pedido(head_prior);
printf("\n\n-- Waiting for DNS message --\n\n");
} else { // Não há pedidos locais -> Tratar dos externos!
#ifdef DEBUG
imprimir_fila(head_normal);
#endif
aux_normal = head_normal->next;
strcpy(dig, "dig +short ");
strcpy(awk, " | awk \"{ print ; exit }\"");
strcat(dig, aux_normal->query);
strcat(dig, awk);
printf("dig = %s\n", dig);
char buffer[100];
if((file = popen(dig, "r")) == NULL) {
perror("Error on pipe or fork.\n");
exit(1);
}
fgets(buffer, 100, file);
pclose(file);
#ifdef DEBUG
printf("IP is = %s\n", buffer);
#endif
printf("\nQUERY A TRATAR = %d\n", aux_normal->dns_id);
printf("QUERY HEAD = %d\n", head_normal->next->dns_id);
if(buffer != NULL && buffer[0] == '\0') {
printf("IP nao encontrado... A enviar 0.0.0.0...\n");
sendReply(aux_normal->dns_id, aux_normal->query, inet_addr("0.0.0.0"), aux_normal->socket, aux_normal->origem);
} else {
sendReply(aux_normal->dns_id, aux_normal->query, inet_addr(buffer), aux_normal->socket, aux_normal->origem);
}
eliminar_pedido(head_normal);
printf("\n\n-- Waiting for DNS message --\n\n");
}
}
rc = pthread_mutex_unlock(&mutex);
}
char* fila_front(fila *f)
{
if (f == NULL || fila_vazia(f))
return NULL;
return f->cabeca->string;
}
bool pilha_vazia(pilha p)
{
return fila_vazia(p->topo);
}
void ordenacaoExterna(int numerosArmazenados){
/* FILE *arqOrdenado;
arqOrdenado = fopen("arqOrdenado.txt", "r"); //arquivo a ser ordenado*/
int i = 0;
int w = 0;
int z = 0;
fila fp; // Fila de prioridade
int *bs; // Buffer de saida
tipo_buffer *be; // Buffer de entrada
tipo_nodo aux,auxRetirada;
int numeroRuns = numerosArmazenados/TAM_RUN; // Runs geradas
int inserirBufferEntrada;
if(numerosArmazenados%TAM_RUN > 0) // Se teve resto tem que gerar mais uma Run pro resto
numeroRuns++;
printf("\nQtd de Runs(50 chaves): %d",numeroRuns);
gerar_runs(numeroRuns,numerosArmazenados);
//Alocando memoria para os buffers
bs = (int*)malloc(sizeof(int)*numeroRuns);
be = (tipo_buffer*)malloc(sizeof(tipo_buffer)*numeroRuns);
//Criando fila de prioridade
fp = cria_fila(numeroRuns);
//---------------------------------ADICIONAR ELEMENTOS NO BUFFER DE ENTRADA
printf("\n\n2 - Adicionando elementos no buffer de entrada");
for (i=0;i<numeroRuns;i++){
be[i].posAtual=0; /* Somente para armazenar o posição corrente do arquivo.
Para quando pegar novamente mais um elemento pegar na posição atual */
//Total de elementos que este buffer podera pegar da RUN
// if( (i < numeroRuns || numeroRuns == 1) && numerosArmazenados >= 50 )
if(i!=numeroRuns-1 || (numerosArmazenados % TAM_RUN) == 0)
be[i].totalElementos = TAM_RUN; // Run completa
else
be[i].totalElementos = numerosArmazenados % TAM_RUN; // Run com menos de TAM_RUM
//Carregando os buffers de entrada e inserindo os itens de cada Run
inserirBufferEntrada = inserirElementosBufferEntrada(be,i);
if (!inserirBufferEntrada){
be[i].posAtualBuffer=-1;
}else {
aux.chave = be[i].chave[0];
aux.run = i;
be[i].posAtualBuffer++;
//printf("\nRecebendo aux.chave %d aux.run %d",aux.chave,aux.run);
insere_fila(fp,aux,numeroRuns); // Coloca na fila o elemento de indice 0 do buffer de entrada
}
}
//-----------------------------------INICIO DA ORDENAÇÃO EXTERNA
printf("\n\n3 - Realizando ordenação externa");
w = 0;
while (fila_vazia(fp)){
imprime_fila(fp);
remove_fila(fp,&auxRetirada);
printf("\nElemento retirado = %d do Buffer de Entrada %d ",auxRetirada.chave,auxRetirada.run);
bs[w]=auxRetirada.chave;
w++;
//verifica se o buffer de saida esta cheio e imprime no arquivo resultado
if (w==numeroRuns){
gravar_resultado(bs,w);
w=0;
}
z=0;
while (z<numeroRuns){
if (z==auxRetirada.run){
if (be[z].posAtualBuffer==TAM_BUFFER)
if (!carregaBE(auxRetirada.run,be)){
be[z].posAtualBuffer=-1;
printf("\nBuffer de entrada %d foi carregado!",auxRetirada.run);
break;
}
if (be[z].posAtualBuffer < be[z].totalBuffer){
auxRetirada.run=z;
auxRetirada.chave=be[z].chave[be[z].posAtualBuffer];
insere_fila(fp,auxRetirada,numeroRuns);
be[z].posAtualBuffer++;
printf("\nElemento inserido = %d no Buffer de Entrada %d ",auxRetirada.chave,auxRetirada.run);
}
break;
}
z++;
}// fim while
//getchar();
}
//verifica se o buffer de saida possui algum elemento restante e salva no arquivo resultado
if (w!=0)
gravar_resultado(bs,w);
//---------------------------------------------------
imprime_fila(fp);
//Finalizando a fila de prioridade
termina_fila(fp);
printf("\n\Final da Ordenacao Externa");
//fclose(arqOrdenado);
}
