Para entender como ordenar palavras alfabeticamente, antes de mais nada é preciso saber que o computador atribui valores numéricos a cada caracter, e que desta forma ele consegue comparar A com B e dizer que o A "é menor que" o B. Ele faz isso com base em padrões provenientes de tabelas de valores de caracteres armazenadas dentro da sua memória de fábrica. O nome desse padrão, ou melhor, dessa tabela é ASCII.
ASCII (acrônimo para American Standard Code for Information Interchange, que em português significa "Código Padrão Americano para o Intercâmbio de Informação") é uma codificação de caracteres de oito bits baseada no alfabeto inglês. Os códigos ASCII representam texto em computadores, equipamentos de comunicação, entre outros dispositivos que trabalham com texto. Desenvolvida a partir de 1960, grande parte das codificações de caracteres modernas a herdaram como base.
A codificação define 128 caracteres, preenchendo completamente os sete bits disponíveis. Desses, 33 não são imprimíveis, como caracteres de controle atualmente não utilizáveis para edição de texto, porém amplamente utilizados em dispositivos de comunicação, que afetam o processamento do texto. Exceto pelo caractere de espaço, o restante é composto por caracteres imprimíveis.
ASCII (acrônimo para American Standard Code for Information Interchange, que em português significa "Código Padrão Americano para o Intercâmbio de Informação") é uma codificação de caracteres de oito bits baseada no alfabeto inglês. Os códigos ASCII representam texto em computadores, equipamentos de comunicação, entre outros dispositivos que trabalham com texto. Desenvolvida a partir de 1960, grande parte das codificações de caracteres modernas a herdaram como base.
A codificação define 128 caracteres, preenchendo completamente os sete bits disponíveis. Desses, 33 não são imprimíveis, como caracteres de controle atualmente não utilizáveis para edição de texto, porém amplamente utilizados em dispositivos de comunicação, que afetam o processamento do texto. Exceto pelo caractere de espaço, o restante é composto por caracteres imprimíveis.
1. TABELA ASCII
Binário
|
Decimal
|
Hexa
|
Glifo
|
0010 0000
|
32
|
20
|
|
0010 0001
|
33
|
21
|
!
|
0010 0010
|
34
|
22
|
"
|
0010 0011
|
35
|
23
|
#
|
0010 0100
|
36
|
24
|
$
|
0010 0101
|
37
|
25
|
%
|
0010 0110
|
38
|
26
|
&
|
0010 0111
|
39
|
27
|
'
|
0010 1000
|
40
|
28
|
(
|
0010 1001
|
41
|
29
|
)
|
0010 1010
|
42
|
2A
|
*
|
0010 1011
|
43
|
2B
|
+
|
0010 1100
|
44
|
2C
|
,
|
0010 1101
|
45
|
2D
|
-
|
0010 1110
|
46
|
2E
|
.
|
0010 1111
|
47
|
2F
|
/
|
0011 0000
|
48
|
30
|
0
|
0011 0001
|
49
|
31
|
1
|
0011 0010
|
50
|
32
|
2
|
0011 0011
|
51
|
33
|
3
|
0011 0100
|
52
|
34
|
4
|
0011 0101
|
53
|
35
|
5
|
0011 0110
|
54
|
36
|
6
|
0011 0111
|
55
|
37
|
7
|
0011 1000
|
56
|
38
|
8
|
0011 1001
|
57
|
39
|
9
|
0011 1010
|
58
|
3A
|
:
|
0011 1011
|
59
|
3B
|
;
|
0011 1100
|
60
|
3C
|
<
|
0011 1101
|
61
|
3D
|
=
|
0011 1110
|
62
|
3E
|
>
|
0011 1111
|
63
|
3F
|
?
|
0100 0000
|
64
|
40
|
@
|
0100 0001
|
65
|
41
|
A
|
0100 0010
|
66
|
42
|
B
|
0100 0011
|
67
|
43
|
C
|
0100 0100
|
68
|
44
|
D
|
0100 0101
|
69
|
45
|
E
|
0100 0110
|
70
|
46
|
F
|
0100 0111
|
71
|
47
|
G
|
0100 1000
|
72
|
48
|
H
|
0100 1001
|
73
|
49
|
I
|
0100 1010
|
74
|
4A
|
J
|
0100 1011
|
75
|
4B
|
K
|
0100 1100
|
76
|
4C
|
L
|
0100 1101
|
77
|
4D
|
M
|
0100 1110
|
78
|
4E
|
N
|
0100 1111
|
79
|
4F
|
O
|
0101 0000
|
80
|
50
|
P
|
0101 0001
|
81
|
51
|
Q
|
0101 0010
|
82
|
52
|
R
|
0101 0011
|
83
|
53
|
S
|
0101 0100
|
84
|
54
|
T
|
0101 0101
|
85
|
55
|
U
|
0101 0110
|
86
|
56
|
V
|
0101 0111
|
87
|
57
|
W
|
0101 1000
|
88
|
58
|
X
|
0101 1001
|
89
|
59
|
Y
|
0101 1010
|
90
|
5A
|
Z
|
0101 1011
|
91
|
5B
|
[
|
0101 1100
|
92
|
5C
|
\
|
0101 1101
|
93
|
5D
|
]
|
0101 1110
|
94
|
5E
|
^
|
0101 1111
|
95
|
5F
|
_
|
0110 0000
|
96
|
60
|
`
|
0110 0001
|
97
|
61
|
a
|
0110 0010
|
98
|
62
|
b
|
0110 0011
|
99
|
63
|
c
|
0110 0100
|
100
|
64
|
d
|
0110 0101
|
101
|
65
|
e
|
0110 0110
|
102
|
66
|
f
|
0110 0111
|
103
|
67
|
g
|
0110 1000
|
104
|
68
|
h
|
0110 1001
|
105
|
69
|
i
|
0110 1010
|
106
|
6A
|
j
|
0110 1011
|
107
|
6B
|
k
|
0110 1100
|
108
|
6C
|
l
|
0110 1101
|
109
|
6D
|
m
|
0110 1110
|
110
|
6E
|
n
|
0110 1111
|
111
|
6F
|
o
|
0111 0000
|
112
|
70
|
p
|
0111 0001
|
113
|
71
|
q
|
0111 0010
|
114
|
72
|
r
|
0111 0011
|
115
|
73
|
s
|
0111 0100
|
116
|
74
|
t
|
0111 0101
|
117
|
75
|
u
|
0111 0110
|
118
|
76
|
v
|
0111 0111
|
119
|
77
|
w
|
0111 1000
|
120
|
78
|
x
|
0111 1001
|
121
|
79
|
y
|
0111 1010
|
122
|
7A
|
z
|
0111 1011
|
123
|
7B
|
{
|
0111 1100
|
124
|
7C
|
|
|
0111 1101
|
125
|
7D
|
}
|
0111 1110
|
126
|
7E
|
~
|
2. O MÉTODO BUBBLE SORT (ORDENAÇÃO BOLHA)
O método que empregaremos para efetuar a ordenação é o método bubble sort, ou ordenação por flutuação (literalmente "por bolha"), que é um algoritmo de ordenação dos mais simples. A idéia é comparar dois elementos e trocá-los de posição, até que os elementos de maior valor sejam levados para o final do vetor. O processo continua até a ordenação total do vetor lembrando a forma como as bolhas em um tanque de água procuram seu próprio nível, e disso vem o nome do algoritmo.
Para entendermos esse método será proposto um exemplo prático que vem a seguir.
3. EXEMPLO 1
Fazer um programa que leia 5 nomes de produtos (mercadorias) e os apresente em ordem alfabética (do menor para o maior / crescente).
Para enterdermos tomemos como valores digitados os produtos ARROZ, FEIJÃO, MACARRÃO, COUVE e CARNE respectivamente:
Para ordená-los segundo o método bubble sort teríamos de compará-los um a um verificando se aquele que estou comparando é maior que o comparado, se for teremos de trocá-los de posição, senão não fazemos nada, faremos isso até termos comparado com todos.
Por fim o pseudocódigo para o VisuAlg seria o seguinte:
algoritmo "MÉTODO BUBBLE SORT"
// Função :
// Autor :
// Data : 06/06/2011
// Seção de Declarações
var
i, j: inteiro // declaração dos contadores que utilizaremos, um para controlar e fazer a variação de qual dos produtos estamos comparando e o outro para fazer a variação de com quem estamos comparando
p: vetor [1..5] de caracter // declaração do vetor que irá armazenar os 5 produtos
x: caracter // declaração da variável que nos auxiliará na troca dos valores
inicio
para i de 1 ate 5 passo 1 faca
escreva ("Informe o", i ,"º produto:") // leitura dos 5 produtos armazenando no vetor p
leia (p[i])
fimpara
para i de 1 ate 4 passo 1 faca // laço que irá contar de 1 até 4 determinando com isso que compararei os 4 primeiros produtos digitados com os demais, o último não é necessário pois já terá sido comparado com todos.
para j de i+1 ate 5 passo 1 faca // laço que contará sempre do produto seguinte até o último, sendo responsável por aquele com quem estou comparando
se (p[i] > p[j]) entao // condição onde verifico se o produto [ i ] e maior que o produto [ j ]
x <- p[i] //caso seja maior eu os trocarei de lugar, para isso o auxiliar receberá o p[ i ]
p[i]<-p[j] //o p[ i ] que teve seu valor guardado receberá o valor do p[ j ]
p[j]<-x // e o p[ j ] receberá o valor do p[ i ] que está guardado no x (auxiliar)
fimse // limite da condição
fimpara //limite do segundo laço
fimpara //limite do primeiro laço
escreval ("---------------------")
escreval("PRODUTOS EM ORDEM ALFABÉTICA")
escreval ("---------------------")
para i de 1 ate 5 passo 1 faca
escreval (p[i]) // apresentação dos produtos ordenados
fimpara
fimalgoritmo
// Função :
// Autor :
// Data : 06/06/2011
// Seção de Declarações
var
i, j: inteiro // declaração dos contadores que utilizaremos, um para controlar e fazer a variação de qual dos produtos estamos comparando e o outro para fazer a variação de com quem estamos comparando
p: vetor [1..5] de caracter // declaração do vetor que irá armazenar os 5 produtos
x: caracter // declaração da variável que nos auxiliará na troca dos valores
inicio
para i de 1 ate 5 passo 1 faca
escreva ("Informe o", i ,"º produto:") // leitura dos 5 produtos armazenando no vetor p
leia (p[i])
fimpara
para i de 1 ate 4 passo 1 faca // laço que irá contar de 1 até 4 determinando com isso que compararei os 4 primeiros produtos digitados com os demais, o último não é necessário pois já terá sido comparado com todos.
para j de i+1 ate 5 passo 1 faca // laço que contará sempre do produto seguinte até o último, sendo responsável por aquele com quem estou comparando
se (p[i] > p[j]) entao // condição onde verifico se o produto [ i ] e maior que o produto [ j ]
x <- p[i] //caso seja maior eu os trocarei de lugar, para isso o auxiliar receberá o p[ i ]
p[i]<-p[j] //o p[ i ] que teve seu valor guardado receberá o valor do p[ j ]
p[j]<-x // e o p[ j ] receberá o valor do p[ i ] que está guardado no x (auxiliar)
fimse // limite da condição
fimpara //limite do segundo laço
fimpara //limite do primeiro laço
escreval ("---------------------")
escreval("PRODUTOS EM ORDEM ALFABÉTICA")
escreval ("---------------------")
para i de 1 ate 5 passo 1 faca
escreval (p[i]) // apresentação dos produtos ordenados
fimpara
fimalgoritmo
Para ficar ainda mais claro abaixo está o teste de mesa do algoritmo acima com os mesmos valores do exemplo:
