ae galera esse é um exemplo de pilha usando lista encadeada.....
muito legal esse script....!!!!

• Download pilha_n2.c
• Enviar nova versão

Esconder código-fonte

/*
 +-----------------------------------------------------------+
 | Programador...: Kleber de Andrade Reis                    |
 | Descrição.....: Programa da lista de exercicio            |
 | Professor ....: Evanderson                                | 
 | Arquivo.......: pilha_n2.c                                |
 +-----------------------------------------------------------+

Lista Simplesmente Encadeada

   Desenvolva um programa, implementando as seguintes operações em pilhas. (cria, empilha, desempilha, vazia, imprime, topo e libera) utilizando structs para controle de alunos e notas dos 4 bimestres. 
Sendo:
Cria: cria uma nova pilha vazia.
Empilha: inclui (empilha) um elemento da pilha
Desempilha: exclui (desempilha) um elemento da pilha
Vazia: retorna se a pilha está vazia ou não
Imprime: Imprime no vídeo os elementos da pilha
Topo: retorna o elemento que está no topo da pilha sem retirá-lo da pilha.

   Desenvolva uma rotina para desempilhar dois elementos na pilha (desempilha2).


   Desenvolva uma rotina para desempilhar n elementos a partir do topo da pilha (desempilhan).

   Desenvolva uma rotina para desempilhar todos os elementos da pilha (esvaziar a pilha).

   Utilizando apenas as funções desenvolvidas anteriormente, dadas por (cria, empilha, desempilha, vazia, imprime, topo e libera). Implemente uma função que receba uma pilha como parâmetro e retorno como resultado uma cópia dessa pilha. Essa função deve obedecer ao protótipo:
Pilha* copia_pilha (Pilha* p);
   
Obs.: Ao final da função copia_pilha, a pilha p recebida como parâmetro deve estar no mesmo estado em que ela começou a função.

   Utilizando apenas as funções desenvolvidas anteriormente, dadas por (cria, empilha, desempilha, vazia, imprime, topo e libera). Implemente uma função que teste se duas pilhas são iguais ou não. Essa função deve obedecer ao seguinte protótipo:
Int pilhas_iguais (Pilha* p1, Pilha* p2);
*/

#include <stdio.h>
#include <stdlib.h>
#define MALLOC(x) ((x *) malloc (sizeof(x)))


//declaração da estrutura
struct no{
   int n1,n2,n3,n4;
   char aluno[30];
   struct no *proximo;
         };

typedef struct no no_t;
no_t *novo;


//declaração das funções
no_t *cria(no_t *lista);
no_t *insini(no_t *lista);
no_t *retira(no_t *lista);
int imprime(no_t *lista);
int vazia(no_t *lista);
int topo(no_t *lista);
no_t *libera(no_t *lista);
no_t *desempilha2(no_t *lista);
no_t *desempilhan(no_t *lista,int j);
no_t *copia_pilha (no_t *p);
int pilhas_iguais(no_t *p1, no_t *p2);


int main(void)
{
   int op,k,r,m;
   no_t *lista;
   no_t *pilha;
   pilha=NULL;
   for (;;)
   {
      system("clear");
      printf("\n0 - Cria uma lista");
      printf("\n1 - Empilha um elelmento");
      printf("\n2 - Menu de desempilhamento");
      printf("\n3 - Verifica se a pilha esta vazia");
      printf("\n4 - Imprime os elementos da pilha");
      printf("\n5 - Imprime o topo da pilha");
      printf("\n6 - Libera memoria");
      printf("\n7 - Copia uma pilha identica");
      printf("\n8 - compara as duas pilhas");
      printf("\n9 - Sair");
      printf("\n\nSua opcao: \n");
      scanf("%d",&op);
      switch(op){
         case 0 : 
       lista=cria(lista);
            break;
         case 1 : 
            getchar();
            lista=insini(lista);
            break;                           
         case 2 :
       system("clear");
            printf("Digite a quantidade a ser desempilhada\n");
            scanf("%d",&k);
            if(k==1)
            {
               lista=retira(lista);
               break;
            }
            else if(k==2)
            {
               lista=desempilha2(lista);
               break;
            }    
            lista=desempilhan(lista,k);
            break;
         case 3 :
            vazia(lista);
            break;
         case 4 : 
            imprime(lista);
            break;
         case 5 :
            topo(lista);
            break;
         case 6 : 
            lista=libera(lista);
            break;
         case 7 :
       pilha=copia_pilha(lista); 
            break;
         case 8 :
            system("clear");
       m=pilhas_iguais(lista,pilha); 
       if(m==1)
               printf("As pilhas sao identicas!!!\n");
            else
               printf("As pilhas sao diferentes!!!\n");
            sleep(3);
            break;
         case 9 : 
            exit(0);
         default: 
            system("clear");
            printf("Opção Errada");
            scanf("%d",&k);
      }
   }    
   return 0;            
}


no_t *cria(no_t *lista){
   system("clear");
   lista = MALLOC(no_t);
   lista=0;
   printf("Lista criada com sucesso!!!\n");
   sleep(3);
   return lista;
};


no_t *retira(no_t *lista)
{
   no_t *p;
   p=lista;
   if(lista!=NULL)
   {
      lista=lista->proximo;
      free(p);
      return lista;
   }
   return NULL;
};


no_t *libera(no_t *lista)
{
   no_t *p;
   p=lista;
   if(lista!=NULL)
   {
      while(p!=NULL)
      {
         p=lista->proximo;
         free(lista);
         lista=p;
      }
   }
    return NULL;
};


no_t *insini(no_t *lista)
{
   int n1,n2,n3,n4;
   char al[30];

   printf("Digite o nome do aluno\n");
   gets(al);
   printf("N1: ");
   scanf("%d",&n1);
   printf("N2: ");
   scanf("%d",&n2);
   printf("N3: ");
   scanf("%d",&n3);
   printf("N4: ");
   scanf("%d",&n4);

   novo = MALLOC(no_t);
   novo->proximo = lista; 
   sprintf(novo->aluno,"%s",al);
   novo->n1 = n1;
   novo->n2 = n2;
   novo->n3 = n3;
   novo->n4 = n4;  
   return novo;
};


int imprime(no_t *lista)
{
   no_t *p;
   int k,i=0;
   system("clear");
   if (lista==NULL)
   {
      system("clear");
      printf("Lista Vazia");
      scanf("%d",&k);
      return 0;
   }
   p = lista;
   do{
      printf("\nAluno: %s",p->aluno);
      printf("\nN1: %d",p->n1);
      printf("\nN2: %d",p->n2);
      printf("\nN3: %d",p->n3);
      printf("\nN4: %d",p->n4);
      printf("\n");
      p = p->proximo;
      i++;
   }while (p!=NULL);
   printf("\n\nTEM %d ITENS NA LISTA",i);  
   scanf("%d",&k);
   return 0; 
};


int vazia(no_t *lista)
{
   system("clear");
   no_t *p;
   p=lista;
   int i=0;
   while(p!=NULL)
   {
      p=p->proximo;
      i++;
   }
   if(i==0)
      printf("A lista esta vazia!!!\n");
   else
      printf("\n\nTEM %d ITENS NA LISTA",i);
   sleep(3);
   return i;
};

int topo(no_t *lista)
{
   no_t *p;
   int k,i=0;
   system("clear");
   if (lista==NULL)
   {
      system("clear");
      printf("Lista Vazia");
      scanf("%d",&k);
      return 0;
   }
   p = lista;

   printf("\nAluno: %s",p->aluno);
   printf("\nN1: %d",p->n1);
   printf("\nN2: %d",p->n2);
   printf("\nN3: %d",p->n3);
   printf("\nN4: %d",p->n4);
   printf("\n");  
   scanf("%d",&k);
   return 0; 
};


no_t *desempilha2(no_t *lista)
{
   int i=0;
   no_t *p;
   p=lista;
   
   while(i<2)
   {
      if(lista!=NULL)
      {
         lista=lista->proximo;
         free(p);
    p=lista;
      }
      else
         return NULL;
      i++;        
   }
   return lista;
};


no_t *desempilhan(no_t *lista,int j)
{
   int i=0;
   no_t *p;
   p=lista;
   
   while(i<j)
   {
      if(lista!=NULL)
      {
         lista=lista->proximo;
         free(p);
    p=lista;
      }
      else
         return NULL;
      i++;        
   }
   return lista;
};


no_t *copia_pilha (no_t *p)
{
   no_t *aux,*pri;
   aux=NULL;
   pri=NULL;
   if(p==NULL)
      return NULL;
   else
   {
      novo = MALLOC(no_t);
      sprintf(novo->aluno,"%s",p->aluno);
      novo->n1=p->n1;
      novo->n2=p->n2;
      novo->n3=p->n3;
      novo->n4=p->n4;
      aux=novo;
      pri=novo;
   }
   p=p->proximo;
   while(p!=NULL)
   {
      novo = MALLOC(no_t);
      sprintf(novo->aluno,"%s",p->aluno);
      novo->n1=p->n1;
      novo->n2=p->n2;
      novo->n3=p->n3;
      novo->n4=p->n4;
      aux->proximo=novo;
      aux=novo;
      p=p->proximo;
   }
   aux->proximo=NULL;
   return pri;  
};


int pilhas_iguais(no_t *p1, no_t *p2)
{
   if((p1==NULL)||(p2==NULL))
   {
      printf("Pelo menos uma lista esta vazia\n");
      sleep(3);
      return 0;
   }
   while((p1!=NULL)&&(p2!=NULL))
   {
      if(!strcmp(p1->aluno,p2->aluno)&&(p1->n1==p2->n1)&&(p1->n2==p2->n2)&&(p1->n3==p2->n3)&&(p1->n4==p2->n4));         
      else
         return 0;
      p1=p1->proximo;
      p2=p2->proximo;
   }
   return 1;
};

Método eficiente de armazenamento utilizando containers (Vector e Map)

Ordenação Bolha

Fila

Métodos de Ordenação - Radix Sort

Algoritmo de Ordenação Radix

Nenhum comentário foi encontrado.