int* intercala (int* vetorE, int* vetorD, int sizeE, int sizeD) { int i, j, k, maior; int* ordenado; ordenado = (int*) malloc ((sizeE + sizeD) * sizeof(int)); #ifdef DEBUG imprimeVetor(vetorE, sizeE, "vetorE"); imprimeVetor(vetorD, sizeD, "vetorD"); #endif for (k = 0, i = 0, j = 0; i < sizeE && j < sizeD; ) { if (vetorE[i] < vetorD[j]) ordenado[k++] = vetorE[i++]; else ordenado[k++] = vetorD[j++]; } while (i < sizeE) ordenado[k++] = vetorE[i++]; while (j < sizeD) ordenado[k++] = vetorD[j++]; #ifdef DEBUG imprimeVetor(ordenado, sizeE+sizeD, "intercalado"); printf("vez=%d\n\n", COUNT++); #endif return ordenado; }
int main(void) { pthread_t threads[QTD_CORES]; float original[TAM_ARRAY] = {0.,0.,1.,0.,2.,0.,3.,0.,0.,0.,1.,0.,2.,0.,3.,0.}; float resultado[TAM_ARRAY]; float data1[TAM_ARRAY]={}; float data2[TAM_ARRAY]={}; carregaDataBloco1(original,struc1); carregaDataBloco2(original,struc2); //imprimeVetor(data1,TAM_ARRAY); //imprimeVetor(data2,TAM_ARRAY); fft(data1-1,QTD_ELEMENTOS,1); imprimeVetor(data1,TAM_ARRAY); fft(data2-1,QTD_ELEMENTOS,1); imprimeVetor(data2,TAM_ARRAY); totalizaResultado(data1,data2,resultado); imprimeVetor(resultado,TAM_ARRAY); fft(original-1,QTD_ELEMENTOS,1); imprimeVetor(original,TAM_ARRAY); pthread_exit (NULL); return 0; }
//-------------------------------------- int main (){ int vetor[] = {12, 5, 9, 1, 4, 3, 13, 0, 8, 10, 11, 14, 2, 7, 6, 15}; int n = 16; imprimeVetor (n,vetor); quickSort (0,n-1,vetor); imprimeVetor (n,vetor); getch(); }
int main(){ int vetor[5]; int tamanho=5; preenche(vetor, tamanho); imprimeVetor(vetor,tamanho); ordenaVetor(vetor,tamanho); imprimeVetor(vetor,tamanho); return 0; }
int main(void) { int v[21]; int n=20; count c; setlocale (LC_ALL, "Portuguese"); resetVetor(v, n); printf("Vetor usado \n"); imprimeVetor(v, n); printf("selection Sort \n"); c = selection_sort(v, n); automato( c, v, n); printf("Selecion Sort v2 \n"); c = selection_sort2(v, n); automato( c, v, n); printf("Insertion Sort \n"); c = insertion_sort(v, n); automato( c, v, n); printf("Bubble Sort \n"); c = bubble_sort(v, n); automato( c, v, n); printf("Merge Sort \n"); c = merge_sort(v, 0, n); automato( c, v, n); return 0; }
int main(){ //Definindo Vetor int v[3] = {1,2,3}; //Mostrando vetor imprimeVetor(v, 3); //Modifica o vetor modificaVetor(v, 3); //Mostrando vetor imprimeVetor(v, 3); //Retorno da Função return 0; }
int main() { int source = 0; int dest = 0; source = 0; dest = 8; algoDijstra(source, dest); imprimeVetor(vetLamb, 9); return 1; }
void ordenaVetor(int vetor[], int tam){ int i, j,aux; for(i=0;i<tam;i++){ for(j=i+1;j<tam;j++){ if(vetor[j]>vetor[i]){ aux=vetor[i]; vetor[i]=vetor[j]; vetor[j]=aux; } } imprimeVetor(vetor,tam); } }
int main (void) { int qtdprocessos, met; FILE* out = fopen("saida.txt","w"); int i, j, fail = 0, cnt = 0, tamProntos, tamIO, tamIO2, seg = 0, inxExec, inxIO; Processo *aux, *procExec, *procIO, *procRetirado; LIS_tppLista listaIO = LIS_CriarLista(); LIS_tppLista listaProntos = LIS_CriarLista(); Memory * mem = (Memory*)malloc(sizeof(Memory)); FILE* fp = fopen("entrada.txt", "r"); Processo *vp = (Processo*)malloc(100*sizeof(Processo)); qtdprocessos = lerEntrada(&fp, vp); imprimeVetor(vp, qtdprocessos); InicializaMemoria(mem); procExec = NULL; // Insere os elementos lidos numa lista de prontos for(i = 0; i < qtdprocessos; i++) { LIS_InserirElementoApos(listaProntos, &vp[i]); LIS_AvancarElementoCorrente(listaProntos, 1); vp[i].segAtual = -1; vp[i].naMemoria = 0; vp[i].t_exec = 0; vp[i].t_io = 0; } printf("1: First Fit \n"); printf("2: Best Fit \n"); printf("3: Worst Fit \n"); printf("4: Next Fit \n"); scanf("%d", &met); EXEC: IrInicioLista(listaProntos); // vai pro inicio da lista de prontos aux = (Processo*)LIS_ObterValor(listaProntos); switch(met) { case 1: firstFit(mem, listaProntos); break; case 2: BestFit(mem, listaProntos); break; case 3: WorstFit(mem, listaProntos); break; case 4: NextFit(mem, listaProntos); break; default: break; } imprimeMemoria(mem); printf("\n Lista de Prontos \n"); ImprimirLista(listaProntos); printf("\n Lista de IO \n"); ImprimirLista(listaIO); /* * * * * * * * * * * * * * * * * * * * * * */ // executar o processo IrInicioLista(listaProntos); tamProntos = LIS_ObterTamanho(listaProntos); tamIO = LIS_ObterTamanho(listaIO); aux = (Processo*)LIS_ObterValor(listaProntos); // obtem o priemeiro elemento da lista de prontos while(tamProntos > 0) { if(!aux->naMemoria) // se o processo não esta em memoria { LIS_AvancarElementoCorrente(listaProntos, 1); aux = (Processo*)LIS_ObterValor(listaProntos); continue; } procExec = aux; for(i = 0; i < 10; i++) // os 10 clocks de cpu { ImprimirEstado(&out, listaIO, procExec, mem, tempoTotal); clock(1); tempoTotal++; inxExec = procExec->t_exec; procExec->exec[inxExec]--; tamIO = LIS_ObterTamanho(listaIO); IrInicioLista(listaIO); for(j = 0; j < tamIO; j++) // diminui 1 de IO para todos q estao na lista de I/O { procIO = (Processo*)LIS_ObterValor(listaIO); inxIO = procIO->t_io; procIO->io[inxIO]--; if(procIO->io[inxIO] == 0) // seu tempo de io acabou { LIS_ExcluirElemento(listaIO); // retira da lista de io e insere-o na lista de prontos IrFinalLista(listaProntos); LIS_InserirElementoApos(listaProntos, procIO); procIO->t_io++; } LIS_AvancarElementoCorrente(listaIO, 1); } tamIO2 = LIS_ObterTamanho(listaIO); if(tamIO != tamIO2) { switch(met) { case 1: firstFit(mem, listaProntos); break; case 2: BestFit(mem, listaProntos); break; case 3: WorstFit(mem, listaProntos); break; case 4: NextFit(mem, listaProntos); break; default: break; } } getNext(listaProntos); if(procExec->exec[inxExec] == 0 || i == 9) // se o seu tempo de exec terminou entao retira da memoria { /* * * * * */ //imprimeMemoria(mem); LIS_ExcluirElemento(listaProntos); if(procExec->exec[inxExec] == 0) procExec->t_exec++; // se acabou um exec inteiro if(procExec->exec[inxExec] == 0 && procExec->t_io < procExec->qtdio) // se o processo terminou um exec e ainda tem io para fazer { IrFinalLista(listaIO); LIS_InserirElementoApos(listaIO, procExec); } // retira da memoria // se o processo ainda tem exec para fazer if(procExec->exec[inxExec] > 0) { IrFinalLista(listaProntos); LIS_InserirElementoApos(listaProntos, procExec); } seg = procExec->segAtual; procRetirado = RetiraProcessoMem(mem, seg); procRetirado->naMemoria = 0; switch(met) { case 1: firstFit(mem, listaProntos); break; case 2: BestFit(mem, listaProntos); break; case 3: WorstFit(mem, listaProntos); break; case 4: NextFit(mem, listaProntos); break; default: break; } break; } imprimeMemoria(mem); printf("\n Lista de Prontos \n"); ImprimirLista(listaProntos); printf("\n Lista de IO \n"); ImprimirLista(listaIO); } /* final dos 10 clocks*/ imprimeMemoria(mem); printf("\n Lista de Prontos \n"); ImprimirLista(listaProntos); printf("\n Lista de IO \n"); ImprimirLista(listaIO); tamProntos = LIS_ObterTamanho(listaProntos); IrInicioLista(listaProntos); aux = (Processo*)LIS_ObterValor(listaProntos); } tamIO = LIS_ObterTamanho(listaIO); while(tamIO > 0) // entao tem IO sobrando e ngm para executar { IrInicioLista(listaIO); clock(1);tempoTotal++; for(j = 0; j < tamIO; j++) // diminui 1 de IO para todos q estao na lista de I/O { procIO = (Processo*)LIS_ObterValor(listaIO); inxIO = procIO->t_io; procIO->io[inxIO]--; if(procIO->io[inxIO] == 0) // seu tempo de io acabou { LIS_ExcluirElemento(listaIO); // retira da lista de io e insere-o na lista de prontos IrFinalLista(listaProntos); LIS_InserirElementoApos(listaProntos, procIO); procIO->t_io++; } LIS_AvancarElementoCorrente(listaIO, 1); } tamIO = LIS_ObterTamanho(listaIO); tamProntos = LIS_ObterTamanho(listaProntos); imprimeMemoria(mem); printf("\n Lista de Prontos \n"); ImprimirLista(listaProntos); printf("\n Lista de IO \n"); ImprimirLista(listaIO); if(tamProntos > 0) // se alguem voltou par a lista de prontos... goto EXEC; } fclose(out); free(mem); free(vp); free(listaProntos); free(listaIO); return 0; }
void testePonteiroVetor () { //Revisao basica de ponteiros //Cria uma variavel inteira sem ponteiro e mostra o valor nela armazenada int numero = 0; printf("Criei um numero.\nO valor de numero eh: %d\n", numero); //Para pegar a posicao de memoria onde 'numero' esta armazenada, usamos o operador &: printf("A posicao de memoria de 'numero' eh %p\n", &numero); //%p serve para imprimir ponteiros. esperaEnter(); //Para declarar um ponteiro, usamos o operador *: int *ponteiro; //Por enquanto, o ponteiro aponta para lixo!! Veja abaixo! //Ponteiros servem para apontar posicoes de memoria. Se declaramos um ponteiro usando *, para pegarmos //o valor da posicao de memoria para que ele aponta, basta usa-lo como uma variavel qualquer: printf("Criei um ponteiro.\nO ponteiro aponta para: %p (lixo)\n", ponteiro); //Essa linha gera um warning em bons IDEs. esperaEnter(); //Podemos atribuir o ponteiro a alguma coisa, como a posicao de memoria da nossa variavel 'numero': ponteiro = № printf("O ponteiro agora aponta para numero!\n"); /*Observemos melhor esta igualdade: So podemos igualar quantidades de mesma especie. IDEs bons avisam se voce tiver tentando igualar um ponteiro a uma variavel, ou algo do tipo. No exemplo acima, estamos igualando ponteiro a &numero. Isso eh coerente, pois declaramos *ponteiro e, para obtermos ponteiro (sem *), eh como se usassemos o operador &, que 'anula' *: &(*ponteiro) = ponteiro; Logo, vemos que o operador & se encontra dos dois lados da igualdade! (Mesmo que escondido) */ //Se quisermos o valor armazenado na posicao de memoria para qual o ponteiro aponta, usamos *: printf("\nO valor armazenado na posicao de memoria do ponteiro eh: %d\n", *ponteiro); //Isso imprime o valor de 'numero' //Vemos que o endereco de memoria apontado por ambos eh o mesmo: printf("Valor de 'ponteiro': %p| Valor de &numero: %p\n", ponteiro, &numero); esperaEnter(); //------------------------------------------------------------------- //Vamos agora operar com ponteiros: printf("Vou tentar mudar o valor de 'numero' com o ponteiro, sem usar '*'"); //Se chamarmos a funcao 'incrementaUm' em numero, estaremos enviando apenas o valor //que a variavel 'numero' possui neste determinado instante, e por isso eh impossivel //modificar o valor que se encontra em 'numero' usando a funcao 'incrementaUm'. //Veja que poderiamos simplesmente chamar incrementaUm(1), que internamente iria gerar o //numero 2. incrementaUm(numero); //Verificando o resultado: printf("\nValor atual de 'numero': %d | Valor atual de *ponteiro: %d\n", numero, *ponteiro); printf(" A funcao nao conseguiu mudar o valor de numero!\n"); esperaEnter(); printf("\nO que acontece se eu alterar o valor do ponteiro (sem *) fora da funcao?\n"); //Podemos pensar no que aconteceria se alterassemos o valor de 'ponteiro', uma referencia //para uma posicao de memoria. //Acontece que esta operacao eh perigosa e nao tem aplicacoes neste exemplo (mas sera //vista mais para frente). Veja a implementacao da funcao para mais detalhes. incrementaUmPonteiro(ponteiro); printf("\nDE VOLTA NO MAIN:\n"); printf("\nValor atual de 'numero': %d | Valor atual de *ponteiro: %d\n", numero, *ponteiro); printf("\n A funcao nao conseguiu mudar o valor do ponteiro!"); printf("\n Ele ainda aponta para 'numero!'\n"); esperaEnter(); printf("Vou tentar mudar o valor de 'numero' com o ponteiro, agora usando '*'\n"); //Agora, se quisermos fazer com que uma funcao possa alterar o valor de uma variavel sem //ter que retorna-la (e isso eh util em casos que temos que modificar mais de uma //variavel por vez), devemos usar ponteiros em sua forma usual: incrementaUmValor(ponteiro); //Lembre-se que ponteiro = &numero, isto eh, 'ponteiro' aponta para a posicao de //memoria onde 'numero' esta armazenado. Qualquer alteracao em *ponteiro altera a //mesma posicao de memoria que 'numero' e, portanto, seu valor. //Podemos verificar se as operacoes foram feitas com sucesso: printf("Valor atual de 'numero': %d | Valor atual de *ponteiro: %d\n", numero, *ponteiro); printf("\n Conseguimos mudar o valor de numero!\n"); esperaEnter(); printf("\n\nVETORES:\n\n"); //------------------------------------------------------------------- //Vamos agora operar com vetores, que estao intimamente relacionados com ponteiros: printf("Criei um vetor de 10 posicoes.\n"); //Vamos criar um vetor de 10 posicoes. Ele contem lixo no momento: int vetor[10]; //Vetores em C sao feitos usando um bloco continuo de memoria. Quando digito: //int vetor[10] //O compilador sabe que tera que arrumar 10 espacos de tamanho 'int'. Ele faz isso //automaticamente, porem o conteudo desses 10 espacos nao eh defindo. Qualquer coisa //que estava la inicialmente armazenada nao foi modificada. Apenas recebemos 'permissao' //para usar aqueles espacos. //Para acessar um ponto do vetor, precisamos saber onde ele esta na memoria. Sabemos //que ele eh um bloco continuo, logo, se soubermos o inicio dele na memoria e o indice //que queremos acessar, podemos encontrar a posicao de memoria que guarda o indice //desejado! //Assim, para definirmos um vetor em C precisamos saber apenas a posicao de memoria em //que este comeca e seu tamanho, para nao pegarmos posicoes de memoria invalidas. //Justamente, quando se declara vetor[10], a variavel 'vetor' nada mais eh do que //um ponteiro que aponta para a posicao de memoria onde comeca o vetor! //Imprime o vetor, mostrando lixo imprimeVetor(vetor, 10); printf("\nQuanto lixo!\n"); esperaEnter(); //Sejamos civilizados e populemos o vetor: int i; for (i = 0; i < 10; i++) { vetor[i] = i; } printf("\nVetor inicializado:\n"); imprimeVetor(vetor, 10); printf("\nPodemos acessar o vetor manualmente:\n"); //Agora sim, podemos pegar um de seus elementos: i = 3; printf("\n\nAcessando vetor\n Elemento %d: %d\n", i, acessaVetor(vetor, i)); esperaEnter(); //Podemos tambem mudar o vetor. Como estamos lidando com ponteiros, modificacoes que //ocorrem fora da funcao onde o vetor foi criado sao refletidas fora dele! printf("\nVou somar 1 em cada elemento do vetor usando uma funcao fora do main!\n"); //Esta funcao em particular assume que o vetor criado eh de comprimento 10. mudaVetor(vetor); printf("\nVerificando se uma mudanca em outra funcao eh permanente:\n"); imprimeVetor(vetor, 10); esperaEnter(); //Allocando um vetor dinamicamente: //Se quisermos ter um pouco mais de liberdade em relacao ao tamanho do vetor, podemos //usar um metodo de allocacao dinamica. //Isso permite que criemos um vetor com um tamanho definido, por exemplo, por uma //variavel qualquer (ou ate lida do usuario!) //O metodo consiste em reservar explicitamente o 'bloco' de memoria em que o vetor reside //passando exatamente o tamanho que ele ira ocupar. //Como vimos, para um vetor de tamanho N: int N = 13; printf("\nVou allocar um vetor de tamanho %d de forma dinamica:\n", N); //Devemos allocar N espacos de tamanho int, isto eh: unsigned long espacoAAllocar = N*sizeof(int); //Para allocarmos o espaco, precisamos da funcao memory alloc (malloc), da biblioteca //stdlib.h: int *vetorMaior = malloc(espacoAAllocar); printf("\nO vetor dinamico pode ter lixo inicial ou nao... depende do seu compilador\n"); //Com isso, reservamos um local na memoria que contem 100 espacos que cabem ints. //Dependendo do compilador, pode haver lixo ou nao... imprimeVetor(vetorMaior, N); esperaEnter(); printf("\nPopulando vetor:\n"); //Vamos popular este vetor tambem: for (i = 0; i < N; i++) { vetorMaior[i] = i; } imprimeVetor(vetorMaior, N); printf("\nVou mudar os elementos nesse vetor:\n"); //Para operar em um vetor de tamanho arbitrario, sempre devemos informar seu tamanho, //para que nao sejam acessadas posicoes de memoria pertencentes a outras variaveis: mudaVetorArbitrario(vetorMaior, N); //Vamos verificar a mudanca: imprimeVetor(vetorMaior, N); esperaEnter(); }
void automato(count c, int v[], int n ) { mostraContador(c); imprimeVetor(v, n); zeraContador(c); resetVetor(v, n); }
void imprimeVetor (int* vetor) { char id[2] = ""; imprimeVetor (vetor, N, id); }
void imprimeVetor (int* vetor, const char* id) { imprimeVetor (vetor, N, id); }
void imprimeVetor (int* vetor, int size) { char id[2] = ""; imprimeVetor (vetor, size, id); }