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