int main(int argc, char *argv[]) { clock_t start, end, elapsed; FILE *entrada, *entrada2, *copia, *consulta, *saida; Words *words=NULL, *aux=NULL; char linha[1024],linha2[1024]; char delimiters[] = " .,;:!?'\n'-*"; char *token=NULL, *cp, c, n,aspas=(char)39,tab=(char)9; int i=0, ok=0,okay=0; if (argc != 5) //numero de parametros corretos { printf("Numero incorreto de parametros.\n Sintaxe: copia arq_origem arq_destino\n"); return 1; } entrada = fopen(argv[1], "r"); //abre o primeiro arquivo (arquivo de entrada) copia = fopen("facil.txt", "w"); //arquivo auxiliar consulta = fopen(argv[2], "r"); //abre o arquivo de consulta saida = fopen (argv[3], "w"); //abre ou cria ou arquivo de saida if(!entrada) //caso arquivos não existam { printf("ERRO\n"); return 1; } if(!consulta) { printf("ERRO\n"); return 1; } while(!feof(entrada)) //cria arquivo auxiliar a ser usado sem pontos, e caracteres separadores especiais { c=fgetc(entrada); if((c==',')||(c==':')||(c==';')||(c=='.')||(c=='-')||(c==EOF)||(c=='!')||(c=='?')||(c=='"')||(c=='*')||(c==aspas)||(c=='(')||(c==')')||(c=='_') || c==tab) c=' '; fputc(tolower(c),copia); } fclose(entrada); fclose(copia); entrada = fopen("facil.txt", "r"); entrada2 = fopen("facil.txt", "r"); if(!entrada) printf("ERRO\n"); ///AQUI COLOCA OS ELEMENTOS NA ABP else { while(fgets(linha,1024, entrada)) { stolower(linha); //função que transforma tudo para minusculo cp = strdup(linha); token = strtok (cp, delimiters); //pega tokens (usa cp como auxiliar para caso o ponteiro fique iinvalido em algum momento) while(token!=NULL) { words = abp(words,token); //insere na abp token = strtok (NULL, delimiters); //pega proximo token } } } words = abp(words, "(NULL)"); //insere a palavra "(NULL)" na abp, para ser apontada pela ultima palavra do texto aux = words; //ponteiro aux fixo no inicio da ABP fseek(entrada, 0, SEEK_SET); n=fscanf(entrada2,"%s",linha2);//inicia o arquivo auxiliar uma palavra na frente ///AQUI COLOCA OS ELEMTTOS NO CAMPO LISTA DO NÓ DA ABP while(n != EOF) { words = aux; n=fscanf(entrada2,"%s",linha2); c=fscanf(entrada,"%s",linha); if(n == EOF) { words=busca(words,linha); //caso seja a ultima palavra do texto, busca ela na árvore words->vizinhos=insere_lista(words->vizinhos,"(NULL)"); //insere ela apontando também para ("NULL") break; } words=busca(words,linha); //busca a palavra no texto words->vizinhos=insere_lista(words->vizinhos,linha2); //insere ela apontando para sua sucessora } // printf("iuti"); fclose(entrada2); fclose(entrada); moda(aux,aux); //calcula a medida estatística para cada elemento da lista ordena(aux); //ordena a lista pelo valor de sua "moda" ///AQUI FAZ A BUSCA E GERA SAIDA start=clock(); fseek(consulta,0,SEEK_SET); while(fgets(linha,1023,consulta)) { words=aux; //volta para o inicio da árvore strcpy(linha, strtok(linha,delimiters)); //paga pegar a linha correta words=busca(words,linha); //vai para o lugar da arvore daquela palavra if(words!=NULL) { fputs("Consulta: ", saida); fputs(words->id, saida); fputs("\n", saida); i=0; while(words->vizinhos!=NULL && i<atoi(argv[4])) { fprintf(saida,"Sugestao: %s",words->vizinhos->id); //printa tudo bonitinho okay=strlen(words->vizinhos->id); for(ok=0; ok<30-okay; ok++) fprintf(saida," "); fprintf(saida,"(%lf)\n",words->vizinhos->moda); words->vizinhos = words->vizinhos->prox; i++; } fputs("\n", saida); } } fputs("\n", saida); end=clock(); //lê o tempo final elapsed = 1000 * (end - start) / (CLOCKS_PER_SEC); fprintf(saida,"Gasto: %ld ms", elapsed); //mostra o tempo final em ms fclose(consulta); fclose(saida); //Desenha(aux,1); deltree(aux); return 0; }
static lista arestas( grafo g ) { lista la = constroi_lista(); if( !g ) return la; for( no nv = primeiro_no(g->vertices); nv; nv = proximo_no(nv) ){ vertice v = conteudo(nv); for( no na = primeiro_no(v->arestas_saida); na; na = proximo_no(na) ){ aresta a = conteudo(na); if( !busca_aresta(la, a->origem, a->destino) ) insere_lista( a, la ); } if( g->direcionado ) { for( no na = primeiro_no(v->arestas_entrada); na; na = proximo_no(na) ){ aresta a = conteudo(na); if( !busca_aresta(la, a->origem, a->destino) ) insere_lista( a, la ); } } } return la; }
void Faz_Reserva(List_head lista, List_head lista_pre) { int option ; cliente dados_cliente ; printf("Insira o nome: \n ") ; fgets(dados_cliente.nome,150, stdin); //gets(dados_cliente.nome) ; // getchar() ; fflush(NULL) ; printf("Insira agora o horario pretendido: \n " ) ; printf("Dia: ") ; scanf("%d", &dados_cliente.D.dia) ; printf("Mes: ") ; scanf("%d", &dados_cliente.D.mes) ; printf("Hora: ") ; scanf("%d", &dados_cliente.D.horas) ; printf("Minuto (tenha em atençao ás meias horas: ") ; scanf("%d", &dados_cliente.D.min) , do{ printf("Deseja reservar: \n") ; printf("\t1-Lavagem \n") ; printf("\t2-Manutencao \n") ; printf("\t3-Sair") ; scanf("%d",&option) ; if(option==1) { dados_cliente.tipo_reserva = 2 ; // printf(" Sera que a lista existe? %d", procura_lista_data(lista,dados_cliente,0)) ; //teste if(procura_lista_data(lista, dados_cliente,0)== 0) { insere_lista(lista,dados_cliente) ; imprime_lista(lista) ; } else { printf("A hora escolhida nao esta disponivel. Podera fazer um pre reserva atraves do Menu se desejar.") ; } return ; } else { dados_cliente.tipo_reserva = 1 ; //elimina_lista(lista,dados_cliente); // printf(" Sera que a lista existe? %d", procura_lista_data(lista,dados_cliente,0)) ; //teste if(procura_lista_data(lista, dados_cliente,0)== 0) { insere_lista(lista,dados_cliente) ; imprime_lista(lista) ; } else { printf("A hora escolhida nao esta disponivel. Podera fazer um pre reserva atraves do Menu se desejar.") ; } return ; } }while(option != 3) ; return ; }
grafo copia_grafo(grafo g) { struct grafo *ng = malloc(sizeof(struct grafo)); if( !ng ) return NULL; vertice v; no nv, na; ng->nome = malloc(sizeof(char) * strlen(nome_grafo(g)+1)); strcpy(ng->nome, g->nome); ng->vertices = constroi_lista(); for( nv = primeiro_no(g->vertices); nv; nv = proximo_no(nv) ){ vertice vt = malloc(sizeof(struct vertice)); v = conteudo(nv); vt->nome = malloc(sizeof(char) * strlen(nome_vertice(v))+1); strcpy(vt->nome, nome_vertice(v)); vt->visitado = v->visitado; vt->coberto = v->coberto; vt->arestas_saida = constroi_lista(); vt->arestas_entrada = constroi_lista(); insere_lista(vt, ng->vertices); } for( nv = primeiro_no(ng->vertices); nv; nv = proximo_no(nv) ){ vertice vd = conteudo(nv); vertice vo = busca_vertice(g->vertices, nome_vertice(vd)); for( na = primeiro_no(vo->arestas_saida); na; na = proximo_no(na) ){ aresta at = copia_aresta( conteudo(na), ng ); insere_lista(at, vd->arestas_saida); } if( g->direcionado ){ for( na = primeiro_no(vo->arestas_entrada); na; na = proximo_no(na) ){ aresta at = copia_aresta( conteudo(na), ng ); insere_lista(at, vd->arestas_entrada); } } } ng->direcionado = g->direcionado; ng->ponderado = g->ponderado; ng->n_vertices = g->n_vertices; ng->n_arestas = g->n_arestas; return ng; }
lista * nova_permuta(lista *l, int *v, int k, int n) { int i, aux; if (k == n - 1) { //mostre(v, n); /*Insere na lista de permutacoes*/ int *tmp = (int*) malloc(sizeof(int)); for(i=0; i < n; i++) tmp[i] = v[i]; insere_lista((void*)tmp, l); return l; } else { l = nova_permuta(l, v, k + 1, n); i = k + 1; while (i < n) { aux = v[k]; // troca v[k] = v[i]; v[i] = aux; /* permuta segmento de k+1 ate n e retorna com o segmento restaurado, isto e, da forma como foi passado para a funcao */ l = nova_permuta(l, v, k + 1, n); aux = v[k]; // restuara v[k] = v[i]; v[i] = aux; i = i + 1; } } return l; }
//------------------------------------------------------------------------------ static void guarda_arcos(Agraph_t *g, Agnode_t *v) { for (Agedge_t *a=agfstout(g,v); a; a=agnxtout(g,a)) if ( ! busca_aresta(a) ) insere_lista(a, lista_arestas); }
static lista vizinhanca_entrada(vertice v){ lista viz = constroi_lista(); for (no n=primeiro_no(v->adjacencias_entrada); n!=NULL; n=proximo_no(n)) { adjacencia a = conteudo(n); insere_lista(a->v_origem, viz); } return viz; }
void insere(Hash* h, char* chave, void* estrutura) { int valor = hash(h, chave); printf("Inserindo um novo valor na tabela Hash ( chave: %s ):\n\tValor da hash: %d\n", chave, valor); if(h->tabela[valor] != NULL) { printf("\tColisao ao inserir, chave %d\n", valor); } else { h->tabela[valor] = inicializa_lista(); } h->tabela[valor] = insere_lista(h->tabela[valor], estrutura); }
static void cria_vizinhanca(grafo g, vertice origem, vertice destino, long int peso){ adjacencia viz_1 = malloc(sizeof(struct adjacencia)); if(viz_1 == NULL) printf("Sem memoria"); else{ viz_1->peso = peso; viz_1->v_origem = origem; viz_1->v_destino = destino; insere_lista(viz_1, origem->adjacencias_saida); origem->grau_saida++; destino->grau_entrada++; if (!direcionado(g)) { // se o grafo não for direcionado, a aresta deve aparecer também na // lista de adjacencia do vertice dest adjacencia viz_2 = malloc(sizeof(struct adjacencia)); if(viz_2 == NULL) printf("Sem memoria"); else{ viz_2->peso = peso; viz_2->v_origem = destino; viz_2->v_destino = origem; insere_lista(viz_2, destino->adjacencias_saida); destino->grau_saida++; origem->grau_entrada++; } } else{ adjacencia viz_3 = malloc(sizeof(struct adjacencia)); if(viz_3 == NULL) printf("Sem memoria"); else{ viz_3->peso = peso; viz_3->v_origem = origem; viz_3->v_destino = destino; insere_lista(viz_3, destino->adjacencias_entrada); } } } g->n_arestas++; }
static lista vizinhanca_saida(vertice v){ lista viz = constroi_lista(); for (no n=primeiro_no(v->adjacencias_saida); n!=NULL; n=proximo_no(n)) { if(n != NULL){ adjacencia a = conteudo(n); insere_lista(a->v_destino, viz); } } return viz; }
//------------------------------------------------------------------------------ // static grafo grafo_emparelhamento(grafo g) { grafo e = malloc(sizeof(struct grafo)); if( !e ) return NULL; e->nome = malloc(sizeof(char) * strlen(g->nome)+1); strcpy(e->nome, g->nome); e->direcionado = g->direcionado; e->ponderado = g->ponderado; e->vertices = constroi_lista(); for( no nv = primeiro_no(g->vertices); nv; nv = proximo_no(nv) ){ vertice ve = malloc(sizeof(struct vertice)); vertice vg = conteudo(nv); ve->nome = malloc(sizeof(char) * strlen(nome_vertice(vg))+1); strcpy(ve->nome, nome_vertice(vg)); ve->visitado = 0; ve->coberto = vg->coberto; ve->arestas_saida = constroi_lista(); ve->arestas_entrada = constroi_lista(); insere_lista(ve, e->vertices); } e->n_vertices = tamanho_lista(e->vertices); e->n_arestas = 0; for( no nv = primeiro_no(e->vertices); nv; nv = proximo_no(nv) ){ vertice ve = conteudo(nv); vertice vg = busca_vertice(g->vertices, nome_vertice(ve)); for( no na = primeiro_no(vg->arestas_saida); na; na = proximo_no(na) ){ aresta ag = conteudo(na); if (ag->origem != vg) continue; if( ag->coberta ){ aresta ae = copia_aresta( ag, e ); insere_lista(ae, ae->destino->arestas_saida); insere_lista(ae, ae->origem->arestas_saida); e->n_arestas++; } } } return e; }
lista vizinhanca(vertice v, int direcao, grafo g) { lista la, lv = constroi_lista(); if( !v || !g ) return lv; switch( direcao ){ case 0 : la = v->arestas_saida; break; case 1 : la = v->arestas_saida; break; case -1 : la = v->arestas_entrada; break; } for( no n = primeiro_no(la); n; n = proximo_no(n) ){ aresta a = conteudo(n); if( v == a->origem ){ insere_lista( a->destino, lv ); } if( v == a->destino ){ insere_lista( a->origem, lv ); } } return lv; }
/* função principal do programa */ int main (int argc, char *argv[]){ char *texto, opcao; /* crio uma string para armazenar cada palavra do texto */ node *head; /* crio um apontador para marcar o começo da lista */ int qtd_impressos = 0, sensitive = 0; /* laço que verifica se há algum parâmetro enviado na chamada do programa */ while((opcao = getopt(argc, argv, "n:I")) != -1){ switch(opcao){ case 'I': /* caso o insensitive case for ativado */ sensitive = 1; break; case 'n': /* caso há um limite nas impressões */ qtd_impressos = atoi(optarg); break; } } texto = malloc (20 * sizeof(char)); /* aloco espaço para o texto */ head = malloc (sizeof(node)); /* aloco espaço para o node */ head->qtd = 0; /* inicializo o valor da variável com 0 */ head->next = NULL; /* o next do node aponta para o nulo */ printf("\n\tEXERCICIO PROGRAMA 1 - MAC0323 ESTRUTURA DE DADOS\n\n\n"); /* loop que lerá uma palavra por vez */ while (scanf("%s", texto) != EOF){ verifica_palavra(texto, sensitive); /* faço a verificação da pontuação */ insere_lista(texto, head); /* insiro na lista */ } head->next = lmergesort_alfabetica(head->next); /* faço o primeiro mergesort para ordenar em ordem alfabética */ contabiliza_strings(head); /* faço a contagem das strings */ head->next = lmergesort_numerico(head->next); /* faço o segundo mergesort para ordenar em ordem numérica */ imprime_lista(head, qtd_impressos); /*imprimo a lista final */ libera_lista(head);/* libero a lista */ /* libero a minha célula usada como cabeça */ free(head); return 0; }
//------------------------------------------------------------------------------ // static int busca_caminho(vertice v, lista l, int last) { // essa função é chamada pela função que tenta achar um caminho aumentante // pra cada vértice não coberto (e retorna assim que achar) // e last é inicialmente 1, pois a primeira aresta será 0 (não coberta) if ( !v->coberto && !v->visitado ) { return 1; // true } v->visitado = 1; lista la = v->arestas_saida; for( no n = primeiro_no(la); n; n = proximo_no(n) ){ aresta a = conteudo(n); if (a->coberta == last) continue; vertice outro = a->origem == v ? a->destino : a->origem; if (!outro->visitado && busca_caminho(outro, l, !last)) { insere_lista(a, l); return 1; // true } } return 0; //false }
grafo le_grafo(FILE *input) { Agraph_t *ag = agread(input, 0); if(!(ag && agisstrict(ag))) return NULL; // struct grafo *g = malloc(sizeof(struct grafo)); grafo g = malloc(sizeof(struct grafo)); if( !g ) return NULL; g->vertices = constroi_lista(); g->nome = malloc(sizeof(char) * strlen(agnameof(ag)+1)); strcpy(g->nome, agnameof(ag)); g->direcionado = agisdirected(ag); g->n_vertices = (unsigned int)agnnodes(ag); g->n_arestas = (unsigned int)agnedges(ag); g->ponderado = 0; for( Agnode_t *v = agfstnode(ag); v; v = agnxtnode(ag,v) ){ vertice vt = malloc(sizeof(struct vertice)); vt->nome = malloc(sizeof(char) * strlen(agnameof(v))+1); strcpy( vt->nome, agnameof(v) ); vt->visitado = 0; vt->coberto = 0; vt->arestas_saida = constroi_lista(); vt->arestas_entrada = constroi_lista(); insere_lista(vt, g->vertices); } for( Agnode_t *v = agfstnode(ag); v; v = agnxtnode(ag,v) ){ vertice vt = busca_vertice(g->vertices, agnameof(v)); if( g-> direcionado ){ for( Agedge_t *e = agfstout(ag,v); e; e = agnxtout(ag,e) ){ aresta at = cria_aresta(g->vertices, e); if( at->peso != 0 ) g->ponderado = 1; insere_lista(at, vt->arestas_saida); } for( Agedge_t *e = agfstin(ag,v); e; e = agnxtin(ag,e) ){ aresta at = cria_aresta(g->vertices, e); if( at->peso != 0 ) g->ponderado = 1; insere_lista(at, vt->arestas_entrada); } } else { for( Agedge_t *e = agfstedge(ag,v); e; e = agnxtedge(ag,e,v) ){ if( agtail(e) != v ) continue; aresta at = cria_aresta(g->vertices, e); if( at->peso != 0 ) g->ponderado = 1; insere_lista(at, at->origem->arestas_saida); insere_lista(at, at->destino->arestas_saida); } } } if( agclose(ag) ) return NULL; return g; }
/* PROGRAMA QUE VERIFICA A FILA DE MSGS, E TRATA A REQUISICAO!*/ int main(){ t_processo *cabeca = NULL; t_processo *aux; t_msg msgrecebida; std::time_t tempoCorrente; struct tm * tempoInfo; int key_msg; int tamanhoLista; int ppid; // Parent Process ID signal(SIGALRM,dummy); //ROTINA DE SIGNAL_ALRM key_msg = msgget(10,0x1FF); //CRIAR FILA DE MSG while(1){ while(msgrcv(key_msg,&msgrecebida,size_msg,0,IPC_NOWAIT) > 0){ //LOOP DE RECEBER MENSAGENS E INSERIR NA FILA PROCESSSOS insere_lista(&cabeca,&msgrecebida); } aux = cabeca; tamanhoLista = 0; while(aux != NULL){ time(&tempoCorrente); // tempoInfo = localtime(&tempoCorrente); //PEGA O TEMPO ATUAL DE FORMA SEPARADA if( aux->minstamp == (unsigned) ((tempoInfo->tm_hour*60) + tempoInfo->tm_min) && aux->vezes > 0 ){ printf("\n\tHORA DE EXECUTAR UM PROCESSO!\n"); ppid = fork(); k printf("\n\tppid = %d \n",pid); if(ppid == 0){ if(execl(aux->msg,aux->msg,EComercial, (char*)0) < 0){ printf("\nErro no execl! \n"); exit(1); } }else{ aux->vezes--; aux->minstamp = ((tempoInfo->tm_hour*60) + tempoInfo->tm_min) + aux->deltaHora*60 + aux->deltaMin ; //ATUALIZAR A PROX VEZ aux->pid = ppid; printf("\n\telse aux->pid = %u \n",aux->pid); } } tamanhoLista++; aux = aux->prox; printf("\n\twhile(aux != NULL)FINAL\n"); } printf("\n\tSAI DO LOOP DE EXEC\n"); imprimeLista(&cabeca); int i ; aux = cabeca; if(aux != NULL){ for( i = 0; i < tamanhoLista - 1; i++){ printf("\n\tProcesso\t%d\t deltaHora %u:%u x %u\t minstamp\t%u\tprox\t=%p\n" ,aux->pid ,aux->deltaHora ,aux->deltaMin ,aux->vezes ,aux->minstamp ,aux->prox); if(aux->vezes > 0 ){ kill(aux->pid,SIGSTOP); kill(aux->prox->pid,SIGCONT); alarm(3); } if(aux->prox != NULL) aux = aux->prox; } kill(aux->pid,SIGSTOP); kill(cabeca->pid,SIGCONT); } } return 0 ; }