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

typedef struct atendimento{//estrutura de uma fila, onde contém a informação, nesse caso um nome, e um ponteiro para a proxima estrutura
        char nome[30];
        struct atendimento *prox;
        }ATEND;

void push(char nome[],ATEND **inicio,ATEND **fim);//função que insere um elemento na fila, recebendo a informação, um endereço de um ponteiro de início e um de fim de fila
void pop(ATEND **inic);//função que retira um elemento da fila, recebendo um endereço de um ponteiro de início de fila

int main(){
   
    ATEND *fim = NULL;//declaração e inicialização de um ponteiro que controla o fim da fila
    ATEND *inicio = NULL;//declaração e inicialização de um ponteiro que controla o início da fila
    ATEND *aux = NULL;//declaração e inicialização de uma variável auxiliar
    char op;
    char nome[20];
    int cont=0;
   
    while(op!='0'){
       clrscr();
       printf("---------MENU---------\n\n");
       printf("(1) - REGISTRAR PESSOAS NA FILA\n");
       printf("(2) - MOSTRAR NOMES DAS PESSOAS DA FILA\n");
       printf("(3) - CHAMAR O PROXIMO DA FILA\n");
       printf("(0) - Sair\n\n");
       printf("Escolha: ");
       op = getche();
       switch(op){
          case '1':
             clrscr();
             printf("REGISTRO NA FILA\n\n");
             printf("Digite o nome do paciente: ");
             fflush(stdin);
             gets(nome);//leitura da informação a ser colocada na fila
             push(nome,&inicio,&fim);//passando o endereço do ponteiro que aponta para o inicio e para o fim da fila
             break;
          case '2':
               clrscr();
               printf("MOSTRANDO A FILA DOS PACIENTES\n\n");
               aux = inicio;//aux recebe o que esta gravado em inicio
               cont=1;
               while(aux != NULL){//enquanto aux nao estiver apontando para NULL executa as instruções abaixo
                  printf("\n%d%c %s",cont,167,aux->nome);
                  cont++;
                  aux = aux -> prox;//aux recebe um ponteiro para o proximo registro
                  if(inicio==fim){//se o registro do inicio da fila for igual ao registro do fim entao aux recebera NULL
                     aux = NULL;              
                  }//fim if
               }//fim while
               if(inicio==NULL){
                   printf("\nA FILA ESTA VAZIA\n");
               }
               getch();
               break;
          case '3':
             clrscr();
             printf("CHAMANDO O PROXIMO DA FILA\n\n");
             pop(&inicio);//passando o endereço do primeiro registro
             break;
          case '0':
             exit(1);
          default:
             printf("\nInvalido...\n");
             getch();
             clrscr();
       }
    }
    getch();
   
}
//função push - incluir na fila
void push(char n[],ATEND **inicio,ATEND **fim){//função que insere um elemento na fila, recebendo a informação, um endereço de um ponteiro de início e um de fim de fila
    
     ATEND *temp=NULL;
    
     temp = malloc(sizeof(ATEND));//aloca espaço do tamanho da struct ATEND
     strcpy(temp->nome,n);//copia n para temp->nome
     if(*fim!=NULL){//na primeira chamada de push *fim == NULL entao não executa as instruções dentro desse if
        (*fim) -> prox = temp;//o campo prox do ultimo registro aponta para o registro atual
        temp->prox = NULL;//o campo prox do registro atual aponta para NULL
     }//fim if
     *fim = temp;//grava o registro no final da fila
     if ((*inicio) == NULL){//na primeira chamada de push *inicio == NULL então ele recebe temp
        *inicio = temp;//inicio recebe o registro atual
     }//fim if
}
//função pop - excluir da fila
void pop(ATEND **inic){//função que retira um elemento da fila, recebendo um endereço de um ponteiro de início de fila

     ATEND *temp;
    
     temp = *inic;//temp recebe o registro do início da fila
     if(temp->nome!=NULL){//sempre que o campo nome do primeiro registro da fila for diferente de NULL, executa as instruçoes desse if
        printf("Nome do proximo a ser atendido ==> %s\n",temp->nome);//mostra o nome que será excluido do inicio da fila
        *inic = (*inic) -> prox;//o inicio da fila aponta para o campo prox do inicio da fila
        free(temp);//libera a memoria equivalente ao registro inicio gravado em temp ( temp = *inic;)
     }else{//se o campo do registro gravado em temp for igual a NULL, significa que não existem mais registros
        printf("\nA FILA ACABOU...");
     }//fim if else
     getch();
}
 

#include<stdio.h>
#include<malloc.h>
#define logico int
#define verdadeiro 1
#define falso 0

//+++++++++++++++++++++++++++++++++++++++++++++++inicio do registro noarvore++++++++++++++++++++++++++++++++++++++++++++++++++++++++
typedef struct noarvore noarvore;
struct noarvore
{
  int info;
  noarvore *esq;
  noarvore *dir;
  noarvore *pai;
};
//++++++++++++++++++++++++++++++++++++++++++++++++fim do registro noarvore+++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//++++++++++++++++++++++++++++++++++++++++++++++++inicio do registro descarvore++++++++++++++++++++++++++++++++++++++++++++++++++++
typedef struct descarvore descarvore;
struct descarvore
{
  noarvore *raiz;
};
//++++++++++++++++++++++++++++++++++++++++++++++++fim do registro descarvore++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//++++++++++++++++++++++++++++++++++++++++++++++++Inicio da vazia+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
logico vazia(descarvore a)
{
  if(a.raiz == NULL) return (verdadeiro);
  else return(falso);
}
//++++++++++++++++++++++++++++++++++++++++++++++++Fim da vazia+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//++++++++++++++++++++++++++++++++++++++++++++++++inicio da inicializar+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void inicializar(descarvore *a)
{
  a->raiz=NULL;
}
//++++++++++++++++++++++++++++++++++++++++++++++++fim da inicializar++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//++++++++++++++++++++++++++++++++++++++++++++++++inicio da criar no+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

noarvore *criarno(int elem)
{
  noarvore *a;
  a=(noarvore *) malloc (sizeof(noarvore));
  if(a) //p!=NULL;
    {
      a->info=elem;
      a->esq=NULL;
      a->dir=NULL;
      a->pai=NULL;
    }
  return a;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++fim da criar no++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//+++++++++++++++++++++++++++++++++++++++++++++++++inicio da inserir++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void inserir(descarvore *a,noarvore *n)
{
  noarvore *x;
  noarvore *y;
  y=NULL;
  x=a->raiz;

  while(x != NULL)
    {
      y=x;
      if (n->info < x->info)
 {
   x = x->esq;
 }
      else
 {
   x = x->dir;
 }
    }
  n->pai = y;

  if (y == NULL)
    {
      a->raiz = n;
    }
  else
    {
      if (n->info < y->info)
 {
   y->esq = n;
 }
      else
 {
   y->dir = n;
 }
    }
}
//+++++++++++++++++++++++++++++++++++++++++++++++++fim da inserir++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//++++++++++++++++++++++++++++++++++++++++++++++++inicio sucessor direito vazia++++++++++++++++++++++++++++++++++++++++++++++++++++
noarvore *sucessordireitovazia(noarvore *n)
{
  if (n->pai == NULL)
    {
      return NULL;
    }
  else
    {
      if (n->pai->esq == NULL)
 {
   return (n->pai);
 }
      else
 {
   return (sucessordireitovazia(n->pai));
 }
    }
}
//++++++++++++++++++++++++++++++++++++++++++++++++fim sucessor direito vazia+++++++++++++++++++++++++++++++++++++++++++++++++++++++

//+++++++++++++++++++++++++++++++++++++++++++++++++inicio menor elemento+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
noarvore *menorelemento(noarvore *n)
{
  while (n->esq != NULL)
    {
      n=n->esq;
    }
  return n;
}
//++++++++++++++++++++++++++++++++++++++++++++++++fim menor elemento+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//++++++++++++++++++++++++++++++++++++++++++++++++inicio da sucessor++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
noarvore *sucessor(noarvore *x)
{
  noarvore *y;
  if (x->dir != NULL)
    {
      return (menorelemento(x->dir));
    }
  y = x->pai;
  while(y != NULL &&  x == y->dir)
    {
      x = y;
      y = y ->pai;
    }
  return y;
}
//++++++++++++++++++++++++++++++++++++++++++++++++fim da sucessor+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//++++++++++++++++++++++++++++++++++++++++++++++++inicio sucessor interativa++++++++++++++++++++++++++++++++++++++++++++++++++++++
noarvore *sucessor_interativa(noarvore *n)
{
  if (n->dir != NULL)
    {
      return (menorelemento(n->dir));
    }
  else
    {
      return (sucessordireitovazia(n));
    }
  for( ; (n=NULL) && (n->pai->esq = n) ; )
    {
      n=n->pai;
    }
  return n;
}
//++++++++++++++++++++++++++++++++++++++++++++++++fim da sucessor interativa++++++++++++++++++++++++++++++++++++++++++++++++++++++

//+++++++++++++++++++++++++++++++++++++++++++++++++inicio da excluir+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
noarvore *excluir(descarvore *a,noarvore *n)
{
  int aux;
  noarvore *x;
  noarvore *y;
  if ((n->esq == NULL) || (n->dir == NULL))
    {
      y = n;
    }
  else
    {   
      y = sucessor(n);    
    }
  if (y->esq != NULL)
    {
      x = y->esq;
    }
  else
    {
      x = y->dir;
    }
  if (x != NULL)
    {
      x->pai = y->pai;
    }
 
  if (y->pai == NULL)
    {
      a->raiz = x;
    }
  else
    {
      if (y == y->pai->esq)
 {
   y->pai->esq = x;
 }
      else
 {
   y->pai->dir = x;
 }
    }
  if (y != n)
    {
      aux = n->info;
      n->info = y->info;
      y->info = aux;
    }
  return y;
}
//++++++++++++++++++++++++++++++++++++++++++++++++fim da exclusao++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//++++++++++++++++++++++++++++++++++++++++++++++++inicio da pre_ordem++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void preordem(noarvore *n)
{
  if (n != NULL)
    {
      printf(" O elemento do info e: %d\n",n->info);
      preordem(n->esq);
      preordem(n->dir);
    }
}
//++++++++++++++++++++++++++++++++++++++++++++++++fim do pre_ordem++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//++++++++++++++++++++++++++++++++++++++++++++++++inicio da pos_ordem++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void posordem(noarvore *n)
{
  if (n != NULL)
    {
      posordem(n->esq);
      posordem(n->dir);
      printf(" O elemento do info e: %d\n",n->info);
    }
}
//++++++++++++++++++++++++++++++++++++++++++++++++fim do pos_ordem++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//++++++++++++++++++++++++++++++++++++++++++++++++inicio da in_ordem++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void inordem(noarvore *n)
{
  if (n != NULL)
    {
      inordem(n->esq);
      printf(" O elemento do info e: %d\n",n->info);
      inordem(n->dir);
    }
}
//++++++++++++++++++++++++++++++++++++++++++++++++fim do in_ordem++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//++++++++++++++++++++++++++++++++++++++++++++++++Quantidades de nos+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
logico qdenos(noarvore *n)
{
  if (n==NULL)
    {
      return 0;
    }
  else
    {
      return (1+qdenos(n->esq)+(qdenos(n->dir)));
    }
}
//++++++++++++++++++++++++++++++++++++++++++++++++fim da quantidade de nos++++++++++++++++++++++++++++++++++++++++++++++++++++++

//++++++++++++++++++++++++++++++++++++++++++++++++inicio da altura++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
logico altura(noarvore *n)
{
  int e,d,maior;
  if (n == NULL)
    {
      return -1;
    }
  else
    {
      e = altura(n->esq);
      d = altura(n->dir);
      if (e > d)
 {
   maior = e;
 }
      else
 {
   maior = d;
 }
      maior =1+ maior;
      return maior;
    }
}
//++++++++++++++++++++++++++++++++++++++++++++++++fim da altura+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//+++++++++++++++++++++++++++++++++++++++++++++++++Inicio da pesquisa 2+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
noarvore *pesquisa(noarvore *n,int elem)
{
  if (n == NULL || elem == n->info)
    {
      return n;
    }
  if (elem < n ->info)
    {
      return (pesquisa(n->esq,elem));
    }
  else
    {
      return (pesquisa(n->dir,elem));
    }
}
//+++++++++++++++++++++++++++++++++++++++++++++++++fim da pesquisa 2+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//+++++++++++++++++++++++++++++++++++++++++++++++++inicio do main+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
int  main (void)
{
  int b,alt,r,num;
  descarvore a;
  noarvore *no;
  noarvore np;

  noarvore *no2;
 
  inicializar(&a);
 
  printf("\nInprimindo em ordem.\n");
  inserir(&a,no=criarno(10));
  inserir(&a,no=criarno(8));
  inserir(&a,no=criarno(5));
  inserir(&a,no=criarno(9));
  inserir(&a,no=criarno(3));
  inserir(&a,no=criarno(20));
  inserir(&a,no=criarno(14));
  inserir(&a,no=criarno(25));
  inserir(&a,no=criarno(23));
  inserir(&a,no=criarno(28));
  inserir(&a,no=criarno(24));
  inordem(a.raiz);
  //inserir(&a,no=criarno(22));
  //inserir(&a,no=criarno(21));
  //printf("\nInprimindo em pre ordem.\n");
  //preordem(a.raiz);
  //printf("\nInprimindo em pos ordem.\n");
  //posordem(a.raiz);
  //b=qdenos(a.raiz);
  //printf("\nA quantidade de nos da arvore a e:%d \n",b);
  //alt=altura(a.raiz);
  //printf("\nA altura da arvore a e:%d \n",alt);
 
  printf("\n Entre com um numero.");
  scanf("%d",&num);
  no=pesquisa(a.raiz,num);
  if (no != NULL)
    {
      printf("\n O numero existe na arvore.\n");
      printf("\n Deseja excluir.\n");
      no2=excluir(&a,no);
      free(no2);
      printf("\nInprimindo em ordem.\n");
      inordem(a.raiz);
    }
  else
    {
      printf("\n Elemento nao existe.\n");
    }
}
//+++++++++++++++++++++++++++++++++++++++++++++++++fim do main+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 

 Objetivo: ler números de uma pilha e os escrever em ordem inversa. 
  
   Entrada : numeros para inserir na pilha

   Saida   : dados invertidos

*/

#include <stdio.h>
#include <conio.c>
#define SEMVALOR 2489321 /* "erro" p/ pop e top*/

typedef struct cel
{
        int valor;
        struct cel *prox;
}* pilha;

void init(pilha *p_Pilha);
void push(pilha *P, int x);
int vazia(pilha P);    
int pop(pilha *P);

int main(void)
{
// Declaracoes
pilha iniPilha;
int val;
char resp;
//Instrucoes
     printf("Escreva os dados a serem inseridos na pilha: ");
     //inicializando pilha
     init(&iniPilha);
     do{
        printf("-> ");
        scanf("%d",&val);
        //empilhando
        push(&iniPilha,val);
        do{
            printf("Deseja inserir mais algum numero na pilha?(S/N)\n");
            resp = tolower(getche());
        }while(resp != 'n' && resp != 's');
        clrscr();
     }while(resp!='n');           
    
    
     //desempilhando
     do{
        printf("%d Desempilhou\n",pop(&iniPilha));
     }while(!vazia(iniPilha));
     getch();
}

//*******************inicializa pilha*******************
//objetivo: inicializar uma pilha
//parametro: endereco da pilha
//retorno: nenhum
void init(pilha *p_Pilha)
{
     p_Pilha = NULL;
}

//******************insere dados na pilha*****************
//objetivo: adicionar elementos na pilha
//parametros: endereco inicial da pilha e valor a ser inserido
//retorno: nenhum
void push(pilha *P, int x)
{
pilha tmp;
  tmp = (pilha)malloc(sizeof(struct cel));
  tmp->prox = *P;
  *P = tmp;
  (*P)->valor = x;
}

//********************pilha vazia?****************
//objetivo: verificar se a pilha esta vazia
//parametro: endereco da pilha
//retorno: TRUE se estiver vazia, FALSE se ja estiver algo empilhado
int vazia(pilha P)
{
  return(P == NULL);
}

//************************TOPO*********************
//objetivo: Verifica qual valor esta no topo da lista
//parametro: endereco da pilha
//retorno: valor que se encontra no topo da lista
int top(pilha P)
{
    if(SEMVALOR != vazia(P))
         return P->valor;
    else
        return SEMVALOR;
}

//*******************POP*********************
//objetivo: desempilhar um elemento da pilha
//parametro: endereco da pilha
//retorno: elemento desempilhado
int pop(pilha *P)
{
pilha tmp;
int ret;
    if(! vazia(*P))
    {
         ret = (*P)->valor;
         tmp = *P;
         *P = (*P)->prox;
         free(tmp);
         return ret;
    }
    else
        return SEMVALOR;
}
 

 Sintese
   Objetivo: Implementar uma pilha, usando vetor
 
   Entrada : elementos da pilha

   Saida   : elementos que foram inseridos na pilha

*/

#include <stdio.h>
#include <conio.c>
#define MAX_PILHA 4
#define SEM_VALOR 99999

typedef struct pilha
{
    int dados[MAX_PILHA];
    int numElem;
} pilha;

void inicializa(pilha *p);
int vazia(pilha *p);
int cheia(pilha *p);
int push(pilha *p,int val);
int pop(pilha *p);
int top(pilha *p);

int main(void)
{
// Declaracoes
pilha pDados;
int val;
char resp;
// Instrucoes
   inicializa(&pDados);
   do{
      printf("\nValor a ser inserido na pilha: ");
      scanf("%d",&val);
      //empilhando dados
      push(&pDados,val);
     
      do{
          printf("\nDeseja inserir mais algum numero na pilha? (S/N)\n");
          resp = toupper(getche());
      }while(resp!='N' && resp!='S');
      if(resp == 'S')
      {
          if( cheia(&pDados))
          {
              printf("\nPilha ja esta cheia!");  
              getch();
              break;
          }
      }
   }while(resp == 'S');
   system("cls");
   printf("Dados da pilha:");
   do{
       //desempilhando dados
       val = pop(&pDados);
       printf("\n %d",val);
   }while(! vazia(&pDados));
  
  getch();
  return 0;
}

//******INICIALIZA*******
//obj: inicializar uma pilha
//parametro: endereco da pilha
//retorno: nenhum
void inicializa(pilha *p)
{
     p->numElem = 0;
}

//***********VAZIA**********
//obj: verificar se a pilha esta vazia
//parametro: endereco da pilha
//retorno: 1 se n estiver vazia, 0 se estiver
int vazia(pilha *p)
{
    if(p->numElem == 0)
        return 1;
    else
        return 0;
}

//***********CHEIA**********
//obj: verificar se a pilha esta cheia
//parametro: endereco da pilha
//retorno: 1 se n estiver cheia, 0 se n estiver
int cheia(pilha *p)
{
    if(p->numElem == MAX_PILHA)
        return 1;
    else
        return 0;
}
//****************PUSH****************
//obj: adicionar elementos na pilha
//parametro: endereco da pilha, valor a ser inserido
//retorno: nenhum
int push(pilha *p,int val)
{
     if(! cheia(p))
     {
          p->dados[p->numElem] = val;
          p->numElem++;
          return 1;
     }
     else
         return 0;
}

//****************POP********************
//obj: retirar elementos da pilha
//parametro: endereco da pilha
//retorno: valor retirado da pilha
int pop(pilha *p)
{
int valRet;
    if(! vazia(p))
    {
         p->numElem--;
         valRet = p->dados[p->numElem];
         return valRet;
    }
    else
        return (SEM_VALOR);
}

//***************TOP**************
//obj: apresentar o elemento topo da pilha,
//     o ultimo elemento empilhado
//parametro: endereco da pilha
//retorno: topo da pilha
int top(pilha *p)
{
    if(! vazia(p))
         return p->dados[p->numElem-1];
    else
        return (SEM_VALOR);
}
 

  Objetivo: Elaborar um programa para armazenar os nomes dos jogadores de carta em uma lista
   simplesmente encadeada.
 
   Entrada : Nome dos Jogadores

   Saida   :  Listagem do jogadores da lista com o endereço de memoria e do prox

*/

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

//ESTRUTURA DOS DADOS CADASTRADOS
typedef struct celula{
   char nome[20];
   struct celula *prox;
}cel;

//DEFINICAO DO TIPO
typedef cel *lista;

lista criaCelula();
void inicializa(lista *iniLst);
void addLista(lista *minhaLst, char nome[]);
void imprimeLista(lista lst);

int main(int argc, char *argv[])
{
     //DECLARACAO DE VARIÁVEIS
     lista lst;  //DECLARANDO VARIÁVEL LST (LISTA DE JOGADORES) PARA O NOVO TIPO
     inicializa(&lst); //INICIALIZANDO A VARIÁVEL

     char nome[20]; //VARIÁVEL A SER CAPTURADA 
     int op;  //VARIAVEL USADA NO MENU
 
     //MENU DO PROGRAMA
     do{
      do{
         system("cls");
         printf(" *** MENU ***\n\n1 - Incluir jogador\n2 - Imprimir Lista\n3 - Sair\n\n\n=> ");
         scanf("%d",&op);
      }while(op<1||op>3);
     
      switch(op){
         case 1:  //ADICIONA NOVO JOGADOR
           fflush(stdin);
           printf("\n\nInforme o nome da cidade [20 caracteres]\n=>");
           gets(nome);  //CAPTURANDO DIGITACAO DO USUARIO    
           addLista(&lst,nome);   //PASSANDO O DADO E A LISTA PARA A FUNÇÃO QUE ADICIONARÁ

           fflush(stdin);  //LIMPANDO TECLADO
           break;
         case 2:  //LISTAGEM DA LISTA DE JOGADORES
           imprimeLista(lst);  //PASSANDO LISTA PARA A FUNÇÃO DE IMPRESSAO
             
           getch();
           break;
         case 3:  // SAI DO PROGRAMA
           exit(0);
           break;
      }
   }while(1);
                    
   system("PAUSE"); 
   return 0;
}

//ADICIONA À LISTA USANDO RECURSIVIDADE
void addLista(lista *minhaLst, char nome[]){
   if(*minhaLst==NULL){  //SE CHEGOU AO FINAL DA LISTA ADICIONA MAIS UM JOGADOR
      lista tmp;         //VARIAVEL TEMPORARIA PARA ENDERECO DA LISTA
      inicializa(&tmp);
     
      tmp=criaCelula();  //CRIA UMA NOVA CELULA DE DADO PARA RECEBER O JOGADOR
      strcpy(tmp->nome,nome);   //PASSA JOGADOR PARA A LISTA
      *minhaLst=tmp;     //ADICIONA NOVA CELULA AO ULTIMO ENDERECO NULL DA LISTA
      return;
   }
   addLista(&(*minhaLst)->prox,nome);  //RECURSIVAMENTE CHAMA A FUNCAO PASSANDO A PROXIMA CELULA
}

//CRIA CÉLULA PARA ADICIONAR À LISTA
lista criaCelula(){
      lista tmp=NULL;
      tmp=(lista)malloc(sizeof(cel));   //ALOCA UMA NOVA CELULA
      tmp->prox=NULL;
     
      return tmp;
}

//INICIALIZA
void inicializa(lista *iniLst){
   *iniLst=NULL; 
}

//IMPRIME LISTA
void imprimeLista(lista lst){
     lista tmp=lst;
        
     printf("\n\nConteudo da lista:\n");
     printf("\NOME\t\tENDERECO NOME\t\tENDERECO PROX\n");
     while(1){
        if(tmp==NULL)  //SE CHEGAR AO FIM DA LISTA SAI
           return;
        
        printf("%s\t\t%d\t\t\t%d\n",tmp->nome,&tmp->nome,tmp->prox);
        tmp=tmp->prox;  //PULA PARA O PROXIMO ENDERECO
     }
}

// Aluno :

/*
 Sintese
   Objetivo: ler números de uma pilha e os escrever em ordem inversa. 
  
   Entrada : numeros para inserir na pilha

   Saida   : dados invertidos

*/

#include <stdio.h>
#include <conio.c>
#define SEMVALOR 2489321 /* "erro" p/ pop e top*/

typedef struct cel
{
        int valor;
        struct cel *prox;
}* pilha;

void init(pilha *p_Pilha);
void push(pilha *P, int x);
int vazia(pilha P);    
int pop(pilha *P);

int main(void)
{
// Declaracoes
pilha iniPilha;
int val;
char resp;
//Instrucoes
     printf("Escreva os dados a serem inseridos na pilha: ");
     //inicializando pilha
     init(&iniPilha);
     do{
        printf("-> ");
        scanf("%d",&val);
        //empilhando
        push(&iniPilha,val);
        do{
            printf("Deseja inserir mais algum numero na pilha?(S/N)\n");
            resp = tolower(getche());
        }while(resp != 'n' && resp != 's');
        clrscr();
     }while(resp!='n');           
    
    
     //desempilhando
     do{
        printf("%d Desempilhou\n",pop(&iniPilha));
     }while(!vazia(iniPilha));
     getch();
}

//*******************inicializa pilha*******************
//objetivo: inicializar uma pilha
//parametro: endereco da pilha
//retorno: nenhum
void init(pilha *p_Pilha)
{
     p_Pilha = NULL;
}

//******************insere dados na pilha*****************
//objetivo: adicionar elementos na pilha
//parametros: endereco inicial da pilha e valor a ser inserido
//retorno: nenhum
void push(pilha *P, int x)
{
pilha tmp;
  tmp = (pilha)malloc(sizeof(struct cel));
  tmp->prox = *P;
  *P = tmp;
  (*P)->valor = x;
}

//********************pilha vazia?****************
//objetivo: verificar se a pilha esta vazia
//parametro: endereco da pilha
//retorno: TRUE se estiver vazia, FALSE se ja estiver algo empilhado
int vazia(pilha P)
{
  return(P == NULL);
}

//************************TOPO*********************
//objetivo: Verifica qual valor esta no topo da lista
//parametro: endereco da pilha
//retorno: valor que se encontra no topo da lista
int top(pilha P)
{
    if(SEMVALOR != vazia(P))
         return P->valor;
    else
        return SEMVALOR;
}

//*******************POP*********************
//objetivo: desempilhar um elemento da pilha
//parametro: endereco da pilha
//retorno: elemento desempilhado
int pop(pilha *P)
{
pilha tmp;
int ret;
    if(! vazia(*P))
    {
         ret = (*P)->valor;
         tmp = *P;
         *P = (*P)->prox;
         free(tmp);
         return ret;
    }
    else
        return SEMVALOR;
}
 

   Objetivo: Implementar uma fila, usando lista encadeada
 
   Entrada : elementos da fila

   Saida   : elementos que foram inseridos na fila

*/

#include <stdio.h>
#include <conio.c>
#define SEM_VALOR 9999
//estrutura da lista
typedef struct cel
{
   int val;
   struct cel *prox;
}* lista;
//estrutura da lista
typedef struct iniFim
{
        lista inicio, final;
} fila;

//prototipos
void inicializa(fila *f);
int vazia(fila *f);
void enqueue(fila *f,int val);
int dequeue(fila *f);

int main(void)
{
//Declaracoes
fila fDados;
int val;
char resp;
//Instrucoes
    inicializa(&fDados);
   do{
      printf("\nValor a ser inserido na pilha: ");
      scanf("%d",&val);
      //emfileirando dados
      enqueue(&fDados,val);
     
      do{
          printf("\nDeseja inserir mais algum numero na fila? (S/N)\n");
          resp = toupper(getche());
      }while(resp!='N' && resp!='S');
   }while(resp == 'S');
   system("cls");
   printf("Dados da fila:");
   do{
       //desemfileirando dados
       val = dequeue(&fDados);
       printf("\n %d",val);
   }while(! vazia(&fDados));
    getch();
    return 0;
}

//******INICIALIZA*******
//obj: inicializar uma fila
//parametro: endereco do inicio da fila
//retorno: nenhum
void inicializa(fila *f)
{
     f->inicio = NULL;
     f->final = NULL;
}

//*************VAZIA*************
//obj: verificar se a fila esta vazia
//parametro: endereco da fila
//retorno: 1-vazia=V, ou 0-vazia=F
int vazia(fila *f)
{
    return (f->inicio == NULL);
}

//****************ENFILEIRA****************
//obj: enfileirar dados na fila
//parametro: endereco da fila e valor a ser inserido
//retorno: nenhum
void enqueue(fila *f,int val)
{
 lista tmp;
       tmp = (lista)malloc(sizeof(struct cel));
       tmp->prox = NULL;
       tmp->val = val;
      
       if(vazia(f))
       {
           f->inicio = tmp;
           f->final = tmp;
       }
       else
       {
           f->final->prox = tmp;
           f->final = tmp;
       }
}

//******************DESENFILEIRA****************
//obj: desenfileirar itens da fila
//parametro: endereco da fila
//retorno: valor retirado da fila
int dequeue(fila *f)
{
 lista tmp;
 int retorno;
    if(!vazia(f))
    {
        tmp = f->inicio;
        retorno = f->inicio->val;
        f->inicio = f->inicio->prox;
        free(tmp);
        if(f->inicio == NULL)
            f->final = NULL;
        return retorno;
    }
    else
        return SEM_VALOR;
}

#include <stdio.h>
#include <conio.c>

typedef struct servico{
char peca[30];
struct servico *prox;
}serv ;

void push(char peca[],serv **inicio,serv **fim);
void pop(serv **inic);

int main(){

serv *fim = NULL;
serv *inicio = NULL;
serv *aux = NULL;
char opcao;
char peca[20];
int cont=0;

while(opcao!='0'){
clrscr();

printf("1 - cadastra pecas:\n");
printf("2 - apresenta pecas:\n");
printf("3 - proximo Servico:\n");
printf("0 - Sair\n\n");
printf("opcao desejada: ");
opcao = getche();
switch(opcao){
case '1':
clrscr();
printf("Digite o codigo: ");
fflush(stdin);
gets(peca);
push(peca,&inicio,&fim);
break;
case '2':
clrscr();
aux = inicio;
cont=1;
while(aux != NULL){
printf("\n%d%c %s",cont,167,aux->peca);
cont++;
aux = aux -> prox;
if(inicio==fim){
aux = NULL;
}
}
if(inicio==NULL){
printf("\n lista vazia\n");
}
getch();
break;
case '3':
clrscr();
printf(" proximo servico\n\n");
pop(&inicio);
break;
case '0':
exit(1);
default:
printf("\ninvalido\n");
getch();
clrscr();
}
}
getch();

}
//função push
void push(char n[],serv **inicio,serv **fim){

serv *temp=NULL;

temp = malloc(sizeof(serv ));
strcpy(temp->peca,n);
if(*fim!=NULL){
(*fim) -> prox = temp;
temp->prox = NULL;
}
*fim = temp;
if ((*inicio) == NULL){
*inicio = temp;
}
}
//função popcao
void pop(serv **inic){

serv *temp;

temp = *inic;
if(temp->peca!=NULL){
printf("proxima entrega = %s\n",temp->peca);
*inic = (*inic) -> prox;

free(temp);
}else{
printf("\nsem pecas");
}
getch();
}
 

#include <stdio.h>
#include <conio.c>
typedef struct no{
    int chave;
    struct no * direita;
    struct no * esquerda;
}arvore;

void push(arvore **end, int valor);
int busca(arvore **end, int valor,int cont);

void imprimir (arvore **end, int busca);
void preOrdem(arvore *end,int valor);
int menu();

int main(void)
{
// Declaracoes
      int valor=0,opcao=0,cont=0,aux;
      arvore *end=NULL;
      do{
          opcao=menu();
     
          switch(opcao){
               case 1:
                    system("cls");
                    do{                        
                         printf("\nDigite o numero (-1 para encerrar): ");
                         scanf("%d", &valor);
                         if(valor!=-1)
                             push(&end,valor);
                        
                    }while (valor!=-1);
                    system("cls");
                    break;     
               
               case 2:
                    system("cls");
                    printf("\nDigite O numero para pesquisa: ");
                    scanf("%d", &valor);  
        
                    aux = busca(&end,valor,cont);
                    if(aux==1)
                       imprimir(&end,valor);
                    getch();
                    system("cls"); 
                    break;      
          }
     }while(opcao!=3);     
     
     getch();
     return 0;
}

void push(arvore **end, int valor){  
      arvore *temp;
      if(*end == NULL){
          temp = (arvore*) malloc (sizeof (arvore));
          temp->chave = valor;
          temp->esquerda=NULL;
          temp->direita=NULL;
          *end=temp;
      }else
          if((*end)->chave < valor){
               push(&(*end)->direita,valor);
          }else if((*end)->chave > valor){
               push(&(*end)->esquerda,valor);
          }else{
               printf("\nElementos iguais, nao pode ser inserido.");
          }    
}

//Busca por valores na árvore
int busca(arvore **end, int valor,int cont){        
      if(*end == NULL){
          printf("\nNumero nao encontrado."); 
          getch(); 
          return 0;   
      }else
          if((*end)->chave == valor){
               cont++;
               printf("\nO Numero %d esta na arvore.",(*end)->chave);
               printf("\nNumero de pesquisa para esse numero e: %d ",cont);
               return 1;
          }else if((*end)->chave < valor){
                cont++;
               return busca(&(*end)->direita,valor,cont);
          }else if((*end)->chave > valor){
                cont++;
               return busca(&(*end)->esquerda,valor,cont);
          } 
}

void imprimir (arvore **end, int busca){
           if((*end)->chave == busca){
               return;
          }else if((*end)->chave < busca){
               imprimir(&(*end)->direita,busca);
          }else if((*end)->chave > busca){
               imprimir(&(*end)->esquerda,busca);
          }
           printf("\n\n %d \n",(*end)->chave);
}

//Menu
int menu(){
    int valor;
    do{
      printf("\n1 - Incluir um elemento na arvore");
      printf("\n2 - Buscar o elemento na arvore");
      printf("\n3 - Sair");
      printf("\n\nDigite a opcao: ");
      scanf("%d",&valor);
    }while(valor<=0); 
    return valor;   
}