Exercícios programa em C

Prévia do material em texto

1) Conte o número de passos e dê a complexidade (pior caso) dos trechos de código abaixo:
(a) int soma= 0; 1
for(i=0; i<=n; i++ ) n+1+1
soma++; n+1
Passos: 1+n+1+1+n+1=2n+4
(b) int soma= 0; 1
for(i=1; i<n-1; i++ ) n-1
soma++; n-2
Passos: 1+n-1+n-2= 2n-2
(c) int soma = 0; 1
for( i=0; i< n; i++ ) n+1
for( j=1; j< n; j++ ) n*n
soma++; (n-1)*n
Passos: 1+n+1+n*n+(n-1)*n== 2n²+2
(d) int soma = 0; 1
for( i=0; i<=n; i++ ) n+2
for( j=1; j<= n; j++ ) (n+1)*(n+1)
soma++; n*(n+1)
Passos: 1+n+2+(n+1)²+n(n+1)= 2n²+4n+4
(e) int soma = 0; 1
for( i=0; i<= n*n; i++ )(n²+2)
for( j=0; j< n*n; j++ )(n²+1)*(n²+1)
soma++;(n²+1)(n²)
Passos: 1 + (n²+2) + (n²+2)*(n²+1) + (n²+1)(n²) = =2n4+5n2+5
(f) int soma = 0; 1
for( i=0; i < n-1; i++ ) n
for( j=1; j < n; j++ ) (n-1)*n
soma++; (n-1)²
Passos: 1+n+(n-1)*n+(n-1)² = 2n²−2n+2
(g) Considere a, b e prod matrizes quadradas n x n.
for ( i = 0; i < n; i++) n+1
{
for ( j=1; j < n; j++) n*n
{
prod[i][j] = 0; n*(n-1)
for ( k = 2; k < n; k++) n*(n-1)*(n-1)
prod[i][j] = prod[i][j] + a[i][k] * b[k][j]; n*(n-1)*(n-2)
}
}
Passos: n+1 + n*n + n*(n-1) + n*(n-1)*(n-1) + n*(n-1)*(n-2) = 2n³−3n²+3n+1
(h) void faz_algo1( int n)
{
int i, j, k;
for ( i = 1; i <= n; i ++) n+1
for (j =2; j <= n; j++) n*n
for (k =3; k <= n ; k++) n*(n-1)*(n-1)
comando X; n*(n-1)*(n-2)
}
Passos: n+1+n*n+n*(n-1)*(n-1)+n*(n-1)*(n-2) = 2n³-4n²+4n+1
(i) void conta( int n)
{
int i, j, k;
for ( i = 0; i <= n; i ++) n+2
{
for (j = 0; j <= n; j++) (n-1)*(n+2)
comando X; (n+1)*(n+1)
for (k= 1; k <= n; k++) (n+1)*(n+1)
comando Y; (n+1)*n
}
}
Passos: n+2+(n-1)*(n+2)+(n+1)*(n+1)+ (n+1)*(n+1)+(n+1)*n = 4n²+7n+2
(j) for (i = 0; i <= n; i++) n+2
{
j = 1; n+1
while (j < 2*n) (n+1)*(2n)
j = j + 1; (n+1)*(2n-1)
}
Passos: n+2+n+1+(n+1)*2n+(n+1)(2n-1) = 4n²+5n+2
3) Faça um programa, usando a estrutura de dados pilha, que converta um número decimal para
binário.
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#define TAM 10
struct tpilha
{
int topo;
int pilha[TAM];
};
void inicializaPilha (struct tpilha *ps)
{
ps->topo = -1;
}
int pilhaVazia (struct tpilha *ps)
{
if(ps->topo == -1)
return 1;
return 0;
}
int pilhaCheia(struct tpilha *ps)
{
if(ps->topo==TAM-1)
return 1;
return 0;
}
int empilha(struct tpilha *ps, int valor)
{
if(pilhaCheia(ps))
return 0;
ps->topo++;
ps -> pilha[ps -> topo] = valor;
return 1;
}
void desempilha(struct tpilha *ps, int *elem)
{
if (pilhaVazia(ps))
return;
*elem=ps -> pilha[ps->topo];
ps->topo--;
}
int main()
{
struct tpilha p1,p2;
int n, i, aux;
inicializaPilha(&p1);
inicializaPilha(&p2);
printf("\nDigite um número inteiro até 1000 que esteja no sistema decimal: ");
scanf("%d", &n);
for(i=0; i<TAM; i++)
{
aux = n%2;
empilha(&p1, aux);
n=n/2;
}
for(i=0; i<TAM; i++)
{
desempilha(&p1, &aux);
empilha(&p2, aux);
}
printf("\n O número em binário fica: \n\n");
for(i=0; i < TAM; i++)
printf("%d", p2.pilha[i]);
}


7) Escreva um programa que leia 30 números inteiros e insira-os numa fila f1. Imprima a fila f1.
Logo após, inverta o conteúdo de f1 nela mesma utilizando uma pilha auxiliar. Imprima a fila f1
invertida.
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#define TAM 30
//COMANDOS FILA
struct tfila{
int F, R;
int fila[TAM];
};
void inicializaFila(struct tfila *pf) {
pf->F=0;
pf->R=-1;
}
int filaVazia(struct tfila *pf) {
if(pf->F > pf->R)
return 1;
return 0;
}
int filaCheia(struct tfila *pf){
if(pf -> R == TAM-1)
return 1;
return 0;
}
int insereFila(struct tfila *pf, int valor){
if(filaCheia(pf))
return 0;
pf->fila[++pf->R]=valor;
return 1;
}
int removeFila(struct tfila *pf){
int y;
if(filaVazia(pf))
return 0;
y = pf->fila[pf->F++];
return y;
};
//COMANDOS PILHA
struct tpilha
{
int topo;
int pilha[TAM];
};
void inicializaPilha (struct tpilha *ps)
{
ps->topo = -1;
}
int pilhaVazia (struct tpilha *ps)
{
if(ps->topo == -1)
return 1;
return 0;
}
int pilhaCheia(struct tpilha *ps)
{
if(ps->topo==TAM-1)
return 1;
return 0;
}
int empilha(struct tpilha *ps, int valor)
{
if(pilhaCheia(ps))
return 0;
ps->topo++;
ps -> pilha[ps -> topo] = valor;
return 1;
}
int desempilha(struct tpilha *p){
int x;
if(pilhaVazia(p))
return 0;
x = p->pilha[p->topo--];
return x;
}
//COMANDOS GERAIS DO PROBLEMA
int main() {
struct tpilha p1;
struct tfila f1;
int i, aux;
inicializaFila(&f1);
for(i=0; i<TAM;i ++) {
printf("\nDigite um valor: ");
scanf("%d", &aux);
insereFila(&f1, aux);
}
printf("\n A fila informada é: \n");
for(i=0; i<TAM; i++){
printf("%d\t", f1.fila[i]);
}
inicializaPilha(&p1);
for(i=0; i<TAM; i++){
empilha(&p1, removeFila(&f1));
}
inicializaFila(&f1);
for(i=0; i<TAM; i++){
insereFila(&f1, desempilha(&p1));
}
printf("\n\nA fila invertida é:\n ");
for(i=0; i<TAM; i++){
printf("%d\t", f1.fila[i]);
}
}
8) Escreva um programa que empilhe uma sequência de números inteiros positivos até o
momento em que for digitado o valor zero. A pilha tem tamanho máximo 50. Neste momento, o
conteúdo da pilha deverá ser distribuído em outras duas pilhas. Uma delas conterá apenas os
valores ímpares e a outra conterá apenas os valores pares. Imprima o conteúdo das duas pilhas.
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#define TAM 50
struct tpilha
{
int topo;
int pilha[TAM];
};
void inicializaPilha (struct tpilha *ps){
ps->topo = -1;
}
int pilhaVazia (struct tpilha *ps){
if(ps->topo == -1)
return 1;
return 0;
}
int pilhaCheia(struct tpilha *ps){
if(ps->topo==TAM-1)
return 1;
return 0;
}
int empilha(struct tpilha *ps, int valor){
if(pilhaCheia(ps))
return 0;
ps->topo++;
ps -> pilha[ps -> topo] = valor;
return 1;
}
void desempilha(struct tpilha *ps, int *elem){
if (pilhaVazia(ps))
return;
*elem=ps -> pilha[ps->topo];
ps->topo--;
}
int main()
{
struct tpilha p1,p2,p3;
int j, i, a, b, aux;
inicializaPilha(&p1);
inicializaPilha(&p2);
inicializaPilha(&p3);
aux =1;
i=0;
a=0;
b=0;
while(aux != 0)
{
printf("\nDigite um número positivo e não nulo: ");
scanf("%d", &aux);
if(aux > 0)
{
empilha(&p1, aux);
if((aux%2)==0){
empilha(&p2, aux);
a=a+1;
}
else{
empilha(&p3, aux);
b=b+1;
}
i=i+1;
}
if (i==TAM) break;
}
printf("\n\n Lista:\n\n");
for(j=0; j <i; j++)
printf("%d\t", p1.pilha[j]);
printf("\n\n Números pares\n\n");
for(j=0; j <a; j++)
printf("%d\t", p2.pilha[j]);
printf("\n\n Números ímpares \n\n");
for(j=0; j <b; j++)
printf("%d\t", p3.pilha[j]);
}
10) Escreva um programa que leia 20 valores inteiros e insira-os numa pilha. Em seguida, leia um
número 20 valores inteiros e insira-os numa fila circular com contador. Logo após, forneça o maior,
o menor e a média aritmética dos elementos na pilha e na fila, respectivamente.
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#define TAM 20
//COMANDOS PILHA
struct tpilha {
int topo;
int pilha[TAM];
};
void inicializaPilha (struct tpilha *ps){
ps->topo = -1;
}
int pilhaVazia (struct tpilha *ps){
if(ps->topo == -1)
return 1;
return 0;
}
int pilhaCheia(struct tpilha *ps){
if(ps->topo==TAM-1)
return 1;
return 0;
}
int empilha(struct tpilha *ps, int valor){
if(pilhaCheia(ps))
return 0;
ps->topo++;
ps -> pilha[ps -> topo] = valor;
return 1;
}
void desempilha(struct tpilha *ps, int *elem){
if (pilhaVazia(ps))
return;
*elem=ps -> pilha[ps->topo];
ps->topo--;
}
//COMANDOS FILA CIRCULAR
struct tfilaC{
int ini;
int fim;
int cont;
int fila[TAM];
};
void inicializaFilaC(struct tfilaC *pf) {
pf->ini=0;
pf->fim=-1;
pf->cont=0;
}
int filaCvazia(struct tfilaC *pf){
if(pf -> cont == 0)
return 1;
return 0;
}
int filaCcheia(struct tfilaC *pf){
if(pf->cont == TAM)
return 1;
return 0;
}
int insereFilaC(struct tfilaC *pf, int valor){
if(filaCcheia(pf))
return 0;
pf -> cont++;
pf -> fim = (pf -> fim == TAM-1) ? 0 : pf ->fim+1;
pf -> fila[pf -> fim] = valor;
return 1;
}
int removeFilaC(struct tfilaC *pf, int *elem){
if(filaCvazia(pf))
return 0;
pf->cont--;
*elem=pf->fila[pf->ini];
pf -> ini = (pf ->ini==TAM-1) ? 0 : pf->ini+1;
return 1;
}
int main()
{
struct tpilha p1;
struct tfilaC f1;
int maiorp=0, menorp=0, mediap=0, maiorf=0,menorf=0, mediaf=0, i, aux;
printf("\nConstrução da Pilha: \n");
inicializaPilha(&p1);
for(i=0; i<TAM; i++)
{
printf("\nDigite um número: ");
scanf("%d", &aux);
empilha(&p1, aux);
if(maiorp<aux) maiorp = aux;
if(menorp>aux) menorp = aux;
mediap=mediap+aux;
}
mediap=mediap/TAM;
printf("\n\nConstrução da Fila: \n");
inicializaFilaC(&f1);
for(i=0; i<TAM;i ++) {
printf("\nDigite um numero: ");
scanf("%d", &aux);
insereFilaC(&f1, aux);
if(maiorf<aux) maiorf = aux;
if(menorf>aux) menorf = aux;
mediaf=mediaf+aux;
}
mediaf=mediaf/TAM;
printf("\n\n Os números da pilha são ");
for(i=0; i < TAM; i++) printf("%d\t", p1.pilha[i]);
printf("\n O Maior número é: ");
printf("%d", maiorp);
printf("\n O menor número é ");
printf("%d", menorp);
printf("\n A média é ");
printf("%d", mediap);
printf("\n\n Os números da fila são ");
for(i=0; i<TAM; i++) printf("%d\t", f1.fila[i]);
printf("\n O Maior número é ");
printf("%d", maiorf);
printf("\n O menor número é ");
printf("%d", menorf);
printf("\n A média é ");
printf("%d", mediaf); }
11) Desenvolva um programa que leia duas filas f1 e f2 circulares com nó bobo com 10 números
reais cada uma. Imprima as filas. Em seguida, chame uma função para testar se as filas f1 e f2
são iguais, ou seja, se possuem os mesmos elementos, na mesma ordem.
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#define TAM 11
//COMANDOS FILA CIRCULAR
struct tfilaC {
int R, F;
float fila[TAM];
};
void inicializaFilaC (struct tfilaC *pf) {
pf->R=0;
pf->F=0;
}
int filaCcheia (struct tfilaC *pf){
if((pf -> R+1)%TAM == pf->F)
return 1;
return 0;
}
int filaCvazia (struct tfilaC *pf) {
if(pf ->R == pf->F)
return 1;
return 0;
}
int insereFilaC (struct tfilaC *pf, int valor) {
if(filaCcheia(pf))
return 0;
pf->R=(pf->R+1)%TAM;
pf->fila[pf ->R] = valor;
return 1;
}
int removeFilaC (struct tfilaC *pf, int *elem){
if(filaCvazia(pf))
return 0;
pf -> F = (pf->F+1)%TAM;
*elem = pf->fila[pf->F];
return 1;
}
void ordem (struct tfilaC *pf1,struct tfilaC *pf2)
{
int i, j;
j=0;
for(i=0; i<TAM;i ++) {
if (pf1->fila[i] == pf2->fila[i]) {
j=1;
}
}
if (j == 1) printf("\n\n Filas são iguais");
else printf("\n\n Filas são diferentes.");
}
int main()
{
struct tfilaC f1, f2;
int i;
float aux;
printf("\n\nConstrução da Fila 1: \n");
inicializaFilaC(&f1);
for(i=1; i<TAM;i ++) {
printf("\nDigite um numero: ");
scanf("%f", &aux);
insereFilaC(&f1, aux);
}
printf("\n\nConstrução da Fila 2: \n");
inicializaFilaC(&f2);
for(i=1; i<TAM;i++) {
printf("\nDigite um numero: ");
scanf("%f", &aux);
insereFilaC(&f2, aux);
}
printf("\n\n Os números da fila 1 são ");
for(i=f1.F+1; i<=f1.R; i++) {printf("\t%f\t", f1.fila[i]);}
printf("\n\n Os números da fila 2 são ");
for(i=f2.F+1; i<=f2.R; i++) {printf("\t%f\t", f2.fila[i]);}
ordem (&f1, &f2);
}
13) Escreva um programa que contenha uma estrutura de lista sequencial não ordenada com
dados de 40 alunos (nome, matricula e média) e forneça as seguintes opções:
1) Inserir um aluno na lista; (ler nome, matricula e média)
2) Excluir um aluno da lista;
3) Calcular média da turma;
4) Imprimir os dados dos alunos acima da média;
5) Imprimir lista;
6) Sair.
O programa termina quando for digitado a opção 6.
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define TAM 40
struct tno{
int matricula;
float media;
char nome[60];
};
struct tlista{
int qtnos;
struct tno lista[TAM];
};
void inicializa_lista(struct tlista *pl){
pl -> qtnos = 0;
}
int lista_vazia(struct tlista *pl) {
if(pl -> qtnos == 0)
return 1;
return 0;
}
int lista_cheia(struct tlista *pl) {
if(pl -> qtnos == TAM)
return 1;
return 0;
}
void percurso(struct tlista *pl){
int i;
for(i=0; i< pl->qtnos; i++)
printf("\n Nome: %s\n Matricula: %d\n Media: %.2f\n\n", pl->lista[i].nome, pl->lista[i].matricula,
pl->lista[i].media);
}
int buscamat(struct tlista *pl, int mat)
{
int i;
for(i=0; i<pl->qtnos; i++){
if(mat == pl -> lista[i].matricula) return i;
}
return -1;
}
int insere_lista(struct tlista *pl, int mat, float media, char nome[]){
int i;
if(lista_cheia(pl))
return 0;
i= buscamat(pl, mat);
if(i>=0) return -1;
pl->lista[pl->qtnos].matricula=mat;
pl->lista[pl->qtnos].media=media;
strcpy(pl->lista[pl->qtnos].nome, nome);
pl-> qtnos++;
return 1;
}
int remove_lista(struct tlista *pl, int mat) {
int i;
if(lista_vazia(pl)) return 0;
i = buscamat(pl, mat);
if(i<0) return -1;
pl->qtnos--;
pl->lista[i].matricula=pl->lista[pl->qtnos].matricula;
pl->lista[i].media=pl->lista[pl->qtnos].media;
strcpy(pl->lista[i].nome, pl->lista[pl->qtnos].nome);
return 1;
}
int main()
{
int j, mat, i, k, l;
float med, medT;
char nome[60];
struct tlista l1;
k=0;
l=0;
inicializa_lista(&l1);
do{
printf("\n Digite uma das opções:\n1-Inserir nome na lista\n2-Remover um elemento na
lista\n3-Calcular média da turma \n4-Dados dos alunos acima da média da turma\n5-Imprimir
lista\n6-Sair\n ");
scanf("%d", &j);
switch(j) {
case 1:
if(l==TAM-1) printf("\nLista com o máximo de informação suportada");
else{
printf("\nPor favor, informe os dados do aluno:");
fgetc(stdin);
printf("\nDigite o nome: ");
gets(nome);
printf("\nDigite a matricula: ");
scanf("%d", &mat);
printf("\nDigite a média: ");
scanf("%f", &med);
insere_lista(&l1, mat, med, nome);
l++;
}
break;
case 2:
printf("Digite a matricula a ser removida: ");
scanf("%d", &mat);
i = remove_lista(&l1, mat);
if(i>0) {
printf("Elemento Removido. \n");
l--;
}
else printf("Elemento não encontrado ou listavazia. \n");
break;
case 3:
if(l==0)printf("Elemento não encontrado ou listavazia. \n");
else{
medT=0;
for(i=0;i<=l;i++)
{
medT=medT+l1.lista[i].media;
}
medT=medT/l;
printf("A media da turma foi de: %.2f\n",medT);
}
break;
case 4:
if(l==0)printf("Elemento não encontrado ou listavazia. \n");
else{
medT=0;
for(i=0;i<=l;i++){
medT=medT+l1.lista[i].media;
}
medT=medT/l;
for(i=0;i<=l;i++){
if(medT< l1.lista[i].media) {
k=1;
printf("\n Nome: %s\n Matricula: %d\n Media: %.2f\n\n",
l1.lista[i].nome,l1.lista[i].matricula, l1.lista[i].media);
}
}
if(k==0)printf("\nNenhum aluno acima da média da turma.\n");
}
break;
case 5:
percurso(&l1);
break;
case 6:
printf("Finalizar!! \n");
break;
default:
printf("\nOpção inválida");
}
}while(j!=6);
}
14) Dada uma estrutura com nome, conta corrente e saldo de 15 clientes de um banco. Criar um
programa, usando lista sequencial ordenada, com opções para
1- Inserir uma conta corrente,
2- Buscar uma conta corrente,
3- Remover uma conta corrente,
4- Imprimir a lista e
5- Sair.
Na busca mostrar o nome e o saldo. Use o número da conta como chave de ordenação da lista.
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define TAM 15
struct tno {
int conta;
float saldo;
char nome[60];
};
struct tlista{
int qtnos;
struct tno lista[TAM];
};
void inicializa_lista(struct tlista *pl){
pl -> qtnos = 0;
}
int lista_vazia(struct tlista *pl) {
if(pl -> qtnos == 0)
return 1;
return 0;
}
int lista_cheia(struct tlista *pl) {
if(pl -> qtnos == TAM)
return 1;
return 0;
}
void percurso(struct tlista *pl){
int i;
for(i=0; i< pl->qtnos; i++)
printf("\n Nome: %s\n Conta: %d\n Saldo: %.2f\n\n", pl->lista[i].nome, pl->lista[i].conta,
pl->lista[i].saldo);
}
int buscaseq(struct tlista *pl, int conta, int *pos)
{
int i;
for(i=0; i < pl -> qtnos && conta > pl -> lista[i].conta; i++);
*pos=i;
if((i == pl -> qtnos) || (conta != pl -> lista[i].conta))
return 0; //não achou
return 1; //achou
}
int buscabinaria(struct tlista *pl, int conta)
{
int ini=0, fim=pl -> qtnos-1, meio;
while(ini <= fim) {
meio= (ini+fim)/2;
if(conta == pl -> lista[meio].conta)
return(meio); //achou
if(conta > pl -> lista[meio].conta)
ini=meio+1;
else
fim=meio-1;
}
return -1; //não achou
}
int insereOrd(struct tlista *pl, int conta, float saldo,char nome[])
{
int i, posicao;
if(pl -> qtnos == TAM)
return 0;
if(buscaseq(pl, conta, &posicao))
return -1;
for(i=pl -> qtnos; i>posicao; i--){
pl -> lista[i].conta = pl->lista[i-1].conta;//e o saldo e o nome???
pl -> lista[posicao].conta = conta;
pl->lista[pl->qtnos].saldo=saldo;
strcpy(pl->lista[pl->qtnos].nome, nome);
pl->qtnos++;
}
return 1;
}
int removeOrd(struct tlista *pl, int conta)
{
int i, posicao;
if(pl->qtnos==0)
return 0;
if(!buscaseq(pl, conta, &posicao))
return -1;
for(i=posicao; i< pl ->qtnos-1; i++){
pl -> lista[i].conta = pl->lista[i+1].conta;
pl->lista[i].saldo=pl->lista[pl->qtnos].saldo;
strcpy(pl->lista[i].nome, pl->lista[pl->qtnos].nome);
}
pl->qtnos--;
return 1;
}
int main (){
int j, conta, i, k, l;
float saldo;
char nome[60];
struct tlista l1;
k=0;
l=0;
inicializa_lista(&l1);
do{
printf("\n Digite uma das opções:\n1- Inserir uma conta corrente\n2- Buscar uma conta
corrente\n3- Remover uma conta corrente\n4- Imprimir a lista\n5- Sair\n ");
scanf("%d", &j);
switch(j) {
case 1:
if(l==TAM-1) printf("\nLista com o máximo de informação suportada");
else{
printf("\nPor favor, informe os dados do cliente:");
fgetc(stdin);
printf("\nDigite o nome: ");
gets(nome);
printf("\nDigite a conta: ");
scanf("%d", &conta);
printf("\nDigite o saldo: ");
scanf("%f", &saldo);
insereOrd(&l1, conta, saldo, nome);
l++;
}
break;
case 2:
printf("\nDigite a conta a ser buscada: ");
scanf("%d", &conta);
i = buscabinaria(&l1, conta);
if(i>=0)
printf("Conta Encontrada! \n");
else
printf("Conta não Encontrada! \n");
break;
case 3:
printf("Digite a conta a ser removida: ");
scanf("%d", &conta);
i = removeOrd(&l1, conta);
if(i>0) {
printf("Elemento Removido. \n");
l--;
}
else printf("Elemento não encontrado ou listavazia. \n");
break;
case 4:
percurso(&l1);
break;
case 5:
printf("Finalizar!! \n");
break;
default:
printf("\nOpção inválida");
}
}while(j!=5);
}
17) Faça um programa que:
a) Crie uma estrutura de fila sequencial de números inteiros de tamanho 20;
b) Exiba o seguinte menu de opções:
-------- --------- EDITOR DE FILA---------------------
1 – INSERIR UM ELEMENTO NA FILA
2 – REMOVER UM ELEMENTO DA FILA
3 – EXIBIR PRIMEIRO ELEMENTO DA FILA
4 – EXIBIR A FILA
5 – ESVAZIAR A FILA
6- SAIR
DIGITE SUA OPÇÃO:
c) Leia a opção do usuário;
d) Execute a opção escolhida pelo usuário através da chamada de função, exceto a opção 6;
e) Após a execução de cada opção, o programa deve retornar ao menu para nova opção do
usuário até que o usuário escolha a opção 6.
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define TAM 5
struct tno {
int num;
};
struct tlista{
int qtnos;
struct tno lista[TAM];
};
void inicializa_lista(struct tlista *pl){
pl -> qtnos = 0;
}
int lista_vazia(struct tlista *pl) {
if(pl -> qtnos == 0)
return 1;
return 0;
}
int lista_cheia(struct tlista *pl) {
if(pl -> qtnos == TAM)
return 1;
return 0;
}
void percurso(struct tlista *pl, int j){
int i;
if(j==4){
printf("\nA lista é formada por:\t");
for(i=0; i< pl->qtnos; i++)
printf("%d\t", pl->lista[i].num);
}
else printf("\nO primeiro número é: %d\n\n", pl->lista[0].num);
printf ("\n\n");
}
int buscaseq(struct tlista *pl, int num, int *pos)
{
int i;
for(i=0; i < pl -> qtnos && num > pl -> lista[i].num; i++);
*pos=i;
if((i == pl -> qtnos) || (num != pl -> lista[i].num))
return 0; //não achou
return 1; //achou
}
int buscabinaria(struct tlista *pl, int num)
{
int ini=0, fim=pl -> qtnos-1, meio;
while(ini <= fim) {
meio= (ini+fim)/2;
if(num == pl -> lista[meio].num)
return(meio); //achou
if(num > pl -> lista[meio].num)
ini=meio+1;
else
fim=meio-1;
}
return -1; //não achou
}
int insereOrd(struct tlista *pl)
{
int i, posicao,num;
printf("\nPor favor, informe um número inteiro: ");
scanf("%d", &num);
if(pl -> qtnos == TAM){
printf("\nLista com o máximo de informação suportada");
return 0;
}
if(buscaseq(pl, num, &posicao))
return -1;
for(i=pl -> qtnos; i>posicao; i--){
pl -> lista[i].num = pl->lista[i-1].num;
}
pl -> lista[posicao].num = num;
pl->qtnos++;
return 1;
}
int removeOrd(struct tlista *pl, int j)
{
int i, posicao, num;
if (j==2){
printf("Digite a conta a ser removida: ");
scanf("%d", &num);
if(pl->qtnos==0){
printf ("\nLista vazia\n");
return 0;
}
if(!buscaseq(pl, num, &posicao)){
printf ("\nNumero não encontrado\n");
return -1;
}
for(i=posicao; i< pl ->qtnos-1; i++){
pl -> lista[i].num = pl->lista[i+1].num;
}
pl->qtnos--;
printf ("\nNumero Removido\n");
return 1;
}
else{
for(i=0; i< pl ->qtnos-1; i++){
pl -> lista[i].num = 0;
}
pl->qtnos=0;
return 1;
}
}
int main (){
int j, i, k, l;
struct tlista l1;
inicializa_lista(&l1);
do{
printf("\n Digite uma das opções:\n1 – INSERIR UM ELEMENTO NA FILA\n2 – REMOVER
UM ELEMENTO DA FILA\n3 – EXIBIR PRIMEIRO ELEMENTO DA FILA\n4 – EXIBIR A FILA\n5 –
ESVAZIAR A FILA\n6- SAIR\n ");
scanf("%d", &j);
switch(j) {
case 1:
insereOrd(&l1);
break;
case 2:
removeOrd(&l1, j);
break;
case 3:
percurso(&l1,j);
break;
case 4:
percurso(&l1,j);
break;
case 5:
removeOrd(&l1, j);
break;
case 6:
printf("Finalizar!! \n");
break;
default:
printf("\nOpção inválida");
}
}while(j!=6);
}
18) Faça um programa que exiba o seguinte menu principal:
- - - - - -Editor de Listas - - - - - - - -
1- Exibir a lista
2- Inserir na lista
3- Remover da lista
4- Exibir um dado elemento da lista
5- Exibir posição de um dado elemento na lista
6- Esvaziar lista
7- Sair
O usuário deve digitar a opção de sua preferência para executar uma operação. implemente a
lista de números inteiros. Cada uma das operações do menu é descrita a seguir:
a) Na opção 1, devem ser exibidos o tamanho corrente da lista e todos os seus elementos;
b) Na opção 2, devem ser lidos não somente o elemento a ser inserido, mas também a posição na
lista onde o usuário deseja realizar a inserção;
c) Na opção 3, deve ser lida a posição na lista do elemento a ser removido;
d) Na opção 4, deve ser lida a posição do elemento;
e) Na opção 5, deve ser lido o valor do elemento cuja posição se quer exibir;
f) Na opção 6, deve ser exibida uma mensagem de confirmação para o usuário antes da lista ser
totalmente esvaziada;
g) Após a execução de cada operação, o programa deve retornar ao menu principal para que o
usuário possa executar outras opções ou encerre o programa;
h) Lembre-se: em cada uma das operações, identifique possíveis situações de erros do usuário e
exiba mensagens para ele nestas situações. (Ex. o programa deve exibir mensagens no caso do
usuário tentar remover um item ou esvaziar uma lista que está vazia, inserir elemento numa lista
que já está cheia, inserir posições inválidas, etc.).
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define TAM 21
struct tno {
int num,ord;
};
struct tlista{
int qtnos;
struct tno lista[TAM];
};
void inicializa_lista(struct tlista *pl){
int i;
pl -> qtnos = 0;
}
int lista_vazia(struct tlista *pl) {
if(pl -> qtnos == 0)
return 1;
return 0;
}
int lista_cheia(struct tlista *pl) {
if(pl -> qtnos == TAM)
return 1;
return 0;
}
int buscaseq(struct tlista *pl, int num, int *pos)
{
int i;
for(i=0; i < pl -> qtnos && num > pl -> lista[i].num; i++);
*pos=i;
if((i == pl -> qtnos) || (num != pl -> lista[i].num))
return 0; //não achou
return 1; //achou
}
int buscabinaria(struct tlista *pl, int num)
{
int ini=0, fim=pl -> qtnos-1, meio;
while(ini <= fim) {
meio= (ini+fim)/2;
if(num == pl -> lista[meio].num)
return(meio); //achou
if(num > pl -> lista[meio].num)
ini=meio+1;
else
fim=meio-1;
}
return -1; //não achou
}
int insereOrd(struct tlista *pl)
{
int i, posicao,num,l,k=0;
if(pl -> qtnos == TAM){
printf("\nLista com o máximo de informação suportada");
return 0;
}
else{
printf("\nPor favor, informe um número inteiro:\t");
scanf("%d", &num);
printf("\nPor favor, informe a posição entre 1 e %d: \t", TAM-1);
scanf("%d", &posicao);
i=pl -> qtnos;
pl -> lista[posicao].num = num;
for(l=0; l<pl -> qtnos;l++){
if(pl -> lista[l].ord == posicao) k=1;
}
if(k==0)
{
pl -> lista[i].ord = posicao;
pl->qtnos++;
}
return 1;
}
}
int removeOrd(struct tlista *pl, int j)
{
int i, posicao, num,k,l;
if (j==3){
printf("Digite a posição referenteao elemento que deseja remover: ");
scanf("%d", &posicao);
if(pl->qtnos==0){
printf ("\nLista vazia\n");
return 0;
}
else{
for(i=0; i< pl ->qtnos; i++){
if(pl -> lista[i].ord==posicao){
k=1;
l=i;
}
}
if(k==0) printf("\nPosição já estava vazia.\n");
else{
i=pl->qtnos;
for (i=j;i<=pl->qtnos;i++){
pl -> lista[i].ord = pl->lista[i+1].ord;
}
pl->qtnos--;
printf ("\nNumero Removido\n");
}
return 1;
}
}
else{
printf("\nDeseja mesmo apagar o número? 1 - Sim; 2 - Não.\t");
scanf("%d", &k);
if(k==1){
l=pl->qtnos;
for(i=0; i< l; i++){
pl -> lista[i].ord = pl->lista[l].num;
}
pl->qtnos=0;
printf("\nElementos Removidos.\n\n");
}
return 1;
}
}
void percurso(struct tlista *pl, int j){
int i,posicao, k=0,l,num;
if(j==1){
if(pl->qtnos==0){
printf("\nLista vazia.\n");
return 0;
}
else{
printf("\nA lista é formada por:\t");
for(i=0; i< pl->qtnos; i++){
l=pl->lista[i].ord;
printf("%d\t", pl->lista[l].num);
}
printf("\nAs posições ocupadas são:\t");
for(i=0; i< pl->qtnos; i++){
printf("%d\t", pl->lista[i].ord);
}
printf("\nA lista possui %d elementos.\n\n", pl->qtnos);
return 1;
}
}
if(j==4){
printf("\nDigite a posição que deseja saber o elemento referente:\t");
scanf("%d", &posicao);
for(i=0; i< pl ->qtnos; i++){
printf("TESTE: %d\t", pl -> lista[i].ord);
if(pl -> lista[i].ord==posicao){
k=1;
}
}
if(k==0) printf("\nPosição está vazia.\n");
else printf("\nNesta posição está presente o elemento %d\n\n", pl->lista[posicao].num);
return -1;
}
else{
printf("\nDigite o numero que deseja saber a posição referente: \t");
scanf("%d", &num);
for(i=0; i<TAM;i++){
if(pl->lista[i].num==num)k=1;
}
if(k==0) printf("\nEste valor não está presente na lista.\n ");
else{
printf("\nO numero está presente nas posições:\t ");
for(i=0; i<TAM;i++){
if(pl->lista[i].num==num)
printf("%d\t", i);
}
}
return 4;
}
printf ("\n\n");
}
int main (){
int j, i, k, l;
struct tlista l1;
inicializa_lista(&l1);
do{
printf("\n Digite uma das opções:\n1- Exibir a lista\n2- Inserir na lista\n3- Remover da lista\n4-
Exibir um dado elemento da lista\n5- Exibir posição de um dado elemento na lista\n6- Esvaziar
lista\n7- Sair\n ");
scanf("%d", &j);
switch(j) {
case 1:
percurso(&l1,j);
break;
case 2:
insereOrd(&l1);
break;
case 3:
removeOrd(&l1, j);
break;
case 4:
percurso(&l1,j);
break;
case 5:
percurso(&l1,j);
break;
case 6:
removeOrd(&l1, j);
break;
case 7:
printf("Finalizar!! \n");
break;
default:
printf("\nOpção inválida");
}
}while(j!=7);
}