ton23
(usa Outra)
Enviado em 11/08/2008 - 14:38h
a 4 tudo bem nao sei como fazer , agora na cinco tenho a estrutura pronta , to meio confuso como jogo os dados ... me ajuda ai gente..
4) [3 pts] Desenvolva um programa principal para receba um numero através do argumentos argc e argv e chame a função fatorial, chame a função retornaVetor() e imprima os valores armazenador no vetor. Criar, incluir os valores armazenado no vetor e imprimir o conteúdo da lista encadeada.
#include <stdio.h>
#include <stdlib.h>
int main (int argc,char *argv[]);
5) [8 pts] Dada os valores: 48 30 14 56 88 34 51 32 (Mantenha os passos)
a) Ordene utilizando o método de seleção
#include <stdio.h>
#include <stdlib.h>
void SelectionSort(tChave tabela[], unsigned nElem)
{
tChave maior;
unsigned i, j, indice;
for (i = nElem-1; i > 0; --i) { /* Coloca em 'maior' o maior */
maior = tabela[0]; /* valor entre 0 e i */
indice = 0;
for (j = 1; j <= i; ++j) /* Escolhe o maior valor entre o */
if (tabela[j] > maior) { /* segundo elemento e i; os elementos */
maior = tabela[j]; /* entre i+1 e nElem-1 já estão ordenados */
indice = j;
}
tabela[indice] = tabela[i];
tabela[i] = maior;
}
}
b) Ordene utilizando o método de Bolha
void BubbleSort(tChave tabela[], unsigned nElem)
{
unsigned i, ordenado = 0;
tChave aux;
while (!ordenado) { /*1*/
ordenado = 1; /* Supõe que a tabela está ordenada */ /*2*/
for (i = 0; i < nElem - 1; i++) /*3*/
if (tabela[i] > tabela[i+1]) { /* Compara elementos adjacentes */ /*4*/
ordenado = 0; /* Pelo menos um elemento está fora de ordem */ /*5*/
/* Troca elementos adjacentes */
aux = tabela[i]; /*6*/
tabela[i] = tabela[i+1]; /*7*/
tabela[i+1] = aux; /*8*/
}
}
}
c) Ordene utilizando o método de HeapSort
void HeapSort(tChave tabela[], unsigned nElem)
{
int i;
tChave aux;
for(i = (nElem-2)/2; i >= 0; i--) /* Constrói o heap a partir do pai */
PercolaAbaixo(tabela, i, nElem); /* do último elemento da tabela */
/* Neste ponto, o heap está construído. Agora, troca-se o */
/* primeiro elemento do heap, diminuído de um elemento, */
/* com o último elemento e reordena-se o heap. */
for(i = nElem-1; i >= 1; i--) {
aux = tabela[0]; /* Remove o maior elemento do heap */
tabela[0] = tabela[i]; /* e coloca-o no final da tabela */
tabela[i] = aux;
PercolaAbaixo(tabela, 0, i); /* Reordena o heap */
}
}
d) Insira os valores acima em uma arvore binária.
*/
#include <stdio.h>
#include <stdlib.h>
#define MALLOC(x) ((x *) malloc (sizeof(x)))
#define TRUE 1
struct arv_bin{
char info;
struct arv_bin *esquerda;
struct arv_bin *direita;
};
typedef struct arv_bin bin_t;
void preordem(bin_t *);
void incluir (void);
void exibir_pre (void);
bin_t *raiz;
bin_t *arvore(bin_t *, bin_t *, char);
int main (void)
{
int op;
raiz=NULL;
for (;;)
{
system ("clear");
printf ("\nMenu");
printf ("\n\n 1. Insere");
printf ("\n 2. Exibe");
printf ("\n 3. Sair");
printf ("\n\n Entre a sua opção: ");
scanf ("%d",&op);
fflush(stdin);
switch (op) {
case 1 : incluir();
break;
case 2 : exibir_pre();
break;
case 3 : exit(0);
default: printf ("\nOpção errada");
break;
}
}
}
void incluir (void)
{
char s[80];
while(TRUE)
{
printf("\nLETRA: ");
scanf("%s",&s);
if (!raiz)
{
raiz = arvore(raiz,raiz, *s);
}
else
{
arvore(raiz,raiz,*s);
}
printf("\n Continua: (s,n) ");
scanf("%s",&s);
if(*s!='s') break;
};
}
bin_t *arvore (bin_t *ra, bin_t *r, char info)
{
if(!r){
r = MALLOC(bin_t);
if (!r)
{
printf("Sem memória");
exit(0);
}
r->esquerda = NULL;
r->direita = NULL;
r->info=info;
if(!ra)
{
printf("\nEssa letra é a raiz");
return r;
}
if(info < ra->info)
{
ra->esquerda=r;
printf("\nEssa letra entrou a esqueda de %c",ra->info);
}
else
{
ra->direita = r;
printf("\nEssa letra entrou a direita %c",ra->info);
}
return r;
}
if(info < ra->info) arvore(r,r->esquerda,info);
else arvore(r,r->direita,info);
}
void exibir_pre (void)
{
char b[80];
preordem(raiz);
printf("\n qualquer tecla sai");
scanf("%s",&b);
}
void preordem (bin_t *ton)
{
if (ton!=NULL)
{
printf("%c",ton->info);
preordem(ton->esquerda);
preordem(ton->direita);
}
}