Como implementar uma pilha em linguagem C usando array

Como implementar uma pilha em linguagem C usando array

Pilha é uma estrutura de dados do tipo LIFO (Last In, First Out), muito importante e empregada na criação de algoritmos diversos, que funciona como uma coleção de elementos, permitindo acesso a somente um item de dados armazenado por vez – o último item inserido na estrutura (chamado de item do topo).

Esse item pode ser lido (acessado) ou removido da pilha.

É possível implementar pilhas de algumas formas, como por meio de arrays ou com o uso de ADTs (Abstract Data Types / Tipos de Dados Abstratos). Neste tutorial mostro como implementar uma pilha em C usando especificamente um array.

Para a implementação desta aplicação, faremos uso de várias estruturas importantes da linguagem C, incluindo cabeçalhos especiais, structs, ponteiros e, claro, arrays.

Uma pilha de livros.

Uma pilha de livros. O último livro a ser colocado na pilha fica no topo, e é o primeiro a ser removido.

Vamos ao código da implementação.

Código: Pilha em C com Array

A seguir temos um exemplo de código que implementa uma pilha em linguagem C usando um array:

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

// Definir o tamanho máximo da pilha
#define TAM_MAX 100

// Definir a estrutura da pilha
struct pilha {
    int topo; // índice do topo da pilha
    int items[TAM_MAX]; // array para armazenar os itens da pilha
};

// Função que cria uma pilha vazia
struct pilha* criar_pilha() {
    struct pilha* nova_pilha = (struct pilha*) malloc(sizeof(struct pilha));
    nova_pilha->topo = -1;
    return nova_pilha;
}

// Função para verificar se a pilha está vazia
int is_empty(struct pilha* pilha) {
    return pilha->topo == -1;
}

// Função que verifica se a pilha está cheia
int is_full(struct pilha* pilha) {
    return pilha->topo == TAM_MAX - 1;
}

// Função para adicionar um item ao topo da pilha
void push(struct pilha* pilha, int item) {
    if (is_full(pilha)) {
        printf("Erro: a pilha está cheia.\n");
    }
    else {
        pilha->topo++;
        pilha->items[pilha->topo] = item;
    }
}

// Função para remover o item do topo da pilha
int pop(struct pilha* pilha) {
    if (is_empty(pilha)) {
        printf("Erro: a pilha está vazia.\n");
        return -1;
    }
    else {
        int item_removido = pilha->items[pilha->topo];
        pilha->topo--;
        return item_removido;
    }
}

// Função para retornar o item do topo da pilha sem removê-lo
int peek(struct pilha* pilha) {
    if (is_empty(pilha)) {
        printf("Erro: a pilha está vazia.\n");
        return -1;
    }
    else {
        return pilha->items[pilha->topo];
    }
}

int main()
{
    struct pilha* minha_pilha = criar_pilha();

    // Adicionar alguns itens à pilha
    push(minha_pilha, 10);
    push(minha_pilha, 20);
    push(minha_pilha, 30);
    push(minha_pilha, 40);

    // Mostrar o item atual do topo da pilha
    printf("Item atual do topo: %d\n", peek(minha_pilha));

    // Remover e imprimir o item do topo da pilha
    printf("Item removido: %d\n", pop(minha_pilha));

    // Mostrar o novo item atual do topo da pilha
    printf("Item atual do topo: %d\n", peek(minha_pilha));

    return 0;
}

Funcionamento

A estrutura de dados utilizada na implementação é definida através da estrutura pilha, que contém um inteiro topo que armazena o índice do elemento que está no topo da pilha e um array de nome items que armazena os elementos da pilha. A pilha tem um tamanho máximo definido pela constante TAM_MAX.

O código contém várias funções que operam na pilha. A função criar_pilha() aloca a memória necessária para a pilha e inicializa o topo da pilha com o valor -1. A função is_empty() verifica se a pilha está vazia, ou seja, se o topo da pilha é igual a -1.

A função is_full() verifica se a pilha está cheia, ou seja, se o topo da pilha é igual a TAM_MAX – 1. A função push() adiciona um elemento ao topo da pilha, verificando se a pilha está cheia antes de adicionar o elemento. A função pop() remove o elemento do topo da pilha, verificando se a pilha está vazia antes de remover o elemento.

A função peek() retorna o elemento atual do topo da pilha, mas sem removê-lo.

O programa principal começa alocando espaço para uma nova pilha chamada minha_pilha, utilizando a função criar_pilha(). Em seguida, o programa adiciona alguns elementos à pilha utilizando a função push().

Depois, o programa mostra o elemento atual do topo da pilha utilizando a função peek(). Então, o programa remove e imprime o elemento do topo da pilha utilizando a função pop().

Por fim, o programa mostra o novo elemento atual do topo da pilha utilizando a função peek().

Ao finalizar, o programa retorna o valor 0 para indicar que a execução foi concluída com sucesso.

Note que, para fins de simplicidade, neste exemplo eu usei um tamanho máximo fixo para a pilha (TAM_MAX), mas isso pode ser modificado para permitir pilhas de tamanho variável.

Conclusão

Neste artigo vimos como realizar uma implementação básica de pilha em linguagem C usando arrays. Nos próximos artigos estudaremos a implementação de outras estruturas de dados em C, empregando técnicas variadas, inclusive reaproveitando estruturas já criadas anteriormente – como as pilhas.

 

Sobre Fábio dos Reis (1192 Artigos)
Fábio dos Reis trabalha com tecnologias variadas há mais de 30 anos, tendo atuado nos campos de Eletrônica, Telecomunicações, Programação de Computadores e Redes de Dados. É um entusiasta de Ciência e Tecnologia em geral, adora Viagens e Música, e estuda idiomas, além de ministrar cursos e palestras sobre diversas tecnologias em São Paulo e outras cidades do Brasil.
Contato: Website

Escreva um comentário

Seu e-mail não será divulgado


*