Solucaoestdados

/*******************************************************************************/

/*** PROGRAMA LIVRARIA 2 - Demonstra como criar lista encadeada ordenada */

/*******************************************************************************/

#include <stdlib.h> /* para a função atof(), que transforma uma string em float */
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
#define TRUE 1

void listatot(void);
void inserealfa(void);

struct prs /* estrutura básica para listas ligadas */
{ char titulo[30];
 char autor[30];
 int regnum;
 double preco;
 struct prs *ptrprox;
};

/* declara estruturas tipo prs para montar a lista encadeada */
struct prs *ptrprim, *ptratual, *ptrnovo;

//Função main():
void main (void)
{ char ch;
 ptrprim = (struct prs *) NULL; /* sem dados ainda */
 for(;ch != 's';)
 { printf("\nDigite: 'i' para adicionar em ordem alfabetica\n");
   printf("\t'l ' para listar os livros\n");
   printf("\t's' para sair:\n");
   ch = getche();
   printf("\n");
   switch(ch)
   { case 'I':
     case 'i': inserealfa(); break;
     case 'L':
     case 'l' : listatot(); break;
     case 'S':
     case 's' : printf("Fim do programa"); break;
    default : puts("\nDigite somente opções válidas: ");
   }//end switch
  }//end for
}//end main

/***** FUNÇÃO INSEREALFA - adiciona um novo livro ao arquivo em ordem alfabética ***/
void inserealfa(void)
{ char numstr[81];
  int encontrou = 0,i=0;
  struct prs * ptemp;
  /* reserva espaço na memória (malloc) para armazenar estrutura do tamanho (sizeof) de prs */
  ptrnovo = (struct prs *) malloc (sizeof(struct prs)); /* novo ponteiro p/ estrut. da lista */

  printf(" Digite titulo: "); // preenche dados do novo registro
  gets (ptrnovo -> titulo);
  printf(" Digite autor: ");
  gets(ptrnovo -> autor);
  printf(" Digite o número do livro (3 digitos): ");
  gets(numstr);
  ptrnovo -> regnum = atoi(numstr); /* função atoi() converte uma string para inteiro */
  printf(" Digite preço:");
  gets(numstr);
  ptrnovo -> preco = atof(numstr);
  ptrnovo->ptrprox = (struct prs *)NULL;

  if (ptrprim == (struct prs *) NULL) /* se o 1o. ponteiro da lista tem conteudo NULL */
  {
     ptrprim = ptrnovo; /* lista ainda não tem dados */
  }
  else   //lista já tem dado(s)
  { ptratual= ptemp = ptrprim;

    do{ //busca por ordem alfabética onde pode inserir novo dado

         if(toupper(ptratual->titulo[i]) <= toupper(ptrnovo->titulo[i]))
         {//caso o novo dado seja MAIOR OU IGUAL ao primeiro:
           if(toupper(ptratual->titulo[i]) < toupper(ptrnovo->titulo[i])) //testa se é MAIOR
           {
               if(ptratual->ptrprox !=(struct prs *)NULL) //se não chegou no final da lista
               {    ptemp = ptratual;
                   ptratual = ptratual->ptrprox;
               }
               else //chegou no final da lista
               {
                   ptratual->ptrprox = ptrnovo;
                   encontrou = 1;
               }

           }
           else //duas primeiras letras são IGUAIS - compara as proximas letras
           {
                while(toupper(ptratual->titulo[i]) == toupper(ptrnovo->titulo[i]) )
                   i++;

                if(toupper(ptratual->titulo[i]) < toupper(ptrnovo->titulo[i]) )
                {//se o titulo que entrou for maior
                   ptrnovo -> ptrprox = ptratual->ptrprox;
                   ptratual->ptrprox = ptrnovo;

                }else //titulo que entrou é menor
                   {
                      ptrnovo->ptrprox = ptratual;
                      if(ptratual == ptrprim) //caso o dado tenha que ser inserido no início da lista
                          ptrprim = ptrnovo;
                      if(ptemp!=ptratual)//caso já haja mais de um dado na lista
                          ptemp->ptrprox = ptrnovo;

                   }
               encontrou = 1;
            } //fim else - dado novo igual ao atual

          }else //dado que entrou é MENOR que atual - tem que ser inserido neste local
              { ptrnovo->ptrprox = ptratual;  //aponta pro próximo da lista

                if(ptratual == ptrprim) //caso o dado tenha que ser inserido no início da lista
                    ptrprim = ptrnovo;
                if(ptemp!=ptratual)//caso já haja mais de um dado na lista
                    ptemp->ptrprox = ptrnovo;
                encontrou = 1;   //sinaliza que encontrou a posição
               }

       }while(!encontrou); /* procura posição alfabética correta para inserir o novo registro */

     }//fim else - lista já tem dados

printf("\n_______________________________\n");

}

/***** FUNÇÃO LISTATOT - lista os dados de todos os livros *****/ void listatot(void) {

if(ptrprim == (struct prs *) NULL)
{ printf("\n\nLista vazia!!\n");
return;
}
ptratual = ptrprim;
do
{ printf("Titulo: %s. \n", ptratual -> titulo);
printf("Autor: %s.\n", ptratual -> autor);
printf("Numero do registro: %3d.", ptratual -> regnum);
printf("Preço: %4.2f. \n\n", ptratual -> preco);
ptratual = ptratual -> ptrprox;
} while(ptratual != (struct prs *) NULL);
printf("\n_______________________\n");
}

---

/*****************************************************************************/

/*** PROGRAMA LIVRARIA - Demonstra como criar listas lineares */

/*** heterogêneas estáticas em C */

/***************************************************************************/

1. include <stdio.h>
2. include <conio.h>
3. include <stdlib.h> /* para funções atoi() e atof(), que transformam uma string em int e float */
4. include <strings.h>

struct livro { char titulo[30];

       char autor[30];
       int regnum;
       double preco;

}*PtrIni, *PtrFim, *PtrAtual;

struct livro * busca(char tit[30]); void novolivro(void); void listatot(void);

struct livro lista_livros[50]; /* declara uma matriz com 50 estruturas do tipo livro */ int n=0; // contadora do número de livros incluídos

int main (void) { char ch, titu[30];

      struct livro * ender;

       for(;ch != 's';)

{ printf("\nDigite: 'e' para adicionar um livro\n");

   	    printf("\t'l ' para listar os livros\n");
   	    printf("\t'b' para buscar um livro pelo titulo\n");
           printf("\t's' para sair:\n");

ch = getche();

           printf("\n");
           {   case 'e' :  novolivro();   break;

case 'l' : listatot(); break; case 'b' : printf("\nEntre com o nome do livro que quer buscar: "); gets(titu); ender = busca(titu); if(ender) printf("\nO autor do livro é: %s", ender->autor); else printf("\nNao foi achada nenhuma ocorrencia deste livro!!"); break;

               case 's' :  printf("\nFim do programa");  break;

default : puts("\nDigite somente opções válidas: "); } }

return 0; }

/***** FUNÇÃO NOVOLIVRO - adiciona um novo livro ao arquivo ***/ void novolivro(void) { char numstr[81];

         if(!n)  PtrIni = &lista_livros[n];

else PtrFim = &lista_livros[n];

         printf("\n Registro   %d. \nDigite titulo:   ", n+1);
	      gets (lista_livros[n].titulo);

printf("Digite autor: "); gets(lista_livros[n].autor); printf("Digite o número do livro (3 digitos): "); gets(numstr); lista_livros[n].regnum = atoi(numstr); printf("Digite preço:"); gets(numstr); lista_livros[n++].preco = atof(numstr); printf("\n_______________________________\n"); }

/***** FUNÇÃO LISTATOT - lista os dados de todos os livros *****/ void listatot(void) {

         int i;
         if( !n)
              printf("\n\nLista vazia!!\n");
         else
              for( i=0; i<n; i++)
             {   printf("\n Registro %d.\n", i+1);
	     printf("Titulo: %s. \n", lista_livros[i].titulo);
                  printf("Autor: %s.\n", lista_livros[i].autor);
                  printf("Numero do registro: %3d.", lista_livros[i].regnum);
                  printf("Preço: %4.2f. \n\n", lista_livros[i].preco);

}

          printf("\n_______________________\n");
    }

/***** FUNÇÃO BUSCA - lista os dados de todos os livros *****/ struct livro * busca(char tit[30]) { PtrAtual = PtrIni;

  while (strcmp(PtrAtual->titulo, tit) && (PtrAtual <= PtrFim))
      PtrAtual ++;
  if(PtrAtual <= PtrFim)  return PtrAtual;
  else return (struct livro *)NULL;
}

/*****************************************************************************/ /*** PROGRAMA LIVRARIA - Demonstra como criar listas lineares */ /*** heterogêneas estáticas em C */ / ***************************************************************************/

1. include <stdio.h>
2. include <conio.h>
3. include <stdlib.h> /* para funções atoi() e atof(), que transformam uma string em int e float */
4. include <strings.h>

struct livro { char titulo[30];

       char autor[30];
       int regnum;
       double preco;

}*PtrIni, *PtrFim, *PtrAtual;

struct livro * busca(char tit[30]); void novolivro(void); void listatot(void);

struct livro lista_livros[50]; /* declara uma matriz com 50 estruturas do tipo livro */ int n=0; // contadora do número de livros incluídos

void main (void) { char ch, titu[30];

      struct livro * ender;

       for(;ch != 's';)

{ printf("\nDigite: 'e' para adicionar um livro\n");

   	    printf("\t'l ' para listar os livros\n");
           printf("\t's' para sair:\n");

ch = getche();

           printf("\n");

switch(ch)

           {   case 'e' :  novolivro();   break;

case 'l' : listatot(); break; case 'b' : printf("\nEntre com o numero do livro que quer buscar: "); gets(titu); ender = busca(titu); printf("\nO autor do livro é: %s", ender->autor); break;

               case 's' :  printf("\nFim do programa");  break;

default : puts("\nDigite somente opções válidas: "); } } }

/***** FUNÇÃO NOVOLIVRO - adiciona um novo livro ao arquivo ***/ void novolivro(void) { char numstr[81];

         if(!n)  PtrIni = &lista_livros[n];

else PtrFim = &lista_livros[n];

         printf("\n Registro   %d. \nDigite titulo:   ", n+1);
	      gets (lista_livros[n].titulo);

printf("Digite autor: "); gets(lista_livros[n].autor); printf("Digite o número do livro (3 digitos): "); gets(numstr); lista_livros[n].regnum = atoi(numstr); printf("Digite preço:"); gets(numstr); lista_livros[n++].preco = atof(numstr); printf("\n_______________________________\n"); }

/***** FUNÇÃO LISTATOT - lista os dados de todos os livros *****/ void listatot(void) {

         int i;
         if( !n)
              printf("\n\nLista vazia!!\n");
         else
              for( i=0; i<n; i++)
             {   printf("\n Registro %d.\n", i+1);
	     printf("Titulo: %s. \n", lista_livros[i].titulo);
                  printf("Autor: %s.\n", lista_livros[i].autor);
                  printf("Numero do registro: %3d.", lista_livros[i].regnum);
                  printf("Preço: %4.2f. \n\n", lista_livros[i].preco);

}

          printf("\n_______________________\n");
    }

/***** FUNÇÃO BUSCA - lista os dados de todos os livros *****/ struct livro * busca(char tit[30]) { PtrAtual = PtrIni;

  while (strcmp(PtrAtual->titulo, tit) && (PtrAtual <= PtrFim))
      PtrAtual ++;
  if(PtrAtual <= PtrFim)  return PtrAtual;
  else return (struct livro *)NULL;
}

---

/************************************************************/

/*** PROGRAMA TABELA - Demonstra como criar estruturas de */

/*** tabela dinâmica em C */

/*************************************************************/

1. include <stdlib.h> /* para as funções atoi() e atof() */
2. include <stdio.h>
3. include <conio.h>
4. define TRUE 1

struct livro /* estrutura básica da lista */ { char titulo[30]; //CHAVE do nó

      char autor[30];
      int regnum;
      double preco;
      struct livro *ptrprox;

struct livro *ptrant; };

void novolivro(void); void listatot(void); struct livro * buscalivro(char [81]);

struct livrod *primlivro, *atuallivro, *novono; // declara ponteiros de estruturas livrod p/ montar lista

void main (void) { char ch;

primlivro = (struct livrod *) NULL; /* lista vazia */

      for(;ch != 's';)

{ printf("\nDigite: 'e' para adicionar um livro\n"); printf("\t'l ' para listar os livros\n");

         printf("\t's'  para sair:\n");
         ch = getche();
         printf("\n");

switch(ch)

         { case 'e' :  novolivro();   break;

case 'l' : listatot(); break;

           case 's' :  printf("Fim do programa");  break;

default : puts("\nDigite somente opções válidas: "); } } }

/***** FUNÇÃO NOVOLIVRO - adiciona um novo nó à lista ***/ void novolivro(void) { char numstr[81];

  /******* ALOCANDO NOVO NÓ NA MEMÓRIA   ********************/
  novono = (struct livrod *) malloc (sizeof(struct livrod));   

  /******* INSERINDO NOVO NÓ NO FINAL DA LISTA  **************/
  if (primlivro == (struct livrod *) NULL) //se lista vazia
        primlivro = atuallivro = novono;   
  else
  { atuallivro = primlivro; /*posiciona ptr atual para começar a percorrer a lista   */                  
  while(atuallivro->ptrprox != (struct livrod *) NULL)                   	// procura ultimo nó da lista  
    atuallivro = atuallivro->ptrprox; //ptr aponta p/ próx nó
  atuallivro->ptrprox = novono;    
  //faz ptr do último nó da lista apontar p/ o novo nó 
    atuallivro = novono; //deixa ptr apontando p/ final lista 
   }

  /******* DANDO CONTEÚDO AO NOVO NÓ DA LISTA ****************/
   printf(" Digite titulo:   ");
   gets (atuallivro -> titulo);
   printf(" Digite autor:  ");
   gets(atuallivro -> autor);
   printf(" Digite o número do livro (3 digitos):  ");
   gets(numstr);
   atuallivro -> regnum = atoi(numstr);  /* função atoi() converte uma string para inteiro   */
   printf(" Digite preço:");
   gets(numstr); 
   atuallivro -> preco = atof(numstr);
   printf("\n_______________________________\n");
   atuallivro -> ptrprox = (struct livrod *) NULL;                      /* último nó aponta para 0       */

}

/** FUNÇÃO LISTATOT - lista os dados de todos os livros *****/ void listatot(void) {

    if(primlivro == (struct livrod *) NULL)
    {      printf("\n\nLista vazia!!\n");
           return;
    }
    atuallivro = primlivro;
    do
    { printf("Titulo: %s. \n", atuallivro -> titulo);
      printf("Autor: %s.\n", atuallivro -> autor);
      printf("Numero do registro: %3d.", atuallivro -> regnum);
      printf("Preço: %4.2f. \n\n", atuallivro -> preco);

atuallivro = atuallivro -> ptrprox;

    }while(atuallivro != (struct livrod *) NULL);

    printf("\n_______________________\n");

}

/************************************************************/ /*** PROGRAMA TABELA - Demonstra como criar estruturas de */ /*** tabela dinâmica em C */ /*************************************************************/

1. include <stdlib.h> /* para as funções atoi() e atof() */
2. include <stdio.h>
3. include <conio.h>
4. define TRUE 1

struct livro /* estrutura básica da lista */ { char titulo[30]; //CHAVE do nó

      char autor[30];
      int regnum;
      double preco;
      struct livro *ptrlin;

struct livro *ptrcol; };

void novolivro(void); void listatot(void); struct livro * buscalivro(char [81]); void inseretabela

struct livrod *primlivro, *atuallivro, *novono; // declara ponteiros de estruturas livrod p/ montar lista

void main (void) { char ch;

primlivro = (struct livrod *) NULL; /* lista vazia */

      for(;ch != 's';)

{ printf("\nDigite: 'e' para adicionar um livro\n"); printf("\t'l ' para listar os livros\n");

         printf("\t's'  para sair:\n");
         ch = getche();
         printf("\n");

switch(ch)

         { case 'e' :  novolivro();   break;

case 'l' : listatot(); break;

           case 's' :  printf("Fim do programa");  break;

default : puts("\nDigite somente opções válidas: "); } } }

/***** FUNÇÃO NOVOLIVRO - adiciona um novo nó à lista ***/ void novolivro(void) { char numstr[81];

  /******* ALOCANDO NOVO NÓ NA MEMÓRIA   ********************/
  novono = (struct livrod *) malloc (sizeof(struct livrod));   

  /******* INSERINDO NOVO NÓ NO FINAL DA LISTA  **************/
  if (primlivro == (struct livrod *) NULL) //se lista vazia
        primlivro = atuallivro = novono;   
  else
  { atuallivro = primlivro; /*posiciona ptr atual para começar a percorrer a lista   */                  
  while(atuallivro->ptrprox != (struct livrod *) NULL)                   	// procura ultimo nó da lista  
    atuallivro = atuallivro->ptrprox; //ptr aponta p/ próx nó
  atuallivro->ptrprox = novono;    
  //faz ptr do último nó da lista apontar p/ o novo nó 
    atuallivro = novono; //deixa ptr apontando p/ final lista 
   }

  /******* DANDO CONTEÚDO AO NOVO NÓ DA LISTA ****************/
   printf(" Digite titulo:   ");
   gets (atuallivro -> titulo);
   printf(" Digite autor:  ");
   gets(atuallivro -> autor);
   printf(" Digite o número do livro (3 digitos):  ");
   gets(numstr);
   atuallivro -> regnum = atoi(numstr);  /* função atoi() converte uma string para inteiro   */
   printf(" Digite preço:");
   gets(numstr); 
   atuallivro -> preco = atof(numstr);
   printf("\n_______________________________\n");
   atuallivro -> ptrprox = (struct livrod *) NULL;                      /* último nó aponta para 0       */

}

/** FUNÇÃO LISTATOT - lista os dados de todos os livros *****/ void listatot(void) {

    if(primlivro == (struct livrod *) NULL)
    {      printf("\n\nLista vazia!!\n");
           return;
    }
    atuallivro = primlivro;
    do
    { printf("Titulo: %s. \n", atuallivro -> titulo);
      printf("Autor: %s.\n", atuallivro -> autor);
      printf("Numero do registro: %3d.", atuallivro -> regnum);
      printf("Preço: %4.2f. \n\n", atuallivro -> preco);

atuallivro = atuallivro -> ptrprox;

    }while(atuallivro != (struct livrod *) NULL);

    printf("\n_______________________\n");

}

/** Estrutura de Dados em C ***************************/ /*** Tarefa 1 - Lista Duplamente Encadeada */

1. include <stdlib.h>
2. include <stdio.h>
3. include <conio.h>

void novo_no(void); void cadastro(void); void mostra_cadastro(); char devolvemaiusc(char l); int ordena(char nome[35], char novo_nome[35]); void buscar();

struct no /** variável tipo estrutura básica da lista */ {

      char nome[35];
      char telefone[14];
      char idade[3];
      struct no *proximo;
      struct no *anterior;

} *primeiro, *atual, *nova_estrutura;

int main(void) {

   char escolha;
   while(escolha!='s')
   {
       printf("\nEscolha a opcao desejada:");
       printf("\nC para cadastrar");
       printf("\nB para buscar um cadastro");
       printf("\nM para mostrar os cadastros registrados");
       printf("\nS para sair");
       printf("\n->");
       escolha=getch();
       switch(escolha)
       {
           case 'c'  :
           case 'C'  : novo_no(); break;
           case 'b'  :
           case 'B'  : buscar(); break;
           case 'm'  :
           case 'M'  : mostra_cadastro(); break;
           case 's'  :
           case 'S'  : break;
           default : printf("Digite somente opções válidas!");
       }

   }

}

/***** FUNÇÃO nova_estrutura - adiciona um novo nó à lista ***/

void novo_no(void) {

  int ordem=0;
  /******* ALOCANDO NOVO NÓ NA MEMÓRIA   ********************/
  nova_estrutura = (struct no *) malloc (sizeof(struct no));
  nova_estrutura->anterior = (struct no *) NULL;
  nova_estrutura->proximo = (struct no *) NULL;

  cadastro();
  /******* INSERINDO NOVO NÓ NO FINAL DA LISTA  **************/
  if (primeiro == (struct no *) NULL)
        primeiro = atual = nova_estrutura;
  else
  {
       atual = primeiro;
       while(atual != (struct no*) NULL)
       {
           ordem=ordena(atual->nome,nova_estrutura->nome);
           if(ordem == -1)
           {
               nova_estrutura->proximo = atual;
               nova_estrutura->anterior = atual->anterior;
               if(atual->anterior == (struct no*) NULL)
               {
                   primeiro = nova_estrutura;
               }
               else
               {
                   atual->anterior->proximo=nova_estrutura;
               }
               atual->anterior = nova_estrutura;
               return;
           }
           else
           {
               if(ordem == 1)
               {
                   if(atual->proximo == (struct no*) NULL)
                   {
                       nova_estrutura->anterior=atual;
                       nova_estrutura->proximo=atual->proximo;
                       atual->proximo = nova_estrutura;
                       return;
                   }
                   else
                   {
                       if(ordena(atual->proximo->nome,nova_estrutura->nome)==-1)
                       {
                           nova_estrutura->anterior=atual;
                           nova_estrutura->proximo=atual->proximo;
                           atual->proximo->anterior = nova_estrutura;
                           atual->proximo = nova_estrutura;
                           return;
                       }
                   }
               }
               else
               {
                   nova_estrutura->anterior = atual->anterior;
                   nova_estrutura->proximo = atual->proximo;
                   if(atual->anterior != (struct no*) NULL)
                   {
                       atual->anterior->proximo = nova_estrutura;
                   }
                   else
                   {
                       primeiro = nova_estrutura;
                   }
                   if(atual->proximo != (struct no*) NULL)
                   {
                       atual->proximo->anterior = nova_estrutura;
                   }
                   free(atual);
                   return;
               }
           }
           atual = atual->proximo;
       }
  }

}

void buscar() {

   char nome_procurar[35];
   printf("\nDigite o nome a procurar:\n>");
   gets(nome_procurar);
   if(primeiro == (struct no*)NULL)
   {
       printf("Lista vazia");
   }
   else
   {
       atual = primeiro;
       while(atual != (struct no*)NULL)
       {
           if(!ordena(atual->nome,nome_procurar))
           {
               printf("Nome:%s\n",atual -> nome);
               printf("Telefone:%s\n",atual -> telefone);
               printf("Idade:%s\n",atual -> idade);
               return;
           }
           atual = atual->proximo;
       }
       printf("Sem cadastro encontrado.");
   }

}

void cadastro(void) {

   /******* DANDO CONTEÚDO AO NOVO NÓ DA LISTA ****************/
   printf("\nDigite um nome:");
   gets (nova_estrutura -> nome);
   printf("Digite um numero de telefone:");
   gets (nova_estrutura -> telefone);
   printf("Digite a idade:");
   gets (nova_estrutura -> idade);
   printf("\n\n");

} void mostra_cadastro() {

   /******* IMPRIME CONTEÚDO DO NOVO NÓ DA LISTA ****************/
   if(primeiro == (struct no*)NULL)
   {
       printf("\n\nLista vazia");
   }
   else
   {
       atual = primeiro;
       while(atual != (struct no*)NULL)
       {
           printf("\n\n");
           printf("\nNome:%s\n",atual -> nome);
           printf("Telefone:%s\n",atual -> telefone);
           printf("Idade:%s\n",atual -> idade);
           atual = atual->proximo;
       }

   }

} int ordena(char nome[35], char novo_nome[35]) {

   int flag = 0;
   int i=0;
   char n=1, nv=1;

   while(!flag && i<35 && n && nv)
   {
     n = devolvemaiusc(nome[i]);
     nv = devolvemaiusc(novo_nome[i]);
     if( n < nv )
          flag=1;
      else if( n > nv )
                flag = -1;
      i++;
  }
     return flag;
}

char devolvemaiusc(char l) {

    if(l >= 97 && l<=122)
       l-= 32;

    return l;

}