Tweet

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.

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.