Escreva o algoritmo da pilha estática

Algoritmo em C, que representa um Pilha Estática, o algoritmo só cadastra um valor, mostrando o conceito de uma pilha feita em C.

#include <stdio.h>
#define T 5

typedef struct{
        int topo;
        int elementos[T];
}PILHA;

void iniciarPilha(PILHA *p);
int menu();
int overflow(PILHA *p);
int underflow(PILHA *p);
int push(PILHA *P, int *x);
int pop(PILHA *p);
void imprimir(PILHA *p);

int main(){
    PILHA pil;
    int opc, novo;
  
    iniciarPilha(&pil);
  
    do{
        opc = menu();
      
        switch(opc){
            case 1:
                
                 if(!overflow(&pil)){
                     printf("informe um novo valor: ");
                     scanf("%d", &novo);printf("valor %d inserido!\n", push(&pil, &novo));
                    
                 }else
                     printf("Pilha cheia!\n");
                    
                 getche();
                 system("cls");
            break;           
            case 2:
                
                 if(!underflow(&pil))
                     imprimir(&pil);
                 else
                     printf("pilha vazia!\n");
                    
                 getch();
                 system("cls");
            break;
            case 3:
                
                 if(!underflow(&pil))
                     printf("valor %d removido!\n", pop(&pil));
                    
                 else
                     printf("Pilha vazia!\n");
                    
                 getche();
                 system("cls");
            break; case 0: break;
            default: printf("opcao %d incorreta!\n",opc);
        }
    }while(opc != 0);
}
void iniciarPilha(PILHA *p){
     p->topo = -1;
}

int menu(){
    int opc;
  
    printf("1-inserir elemento\n"
           "2-Imprimir pilha\n"
           "3-remover elemento\n"
           "0-sair\n");
    scanf("%d", &opc);
    return opc;
}

int overflow(PILHA *p){
    return p->topo == T -1;
}

int underflow(PILHA *p){
    return p->topo == -1;
}

int push(PILHA *p, int *x){
    p->topo++;
    p->elementos[p->topo] = *x;return p->elementos[p->topo];
}

int pop(PILHA *p){
    int ult;
    ult = p->elementos[p->topo];
    p->topo--;
  
    return ult;
}

void imprimir(PILHA *p){
     int aux;
    
     for(aux = p->topo; aux >= 0; aux--)
         printf("elemento[%d] = %d\n", aux+1, p->elementos[aux]);
} 

Para responder essa questão devemos aplicar nosso conhecimento sobre algoritmo e programação.

Aplicando o método TAD – Tipo abstrato de dados, temos o código:

#include<stdio.h>

#include<stdlib.h>

#include"Pilha.h"

# define max 20

struct pilha {

int vetor [max];

int topo;

};

Pilha cria_pilha () {

Pilha p;

p = (Pilha) malloc (sizeof (struct pilha));

if (p != NULL) p->topo = -1;

return p;

}

int pilha_vazia (Pilha p) {

if (p->topo == -1) return 1;

else return 0;

}

int pilha_cheia (Pilha p) {

if (p->topo == max-1) return 1;

else return 0;

}

int push (Pilha p, int elem) {

if (p == NULL || pilha_cheia(p) == 1) return 0;

p->topo++;

p->vetor[p->topo] = elem;

return 1;

}

int pop (Pilha p, int *elem) {

if (p == NULL || pilha_vazia(p) == 1) return 0;

*elem = p->vetor[p->topo];

p->topo--;

return 1;

}

typedef struct pilha * Pilha;

Pilha cria_pilha ();

int pilha_vazia (Pilha p);

int pilha_cheia (Pilha p);

int push (Pilha p, int elem);

int pop (Pilha p, int *elem);

#include<stdio.h>

#include<stdlib.h>

#include"Pilha.h"

int main(){

char expre[20], removi;

int i;

scanf("%s", &expre);

Pilha p;

p=cria_pilha();

for(i=0; expre!=´´; i++){

if(expre[i]== ´+´ || expre[i]==´-´ || expre[i]==´*´ || expre[i]==´⁄´){

pop(p, &removi);

}else{

push(p, expre[i]);

}

}

if(pilha_vazia(p)==1) printf("Escopo valido ");

else printf("Escopo invalido ");

return 0;

}

Portanto temos acima o código que valida o escopo de uma expressão posfixa.

Para responder essa questão devemos aplicar nosso conhecimento sobre algoritmo e programação.

Aplicando o método TAD – Tipo abstrato de dados, temos o código:

#include<stdio.h>

#include<stdlib.h>

#include"Pilha.h"

# define max 20

struct pilha {

int vetor [max];

int topo;

};

Pilha cria_pilha () {

Pilha p;

p = (Pilha) malloc (sizeof (struct pilha));

if (p != NULL) p->topo = -1;

return p;

}

int pilha_vazia (Pilha p) {

if (p->topo == -1) return 1;

else return 0;

}

int pilha_cheia (Pilha p) {

if (p->topo == max-1) return 1;

else return 0;

}

int push (Pilha p, int elem) {

if (p == NULL || pilha_cheia(p) == 1) return 0;

p->topo++;

p->vetor[p->topo] = elem;

return 1;

}

int pop (Pilha p, int *elem) {

if (p == NULL || pilha_vazia(p) == 1) return 0;

*elem = p->vetor[p->topo];

p->topo--;

return 1;

}

typedef struct pilha * Pilha;

Pilha cria_pilha ();

int pilha_vazia (Pilha p);

int pilha_cheia (Pilha p);

int push (Pilha p, int elem);

int pop (Pilha p, int *elem);

#include<stdio.h>

#include<stdlib.h>

#include"Pilha.h"

int main(){

char expre[20], removi;

int i;

scanf("%s", &expre);

Pilha p;

p=cria_pilha();

for(i=0; expre!='\0'; i++){

if(expre[i]== '+' || expre[i]=='-' || expre[i]=='*' || expre[i]=='/'){

pop(p, &removi);

}else{

push(p, expre[i]);

}

}

if(pilha_vazia(p)==1) printf("Escopo valido\n");

else printf("Escopo invalido\n");

return 0;

}

Portanto temos acima o código que valida o escopo de uma expressão posfixa.