Agora que já aprendemos como fazer uma pilha estática. Agora devemos aprender como utilizar esta pilha de uma maneira dinâmica, deste modo devemos começar da seguinte forma:
-Código:
#include <stdlib.h>
#include <stdio.h>
struct TipoPilha{
int item; // Dado do tipo Inteiro que ficará dentro da pilha.
TipoPilha *prox; // Ponteiro que irá apontar para o próximo item da pilha.
};
int Pilha_contador; // Variável que irá contar o número de itens existentes na pilha.
TipoPilha *Topo; // Ponteiro que irá apontar para o item que estará no topo da pilha.
Agora já definimos nossa pilha, como podem ver ela não tem um limite de memória utilizada, pois este limite será utilizado de forma dinâmica.
----- Funções -----
Pilha_Construtor - Função que cria ou redefine a pilha para seu estado nulo.
-Código:
void Pilha_Construtor(){
Topo=NULL; // Define o topo como nulo.
Pilha_contador=0; //Define o contador como 0.
}
Pilha_Vazia - Função que irá verificar se a pilha está vazia.
-Código:
bool Pilha_Vazia(){
if(Topo==NULL){ // Caso o topo for igual a nulo ele retorna true.
return true;
}else{
return false;
}
}
Pilha_Destrutor - Função que destrói a pilha.
-Código
bool Pilha_Destrutor(){
int Aux; // Variável temporária.
TipoPilha *Temp; // Ponteiro Temporário
if( Pilha_Vazia() ){
return false; // Verifica se a pilha está vazia. Caso esteja ele retorna False.
}else{ // Caso não esteja vazia ele continua a execução.
while(Topo!=NULL){ // Enquanto topo não for nulo ele executa.
Temp=Topo; // Ponteiro Temporário aponta para Topo.
Temp->prox=NULL; // Ponteiro temporário define Prox como Nulo.
Topo=Topo->prox; // Topo vai para o próximo item.
free(Temp); // Liberamos o ponteiro temporário.
}
Pilha_contador=0; // Define o contador como 0.
return true;
}
}
Pilha_Tamanho - Função que mostra o tamanho atual da pilha.
-Código:
int Pilha_Tamanho(){
return Pilha_contador; // Retorna o valor que está dentro da variável contador.
}
Pilha_Push - Função que empilha itens na pilha.
-Código:
bool Pilha_Push(int valor){ // Recebe o valor inteiro digitado pelo usuário.
TipoPilha *Novo_item = (TipoPilha*)malloc(sizeof(TipoPilha)); // Reserva um espaço de memória para o novo item na piha.
if(Novo_item==NULL){ //Caso o SO não forneça memória RAM.
return false;
}else{
Novo_item->item = valor; // Define o item como valor.
Novo_item->prox = Topo; // prox aponta para o Topo.
Topo=Novo_item; // Topo aponta para Novo_item.
Pilha_contador++; // Contador aumenta.
return true;
}
}
Pilha_Pop - Função que desempilha itens na pilha.
-Código:
bool Pilha_Pop(int &valor){ // Recebe a referencia de valor.
TipoPilha *Temp; // Ponteiro Temporário.
if(Pilha_Vazia()){
return false; // Caso pilha esteja vazia retorna Falso.
}else{
valor = Topo->item; // Define valor como item no Topo.
Temp = Topo; // Temp aponta para Topo.
Topo = Topo->prox; // Topo aponta para Topo-Prox.
Temp->prox=NULL; //Medida de segurança para desligar a célula removida da pilha.
free(Temp); //Libera Temp (deleta).
Pilha_contador--; //Contador Diminui.
return true;
}
}
Pilha_Get - Função que pega valor que está no topo.
-Código:
bool Pilha_Get(int &valor){ //Obtém o elemento no topo da pilha.
if(Pilha_Vazia()){
return false; // Caso pilha esteja vazia ele retorna falso.
}else{
valor=Topo->item; // Define valor como Topo-Item.
return true;
}
}
Agora que criamos todos estes métodos, devemos então utiliza-los para criar a pilha, assim como na postagem anterior, não vou utilizar muitos métodos, já que cada um deve ser usado dependendo de sua necessidade. Porém irei adicionar uma pequena parte do código principal como exemplo.
-Código:
int main(){
Pilha_Construtor(); //cria o começo da pilha.
system("pause");
return 0;
}
Basicamente é isto, agora você pode pegar as funções acima e ir fazendo a sua pilha de acordo com sua necessidade. Por fim vou adicionar aqui o video que eu assisti para trazer todas estas informações acima aqui para o blog. Aconselho muito a vocês assistirem!
Video/Referência:
Nenhum comentário:
Postar um comentário