Ordenao - Insero direta: o mtodo mais simples, normalmente utilizado para um conjunto pequeno de dados.

. Isso acontece porque esse mtodo apresenta uma baixa eficincia em relao ao tempo total para realizar uma classificao. medida que o conjunto de dados a ser classificado aumenta, observa-se uma queda no tempo necessrio para termos o conjunto de dados classificado. Existe a diviso do vetor a ser ordenado em dois segmentos: o primeiro contendo os elementos j ordenados e o segundo, contendo os elementos ainda no ordenados. *Algoritmo da insero direta: 1) Um primeiro elemento est no vetor ordenado e os demais no vetor desordenado; 2) Retira-se o primeiro elemento do vetor desordenado. Ao coloc-lo no vetor ordenado, realizada a devida comparao para inseri-lo na sua posio correta; 3) Repte-se o processo at que todos os elementos do vetor desordenado tenham passado para o vetor ordenado. #include <stdio.h> #include <conio.h> Void insercaodireta (int *vet, int x); { int j,z; if (i==0) vet [i]=x; else { j=0; while(x>vet[j]) j++; z=i; while(z>j){ vet[z]=vet[z-1]; z--; } vet [j]=x; }} -Seleo: consiste numa seleo sucessiva do maior (ou menos) valor contido no vetor. Feita essa escolha, coloca-se o valor maior ou menos em cada passo realizado, diretamente na sua posio correta. Esse processo repetido para o segmento que contm os elementos ainda no selecionados. *Algoritmo da seleo direta: 1) A cada etapa realizada, identificado o menos elemento dentro do segmento que contm os elementos ainda no selecionados; 2) realizada uma troca do elemento identificado na etapa anterior, com o primeiro elemento do segmento; 3) O tamanho do segmento atualizado, ou seja, subtrai-se um do tamanho do segmento (menos um elemento); 4) Esse processo interrompido no momento em que o segmento ficar com apenas um elemento. #include <conio.h> #include <stdio.h> void selecao(int *vet, int n) { int i,maior,pm,aux; while(n>1) { pm=0; maior=vet[0]; for(i=1;i<n;i++) if(maior<vet[i]) { maior=vet[i]; pm=i; } aux=vet[n-1]; vet[n-1]=vet[pm]; vet[pm]=aux; n--; } }

void main() { int vet[50],i,n; clrscr(); printf("Digite o n de elementos do vetor: "); scanf("%d", &n); for(i=0;i<n;i++) { printf("Digite um numero: "); scanf("%d", &vet[i]); } selecao(vet,n); for(i=0;i<n;i++) printf("%d ",vet[i]); getch(); } -Ordenao por troca: a idia fazer uma varredura no vetor como um todo. No momento em que dois elementos fora de ordem forem encontrados, suas posies so simplesmente trocadas. Esse processo de varredura pressupe a realizao de comparaes sucessivas de pares de elementos. -Mtodo da bolha (bubble sort): considerado um mtodo bastante trivial e, de forma geral, muito lento na realizao da ordenao de um conjunto de dados. O nome bolha deve-se ao fato de que, ao se fazer o acompanhamento ilustrativo do processo de ordenao, tem-se a impresso de que os valores flutuam at sua correta posio, como bolhas num liquido. *Algoritmo da bolha: 1) Em cada passo, cada elemento comparado com o prximo; 2) Se o elemento estiver fora de ordem, a troca realizada; 3) Realizam-se tantos passos quantos forem necessrios at que no ocorram mais trocas. #include <stdio.h> #include <conio.h> void bolha(int *vet, int n) { int i,aux, trocou; trocou=1; while (trocou) { trocou=0; for(i=0;i<n-1;i++) { if (vet[i] >vet[i+1]) { aux=vet[i]; vet[i]=vet[i+1]; vet[i+1]=aux; trocou=1; } } n--; } } void main() { int vet[50],i,n; clrscr(); printf("Digite o n de elementos do vetor: "); scanf("%d", &n); for(i=0;i<n;i++) { printf("Digite um numero: "); scanf("%d", &vet[i]); } bolha(vet,n); for(i=0;i<n;i++)

printf("%d",vet[i]); getch();

-Quicksort: considerado como o mais rpido em relao aos outros mtodos, sendo este o principal motivo de sua preferncia quando necessrio classificar um conjunto de dados. Adota como principio que mais rpido classificar dois vetores com n/2 elementos cada um, do que um com n elementos; ou seja, segue a linha do dividir para conquistar. *Algoritmo do quicksort: 1) escolhido de forma arbitrria um elemento do vetor (normalmente, o meio). Em seguida, o elemento colocado em uma varivel auxiliar aux; 2) Iniciar dois ponteiros i e j (i=1 e j=n); 3) O vetor percorrido a partir da esquerda at que se encontre um V[i]>=aux (incrementando o valor de i); 4) O vetor percorrido a partir da direita at que se encontre um V[j]<=aux (decrementando o valor de j); 5) efetuada a troca dos elementos V[i] e V[j] (esto fora do lugar). Em seguida, realizado i=i+1 e j=j-1; 6) Esse processo repetido at o instante em que i e j se cruzem em algum ponto do vetor; 7) No momento em que obtemos os dois segmentos do vetor por meio do processo de partio, realiza-se a ordenao de cada um deles de forma recursiva. #include <stdio.h> #include <conio.h> void quicksort (int *vet,int ivet,int fvet) { int i, j, aux, pivo; i = ivet; j = fvet; pivo = vet[(ivet + fvet)/2]; do{ while (vet[i]<pivo) i++; while (vet[j]>pivo) j--; if(i<=j) { aux = vet[i]; vet[i] = vet[j]; vet[j] = aux; i++; j--; } }while (i<j); if (j>ivet) quicksort(vet,ivet,j); if (i<fvet) quicksort(vet,i,fvet); } int buscabinaria (int *vet,int ivet,int fvet,int x) { int meio,pmeio; pmeio = (ivet + fvet)/2; meio = vet[pmeio]; if (ivet>fvet) return(0); if (meio==x) return(1); else if(x>meio) buscabinaria(vet,(pmeio+1),fvet,x); else buscabinaria(vet,ivet,(pmeio-1),x); } void main() { int vet[50];

int i,n,j,x; clrscr(); printf("Digite o nmero de elementos do vetor:"); scanf("%d",&n); for(i=0;i<n;i+=); { printf("Digite o %d numero.", i++); scanf("%d",&vet[i]); } quicksort(vet,0,n-1); printf("O vetor ordenado :"); for(i=0;i<n;i++) printf("%d",vet[i]); printf("\nDigite o nmero a ser procurado:"); scanf("%d",&x); int r; r=buscabinaria(vet,0,n-1,x); if(r==0) printf("Elemento no encontrado."); else printf("Elemento encontrado."); getch(); } Busca -Sequencial: o algoritmo mais simples para fazer busca em uma lista a busca seqencial. Cada item da lista examinado em seqncia at que o item desejado seja encontrado. Fica impraticvel para listas muito grandes. *Algoritmo: #include <stdio.h> #include <conio.h> void main() { int vet[100]; int n,i,x; clrscr(); printf("Digite a quantidade de elementos do vetor:"); scanf("%d",&n); for(i=0;i<n;i+=) { printf("Digite um valor:"); scanf("%d",&vet[i]); } printf("Digite o numero procurado:"); scanf("%d",&x); i=0; while((i<n)&&(vet[i]!=x)) i++; if(i<n) else getch(); } -Em sentinela: Coloca-se a chave a ser procurada aps a ltimo elemento do vetor. A busca feita com uma nica pergunta, se o elemento na posio i diferente do procurado (otimizando a condio do for na busca seqencial tradicional). Ao terminar deve-se verificar a posio de i, se for igual posio onde a chave foi inserida artificialmente significa que a chave no constava no vetor. void main() { printf("Elemento encontrado na posio %d",i); printf("Elemento nao encontrado.");

float vet[MAX+1], chave; int tam_log, i; /*Leitura*/ scanf(%f,&chave); vet[tam_log]=chave; for (i=0;vet[i]!=chave;i++); if (i==tam_log) printf(Nao achou); else printf(Achada a chave na posicao: %d,i);

-Binria: uma alternativa mais eficiente em relao pesquisa sequencial, exigindo, contudo, que os elementos sobre os quais a pesquisa ser realizada estejam ordenados. Consideramos, em primeiro lugar, o elemento que pode ser encontrado no meio da tabela. Se esse elemento maior do que o elemento que estamos procurando, podemos ento garantir que o elemento que estamos procurando no pode ser encontrado na segunda metade da tabela. Repetimos o processo da pesquisa binaria para a primeira metade da tabela. Se o elemento no meio da tabela menor do que o elemento que estamos procurando, ento, garantir que o elemento que estamos procurando no poder ser encontrado na primeira metade da tabela. Se o elemento no meio da tabela for igual ao elemento que estamos procurando, a procura termina. int buscaBin(int vet[],int tam, int chave, int *meio) { int fim=tam-1,ini=0; while(ini<=fim) { *meio=(ini+fim)/2; if(vet[*meio]==chave) return 1; else if(vet[*meio]>chave) fim=*meio-1; else ini=*meio+1; } return 0; } Inordem: sub-arvore esquerda, raiz, sub-arvore direita. Pr-ordem: raiz, sub-arvore esquerda, sub-arvore direita. Ps-ordem: sub-arvore esquerda, sub-arvore direita, raiz. Remoo de elementos: o n no tem filhos (retira o elemento); o n tem um filho (liga o filho ao pai do elemento); o n tem dois filhos (substituir o elemento pelo maior elemento da sub-arvore da esquerda). Huffman: esquerda = 0; direita = 1. Programa media.c Void media (float*A, float*B, float*med) { *med = ((*A) + (*B))/2; } Programa main.c #include <stdio.h> Int main (void) { Float A, B, result; Printf(Digite um numero:); Scanf(%f,&A); Printf(Digite outro numero:);

Scanf(%f,&B); Media(&A,&B,&result); Printf(A media %f,result); Return 0; } O comando make verifica o grafo de dependencias de acordo com um arquivo de texto designado por makefile. O make verifica se algum arquivo mais recente do que outro que depende dele e completa os arquivos de acordo com as necessidades existentes.