Lista 3 Estrutura de Dados

2) Escreva uma função recursiva para apresentar a soma de todos os números

inteiros pares de
zero até um número informado pelo usuário.
Por exemplo: Para n = 9 a função deve retornar 0 + 2 + 4 + 6 + 8 = 20

#include <stdio.h>
#include <stdlib.h>

int somapar( int n )

{

if ( ( n > 1 ) && !( n % 2 ) )
return n + somapar(n - 1);
if ( ( n > 1 ) && ( n % 2 ) )
return somapar(n - 1);

return 0;
}

int main(void)
{
int n;

printf("Informe um valor:");
scanf("%d", &n);

printf("\nO valor da soma dos números pares de 1 até %d é : %d\n", n, somapar(n)

);

return 0;

4) Escreva um programa que leia e imprima um vetor de inteiros. Em seguida,

chame as
seguintes funções recursivas:
a) Função para calcular e retornar a soma dos elementos no vetor;
b) Função para calcular e retornar o valor mínimo do vetor;
c) Função para calcular e retornar o valor máximo do vetor;
d) Função para calcular e retornar a média dos valores no vetor;
e) Função para imprimir os valores do vetor em ordem inversa (sem trocá-los de
ordem no vetor).

Lista 3 Estrutura de Dados 1

 #include <stdio.h>
#define TAM 100
//soma
int soma(int v[], int ini, int len)
{
if(ini >= len)
return 0;

return (v[ini] + soma(v, ini + 1, len));

}

//val min
int minvet(int v[], int ini, int len)
{
int min;

if(ini >= len-2)

{
if(v[ini] < v[ini + 1])
return v[ini];
else
return v[ini + 1];
}

min = minvet(v, ini + 1, len);

if(v[ini] < min)

return v[ini];
else
return min;
}

//val max
int maxvet(int v[], int ini, int len)
{
int max;
if(ini >= len-2)
{
if(v[ini] > v[ini + 1])
return v[ini];
else
return v[ini + 1];
}

max = maxvet(v, ini + 1, len);

if(v[ini] > max)

return v[ini];
else
return max;
}

//média
float media(int v[], int s)
{
if (s == 1)

Lista 3 Estrutura de Dados 2

 return (float)v[s-1];
else
return ((float)(media(s, s-1)*(s-1) + v[s-1]) / s);
}

//inverte
void imprimirinverso(int v[],int k)
{
int z;
if (k>0)
{
z= k-1;
printf("%d ",v[z]);
imprimirinverso(v,z);
}
return;
}

//

int main(){
int v[TAM];
int N, i, somav, max,min,minvet, maxvet, op;
float med = 0;
float media;

printf("Insira tamanho do vetor: ");

scanf("%d", &N);
printf("Insira elementos do vetor: ");
for(i=0; i<N; i++)
{
scanf("%d", &v[i]);
}
int s = sizeof(v)/sizeof(v[0]);
do{
printf("\n 1-Soma\n 2-Valor mínimo vetor\n 3-Valor máximo do vetor\n 4- Média\n 5-
Imprimir os valores do vetor em ordem inversa\n 6-Sair\n Digite uma das opções: ");

scanf("%d", &op);
switch(op) {
case 1:
somav = soma(v, 0, N);
printf("Sum of array elements: %d", somav);
break;
case 2:
min = minvet(v, 0, TAM);
printf("Maximum element in array: %d\n", min);
break;
case 3:
max = maxvet(v, 0, TAM);
printf("Maximum element in array: %d\n", max);
break;
case 4:
printf("%.2f\n", media(v, s));
break;
case 5:
imprimirinverso(v,N);
break;

Lista 3 Estrutura de Dados 3

 case 6:
printf("Finalizar!! \n");
break;
default:
printf("\nOpção inválida");

}
}while(op!=6);
}

8) Escreva uma função recursiva para retornar o tamanho de uma string (não é para
usar a
função strlen()). Escreva também a chamada da função.

#include <stdio.h>
#include <stdlib.h>

int tamstring(char s[]){

if (s[0] == '\0')
return 0;
return 1+tamstring(&s[1]); }

int main(void){
char s[20];
int t;

printf("\nDigite a string: ");

scanf("%s", s);
printf("\nO tamanho da string é %d", tamstring(s));

return 0;
}

12) Escreva uma função recursiva que recebe um número n e retorne a soma dos
dígitos do
número.

#include <stdio.h>

int soma(int numero){

if (numero % 10 == numero)
return numero;
return ((numero % 10) + soma(numero / 10));
}

int main()
{
int n;
printf("Informe um número: ");

Lista 3 Estrutura de Dados 4

 scanf("%d", &n);
printf("\nA soma dos digiots é %d", soma(n));

return 0;
}

13) Escreva uma função recursiva recebe um número inteiro n > 0, conta e retorna o
número de
dígitos pares do número.

#include <stdio.h>

int Pares(int n){

if (n == 0)
return 0;
if (n % 2 != 0)
return Pares(n / 10);
return Pares(n / 10) * 10 + n % 10;
}

int main(){
int n;
printf("Informe um número: ");
scanf("%d", &n);
printf("\nA soma dos digitos é %d", Pares(n));

return 0;

14) Escreva uma função recursiva que calcule e retorne a soma dos elementos
positivos do
vetor de inteiros.

#include <stdio.h>
#define TAM 100

int soma(int v[], int ini, int len)

{
if(ini >= len)
return 0;
if(ini>=0)
return v[ini] + soma(v, ini + 1, len);
}

int main()
{
int v[TAM];
int n, i, somav;

Lista 3 Estrutura de Dados 5

 /* Input size and elements in array */
printf("Enter size of the array: ");
scanf("%d", &n);
printf("Enter elements in the array: ");
for(i=0; i<n; i++)
{
scanf("%d", &v[i]);
}
somav = soma(v,0,n);
printf("soma of array elements: %d", somav);

return 0;
}

20) Escreva uma função recursiva para contar o número de caracteres maiúsculos
que a string
possui.

#include<stdio.h>
#include<string.h>

int maiusculo(char str[],int i){

static int n=0;
if(str[i]>='A' && str[i]<='Z')
n++;
if(i>=0)
maiusculo(str, i-1);
return n;
}

int main(){

char str[30];
printf("Informe sua string:");
scanf("%[^\n]",str);
int letrasm=maiusculo(str,strlen(str)-1);
if(letrasm==0)
printf("Não tem letras maiúsculas.");
else
printf("O número de letras maiúsculas é:%d",letrasm);
}

21) Escreva uma função recursiva para testar se um número é primo.

#include<stdio.h>

int ePrimo(int n, int i)

{
if(i == 1)
return 1;

Lista 3 Estrutura de Dados 6

 else
{
if(n%i == 0)
return 0;
else
ePrimo(n, i-1);
}
}

int main()
{
int num, primo;
printf("Informe um número: ");
scanf("%d", &num);
primo = ePrimo(num, num/2);
if(primo == 1)
{
printf("\n\n%d é primo.\n\n", num);
}
else
{
printf("\n\n%d não é primo.\n\n", num);
}
return 0;
}

22) Considere a função abaixo:

int eureka(int a){

if ( a <= 0 )
return 0;
else
return (a + eureka(a-1));
}

a) O que essa função faz? Explique com um exemplo.

A função faz um somatório. Ex: a=4, eureka=1+2+3+4=10

b) Calcule a sua ordem de complexidade. Mostre como você chegou a esse

resultado.

T (1) = 1
T (n) = 1 + T (n − 1)

Lista 3 Estrutura de Dados 7

 T (n) = 1 + T (n − 1)
T (n) = 1 + (1 + T (n − 2))
T (n) = 2 + T (n − 2)
T (n) = 2 + (1 + T (n − 3))
T (n)3 + T (n − 3)

T (n) = k − T (n − k)

T (n) = n − 1 − T (n − (n − 1))
T (n) = n − 1 − T (1)
T (n) = n − 1 + 1

A complexidade é O(n)

c) Escreva uma função não-recursiva que resolve o mesmo problema. Qual é a

ordem de
complexidade da sua função? Explique.

int somatorio(int n){

int som, i;
som = 0;
i = 1;

while (i <= n){

som = som + i * (i + 1);
i = i + 1;
}

return 0;
}

d) Qual implementação é mais eficiente? Justifique.

A recursiva, pois reduz o tamanho do código e torna mais fácil

de chamar a função ao longo do código

26) Faça uma função recursiva que retorne a quantidade de nós de uma árvore
binária de busca
que possuem apenas um filho.

int conta_pais(No* t) {
if (t == NULL ||
(t->esq == NULL && t->dir == NULL)

Lista 3 Estrutura de Dados 8

 return 0;
return 1 + conta_pais(t->esq) + conta_pais(t->dir);
}

31) Escreva um programa para manipular Árvore Binária de Busca (ABB) com n
(lido via
teclado) números inteiros que contenha o seguinte menu de opções:
1- Inserir um nó na ABB
2- Imprimir a ABB
I- Inoder
P- Preorder
O- Postorder
S- Sair
3- Buscar uma chave na ABB
4- Mostrar a altura da ABB
5- Mostrar a quantidade de nós da ABB
6- Mostrar a quantidade de folhas da ABB
7- Mostrar a quantidade de pais da ABB
8- Mostrar a maior chave da ABB
9- Mostrar a menor chave da ABB
10- Remover um nó da ABB
11- Sair
Para as opções 1 a 9 crie uma função recursiva para resolver cada item.
Na opção 10, crie uma função não recursiva. Mostre a árvore resultante após a
remoção do
nó.
Na opção 2, mostre o menu com as opções de caminhamentos para o usuário.
Na opção 11, mostre uma mensagem. O menu acaba quando o usuário escolher a
opção 11.

#include <stdio.h>
#include <stdlib.h>

struct tree{
struct tree *esq;
int chave;
struct tree *dir;
};

//inserir nó
struct tree *insereABB(struct tree *raiz, int valor){
if (raiz==NULL) {

Lista 3 Estrutura de Dados 9

 raiz = (struct tree*)malloc(sizeof(struct tree));
raiz->info = valor;
raiz->esq = raiz->dir = NULL;
}
else if (v < raiz->info)
raiz->esq = insereABB(raiz->esq,valor);
else
raiz->dir = insereABB(raiz->dir,valor);
return raiz;
}

//imprimir abb
//Inorder
void inorder(struct tree *raiz){

if(raiz != NULL)
{
inorder(raiz -> esq);
printf(“%d \t”, raiz -> chave);

inorder(raiz -> dir);

}
}

//Preorder
void preorder(struct tree *raiz){

if(raiz != NULL){
printf(“%d \t”, raiz -> chave);
preorder(raiz -> esq);
preorder(raiz -> dir);
}
}

//Postorder
void postorder(struct tree *raiz){

if(raiz != NULL){

postorder(raiz -> esq);

postorder(raiz -> dir);
printf(“%d \t”, raiz -> chave);
}
}
//buscar chave
struct tree *busca (struct tree *raiz, int valor){
if (raiz == NULL)
return NULL;
else if (raiz->info > valor)
return busca (raiz->esq, valor);
else if (raiz->info < valor)
return busca (raiz->dir, valor);
else return raiz;
}

//altura
int altura(struct tree *raiz){
int e, d;

Lista 3 Estrutura de Dados 10

 if(!raiz)
return 0;
e=1+altura(raiz -> esq);
d=1+altura(raiz -> dir);
return (e >= d ? e : d);
}

//quantidade de ní
int contaNos(struct tree *raiz){
if(!raiz)
return 0;
return (1+contaNos(raiz->esq)+contaNos(raiz->dir));
}

//quantidade de folha
int contaFolhas(struct tree *raiz){
if(!raiz)
return 0;
if(!raiz->esq && !raiz->dir)
return 1;
return (contaFolhas(raiz->esq) + contaFolhas(raiz->dir);
}

//quantidade de pais
int conta_pais(No* t) {
if (t == NULL ||
(t->esq == NULL && t->dir == NULL)
return 0;
return 1 + conta_pais(t->esq) + conta_pais(t->dir);
}

//mairo chave

//menor chave

//remover nó
void removeABB(struct tree *raiz, int x){
struct tree *p, *q, *rp, *f, *s;
q=NULL;
p=raiz;
while(p && x!=p -> chave){
q=p;
p=(x<p->chave) ? P -> esq : p->dir;
}
if(!p)
return;
if(!p->esq)
rp=p->dir;
else{
if(!p->dir)
rp=p->esq;
else{
f=p;
rp=p->dir;
s=rp->esq;
while(s){

Lista 3 Estrutura de Dados 11

 f=rp;
rp=s;
s=r->esq;
}
if(f!=p)
{
f->esq=rp->dir;
rp->dir=p->dir;
}
rp->esq=p->esq;
}
}
if(!q)
raiz=rp;
else
(p==q->esq) ? (q->esq=np):(q->dir=rp);
free(p);
}

int main(){
int N, i, op, op2;

do{
printf("\n 1-Inserir um nó na ABB\n 2-Imprimir a ABB\n 3-Buscar uma chave na ABB\n
4- Mostrar a altura da ABB\n 5- Mostrar a quantidade de nós da ABB\n 6- Mostrar a qua
ntidade de folhas da ABB\n 7- Mostrar a quantidade de pais da ABB\n 8- Mostrar a maior
chave da ABB\n 9- Mostrar a menor chave da ABB\n 10- Remover um nó da ABB\n 11-Sair\n
Digite uma das opções: ");

scanf("%d", &op);
switch(op) {
case 1:
printf("Insira o valor: ");
scanf("%d", &v);
insereABB(v);
break;
case 2:
do{
printf("\n I- Inoder\n P- Preorder\n O- Postorder\n S- Sair \n Digite
uma das opções: ");
scanf("%d", &op2);
switch(op2) {
case 1:
inorder();
break;
case 2:
preorder();
break;
case 3:
postorder();
break;
case 4:
printf("Finalizar!! \n");
break;
}while(op2!=4);
break;
case 3:

Lista 3 Estrutura de Dados 12

 printf("Infomer a chave: ");
scanf("%d", &c);
busca(c);
break;
case 4:
altura();
break;
case 5:
contaNos();
break;
case 6:
contaFolhas();
break;
case 7:
conta_pais();
break;
case 8:
maiorChave();
break;
case 9:
menor_chave();
break;
case 10:
printf("Insira a chave: ");
scanf("%d", &c);
removeABB(c);
break;
case 11:
printf("Finalizar!! \n");
break;
default:
printf("\nOpção inválida");

}
}while(op!=11);
}

43) Escreva uma função recursiva que retorna o número de nós numa árvore binária
cujos
valores das chaves são múltiplos de três.

struct tree{
struct tree *esq;
int chave;
struct tree *dir;
};

int contaNos(struct tree *raiz){

if(!raiz)
return 0;
return (1+contaNos(raiz->esq)+contaNos(raiz->dir));
}

Lista 3 Estrutura de Dados 13

Lista 3 Estrutura de Dados 14