Marcos Aurélio Alves Caval
-
Posts
3 -
Cadastrado em
-
Última visita
Tipo de conteúdo
Artigos
Selos
Fabricantes
Livros
Cursos
Análises
Fórum
posts postados por Marcos Aurélio Alves Caval
-
-
poderia colocar os códigos que devo acrescentar?
-
int main(int argc, char** argv) { setlocale(LC_ALL, "Portuguese"); int mat[LIN][COL], i, j, vet[COL] = {0}; for(i = 0; i < LIN; i++){ for(j = 0; j < COL; j++){ printf("Digite o elemento[%d][%d]: ", i, j); scanf("%d", &mat[i][j]); } } printf("\n\n"); for(i = 0; i < COL; i++){ for(j = 0; j < LIN; j++) vet[i] = vet[i] + mat[j][i]; } for(j = 0; j < COL; j++) printf("VETOR [%d]: %d\n", j, vet[j]); return 0; }int main(int argc, char** argv) {
setlocale(LC_ALL, "Portuguese");
int mat[LIN][COL], i, j, vet[COL] = {0};for(i = 0; i < LIN; i++){
for(j = 0; j < COL; j++){
printf("Digite o elemento[%d][%d]: ", i, j);
scanf("%d", &mat[j]);
}
}
printf("\n\n");for(i = 0; i < COL; i++){
for(j = 0; j < LIN; j++)
vet = vet + mat[j];
}for(j = 0; j < COL; j++)
printf("VETOR [%d]: %d\n", j, vet[j]);
return 0;
}
Sobre o Clube do Hardware
No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas comunidades sobre tecnologia do Brasil. Leia mais
Direitos autorais
Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais
Problema na execução das funções. Alguém daria uma força.
em C/C#/C++
Postado
//IMPLEMENTAÇÃO DE ÁRVORE BINÁRIA AVL
/* prótotipos das funções;
tipo de dado armazenado na árvore;
o ponteiro "árvore". */
typedef struct{
int chave;
}elem;
typedef struct no{
elem info;
struct no *esq;
struct no *dir;
int fb;
}No;
typedef struct{
No *raiz;
}Avl;
void Criar(Avl *A);
int Vazia(Avl *A);
void Libera(Avl *A);
void LiberaRec(No **pt);
No *Busca(Avl *A, int chave);
No *BuscaRec(No *pt, int *chave);
void RotEsq(Avl *A);
void RotEsqRec(No **pt);
void RotDir(Avl *A);
void RotDirRec(No **pt);
void RotEsqDir(Avl *A);
void RotEsqDirRec(No **pt);
void RotDirEsq(Avl *A);
void RotDirEsqRec(No **pt);
int Insere(Avl *A, elem v);
int InsereRec(No **pt, elem *v);
int Remove(Avl *A, int chave);
int RemoveRec(No **pt, int *chave);
elem BuscaMenor(No *pt);
elem BuscaMaior(No *pt);
void PreOrdem(Avl *A);
void EmOrdem(Avl *A);
void PosOrdem(Avl *A);
void PreOrdemRec(No *pt);
void EmOrdemRec(No *pt);
void PosOrdemRec(No *pt);
int Altura(No *pt);
int NumNos(Avl *A);
int NumNosRec(No *pt);
int Bal(Avl *A);
int BalRec(No *pt);
int PerfBal(Avl *A);
int PerfBalRec(No *pt);
void RotEsq(Avl *A);
void RotEsqRec(No **pt);
void RotDir(Avl *A);
void RotDirRec(No **pt);
void RotEsqDir(Avl *A);
void RotEsqDirRec(No **pt);
void RotDirEsq(Avl *A);
void RotDirEsqRec(No **pt);
int ContarFolhas(No *pt);
int Nivel(Avl *A, int chave);
int NivelRec(No *pt, int *chave);
//IMPLEMENTAÇÃO DE ÁRVORE BINÁRIA
/* tipo de dado "árvore";
implementar as suas funções. */
#include <stdio.h>
#include <stdlib.h>
#include "avl.h"
//cria uma árvore vazia
void Criar(Avl *A){
A->raiz = NULL;
}
//verifica se está vazia
int Vazia(Avl *A){
return (A->raiz==NULL);
}
//Libera (destroi) a árvore
void Libera(Avl *A){
LiberaRec(&(A->raiz));
}
void LiberaRec(No **pt){
if(*pt != NULL){
LiberaRec(&((*pt)->esq));
LiberaRec(&((*pt)->dir));
free(*pt);
}
}
//Inserir uma chave
int Insere(Avl *A, elem v){
return(InsereRec(&(A->raiz), &v));
}
int InsereRec(No **pt, elem *v){
No *aux; //variável ponteiro auxiliar
if(*pt == NULL){
aux = (No*)malloc(sizeof(No));
if(aux==NULL) return 0;
else{
aux->info = *v;
aux->esq = aux->dir = NULL;
*pt = aux;
return 1;
}
}
if(v->chave < (*pt)->info.chave)
return(InsereRec(&((*pt)->esq), v));
if(v->chave > (*pt)->info.chave)
return(InsereRec(&((*pt)->dir), v));
else return 0; //Já tem uma chave com o mesmo valor: não insere.
}
// Remoção de um NÓ
int Remove(Avl *A, int chave){
return (RemoveRec(&(A->raiz), &chave));
}
int RemoveRec(No **pt, int *chave){
No *aux;
elem v;
if(*pt==NULL) return 0; //não achou a chave a remover
if(*chave < (*pt)->info.chave)
return(RemoveRec(&((*pt)->esq), chave));
if(*chave > (*pt)->info.chave)
return (RemoveRec(&((*pt)->dir), chave));
//achou a chave remover
//caso 1: NÓ FOLHA
if(!(*pt)->esq && !(*pt)->dir){
free(pt);
*pt = NULL;
}
//caso 2.a: NÓ a remover tem só SAE
else if((*pt)->dir == NULL){
aux = *pt;
*pt = (*pt)->esq;
free(aux);
}
//case 2.b: NÓ a remover tem só SAD
else if((*pt)->esq == NULL){
aux = *pt;
*pt = (*pt)->dir;
free(aux);
}
//caso 3: NÓ a remover tem as SAE e SAD
else{
(*pt)->info = BuscaMenor((*pt)->dir);
*chave = (*pt)->info.chave;
return RemoveRec(&((*pt)->dir), chave);
}
return 1;
}
//Rotação à esquerda
void RotEsq(Avl *A){
RotEsqRec(&(A->raiz));
}
void RotEsqRec(No **pt){
No *b = *pt;
No *a = b->esq;
a->dir = b;
a->fb = 0;
b->fb = 0;
*pt = a;
}
//Rotação à direita
void RotDir(Avl *A){
RotDirRec(&(A->raiz));
}
void RotDirRec(No **pt){
No *a = *pt;
No *b = a->dir;
a->dir = b->esq;
b->esq = a;
a->fb = 0;
b->fb = 0;
*pt = b;
}
//Rotação Esquerda/Direita
void RotEsqDir(Avl *A){
(&(A->raiz));
}
void RotEsqDirRec(No **pt){
No *c = *pt;
No *a = c->esq;
No *b = a->dir;
c->esq = b->dir;
a->dir = b->esq;
b->esq = a;
b->dir = c;
switch(b->fb){
case -1:
a->fb = 0;
c->fb = 1;
break;
case 0:
a->fb = 0;
c->fb = 0;
break;
case 1:
a->fb = -1;
c->fb = 0;
break;
}
b->fb = 0;
*pt = b;
}
//Rotação Direita/Esquerda
void RotDirEsq(Avl *A){
RotDirEsqRec(&(A->raiz));
}
void RotDirEsqRec(No **pt){
No *a = *pt;
No *c = a->dir;
No *b = c->esq;
c->esq = b->dir;
a->dir = b->esq;
b->esq = a;
b->dir = c;
switch(b->fb){
case -1:
a->fb = 0;
c->fb = 1;
break;
case 0:
a->fb = 0;
b->fb = 0;
break;
case 1:
a->fb = -1;
c->fb = 0;
break;
}
b->fb = 0;
*pt = b;
}
//Busca uma chave
No *Busca(Avl *A, int chave){
if(Vazia(A)) return NULL;
else return(BuscaRec(A->raiz, &chave));
}
No *BuscaRec(No *pt, int *chave){
if(pt==NULL) return pt;
if(pt->info.chave == *chave)
return pt;
if(pt->info.chave < *chave)
return(BuscaRec(pt->dir, chave));
else return(BuscaRec(pt->esq, chave));
}
//Retorna o menor valor da árvore
elem BuscaMenor(No *pt){
while(pt->esq != NULL)
pt = pt->esq;
return pt->info;
}
//Retorna o maior valor da árvore
elem BuscaMaior(No *pt){
while(pt->dir != NULL)
pt = pt->dir;
return pt->info;
}
//Exibe em Pre-ordem
void PreOrdem(Avl *A){
PreOrdemRec(A->raiz);
}
void PreOrdemRec(No *pt){
if(pt != NULL){
printf("%d ", pt->info.chave);
PreOrdemRec(pt->esq);
PreOrdemRec(pt->dir);
}
}
//Exibe Em-ordem (E-R-D)
void EmOrdem(Avl *A){
EmOrdemRec(A->raiz);
}
void EmOrdemRec(No *pt){
if(pt != NULL){
EmOrdemRec(pt->esq);
printf("%d ", pt->info.chave);
EmOrdemRec(pt->dir);
}
}
//Exibe em Pos-ordem (E-D-R)
void PosOrdem(Avl *A){
PosOrdemRec(A->raiz);
}
void PosOrdemRec(No *pt){
if(pt != NULL){
PosOrdemRec(pt->esq);
PosOrdemRec(pt->dir);
printf("%d ", pt->info.chave);
}
}
//Mostra a altura da árvore
int Altura(No *pt){
int He, Hd;
if(pt == NULL) return -1; //Altura da árvore vazia é -1.
if(pt != NULL){
He = Altura(pt ->esq);
Hd = Altura(pt->dir);
if(He > Hd) return He+1;
else return Hd+1;
}
}
//Mostra o número de nós
int NumNos(Avl *A){
return(NumNosRec(A->raiz));
}
int NumNosRec(No *pt){
int NumEsq, NumDir;
if(pt == NULL) return 0;
else{
NumEsq = NumNosRec(pt->esq);
NumDir = NumNosRec(pt->dir);
return(NumEsq + NumDir + 1);
}
}
//Verifica se está balanceada
int Bal(Avl *A){
return(BalRec(A->raiz));
}
int BalRec(No *pt){
int DifAlturas;
if(pt != NULL){
if(pt->esq == NULL && pt->dir == NULL) //só tem raiz
return 1; //balanceada
else if(pt->esq != NULL && pt->dir != NULL){ //SAE e SAD não nulas
DifAlturas = Altura(pt->esq) - Altura(pt->dir);
return(BalRec(pt->esq) && BalRec(pt->dir) && ((DifAlturas==0) ||
(DifAlturas==1) || (DifAlturas==-1)));
}
else if(pt->esq != NULL)
return (Altura(pt->esq) == 1);
else return (Altura(pt->dir) == 1);
}
}
//Ver se é Perfeitamente Balanceada (usa a função NumNos)
int PerfBal(Avl *A){
return(PerfBalRec(A->raiz));
}
int PerfBalRec(No *pt){
int DifNumNos;
if(pt != NULL){
if(pt->esq == NULL && pt->dir == NULL) //só tem raiz
return 1; //balanceada
else if(pt->esq != NULL && pt->dir != NULL){ //SAE e SAD não nulas
DifNumNos = NumNosRec(pt->esq) - NumNosRec(pt->dir);
return(PerfBalRec(pt->esq) && PerfBalRec(pt->dir) && ((DifNumNos==0) ||
(DifNumNos==1) || (DifNumNos==-1)));
}
}
return(PerfBalRec(pt->esq) && PerfBalRec(pt->dir));
if(pt->esq != NULL) //tem um único filho à esquerda
return (NumNosRec(pt->esq) == 1);
else return (NumNosRec(pt->dir) == 1);
}
//Retorna o número de NÓS folha
int ContarFolhas(No *pt){
if(pt == NULL)
return 0; //árvore vazia
if(pt->esq == NULL && pt->dir == NULL)
return 1; //A raiz é folha.
else return ContarFolhas(pt->esq) + ContarFolhas (pt->dir);
}
int Nivel(Avl *A, int chave){
return NivelRec(A->raiz, &chave);
}
int NivelRec(No *pt, int *chave){
int nivel = 0;
if(pt == NULL) return nivel;
if(! pt->esq && ! pt->dir)
return nivel;
else{
nivel ++;
return nivel;
}
}
//IMPLEMENTAÇÃO DE ÁRVORE BINÁRIA AVL
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include "avl.h"
int main() {
setlocale(LC_ALL, "Portuguese");
Avl A;
Criar(&A);
int opcao;
elem dado;
do{
system("cls");
printf(" 1 - Árvore vazia. \n");
printf(" 2 - Destruir a árvore. \n");
printf(" 3 - Buscar uma chave. \n");
printf(" 4 - Insere uma chave. \n");
printf(" 5 - Remove um nó. \n");
printf(" 6 - Mostra o menor valor. \n");
printf(" 7 - Mostra o maior valor. \n");
printf(" 8 - Exibe Pré-Ordem. \n");
printf(" 9 - Exibe Em-Ordem. \n");
printf(" 10 - Exibe Pós-Ordem. \n");
printf(" 11 - Balanceada. \n");
printf(" 12 - Perfeitamente balanceada. \n");
printf(" 13 - Rotação à esquerda. \n");
printf(" 14 - Rotação à direita. \n");
printf(" 15 - Rotação esquerda/direita. \n");
printf(" 16 - Rotação direita/esquerda. \n");
printf(" 17 - Número de Nós. \n");
printf(" 18 - Nível do Nó. \n");
printf(" 19 - Sair. \n");
printf("\n Escolha uma opção: ");
scanf("%d ", &opcao);
switch(opcao){
case 1: //Ver se está vazia.
if(Vazia(&A)) printf("\n Está vazia. \n");
else printf(" Não está vazia. \n");
break;
case 2: //Destruir a árvore
Libera(&A);
break;
case 3: //Busca uma chave
printf("\n Digite a chave a ser buscada: ");
scanf("%d ", &dado.chave);
if(Busca(&A, dado.chave))
printf(" Encontrou a chave buscada. \n");
else (" Não encontrou. \n");
break;
case 4: //Insere uma chave
printf("\n Digite a chave a inserir: ");
scanf("%d ", &dado.chave);
if(Insere(&A, dado))
printf("\n Chave inserida. \n");
else printf("\n Não inseriu. \n");
break;
case 5: //Remove o nó
printf("\n Digite a chave a remover: ");
scanf("%d ", &dado.chave);
if(Remove(&A, dado.chave))
printf("\n Removeu. \n");
else printf(" Não removeu. \n");
break;
case 8: //Exibe Pré-Ordem
PreOrdem(&A);
break;
case 9: //Exibe Em-Ordem
EmOrdem(&A);
break;
case 10: //Exibe Pós-Ordem
PosOrdem(&A);
break;
case 11: //Balanceada
if(Bal(&A))
printf("\n Balanceada. \n");
else printf("\n Não está balanceada. \n");
break;
case 12: //Perfeitamente balanceada
if(PerfBal(&A))
printf("\n Perfeitamente balanceada. \n");
else printf(" Não está perfeitamente balanceada. \n");
break;
case 13: //Rotação à esquerda
RotEsq(&A);
break;
case 14: //Rotação à direita
RotDir(&A);
break;
case 15: //Rotação esquerda/direita
RotEsqDir(&A);
break;
case 16: //Rotação direita/esquerda
RotDirEsq(&A);
break;
case 17: //Número de nós
NumNos(&A);
break;
/*case 18: //Nível de um nó.
printf("\n Digite o valor da chave: ");
scanf("%d ", &dado.chave);
if(Nivel(&A)) printf("\n O nível de %d é %d ", dado.chave, nivel);
else printf("\n Não encontrou a chave buscada. ");
*/
case 19: //Encerrar o programa
printf("\n Encerrar a execução. \n");
break;
}
system("pause");
}while(opcao != 18);
return 0;
}