Problemas com Torre de Hanoi

CrazyHommer · 1 de setembro de 2011

Galera, eu preciso entregar esse trabalho sobre torre de Hanoi e infelizmente não consigo finalizar ele, o algoritmo com a lógica está pronto e funcionando, porém preciso fazer com que apareçam os discos no e em quais torres eles estão ao invés de mova o disco x para a torre y. Não precisa ser algo muito espetacular, pode apenas serem riscos no lugar de discos, ja ajudaria bastante, mas é que não tenho ideia de como fazer :/ ... Tentei usando o código ASCII com o traço (numero 220 do código) mais não deu muito certo, alguem poderia me dar algumas dicas ou me mostrar como fazer?

Este é meu código:

#include <stdio.h>
#include <conio2.h>

void movedisco (int n, char orig, char dest, char aux)
{
   if (n==1) 
   {
        printf("\nMover disco 1 da torre %c para a torre %c", orig, dest);
        return;
   }

	movedisco(n-1,orig,aux,dest);
	printf("\nMover disco %d da torre %c para a torre %c", n, orig, dest);
	movedisco(n-1,aux,dest,orig);
}

main(){
   int discos;
   textcolor(RED);
   puts("--------------------------------------------------------------------------------");

   printf("\t\t\t\tTORRE DE HANOY");

   puts("\n\n\n--------------------------------------------------------------------------------\n");
   normvideo();

   printf("Digite a quantidade de discos: ");
   scanf("%d",&discos);


   movedisco(discos,'A','C','B');
   getch();

}

CrazyHommer · 4 de setembro de 2011

Galera, fiz uma pequena alteração no código, mais ainda não consigo mostrar as torres, ninguém sabe como fazer?

Novo código:

#include <stdio.h>
#include <conio2.h>
#include <math.h>

void movedisco (int n, char orig, char dest, char aux)
{
   if (n==1) 
   {
        printf("\nMover disco 1 da torre %c para a torre %c", orig, dest);
        return;
   }

	movedisco(n-1,orig,aux,dest);
	printf("\nMover disco %d da torre %c para a torre %c", n, orig, dest);
	movedisco(n-1,aux,dest,orig);
}

main()
{
   int discos, total_mov;
   textcolor(RED);
   puts("--------------------------------------------------------------------------------");

   printf("\t\t\t\tTORRE DE HANOY");

   puts("\n\n\n--------------------------------------------------------------------------------\n");
   normvideo();

   printf("Digite a quantidade de discos: ");
   scanf("%d",&discos);

   total_mov = pow(2, discos)-1 ;


   movedisco(discos,'A','C','B');

   printf("\n\nO total de movimentos feitos foram: %d", total_mov);


   getch();

}

SharaMoustache · 5 de setembro de 2011

Nem torre tem, vai imprimir como?

Use no mínimo arrays que você chega em algum lugar.

CrazyHommer · 8 de setembro de 2011

Nem torre tem, vai imprimir como?
Use no mínimo arrays que você chega em algum lugar.

Shara, acho que você não entendeu meu problema ou eu que não consegui explicar direito, deixe-me tentar novamente.

Eu não preciso criar uma torre, posso apelas colocar "underlines" um em cima do outro para simular uma piramide, entende? Tenho que "printar" na tela cada movimento, por exemplo, na "torre" A tem 3 discos e na torre B e C não tem nenhum, ao passar o disco 3 para a "torre" C, é só colocar um risco no lugar onde seria a torre C e aparecer apenas 2 discos na torre A, e assim sucessivamente até o programa terminar o jogo, não precisa aparecer nenhuma "torre" apenas algo para demonstrar os discos, e um espaço como se fosse a separação das torres, para o espaço pensei em usar o goto(x,y) ... mas não tenho ideia de como fazer a demonstração :/

Alguém pode me ajudar, este trabalho vale 30 pontos e é pra semana que vem, não consigo de maneira nenhuma, ja perdi horas tentando ...

Bom, vou ficar esperando alguma ajuda.

@EDIT

Galera, tentei fazer algo aqui mas não está dando certo, consigo printar os "discos" mais se eu digito 7 discos, aparecem apenas 6 :/ ... E ainda falta o problema com a continuação do jogo, para ir trocando os discos ao invés de Mover disco X para a torre Y ...

Será que agora alguém consegue dar uma ajuda?

Código:

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

void movedisco (int n, char orig, char dest, char aux)
{
   if (n==1) 
   {
        printf("\nMover disco 1 da torre %c para a torre %c", orig, dest);
        return;
   }

	movedisco(n-1,orig,aux,dest);
	printf("\nMover disco %d da torre %c para a torre %c", n, orig, dest);
	movedisco(n-1,aux,dest,orig);
}



void mostra_discos (int num_discos, int i, int j, int x)
{
   for(i=1; i<num_discos; i++)
   {
            for(j=1; j<=i+x; j++)
            {
                     gotoxy(10-j+x, 5+i);
                     printf("\xDC");
            }

            x++;
   }

   gotoxy(10,20);
   printf("A");

   gotoxy(40,20);
   printf("B");

   gotoxy(70,20);
   printf("C");
}

main()
{
   int discos, total_mov, i, j, x=0;

   textcolor(RED);
   puts("--------------------------------------------------------------------------------");

   printf("\t\t\t\tTORRE DE HANOY");

   puts("\n\n\n--------------------------------------------------------------------------------\n\n");
   normvideo();

   printf("Digite a quantidade de discos: ");
   scanf("%d",&discos);

   total_mov = pow(2, discos)-1 ;

   mostra_discos(discos, i, j, x);

   movedisco(discos,'A','C','B');

   printf("\n\nO total de movimentos feitos foram: %d", total_mov);


   getch();

}

Obs.: A biblioteca <stdlib.h> foi incluída pra quando terminar o código eu colocar um delay pro usuário ver a "movimentação"

SharaMoustache · 9 de setembro de 2011

Se você tiver uma variável para cada torre (contendo a quantidade de discos), basta usar for e imprimir...

Como você usa gotoxy, dá pra alinhar as torres tranquilamente...

CrazyHommer · 9 de setembro de 2011

Se você tiver uma variável para cada torre (contendo a quantidade de discos), basta usar for e imprimir...
Como você usa gotoxy, dá pra alinhar as torres tranquilamente...

Então, o problema é que eu não estou conseguindo pensar numa maneira de fazer isso, não consigo pensar na lógica, um colega meu conseguiu fazer, mas não queria copiar, quero fazer, não quero pegar pronto ... Ele usou o switch e fez os discos trocarem de variáveis, por exemplo o disco esta na torre ORI que é a torre de origem ou a torre A, depois ele manda o disco para a torre C que é a torre dest, ou destino/ torre C, mais nao consigo pensar em como fazer isso :/

SharaMoustache · 9 de setembro de 2011

Se for um inteiro de quantidade de discos, fica um inteiro para cada torre, contendo a quantidade de discos.

você vai usar o gotoxy para posicionar o cursor no ponto mais alto de torre que você desejar, aí você subrai da quantidade de discos presente na torre atual e salta essa quantidade de posições para baixo, a partir daí você imprime a quantidade de discos na torre. Para a do meio, a mesma coisa e assim por diante...

Uma maneira mais fácil em vez de usar isso é usando uma variável de controle(quantidade total de discos) e um for simples sem gotoxy, só imprimindo '-' caso na altura atual exista disco na torre...

E obviamente, se um disco sai de uma torre para outra:

torreA--;

torreB++;

...

CrazyHommer · 23 de setembro de 2011

Galera, dei uma pequena mexida no código, consegui imprimir a torre, agora só faltam os movimentos que não to conseguindo fazer de maneira nenhuma, e o trabalho é pra entregar hoje, to meio que desesperado, não posso ficar sem entrega-lo, espero que alguem consiga me ajudar :/

Aqui ta a última modificação do código

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

void movedisco (int n, char orig, char dest, char aux)
{
   if (n==1) 
   {
        printf("\nMover disco 1 da torre %c para a torre %c", orig, dest);
        return;
   }

	movedisco(n-1,orig,aux,dest);
	printf("\nMover disco %d da torre %c para a torre %c", n, orig, dest);
	movedisco(n-1,aux,dest,orig);
}



void mostra_discos (int num_discos, int i, int j, int x)
{
   for(i=1; i<=num_discos; i++)
   {
            for(j=1; j<=i+x; j++)
            {
                     gotoxy(10-j+x, 13+i);
                     printf("\xDC");
            }

            x++;
   }

   gotoxy(10,20);
   printf("A");

   gotoxy(40,20);
   printf("B");

   gotoxy(70,20);
   printf("C");
}

main()
{
   int discos, total_mov, i, j, x=0;

   textcolor(RED);
   puts("--------------------------------------------------------------------------------");

   printf("\t\t\t\tTORRE DE HANOY");

   puts("\n\n\n--------------------------------------------------------------------------------\n\n");
   normvideo();

   printf("Digite a quantidade de discos: ");
   scanf("%d",&discos);

   total_mov = pow(2, discos)-1 ;

   mostra_discos(discos, i, j, x);

   movedisco(discos,'A','C','B');

   printf("\n\nO total de movimentos feitos foram: %d", total_mov);

   getch();

}

Por favor, se alguem souber como resolver ele eu fico muito grato MESMO ... Fico esperando por respostas. E valeu por toda a ajuda pessoal

SharaMoustache · 23 de setembro de 2011

Torre de hanoi é basicamente comparações de pares de torres...

Suponha que você tenha 3 torres. A, B e C.

A começa com todos os discos.

A partir daí você faz com parações par a par, ou seja, ou compara A e B ou B e C.

**** que para torre de Hanoi mesmo você teria que ter vetores para diferenciar o tamanho dos discos...

Porque você não pode colocar um disco maior em cima de um menor...

Por que a comparação é simplesmente essa:

(considerando as torres como structs...)

if( (torreA->discos[ torreA->topoA ]) < (torreB->discos[ torreB->topoB ]) )
{
    movedisco(torreA,torreB)
}
else
{
    movedisco(torreB,torreA);
}

Sem vetor fica basicamente transferência simples de discos entre torres...

Sem problema nenhum...

-

CrazyHommer · 24 de setembro de 2011

Se for um inteiro de quantidade de discos, fica um inteiro para cada torre, contendo a quantidade de discos.
você vai usar o gotoxy para posicionar o cursor no ponto mais alto de torre que você desejar, aí você subrai da quantidade de discos presente na torre atual e salta essa quantidade de posições para baixo, a partir daí você imprime a quantidade de discos na torre. Para a do meio, a mesma coisa e assim por diante...

Uma maneira mais fácil em vez de usar isso é usando uma variável de controle(quantidade total de discos) e um for simples sem gotoxy, só imprimindo '-' caso na altura atual exista disco na torre...

E obviamente, se um disco sai de uma torre para outra:

torreA--;

torreB++;

...

Não sei se fiz exatamente o que você havia dito mas consegui, claro com algumas ajudas de amigos, mais consegui, ficou meio complexo mais o importante é que está funcionando =).

Conversei com o professor e vou poder entregar o trabalho na segunda-feira, porém gostaria de saber se tem como deixar o mesmo menor, ou até mais simples. Não consegui fazer o desenho das torres como no código acima, então usei "─" ... Queria conseguir colocar aquelas barras que havia colocado, só que não estou conseguindo, se alguém puder me ajudar a colocar elas fico grato, e se tiver como diminuir o código em alguma coisa também =)

Bom galera, de antemão eu agradeço a ajuda de todos que ajudaram, Shara, você ajudou DEMAIS, então valeu mesmo.

Bom, o código finalizado está aqui, se tiver mais alguma sugestão de como resolver os casos acima, ficaria muito feliz *-* ... hehehe

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

int A, B, C, tam, es, mov=0;

void limpa(int i,int es,int n)
{
     int j;

     for(j=0;j<=i*2;j++)
     {
         if(j+1==n || j+1==n+es || j+1==n+(es*2))
         {
            putchar(179);
         }
         else
         {
            putchar(' ');
         }
     }
}

void pecas(int i,int es,int n)
{
     int j;

     for(j=0;j<=i*2;j++)
     {
         if(j+1==n || j+1==n+es || j+1==n+(es*2))
         {
            putchar(197);
         }  
         else
         {
            putchar(196);
         }
     } 

     gotoxy(1, tam+4);
     printf("Quantidade de movimentos: %d",mov);

}

void desenha(char origem, char dest, int n)
{
     int i,j;

     mov++;
     if(origem == 'A')
     {
        A--;
     }  
     else
         if(origem == 'B')
         {
            B--;
         }
         else
             if(origem == 'C')
             {
                C--;
             }
                for(i=0;i<n;i++)
                {
                    if(origem == 'A')
                    {
                       gotoxy(tam-i,tam-A); 
                       }  
                     else
                         if(origem == 'B')
                         {
                            gotoxy(tam-i+es,tam-;
                            }
                         else
                             if(origem == 'C')
                             {
                                gotoxy(tam-i+(es*2),tam-C);
                                }
                     limpa(i, es, n);           
                }


        if(dest=='A')
        {
           A++;
        }

        else
            if(dest=='B')
            {
               B++;
            }

            else
                if(dest=='C')
                {
                   C++;
                }  
        for(i=0;i<n;i++)
        {
            if(dest=='A')
            {
               gotoxy(tam-i,tam-A+1);
            }

            else
                if(dest=='B')
                {
                   gotoxy(tam-i+es,tam-B+1);
                }
                else
                    if(dest=='C')
                    {
                       gotoxy(tam-i+(es*2),tam-C+1);
                    }

            pecas(i, es, n);
        }
        _sleep(1000);  
}

int transporta(int n, char origem, char aux, char dest)
{
      int i,j;
      if(n==1)
      {
         desenha(origem,dest,n);
         return 1;
      }
      else
      {
          transporta(n-1, origem, dest, aux);
          desenha(origem, dest, n);
          transporta(n-1, aux, origem, dest);
      }
}



main()
{   
   textcolor(RED);
   puts("--------------------------------------------------------------------------------");

   printf("\t\t\t\tTORRE DE HANOY");

   puts("\n\n\n--------------------------------------------------------------------------------\n\n");
   normvideo();

      int i, discos, j;

      printf("Quantidade de discos: "); 
      scanf("%d", &discos);

      system("cls");

      es = discos + 25;

      //Desenhando as torres.
      for(i=0;i<discos;i++)
      {
          gotoxy(discos-i,i+1);

          for(j=0;j<=i*2;j++)
          {
              if(j==i)
              {
                 putchar(197);
              }
              else
              {
                 putchar(196);
              }
          }

          gotoxy(discos + es, i+1);
          putchar(179);
          gotoxy(discos + es*2, i+1);
          putchar(179);
      }


      //Desenhando a barra das torres.
      gotoxy(1, discos+1);

      for(i=0; i<=(discos*2) + (es*2); i++)
      {
          if(i+1 == discos || i+1 == discos+es || i+1==discos + (es*2))
          {
             putchar(193);
          }
          else
          {
             putchar(196);
          }
      }

      gotoxy(discos, discos+2);

      putchar('A');

      gotoxy(discos+es, discos+2);

      putchar('B');
      gotoxy(discos+(es*2), discos+2);
      putchar('C');

      A=tam=discos;

      B=C=0;

      gotoxy(1, tam+4);

      printf("Quantidade de movimentos: %d", mov);

      _sleep(1000);

      transporta(discos, 'A', 'B', 'C');

      puts("");

      getch();
}

CrazyHommer · 30 de setembro de 2011

Consegui finalizar do modo que eu queria, postarei aqui pois talvez possa ajudar alguém no futuro =)

Código completo:

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

int A, B, C, tamanho, es, mov=0;

void limpa(int i,int es,int n)
{
     int j;

     for(j=0;j<=i*2;j++)
     {
         if(j+1==n || j+1==n+es || j+1==n+(es*2))
         {
            putchar(179); 
         }
         else
         {
            putchar(' ');
         }
     }
}

//Faz o desenho das peças quando elas sao movimentadas.
void pecas(int i,int es,int n)
{
     int j;

     for(j=0;j<=i*2;j++)
     {
         printf("\xDC");    
     } 

     gotoxy(1, tamanho + 4);
     printf("\n\nQuantidade de movimentos efetuados: %d",mov);

}

void desenha(char origem, char dest, int n)
{
     int i,j;

     mov++;
     if(origem == 'A')
     {
        A--;
     }  
     else
         if(origem == 'B')
         {
            B--;
         }
         else
             if(origem == 'C')
             {
                C--;
             }
                for(i=0;i<n;i++)
                {
                    if(origem == 'A')
                    {
                       gotoxy(tamanho - i,tamanho - A); 
                       }  
                     else
                         if(origem == 'B')
                         {
                            gotoxy((tamanho-i) + es, tamanho-;
                            }
                         else
                             if(origem == 'C')
                             {
                                gotoxy(tamanho-i+(es*2), tamanho-C);
                                }
                     limpa(i, es, n);           
                }


        if(dest=='A')
        {
           A++;
        }

        else
            if(dest=='B')
            {
               B++;
            }

            else
                if(dest=='C')
                {
                   C++;
                }  
        for(i=0;i<n;i++)
        {
            if(dest=='A')
            {
               gotoxy(tamanho-i, tamanho-A+1);
            }

            else
                if(dest=='B')
                {
                   gotoxy((tamanho-i)+es, tamanho-B+1);
                }
                else
                    if(dest=='C')
                    {
                       gotoxy(tamanho-i+(es*2), tamanho-C+1);
                    }

            pecas(i, es, n);
        }
        _sleep(1000);  
}


//Recebe os discos e faz a recursividade para a movimentação correta deles.
int transporta(int n, char origem, char aux, char dest)
{
      int i,j;
      if(n==1)
      {
         desenha(origem,dest,n);
         return 1;
      }
      else
      {
          transporta(n-1, origem, dest, aux);
          desenha(origem, dest, n);
          transporta(n-1, aux, origem, dest);
      }
}



main()
{   
   textcolor(RED);
   puts("--------------------------------------------------------------------------------");

   printf("\t\t\t\tTORRE DE HANOY");

   puts("\n\n\n--------------------------------------------------------------------------------\n\n");
   normvideo();

      int i, discos, j;

      printf("Digite a quantidade de discos: "); 
      scanf("%d", &discos);

      system("cls");

      es = discos + 25;

      //Desenhando as torres.
      for(i=0;i<discos;i++)
      {
          gotoxy(discos-i,i+1);

          for(j=0;j<=i*2;j++)
          {
              if(j==i)
              {
                 printf("\xDC");
              }
              else
              {
                 printf("\xDC");
              }
          }

          gotoxy(discos + es, i+1);
          putchar(179);
          gotoxy(discos + es*2, i+1);
          putchar(179);
      }


      //Desenhando a barra das torres.

      gotoxy(discos, discos+2);
      putchar('A');

      gotoxy(discos+es, discos+2);
      putchar('B');

      gotoxy(discos+(es*2), discos+2);
      putchar('C');

      A = tamanho = discos;

      B=C=0;

      gotoxy(1, tamanho+4);

      _sleep(1000);

      transporta(discos, 'A', 'B', 'C');

      puts("");
   getch();

}

Não possuo mais dúvidas, então se algum moderador desejar, pode fechá-lo. ^^'

naldoP · 7 de abril de 2012

Galera, eu preciso entregar esse trabalho sobre torre de Hanoi e infelizmente não consigo finalizar ele, o algoritmo com a lógica está pronto e funcionando, porém preciso fazer com que apareçam os discos no e em quais torres eles estão ao invés de mova o disco x para a torre y. Não precisa ser algo muito espetacular, pode apenas serem riscos no lugar de discos, ja ajudaria bastante, mas é que não tenho ideia de como fazer :/ ... Tentei usando o código ASCII com o traço (numero 220 do código) mais não deu muito certo, alguem poderia me dar algumas dicas ou me mostrar como fazer?
Este é meu código:
#include <stdio.h>
#include <conio2.h>

void movedisco (int n, char orig, char dest, char aux)
{
   if (n==1) 
   {
        printf("\nMover disco 1 da torre %c para a torre %c", orig, dest);
        return;
   }

	movedisco(n-1,orig,aux,dest);
	printf("\nMover disco %d da torre %c para a torre %c", n, orig, dest);
	movedisco(n-1,aux,dest,orig);
}

main(){
   int discos;
   textcolor(RED);
   puts("--------------------------------------------------------------------------------");

   printf("\t\t\t\tTORRE DE HANOY");

   puts("\n\n\n--------------------------------------------------------------------------------\n");
   normvideo();

   printf("Digite a quantidade de discos: ");
   scanf("%d",&discos);


   movedisco(discos,'A','C','B');
   getch();

}

Você precisa chamar a função movedisco(n,orig,dest,aux) dentro da "main"; lembrando que esse codigo é recursão, dessa forma é a maquina que resolve o problema não contém interatividade nenhuma, se for trabalho de faculdade, provavelmente não sera viável mesmo porque o ideal e que o universitário desenvolva uma versao interativa, onde o usuário resolva o problema da torre de hanoi, para isso requer estudos relacionado a pilha (LIFO).

Vai aqui um exemplo de pilha:

// Função para empilhar o dados genericamente //

void Empilhar(Pilha* p, int i){

if(p->topo==MAX-1 ){

printf("\nA pilha esta cheia ");

return;

}

p->vet[p->topo]= i;

p->topo++;

}

// Função para desempilhar os dados genericamente //

int Desempilhar(Pilha* p){

if(p->topo ==0){

printf("\nA pilha esta vazia ");

}

p->topo--;

p->vet[p->topo];

return p->vet[p->topo];

}

// Função para inicializar os topos da pilha com valor 0 //

void InicializarPilhas(Pilha* p){

p->topo=0;

}

// Função para Imprimir os dados da pilhas //

void ExibirPilhas(Pilha* p){

int i;

for(i=p->topo-1;i>=0;i--){

printf("\n%d", p->vet);

}

Procura saber mais sobre struct porque voce precisara para criar as pilhas.

Aqui vai um simples exemplo de struct ja com a criação de 3 pilhas, lembrando que com a struct voce pode criar quantas pilhas você quiser , assim podendo entender como um objeto de pilhas:

typedef struct Pilha{

int vet[MAX];

int topo;

}Pilha;

// Cria pilha //

Pilha pi1,pi2,pi3;

O estudo da torre de hanoi e fundamental para programadores iniciante justamente pelo fato de poder entender a pilha que está relacionado a estrutura de dados, dessa forma o principal motivo de se programar uma torre de hanoi é justamente para fazer que o futuro programador tenha experiencia em programar uma pilha, e la na frente a fila, bubblesort e quicksort lembrando que a pilha hoje e presente em qualquer sistemas.

CrazyHommer · 2 de maio de 2012

Você precisa chamar a função movedisco(n,orig,dest,aux) dentro da "main"; lembrando que esse codigo é recursão, dessa forma é a maquina que resolve o problema não contém interatividade nenhuma, se for trabalho de faculdade, provavelmente não sera viável mesmo porque o ideal e que o universitário desenvolva uma versao interativa, onde o usuário resolva o problema da torre de hanoi, para isso requer estudos relacionado a pilha (LIFO).
Vai aqui um exemplo de pilha:

// Função para empilhar o dados genericamente //

void Empilhar(Pilha* p, int i){

if(p->topo==MAX-1 ){

printf("\nA pilha esta cheia ");

return;

}

p->vet[p->topo]= i;

p->topo++;

}

// Função para desempilhar os dados genericamente //

int Desempilhar(Pilha* p){

if(p->topo ==0){

printf("\nA pilha esta vazia ");

}

p->topo--;

p->vet[p->topo];

return p->vet[p->topo];

}

// Função para inicializar os topos da pilha com valor 0 //

void InicializarPilhas(Pilha* p){

p->topo=0;

}

// Função para Imprimir os dados da pilhas //

void ExibirPilhas(Pilha* p){

int i;

for(i=p->topo-1;i>=0;i--){

printf("\n%d", p->vet);

}

Procura saber mais sobre struct porque voce precisara para criar as pilhas.

Aqui vai um simples exemplo de struct ja com a criação de 3 pilhas, lembrando que com a struct voce pode criar quantas pilhas você quiser , assim podendo entender como um objeto de pilhas:

typedef struct Pilha{

int vet[MAX];

int topo;

}Pilha;

// Cria pilha //

Pilha pi1,pi2,pi3;

O estudo da torre de hanoi e fundamental para programadores iniciante justamente pelo fato de poder entender a pilha que está relacionado a estrutura de dados, dessa forma o principal motivo de se programar uma torre de hanoi é justamente para fazer que o futuro programador tenha experiencia em programar uma pilha, e la na frente a fila, bubblesort e quicksort lembrando que a pilha hoje e presente em qualquer sistemas.