Pilha usando lista encadeada

Publicado por Kleber de Andrade Reis 13/06/2005

[ Hits: 19.480 ]

Download pilha_n2.c




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

  



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;
};

Scripts recomendados

Métodos de Ordenação - Radix Sort

Run Length Encoding

Deep First Search

Algoritmo do método de Newton

Raiz cúbica pelo método de bissecção


  

Comentários

Nenhum comentário foi encontrado.


Contribuir com comentário




Patrocínio

Site hospedado pelo provedor RedeHost.
Linux banner
Linux banner

Destaques

Artigos

Dicas

Tópicos

Top 10 do mês

Scripts