Estruturas de Dados em C#: Part 2 -> Pilha

Publicado: 17/11/2004 em IntoSpaces
Nessa série de estruturas de dados em C#, vou regredir um pouco, pois acabei por engano me esquecendo de estruturas mais simples, que devem ser mostradas antes da Lista Simplesmente Encadeada, Pilha e Fila.

Hoje mostrarei uma pilha aqui. A estrutura de dados Pilha(Stack), como o próprio nome já diz se dispõe a empilhar os dados, como se fossem uma pilha de livros.
Essa estrutura é do tipo LIFO, last-in-first-out, ou seja o último a entraré o primeiro a sair, da mesma forma como seria uma pilha de livros, o último livro depositado na pilha precisa ser o primeiro a sair para não desmontar a pilha e desorganizar tudo que estava empilhado.

Nossa classe Stack é bem simples, com propriedades quem informam se a pilha está vazia e quantos objetos estão empilhados na pilha e métodos para remoção, inserção e listagem de objetos, seguindo a linha de raciocínio LIFO.
Um método interessante é o ToArray(), que gera um array da sua pilha, no caso um array seria a primeira estrutura um pouco mais complexa para se armazenar dados, mas não precisamos abordar ele aqui pois já é de conhecimento de todos certo?

Antes da codificação vale lembrar que a biblioteca de classes do .NET Framework já vem com uma implementação para pilha de dados LIFO, ela está localizada no Namespace System.Collections.Stack, você pode ver que os métodos são muito próximos desses mostrados aqui.

Vejam as classes, Stack e Objects, onde objects seria uma coleção de objetos para facilitar o nosso trabalho, deixando tudo mais limpo, como no exemplo anterior da Lista Simplesmente Encadeada.

using System;
using System.Collections;
namespace Estruturas
{
  
public class Stack
   {
         private object top = null;
         private Objects objs = new Objects();
         private bool isEmpty = true;
         private int count = 0;

         public bool IsEmpty
         {get{return isEmpty;}}

         public int Count
         {get{return count;}}

         public void Push(object obj)
         {
              objs.Add(obj);
              count++;
              top = obj;
              if(isEmpty)
                isEmpty = false;
         }

         public object Pop()
         {
              object robj = null;
              if(!isEmpty)
              {
                 robj = top;
                 objs.Remove(count–);
                 if(count > 0)
                    top = objs[count-1];
                 else
                 {
                    top = null;
                    isEmpty = true;
                 }
           }
           return robj;
      }

       public object Peek()
       {return top;}

        public void Clear()
        {
           objs.Clear();
           isEmpty = true;
           count = 0;
         }

          public object[] ToArray()
          {
              object[] obj = new object[objs.Count];
              for(int i = 0; i < objs.Count; i++)
              {
                  obj[i] = objs[i];
               }
               return obj;
          }
   }

   public class Objects : CollectionBase
   {
        public object this[int item]
        {get{return this.GetObject(item);}}

         public void Add(object obj)
         {
             List.Add(obj);
         }

         public void Clear()
         {
             List.Clear();
         }

         public bool Remove(int index)
         {
            if (index > Count – 1 || index < 0)
                return false;
             else
             {
                 List.RemoveAt(index);
                 return true;
             }
          }

          private
object GetObject(int Index)
          {
              return List[Index];
           }
      }
}

Bastante simples não? Uma estrutura pode ajudar bastante quando ser precisa otimizar uma aplicação empilhando dados.
Porém vale lembrar que é recomendado utilizar as Classes do .NET Framework, que são otmizadas ao máximo para essas tarefas.

Os fontes comentados junto com programa de demonstração estão em www.shindesign.net/thespoke/pt-br/11-11-2004/pilha.zip

Para quem quiser dar uma olhada na primeira parte dessa série de posts sobre estruturas de dados visite
Estruturas de Dados em C#: Part 1 :: Lista Simplesmente Encadeada
e confira uma explicação um pouco melhor sobre a coleção de dados.

Espero que seja útil para vocês e que sirva para esclarecer e mostrar como a Orientação a Objetos nos ajuda, principalmente com os Objetos Relacionais do .NET Framework.

Grande abraço e até a próxima
Shinji

Deixe uma resposta

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s