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. 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.

O post Como implementar uma pilha em linguagem C usando array apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Anteriormente nós estudamos o funcionamento e aplicações das pilhas em estruturas de dados. Vamos ver agora como implementar uma estrutura de pilha na linguagem Java, usando um array como base.

Lembrando que também é possível implementar pilhas usando listas ligadas, assunto que abordaremos mais à frente em nosso curso de Estruturas de Dados.

Criando a Pilha

Primeiramente criaremos uma classe de nome Pilha para representar as pilhas no programa principal:

/*
Implementando operações com pilhas em Java
Criando a Classe Pilha
Implementamos as funções isEmpty, peek, push e pop
*/
public class Pilha {
   static final int MAX = 1000;
   int top;
   int a[] = new int[MAX]; // Define tamanho máximo da pilha   

   // Construtor
   Pilha() {
      top = -1;
   }

   // Métodos da pilha
   boolean isEmpty() {
     return (top < 0);
   }
   boolean push(int x) {
      if (top >= (MAX-1)) {
         System.out.println("Estouro de Pilha!");
         return false;
      }
      else {
         a[++top] = x;
         return true;
      }
   }
   int pop() {
      if (top < 0) {
         System.out.println("Pilha Vazia!");
         return 0;
      }
      else {
         int x = a[top--];
         return x;
      }
   }
   int peek() {
      if (top < 0) {
         System.out.println("Pilha Vazia!");
         return 0;
      }
      else {
         return a[top];
      }
   }
}

Usando a pilha

Para usar a nossa classe Pilha vamos instanciá-la no programa principal e realizar algumas operações push e pop para inserir e retirar itens na pilha:

// Código do main
import java.util.Scanner;
public class PilhaJava {

   public static void main(String args[]) {
      Scanner entrada = new Scanner(System.in);
      System.out.println("Entre com um número:");
      int valor = entrada.nextInt();

      Pilha novaPilha = new Pilha();

      novaPilha.push(valor);
      novaPilha.push(70);
      novaPilha.push(88);
      System.out.println("Item de valor " + novaPilha.pop() + " retirado da pilha");
      System.out.println("Item restante: " + novaPilha.peek());
      System.out.println("Item de valor " + novaPilha.pop() + " retirado da pilha");
      System.out.println("Item restante: " + novaPilha.peek()); 
   }
}

Resultado:

É isso aí! No próximo tutorial veremos como criar e utilizar pilhas em linguagem C.

Até lá!

O post Como implementar uma pilha em Java usando Arrays apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste artigo trazemos alguns exercícios resolvidos de vetores (arrays unidimensionais) para estudo em lógica de programação, com as resoluções em português estruturado, e que podem ser rodados e testados no VisualG.

Exercícios

1. Escreva um algoritmo que solicite ao usuário a entrada de 5 números, e que exiba o somatório desses números na tela.
Após exibir a soma, o programa deve mostrar também os números que o usuário digitou, um por linha.

Var
numeros : vetor [0..4] de inteiro
cont, soma : inteiro

Inicio
para cont de 0 ate 4 faca
   escreval("Entre com um número:")
   leia(numeros[cont])
   soma <- soma + numeros[cont])
fimpara

escreval("A soma dos números é", soma)
escreval()

escreval("Os números digitados foram:")
para cont de 0 ate 4 faca
   escreval(numeros[cont])
fimpara
Fimalgoritmo

2. Escreva um algoritmo que solicite ao usuário a entrada de 5 nomes, e que exiba a lista desses nomes na tela.
Após exibir essa lista, o programa deve mostrar também os nomes na ordem inversa em que o usuário os digitou, um por linha.

Var
nomes : vetor [0..4] de caractere
cont : inteiro

Inicio
para cont de 0 ate 4 faca
   escreval("Entre com um nome:")
   leia(nomes[cont])
fimpara

escreval()
escreval("Os nomes digitados foram:")

para cont de 0 ate 4 faca
   escreval(nomes[cont])
fimpara
escreval()

escreval("Os nomes digitados em ordem inversa foram:")
para cont de 4 ate 0 passo - 1 faca
   escreval(nomes[cont])
fimpara
Fimalgoritmo

3. Crie um programa que solicite a entrada de 10 números pelo usuário, armazenando-os em um vetor, e então monte outro vetor com os valores do primeiro multiplicados por 5.
Exiba os valores dos dois vetores na tela, simultaneamente, em duas colunas (um em cada coluna), uma posição por linha.

Var
nums1 : vetor [0..5] de inteiro
nums2 : vetor [0..5] de inteiro
cont : inteiro
Inicio

para cont de 0 ate 5 faca
   escreval("Digite um número:")
   leia(nums1[cont])
   nums2[cont] <- nums1[cont] * 5
fimpara
escreval()
escreval("Resultado:")
para cont de 0 ate 5 faca
   escreval(nums1[cont], " ", nums2[cont])
fimpara
escreval()
Fimalgoritmo

4. Crie um programa que armazene 10 números digitados pelo usuário em dois vetores: um somente para números pares, e outro somente para números ímpares.
Após, exiba os valores dos dois vetores na tela, em sequência.
Obs.: As posições que não receberem valores exibirão o número zero. Não se preocupe com isso por enquanto.

Var
numPar : vetor [0..9] de inteiro
numImpar : vetor [0..9] de inteiro
num, cont : inteiro
Inicio

para cont de 0 ate 9 faca
   escreval("Digite um número:")
   leia(num)
   se (num % 2 = 0 ) entao
      numPar[cont] <- num
   senao
      numImpar[cont] <- num
   fimse
fimpara
escreval()
escreval("Resultados:")
escreval("Array de Pares:")
para cont de 0 ate 9 faca
   escreval(numPar[cont])
fimpara
escreval()
escreval("Array de Ímpares:")
para cont de 0 ate 9 faca
   escreval(numImpar[cont])
fimpara
Fimalgoritmo

5. Modifique o programa anterior para não aceitar a entrada do número zero, e requisitar a digitação de outro número neste caso.

Var
numPar : vetor [0..9] de inteiro
numImpar : vetor [0..9] de inteiro
num, cont : inteiro
Inicio

para cont de 0 ate 9 faca
   escreval("Digite um número:")
   leia(num)
   enquanto (num = 0) faca
      escreval("Zero é número inválido. Digite outro número:")
      leia(num)
   fimenquanto
   se (num % 2 = 0 ) entao
      numPar[cont] <- num
   senao
      numImpar[cont] <- num
   fimse
fimpara
escreval()
escreval("Resultados:")
escreval("Array de Pares:")
para cont de 0 ate 9 faca
   escreval(numPar[cont])
fimpara
escreval()
escreval("Array de Ímpares:")
para cont de 0 ate 9 faca
   escreval(numImpar[cont])
fimpara
Fimalgoritmo

6. Modifique novamente o programa anterior, de modo a não exibir na saída os números zero que são mostrados para todas as posições que não receberam nenhum valor durante a atribuição (e portanto estão vazias).

Var
numPar : vetor [0..5] de inteiro
numImpar : vetor [0..5] de inteiro
num, cont : inteiro
Inicio

para cont de 0 ate 5 faca
   escreval("Digite um número:")
   leia(num)
   enquanto (num = 0) faca
      escreval("Zero é número inválido. Digite outro número:")
      leia(num)
   fimenquanto
   se (num % 2 = 0 ) entao
      numPar[cont] <- num
   senao
      numImpar[cont] <- num
   fimse
fimpara
escreval()
escreval("Resultados:")
escreval("Array de Pares:")
para cont de 0 ate 5 faca
   se (numPar[cont] <> 0) entao
      escreval(numPar[cont])
   fimse
fimpara
escreval()
escreval("Array de Ímpares:")
para cont de 0 ate 5 faca
   se (numImpar[cont] <> 0) entao
      escreval(numImpar[cont])
   fimse
fimpara
Fimalgoritmo

É isso aí! Em nossa próxima lição vamos mostrar uma técnica simples que permite intercambiar os valores armazenados em duas variáveis, sem que haja perda de dados.

Anterior: Atribuição de Valores e Leitura de Dados em Vetores

Próximo: Técnica para trocar valores entre duas Variáveis

O post Lógica de Programação – Exercícios resolvidos de Vetores apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Um Registro é uma estrutura que fornece um formato especializado para armazenar informações em memória.

Ele inclui as informações sobre uma entidade específica, podendo, por exemplo, corresponder às informações pertinentes a um cliente em um arquivo de clientes ou a um automóvel em um arquivo de controle de uma concessionária, entre outros.

Um registro é dividido em unidades de dados chamadas de Campos. Cada campo é utilizado para armazenar um dado específico, de um tipo determinado. Por exemplo, em um registro de clientes podemos ter um campo para armazenar o nome do cliente, outro para seu sobrenome, e um outro campo para armazenar seu CPF.

Representando os registros

Os registros podem ser representados de formas distintas, dependendo da linguagem de programação adotada para a criação do algoritmo no qual eles serão empregados. Em linguagem C, por exemplo, os registros podem ser representados por estruturas (structures), ao passo que em C++ e Java, por objetos de uma classe.

Os membros de dados dentro desses objetos equivalem aos campos no registro.

Exemplo de um registro

Tomemos como exemplo os dados de um cliente de uma loja qualquer. Para representar esses dados na memória do computador, e posteriormente armazená-los em disco, podemos lançar mão do uso de um registro.

Abaixo podemos ver alguns campos de exemplo que constituem o registro de um cliente:

O registro é identificado por um nome, como por exemplo “Cliente”, e seus membros (campos) podem ser acessados por meio do uso do operador ponto (.). Por exemplo, para acessar o CPF do cliente poderíamos utilizar a seguinte declaração:

Cliente.CPF

Além disso, um campo qualquer pode conter um outro registro, caso seja um campo de dados composto. Em nosso exemplo, o campo Rua poderia ser subdividido em mais campos, como Nome_Rua e Número_Rua, para diferenciar esses dois dados.

O conceito de Chave

Geralmente um dos campos de um registro é denominado Chave, ou ainda Campo-Chave. Usamos esse campo em particular para nos auxiliar na procura de um conjunto específico de dados dentro de um arquivo de dados (ou seja, na busca de um registro).

Em nosso exemplo, poderíamos pesquisar um cliente específico a partir de seu número de CPF, armazenado em um campo homônimo, que pode ser considerado o campo-chave.

Exemplos

A seguir temos um exemplo de implementação desse registro de clientes em C, usando uma estrutura:

struct cliente
{
  char CPF[11];
  char nome[30];
  char sobrenome[50];
  char rua[60];
  int numero;
  char telefone[11];
};

Note que na linguagem, além de definirmos os nomes de cada campo, também precisamos definir o tipo de dados de cada um, para que sejam realizadas as alocações de memória adequadas quando o registro for devidamente criado em tempo de execução do programa.

Essas estruturas são usadas para definir os registros que são armazenados em arquivos, e, juntamente com outras técnicas de programação, como os ponteiros, permitem e simplificam a criação de estruturas de dados mais complexas, como por exemplo as pilhas, listas ligadas, filas e árvores, entre outras.

(Clique aqui para saber mais sobre estruturas em linguagem C).

Nos próximos artigos vamos explorar essas e outras estruturas de dados. Até!

O post Estruturas de Dados: o Registro apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Uma Pilha é uma estrutura de dados que serve como uma coleção de elementos,  e permite o acesso a somente um item de dados armazenado – o último item que foi inserido na estrutura (item do topo). Esse item pode ser lido ou removido.

Caso seja removido, teremos acesso ao item imediatamente anterior a ele que se torna automaticamente o último item da pilha (topo), e assim sucessivamente, até que a estrutura esteja vazia.

Uma pilha difere de um array, que é outra estrutura que permite o armazenamento de itens (dados) pois o acesso aos itens de uma pilha é restrito – somente um item pode ser lido ou removido por vez, na ordem inversa em que foram colocado na pilha, ao contrário de um array (vetor), onde podemos acessar qualquer elemento em qualquer posição diretamente, sem a necessidade de acessar itens anteriores primeiro (desde que conhecida a posição do elemento que se deseja acessar).

Podemos implementar pilhas de algumas formas, como por meio de arrays ou com o uso de ADTs (Abstract Data Types / Tipos de Dados Abstratos). Estudaremos ambas as formas nestas lições.

Aplicações das pilhas

As pilhas encontram inúmeras aplicações em programação e desenvolvimento de algoritmos, como por exemplo:

• Avaliação de Expressões e Parsing Sintático
• Algoritmos de Backtracking
• Gerenciamento de Memória em Tempo de Compilação
• Implementação de diversos algoritmos, como Grahan scan e SMAWK
• Operações como desfazer e refazer em aplicações
• Controle de navegação em browsers
• Endereçamento de instruções em microprocessadores
• Análise de expressões aritméticas

e muitas outras.

Como funciona um Pilha

Para entender como uma pilha funciona, faremos uma analogia com o mundo real.

Imagine uma pilha de pratos na cozinha. Se quisermos utilizar um prato, pegamos um do topo desta pilha (último prato). Se necessitarmos de outro, pegamos o próximo da pilha (que agora é o último), e assim por diante.

Quando um prato é lavado, após seu uso, pode ser recolocado novamente na pilha de pratos, sempre no topo. Esse prato recém-colocado na pilha passa a ser o último, e o primeiro que será retirado quando precisarmos usar um prato novamente.

Essa é a ideia geral de uma estrutura de dados do tipo pilha. Nela, os dados são inseridos na pilha (empilhados), e acessados em ordem inversa (o último a ser inserido é sempre o primeiro a ser utilizado). Colocar um elemento no topo de uma pilha é uma operação que recebe um nome especial: push. Já a remoção de um elemento do topo da pilha é uma operação denominada pop.

Por conta deste modo de operação, as pilhas são classificadas como estruturas de dados de armazenamento Last-In, First-Out – LIFO, “o último a entrar é o primeiro a sair”, pois o último item inserido na pilha é sempre o primeiro a ser removido (ou lido).

A figura a seguir ilustra uma pilha contendo valores numéricos, e seu topo assinalado:

Operações Push e Pop

Uma pilha permite o acesso somente ao último item de dados inserido. Ao ser removido esse item, é possível acessar o item anterior a ele, e assim por diante. Para tal, lançamos mão de algumas operações específicas, tanto para inserir quanto para retirar itens da pilha.

As duas principais operações realizadas sobre uma pilha são as operações básicas push e pop.

A operação push é executada para adicionar um elemento ao topo de uma pilha.

A operação pop é executada para retirar um elemento do topo de uma pilha. O elemento retirado é sempre o último que foi adicionado com a operação push.

A figura a seguir ilustra a operação push em uma pilha, sendo executada duas vezes para permitir a inserção de dois novos valores em uma pilha já existente:

Operação push em uma pilha

Já a figura a seguir ilustra a operação pop sendo efetuada sobre a pilha, de modo a remover elementos. Note que se trata de uma operação exatamente inversa à operação push:

Operação pop em uma pilha

Mais sobre pilhas

As pilhas, no geral, são estruturas de dados de tamanho pequeno. Com apenas alguns itens de dados, uma pilha pode ser útil na realização de diversas tarefas computacionais.

Além das operações push e pop, existem algumas outras operações comuns implementadas em pilhas, como peek, isFull e isEmpty. A seguir temos uma breve descrição de cada uma:

• peek – Consiste na leitura do valor armazenado no topo da pilha, sem no entanto removê-lo. Às vezes chamada de top.
• isFull – Função utilizada para verificar se uma pilha está cheia (ou seja, se não é mais possível armazenar itens)
• isEmpty – Função que verifica se uma pilha está vazia – ou seja, se não é possível continuar a remover itens.

As pilhas podem ser implementadas de duas formas principais: usando arrays ou usando listas encadeadas (linked lists). Na próxima lição veremos como implementar uma pilha usando arrays em linguagem C, e posteriormente como implementar pilhas em Java.

Anterior: O que são Estruturas de Dados

Próximo: Como implementar uma pilha em linguagem C usando array.

O post Estruturas de Dados: O que são Pilhas apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Uma Estrutura de Dados consiste em uma organização de dados na memória de um computador ou em um dispositivo de armazenamento, de modo que esses dados possam ser utilizados de forma eficiente.

Estruturas de dados diversas encontram muitas aplicações em desenvolvimento de sistemas, sendo que algumas são altamente especializadas e utilizadas em tarefas específicas. Usando estruturas de dados adequadas, podemos administrar uma grande quantidade de dados de forma eficiente, com aplicações em bancos de dados ou serviços de busca e indexação de dados, e no desenvolvimento de algoritmos eficientes.

Figura 1: Estrutura de Dados básica – Array

Um Algoritmo é um conjunto de instruções detalhadas e ordenadas, cujo propósito é realizar uma tarefa ou operação específica.

Os algoritmos são utilizados para manipular dados nestas estruturas de várias formas, como por exemplo, inserindo dados, procurando itens específicos ou ainda ordenando seus elementos.

Neste tutorial vamos tratar exclusivamente da definição de Estrutura de Dados.

Operações básicas em Estruturas de Dados

No geral, em uma estrutura de dados precisamos saber como realizar um determinado conjunto de operações básicas, como por exemplo:

• Inserir um novo item
• Excluir um item existente
• Localizar (procurar) um elemento específico
• Varrer (percorrer) todos os itens constituintes da estrutura para visualização
• Classificar (ordenar), o que consiste em colocar os itens de dados em uma determinada ordem (numérica, alfabética, etc.)

Entre outras que estudaremos nas pŕoximas lições.

Estruturas de Dados principais

As principais estruturas de dados que estudaremos neste curso da Bóson Treinamentos em Tecnologia são as seguintes:

• Array (vetores e matrizes)
• Registro
• Union
• Lista encadeada
• Pilha
• Fila
• Fila de prioridades
• Árvore binária
• Tabela Hash
• Heap
• Grafo

As estruturas de dados podem implementar um ou mais tipos de dados abstratos (ADT / Abstract Data Types), os quais especificam operações que podem ser executadas em uma estrutura de dados, além da complexidade dessas operações.

A seguir, discutiremos o conceito de Registro, estrutura amplamente utilizada na construção de estruturas de dados.

Próximo: O Conceito de Registro em Estruturas de Dados

O post O que são Estruturas de Dados apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.