VisualG BubbleSort de ordenação com passagem de parâmetro

ana_c_martins · 14 de fevereiro de 2022

Boa noite!! Nesta atividade preciso utilizar o algoritmo BubbleSort de ordenação, implementar função/procedimento que receba por parâmetro uma estrutura desordenada. O professor ainda pediu pra adicionar um comando de repetição, e foi ai que me perdi...

Algoritmo "Ordenação BubbleSort SA6 Etapa 1"
Var
   vet: vetor[1..5] de inteiro
   i,aux: inteiro
   troca: logico

Procedimento Ordenar()

Inicio
   troca <- verdadeiro
   ENQUANTO troca = verdadeiro FACA
      troca <- falso
      PARA i DE 1 ATE 4 FACA
         SE vet[i] > vet[i+1] ENTAO
            aux <- vet[i]
            vet[i] <- vet[i+1]
            vet[i+1] <- aux
            troca <- verdadeiro
         FIMSE
      FIMPARA
   FIMENQUANTO
FIMPROCEDIMENTO

Inicio
   vet[1] <- 48
   vet[2] <- 75
   vet[3] <- 11
   vet[4] <- 52
   vet[5] <- 27

   Ordenar()
   PARA i DE 1 ATE 5 FACA
      ESCREVAL(vet[i])
   FIMPARA
Fimalgoritmo

Eu tinha feito assim, e estava rodando de boa. Mas ele disse q estava muito simples, então tentei fazer algumas modificações!

Algoritmo "Ordenação BubbleSort SA6 Etapa 1"

Var
   vet: vetor[1..5] de inteiro
   ultimo,i,J,aux,opcao: inteiro
   troca: logico
   x : caractere

inicio
   ultimo <- -1
   REPITA
      ESCREVAL("1 - Adicionar")
      ESCREVAL("2 - Excluir")
      ESCREVAL("3 - Ordenar")
      ESCREVAL("4 - Sair")
      ESCREVAL("====================")
      ESCREVAL("Opção: ")
      LEIA(opcao)
      ESCREVAL("====================")
      ESCOLHA(opcao)

PROCEDIMENTO Adicionar()

Var

Inicio
   SE ultimo < 4 ENTAO
      ultimo <- ultimo + 1
      ESCREVA("Adicione um elemento : ")
      LEIA(vet[ultimo])

   SENAO

      ESCREVAL("Número máximo de elementos adicionados - <enter>")
      LEIA(x)

   FIMSE

FIMPROCEDIMENTO
//=========================================================================================

PROCEDIMENTO Excluir()

Var

Inicio

   SE ultimo >= 0 ENTAO
      PARA j DE 0 ATE 4 FACA

         SE j < 4 ENTAO
            vet[j] <- vet[j+1]
         SENAO
            vet[j] <- 0
         FIMSE

      fimpara

fimprocedimento

//=========================================================================================
Procedimento Ordenar()

Inicio
   troca <- verdadeiro
   ENQUANTO troca = verdadeiro FACA
      troca <- falso
      PARA i DE 1 ATE 4 FACA
         SE vet[i] > vet[i+1] ENTAO
            aux <- vet[i]
            vet[i] <- vet[i+1]
            vet[i+1] <- aux
            troca <- verdadeiro
         FIMSE
      FIMPARA
   FIMENQUANTO
FIMPROCEDIMENTO

Inicio
caso 1
   Adicionar()
caso 2
   Excluir()
caso 3
   Ordenar()
   escreval("<enter> para continuar")
   leia(x)
fimescolha
limpatela
ATE(opcao=4)
Fimalgoritmo

Este algoritmo não está rodando...

devair1010 · 15 de fevereiro de 2022

@ana_c_martins no segundo código você colocou os comandos fora das posições adequadas deles , pois os procedimentos precisam ficar antes do inicio do programa , e também usar letras maiúsculas nos comandos não ajudam em nada , apesar de Que o VisualG não faz distinção , delas , mas fica bem estranho , melhor usar minúsculas mesmo , os procedimento sem parâmetros não precisam dos parênteses , e seu código modificado para compilar poderia ser assim :

Algoritmo "Ordenação BubbleSort SA6 Etapa 1"
Var
  vet        : vetor[1..5] de inteiro
  ultimo,i,J : inteiro
  aux,opcao  : inteiro
  troca      : logico
  x          : caractere
procedimento adicionar
Inicio
  se ultimo < 4 entao
    ultimo <- ultimo + 1
    escreva("Adicione um elemento : ")
    leia(vet[ultimo])
 senao
   escreval("Número máximo de elementos adicionados - <enter>")
   leia(x)
 fimse
fimprocedimento
//=========================================================================================
procedimento Excluir
Var
Inicio
  se ultimo >= 0 entao
    para j de 0 ate 4 faca
      SE j < 4 ENTAO
        vet[j] <- vet[j+1]
      senao
        vet[j] <- 0
      fimse
    fimpara
fimprocedimento
//=========================================================================================
Procedimento ordenar
Inicio
  troca <- verdadeiro
  enquanto troca = verdadeiro faca
    troca <- falso
    para i de 1 ate 4 faca
      se vet[i] > vet[i+1] entao
        aux <- vet[i]
        vet[i] <- vet[i+1]
        vet[i+1] <- aux
        troca <- verdadeiro
      fimse
    fimpara
  fimenquanto
fimprocedimento
Inicio
  ultimo <- -1
  repita
    escreval("1 - Adicionar")
    escreval("2 - Excluir")
    escreval("3 - Ordenar")
    escreval("4 - Sair")
    escreval("====================")
    escreval("Opção: ")
    leia(opcao)
    escreval("====================")
    escolha opcao
    caso 1
      adicionar
    caso 2
      excluir
    caso 3
      ordenar
      escreval("<enter> para continuar")
      leia(x)          // uma pausa
    fimescolha
    limpatela
  ate opcao = 4
Fimalgoritmo
// Este algoritmo  está rodando...

ana_c_martins · 15 de fevereiro de 2022

@devair1010 Boa noite, em relação as letras maiúsculas meu professor ensinou assim em palavras reservadas, então só segui. E sobre os procedimentos eu preciso usar nesta atividade, tentei rodar o programa q você postou e tá dando erro, não sei se é a versão do meu visualG mas não está lendo o vetor. segue anexo;

devair1010 · 16 de fevereiro de 2022

@ana_c_martins no código foi adicionado o valor -1 nessa variável "uktimo" e assim quando soma mais 1 nela , ela vai para zero , e o vetor está declarado para iniciar a partir de 1 , e então dois modos de fazer isso , colocar o vetor começando em zero

vet  : vetor[0..5] de inteiro

ou não adicionar nenhum valor â variável ultimo

Em 14/02/2022 às 21:23, devair1010 disse:
Inicio
  ultimo <- -1
  repita

que ficaria assim :

Inicio
  // ultimo <- -1 não adiciona nenhum valor 
  // pois ela ja tem o valor zero ao ser criada               
  repita
    escreval("1 - Adicionar")
    escreval("2 - Excluir")
    escreval("3 - Ordenar")
    escreval("4 - Sair")
    escreval("====================")
    escreval("Opção: ")
    leia(opcao)

e creio que seja o mais correto a se fazer .

Simon Viegas · 16 de fevereiro de 2022

Sobre:

16 horas atrás, ana_c_martins disse:

@devair1010 Boa noite, em relação as letras maiúsculas meu professor ensinou assim em palavras reservadas, então só segui.

Para mim também o uso de "CAIXA ALTA" é desnecessário.. Deixa o código muito feio. Parece que está gritando .

Minha sugestão é deixar tudo em camelCase. Ao poucos vai reajustando o seu próprio padrão.

Segue seu primeiro código seguindo um meu padrão:

algoritmo "Ordenação BubbleSort SA6 Etapa 1"
var
   vet :vetor[1..5] de inteiro
   aux :inteiro
   troca :logico
   i : inteiro

procedimento Ordenar() //eu prefiro sempre deixar o (). Fica explícito que é um método (função ou procedimento)
inicio
   troca <- VERDADEIRO //constantes todo em MAIÚSCULO (constante = variável de valor fixo)

   enquanto (troca) faca //tanto faz usar "()", eu prefiro com mesmo quando não é necessário (tem caso é que obrigatório)
      troca <- FALSO
      
      para i de 1 ate 5-1 faca
         se (vet[i] > vet[i+1]) entao
            aux <- vet[i]
            vet[i] <- vet[i+1]
            vet[i+1] <- aux
            troca <- VERDADEIRO
         fimSe
      fimpara
   fimEnquanto
fimProcedimento

inicio
   vet[1] <- 48
   vet[2] <- 75
   vet[3] <- 11
   vet[4] <- 52
   vet[5] <- 27

   Ordenar()
   
   para i de 1 ate 5 faca
      escrevaL(vet[i])
   fimPara
fimAlgoritmo

Aí sempre vá alterando os código aos poucos, nunca tente fazer tudo de uma vez!

Cada um dos itens abaixo poderia ser feito de cada vez, mas para não ficar massivo, vai os 3 de vez:

- Adicionado constante para o tamanho máximo;

- Criado procedimento para efetuar troca de posição;

- Melhor uso de variáveis locais, em detrimento de usar globais.

algoritmo "Ordenação BubbleSort SA6 Etapa 1"
const
   MAX = 5
var
   vet :vetor[1..MAX] de inteiro
   i : inteiro

procedimento Trocar(i:inteiro) //esse procedimento poderia ficar do no Ordenar, mas deixa aqui
var
   aux : inteiro
inicio
   aux <- vet[i]
   vet[i] <- vet[i+1]
   vet[i+1] <- aux
fimProcedimento

procedimento Ordenar()
var
   trocou :logico
   i :inteiro //essa variável não é a mesma criada acima
inicio
   trocou <- VERDADEIRO

   enquanto (trocou) faca
      trocou <- FALSO

      para i de 1 ate MAX-1 faca
         se (vet[i] > vet[i+1]) entao
            Trocar(i)
            trocou <- VERDADEIRO
         fimSe
      fimpara
   fimEnquanto
fimProcedimento

inicio
   vet[1] <- 48
   vet[2] <- 75
   vet[3] <- 11
   vet[4] <- 52
   vet[5] <- 27

   Ordenar()

   para i de 1 ate 5 faca
      escrevaL(vet[i])
   fimPara
fimAlgoritmo

Aí, vai evoluindo. Um item essencial é a EXIBIÇÃO DO VETOR antes e depois. Logo, aproveitar para criar um procedimento para listar:

procedimento Listar()
var
   i :inteiro
inicio
   para i de 1 ate MAX faca
      escrevaL(vet[i])
   fimPara
fimProcedimento
     
...

inicio
   vet[1] <- 48
   vet[2] <- 75
   vet[3] <- 11
   vet[4] <- 52
   vet[5] <- 27

   Ordenar()
   Listar()
fimAlgoritmo

Agora que tal adicionar um menu?

algoritmo "Ordenação BubbleSort SA6 Etapa 1"
const
   MAX = 5
var
   vet :vetor[1..MAX] de inteiro
   i : inteiro
   opcao :caractere

procedimento Trocar(i:inteiro)
var
   aux : inteiro
inicio
   aux <- vet[i]
   vet[i] <- vet[i+1]
   vet[i+1] <- aux
fimProcedimento

procedimento Ordenar()
var
   trocou :logico
   i :inteiro
inicio
   trocou <- VERDADEIRO

   enquanto (trocou) faca
      trocou <- FALSO

      para i de 1 ate MAX-1 faca
         se (vet[i] > vet[i+1]) entao
            Trocar(i)
            trocou <- VERDADEIRO
         fimSe
      fimpara
   fimEnquanto
fimProcedimento

procedimento Listar()
var
   i :inteiro
inicio
   para i de 1 ate MAX faca
      escrevaL(vet[i])
   fimPara
fimProcedimento

inicio
   vet[1] <- 48
   vet[2] <- 75
   vet[3] <- 11
   vet[4] <- 52
   vet[5] <- 27

   repita
      escreval("1 - Listar")
      escreval("2 - Ordenar")
      escreval("0 - Sair")
      leia(opcao)

      escolha opcao
      caso "1"
         Listar()
      caso "2"
         Ordenar()
      fimEscolha
   ate (opcao = "0")
fimAlgoritmo

Se atenha que em todo momento, em toda qualquer alteração, o código deve está funcionando corretamente, ou seja, como terá o pressuposto que o código atual está certo, você só precisará se preocupar com aquilo novo que está sendo inserido, entende?

Se o anterior estava bom, e com o menu deu problema, então foi algo novo que fiz agora!!! Por isso (e outras coisas) que não se deve tentar fazer tudo de uma vez... vá alterando e testando, alterando e testando... não altere muita coisa de vez, pois fica mais difícil identificar os erros...

SUGESTÃO

- altere o código para gerar o vetor com dados aleatórios. É bem simples fazer isso; (já aprenda que é perda de tempo ficar digitando dados na fase de criação... na versão final ajusta);

- inserir um procedimento para exclusão da forma que você já fez. Ajuste o menu da forma desejada;

- ajustar a exclusão para remover qualquer elemento, e não apenas o último. (já que é uma lista, e não uma fila)

Por aí vai.

ana_c_martins · 16 de fevereiro de 2022

@Simon Viegas Uau , ótima exolicação Simon. Muito obrigada, vou aplicar todas as suas dicas!!

@devair1010 Obrigada, vou tentar aplicar as modificações para ver se roda!!

Simon Viegas · 17 de fevereiro de 2022

Para gerar números aleatórios:

algoritmo "Ordenação BubbleSort SA6 Etapa 1"
const
   MAX = 5

procedimento Trocar(i:inteiro)
var
   aux : inteiro
inicio
   aux <- vet[i]
   vet[i] <- vet[i+1]
   vet[i+1] <- aux
fimProcedimento

procedimento Ordenar()
var
   trocou :logico
   i :inteiro
inicio
   trocou <- VERDADEIRO

   enquanto (trocou) faca
      trocou <- FALSO

      para i de 1 ate MAX-1 faca
         se (vet[i] > vet[i+1]) entao
            Trocar(i)
            trocou <- VERDADEIRO
         fimSe
      fimpara
   fimEnquanto
fimProcedimento

procedimento Listar()
var
   i :inteiro
inicio
   para i de 1 ate MAX faca
      escrevaL(vet[i])
   fimPara
fimProcedimento

//No VisualG funciona deixar as variáveis Globais em baixo!!
//Obs.: para mim isso não faz o menor sentido. Eu suponho que seja algo que
//o criador do problema disponibilizou manualmente para "facilitar a vida dos
// iniciantes".
var
   //Aqui é a sessão das variáveis GLOBAIS (todo o programa enxerga)
   //As variáveis que são declaradas dentros dos métodos são locais e
   //são enxergadas apenas neles. Se existir uma variável com o mesmo nome
   //no local e outra no global, o VisualG vai usar a variável local. Não dá para
   // acessar a global neste caso (teria que usar nomes diferentes)
   vet :vetor[1..MAX] de inteiro
   i : inteiro //esse i é global.
   opcao :caractere

inicio
   //gera 3 números aleatórios para adiantar o lado! (sobram MAX-3 vagas)
   para i de 1 ate 3 faca
      vet[i] <- RandI(100)
   fimPara

   repita
      escreval("1 - Listar")
      escreval("2 - Ordenar")
      escreval("0 - Sair")
      leia(opcao)

      escolha opcao
      caso "1"
         Listar()
      caso "2"
         Ordenar()
      fimEscolha
   ate (opcao = "0")
fimAlgoritmo

Apenas inserir a geração de alguns números... observe que a listagem deu pau:

Por quê? Isso aí você que teria que parar para entender? Sacou?

"Ah! porque antes sempre vinha com todos preenchidos, e na hora de listar, está listando a partir do limite máximo"... logo, "para corrigir vou fazer......".

Por aí vai.

@ana_c_martins, uma boa sugestão é refazer todo o código... faça do zero!!! Veja, como tem coisa que já meio que entendeu, vai ser rápido, entretanto vai reforçar o aprendizado, já que eventualmente vai errar alguma coisa ali e aqui (sempre ocorre erro de digitação, esquecer alguma coisa etc)... vai entendendo os problemas e corrigindo. Mas sempre deixe o código rodando certo antes de inserir uma coisa nova.

Reforçando: NÃO tente fazer muita coisa de uma vez só e depois testar tudo... vai dá BO!