#include <stdlib.h> #include <stdio.h> int troca (int p[], int i){ int aux; aux = p[i+1]; p[i+1] = p[i]; p[i] = aux; int bubble(int p[],int tamanho){

Transcrição

1 #include <stdlib.h> #include <stdio.h> int troca (int p[], int i) int aux; aux = p[i+1]; p[i+1] = p[i]; p[i] = aux; int bubble(int p[],int tamanho) int i,pi,pf,aux; if (tamanho > 0) for (i=0;i<tamanho;i++) pi=p[i]; pf=p[i+1]; if (pf<pi) troca(p,i); return bubble(p,tamanho-1); int main () int i,tm=5,v[6]=21,22,02,01,40,45; int *p; p=v; bubble(p,tm); for(i=0;i<6;i++) printf("%d\n",v[i]);

2 system("pause"); return 0; HASH #include <stdio.h> #include <stdlib.h> int main() int vet[10], l, i, c; int hash1[10][10],hash2[10][10],hash3[10][10], aux; for(i=0;i<=10;i++) vet[i]= 7*(1+i) ; for(l=0;l<10;l++) hash1[i][l] = 0; hash2[i][l] = 0; hash3[i][l] = 0; aux = vet[i] %7; c=0; while(hash1[aux][c]!=0) c++; hash1[aux][c] = vet[i];

3 aux = vet[i] % 14; c=0; while(hash2[aux][c]!=0) c++; hash2[aux][c] = vet[i]; aux = vet[i] % 5; c=0; while(hash3[aux][c]!=0) c++; hash3[aux][c] = vet[i]; for(l=0;l<10;l++) printf("%3d",hash1[i][l]); printf("\n"); printf("\n\n\n"); for(l=0;l<10;l++) printf("%3d",hash2[i][l]); printf("\n"); printf("\n\n\n"); for(l=0;l<10;l++) printf("%3d",hash3[i][l]); printf("\n");

4 printf("\n\n\n"); return 0; Arvore int ok; // se t aponta para null, a inserção é na raiz... if (*t == NULL) *t = (tnoarv *) malloc(sizeof(tnoarv)); if (*t == NULL) return; (*t)->esq = NULL; (*t)->dir = NULL; (*t)->info = dado; // Se o dado a ser inserido for menor que o nó atual, recursividade à esquerda if (dado < (*t)->info) inserir(&((*t)->esq), dado); else // Se o dado a ser inserido for menor que o nó atual, recursividade à direita if (dado > (*t)->info) inserir(&((*t)->dir), dado);

5 Função remover da árvore binária: void remover(tarv *raiz, int valor) tarv aux; if(!arvore_vazia(*raiz)) // se o valor que será removido for menor que o nó atual, if(valor < (*raiz)->info) remover(&((*raiz)->esq), valor); // faz recursividade á esquerda else // se o valor que será removido for maior que o nó atual, if(valor > (*raiz)->info) remover(&((*raiz)->dir), valor); // faz recursividade á direita. else // encontrou // quando o nó a ser removido for encontrado, if(!arvore_vazia((*raiz)->esq) &&!arvore_vazia((*raiz)->dir) ) // verificamos se os nós filhos da esquerda e direita não são null. // se não forem null, buscamos o menor nó a partir do nó da direita. aux = minimo((*raiz)->dir); (*raiz)->info = (aux->info); remover(&(*raiz)->dir, (*raiz)->info); else // caso os nó da direita e da esqueda, ou somente o da direita for null, // precisamos apenas remover aux = *raiz; // o nó atual e fazer ajustar os ponteiros if(arvore_vazia((*raiz)->esq)) // se o nó da esquerda for vazio // o nó pai do atual, apontará para o filho da direita do nó atual. *raiz = (*raiz)->dir;

6 else // se o nó da esquerda não for vazio. // o nó pai do atual, apontará para o filho da esquerda do nó atual. *raiz = (*raiz)->esq; free(aux); void remover(tarv *raiz, int valor) tarv aux; if(!arvore_vazia(*raiz)) // se o valor que será removido for menor que o nó atual, if(valor < (*raiz)->info) remover(&((*raiz)->esq), valor); // faz recursividade á esquerda else // se o valor que será removido for maior que o nó atual, if(valor > (*raiz)->info) remover(&((*raiz)->dir), valor); // faz recursividade á direita. else // encontrou // quando o nó a ser removido for encontrado, if(!arvore_vazia((*raiz)->esq) &&!arvore_vazia((*raiz)->dir) ) // verificamos se os nós filhos da esquerda e direita não são null. // se não forem null, buscamos o menor nó a partir do nó da direita. aux = minimo((*raiz)->dir); (*raiz)->info = (aux->info); remover(&(*raiz)->dir, (*raiz)->info); else // caso os nó da direita e da esqueda, ou somente o da direita for null,

7 // precisamos apenas remover aux = *raiz; // o nó atual e fazer ajustar os ponteiros if(arvore_vazia((*raiz)->esq)) // se o nó da esquerda for vazio // o nó pai do atual, apontará para o filho da direita do nó atual. *raiz = (*raiz)->dir; else // se o nó da esquerda não for vazio. // o nó pai do atual, apontará para o filho da esquerda do nó atual. *raiz = (*raiz)->esq; free(aux);

8 Função minimo, retorna o nó com valor minímo: tarv minimo(tarv T)// procura o nó com valor mínimo if(arvore_vazia(t)) return NULL; else if( arvore_vazia(t->esq) ) return T; else return minimo(t->esq); tarv minimo(tarv T)// procura o nó com valor mínimo if(arvore_vazia(t)) return NULL; else if( arvore_vazia(t->esq) ) return T; else return minimo(t->esq);

9 Função maximo, retorna o nó com o valor máximo: tarv maximo(tarv T)// procura o nó com valor máximo if(!arvore_vazia(t) ) while(!arvore_vazia(t->dir) ) T = T->dir; return T; tarv maximo(tarv T)// procura o nó com valor máximo if(!arvore_vazia(t) ) while(!arvore_vazia(t->dir) ) T = T->dir; return T; Função para buscar elemento na árvore binária: //======================================================================= // A função pesquisa nos nós da árvore o valor passado como parâmetro, // caso o valor esteja na árvore, ela retorna este nó que está o valor. tarv busca_elemento(tarv t, int dado) tarv achou; if (arvore_vazia(t)) return NULL; if (t->info == dado) return t; achou = busca_elemento(t->esq, dado); if (arvore_vazia(achou)) achou = busca_elemento(t->dir, dado); return achou;

10 //======================================================================= // A função pesquisa nos nós da árvore o valor passado como parâmetro, // caso o valor esteja na árvore, ela retorna este nó que está o valor. tarv busca_elemento(tarv t, int dado) tarv achou; if (arvore_vazia(t)) return NULL; if (t->info == dado) return t; achou = busca_elemento(t->esq, dado); if (arvore_vazia(achou)) achou = busca_elemento(t->dir, dado); return achou; Merge #include<stdio.h> void intercalar (int v[],int aux[],int inicialv1, int inicialv2,int final2); void mergesort (int v[], int aux[],int PontoA, int dir); int main() int v[10]= 9,8,7,6,5,4,3,2,1,0,aux[10],i; mergesort(v,aux,0,9); for(i=0; i<10; i++) printf("%d\n",v[i]); return 0; void intercalar (int v[],int aux[],int inicialv1, int inicialv2,int final2) int inicial1=inicialv1,inicial2=inicialv2,fim1=inicial2-1,au=0,i; while(inicial1<=fim1 && inicial2<=final2) if (v[inicial1]<v[inicial2]) aux[au++] = v[inicial1++]; else

11 aux[au++] = v[inicial2++]; while(inicial1<=fim1) aux[au++] = v[inicial1++]; while(inicial2<=final2) aux[au++] = v[inicial2++]; for(i=0; i<au; i++) v[i+inicialv1]=aux[i]; void mergesort (int v[], int aux[],int PontoA, int dir) int PontoB,i; if(pontoa<dir) PontoB=(PontoA+dir)/2; mergesort(v,aux,pontoa,pontob); mergesort(v,aux,pontob+1,dir); intercalar(v,aux,pontoa,pontob+1,dir); Shell // Libs #include <stdio.h> #include <stdlib.h> #define MAX 10 void shell_sort(int *a, int Tamanho); int main(int argc, char** argv) int i, vet[max]= 9,8,7,6,5,4,3,2,1,0; shell_sort(vet, MAX); for(i = 0; i < MAX; i++) printf("%d\n", vet[i]); system("pause"); return 0; void shell_sort(int *a, int Tamanho) int i, j, valor; int Lacuna = 1;

12 do Lacuna = 3*Lacuna+1; while(lacuna < Tamanho); do Lacuna /= 3; for(i = Lacuna; i < Tamanho; i++) valor = a[i]; j = i - Lacuna; while (j >= 0 && valor < a[j]) a[j + Lacuna] = a[j]; j -= Lacuna; a[j + Lacuna] = valor; while(lacuna > 1); Grafo