UNIP – UNIVERSIDADE PAULISTA

Curso de Ciências da computação

ATIVIDADES PRÁTICAS SUPERVISIONADAS – APS

Análise e comparação de algoritmos de ordenação

Felipe Moraski da Silva: RA-N35665-0

GOIÂNIA GO, 09 de novembro de 2019

UNIP – UNIVERSIDADE PAULISTA
 UNIP – UNIVERSIDADE PAULISTA
Curso de Ciências da computação

ATIVIDADES PRÁTICAS SUPERVISIONADAS – APS

Análise e comparação de algoritmos de ordenação

Atividades Práticas Supervisionadas, quarto semestre do

curso de ciências da computação, da Universidade
Paulista – UNIP.
Coordenador do curso: Prof. Nelson

GOIÂNIA GO, 09 de novembro de 2019

UNIP – UNIVERSIDADE PAULISTA
SUMARIO.

1.INTRODUÇÃO .........................................................................................................4
2.OBJETIVO ................................................................................................................6
2.1 Objetivos específicos ................................................................................................................. 6
3.REFERENCIAL TEORICO .......................................................................................7
3.1 Bubble Sort ................................................................................................................................... 7

3.2 Merge Sort .................................................................................................................................... 7

3.3 Selection Sort ................................................................................................................................ 8

4.DESENVOLVIMENTO ............................................................................................10
5.RESULTADOS E DISCUSSÃO ..............................................................................16
5.1 Bubble Sort ................................................................................................................................. 16

5.2 Merge Sort .................................................................................................................................. 17

5.3 Selection Sort .............................................................................................................................. 20

6.CONSIDERAÇOES FINAIS ....................................................................................22

7.REFERENCIAS BIBLIOGRÁFICAS .......................................................................23
8.CODIGO FONTE ....................................................................................................24
8.1 Bubble Sort ................................................................................................................................. 24

8.2 Merge Sort .................................................................................................................................. 25

8.3 Selection Sort .............................................................................................................................. 27

 4

1. INTRODUÇÃO.

Quanto mais a tecnologia vai sendo melhorada, mais espaço ela ganha dentro
do mercado, um grande exemplo de área dominada pela tecnologia são os controles
de estoque de grandes e pequenas empresas, que vem utilizando cada vez mais os
computadores, e dentre as tecnologias mais utilizadas estão os programas que fazem
o armazenamento de dados, porem estes programas precisam armazenar cada vez
mais dados, e quando se está armazenando quantidades muito grandes de dados,
manter a organização dos dados manualmente acaba se tornando uma tarefa muito
difícil e até mesmo inviável. Assim surgiu a necessidade de desenvolver métodos que
realizem a organização destes dados de forma automática, e é exatamente para isso
que servem os algoritmos de ordenação.

Algoritmos são uma parte essencial do desenvolvimento da tecnologia, eles

estão por trás de grande parte dos programas conhecidos atualmente. Segundo Paula
Pereira (2009) ” os algoritmos não respondem à pergunta “o que é possível fazer?
Mas sim, como pode ser feito. De forma mais específica, os algoritmos são uma
sequência finita, lógica e definida, partindo de instruções que devem ser seguidas para
se obter o resultado de algum problema, ou até mesmo a execução de determinadas
tarefas”.

Os algoritmos de ordenação são os algoritmos utilizados para realizar a

organização dos dados em uma certa ordem, ou seja, ele recebe um conjunto de
dados e os reorganiza de acordo com os critérios desejados, algumas das formas de
organização mais comuns são a ordem numérica e a ordem alfabética. O motivo para
se realizar a ordenação dos dados geralmente é a organização, que
consequentemente facilita a localização dos dados que estão dentro da lista.

Existem diversos algoritmos de ordenação, cada um deles com um método

diferente de ordenar os dados. Os Algoritmos mais conhecidos são o Bubble Sort,
Selection Sort, Merge Sort e Insertion Sort. Cada método possui suas próprias
características, alguns são mais simples, outros são mais complexos, alguns
demoram para realizar a ordenação, já outros realizam de forma rápida e eficiente, a
 5

escolha do algoritmo de ordenação a ser aplicado depende de vários fatores, tais

como, saber se o computador consegue executar o método e a eficiência do método.

O Bubble Sort percorre o vetor de dois em dois itens e faz a comparação entre
eles, e troca eles de lugar quando necessário realizando dessa forma ordenação.
Segundo Robson (2012) “O algoritmo Bubble Sort percorre todo o vetor diversas
vezes, por isso, não é recomendado o uso dele para aplicações que requerem
velocidade ou trabalhem com uma grande quantidade de dados”.

Usando o Selection sort a ordenação é feita selecionando os menores itens da

lista e os colocando da esquerda para a direita. Possuí a mesma desvantagem que o
Bubble Sort, que é o fato dele percorrer o vetor diversas vezes, e por isso ele não é
muito bom para ordenar grandes quantidades de dados.

O Insertion sort Percorre o vetor a partir do segundo item e vai jogando os

dados para o inicio do vetor, ele só percorre o vetor uma vez. Segundo BRAGA (2018)
“Em relação às desvantagens, o Insertion sort é um algoritmo com uma performance
ruim para grande quantidades de itens a serem ordenados, pois assim
como selection e bubble sort, ele precisa percorrer a lista para cada elemento”.

Segundo Farias (2014) “A ideia básica do Merge Sort é criar uma sequência
ordenada a partir de duas outras também ordenadas. Para isso, o algoritmo Merge
Sort divide a sequência original em pares de dados, agrupa estes pares na ordem
desejada; depois as agrupa as sequências de pares já ordenados, formando uma
nova sequência ordenada de quatro elementos, e assim por diante, até ter toda a
sequência ordenada”.
 6

2. OBJETIVO

Elaborar uma pesquisa sobre algoritmos de ordenação e desenvolver um

programa utilizando 3 algoritmos para ordenar uma tabela de 1000 imagens, e
comparar qual dos algoritmos é o mais rápido.

2.1. Objetivos específicos

• Falar sobre os algoritmos de ordenação;

• Implementar 3 algoritmos de ordenação;
• Comparar os resultados dos algoritmos ao ordenar uma tabela com 1000
imagens.
 7

3.REFERENCIAL TEÓRICO.

3.1.Bubble Sort.

É um algoritmo de ordenação com uma estrutura bem simples e fácil de se

fazer. Segundo Gatto (2017) “Bubble Sort é um algoritmo de ordenação que pode ser
aplicado em Arrays e Listas dinâmicas. Se o objetivo é ordenar os valores em forma
decrescente, então, a posição atual é comparada com a próxima posição e, se a
posição atual for maior que a posição posterior, é realizada a troca dos valores nessa
posição. Caso contrário, não é realizada a troca, apenas passa-se para o próximo par
de comparações”.

Para ordenar uma lista, o Bubble Sort precisa percorrer o vetor várias vezes,
oque acaba sendo muito ruim com quantidades de dados muito grandes.

A Figura 1 pode ajudar a entender melhor como funciona o BubbleSort.

Figura 1 : Funcionamento do BubbleSort. Fonte: Programiz.

 8

3.2.Merge Sort

É um algoritmo de ordenação com uma estrutura um pouco mais complexa e com

um pouco mais de dificuldade para ser implementada, porem consegue ordenar as
listas rapidamente, por isso é muito boa para vetores com grandes quantidades de
dados. Segundo Farias (2014) “Os três passos úteis dos algoritmos dividir-para-
conquistar, que se aplicam ao Merge Sort são:

1.Dividir: Dividir os dados em subsequências pequenas;

Este passo é realizado recursivamente, iniciando com a divisão do vetor de n
elementos em duas metades, cada uma das metades é novamente dividida em duas
novas metades e assim por diante, até que não seja mais possível a divisão (ou
seja, sobrem n vetores com um elemento cada).

2.Conquistar: Classificar as duas metades recursivamente aplicando o merge

sort.

3.Combinar: Juntar as duas metades em um único conjunto já classificado.

Para completar a ordenação do vetor original de n elementos, faz-se o merge ou a

fusão dos sub-vetores já ordenados. A desvantagem do Merge Sort é que requer o
dobro de memória, ou seja, precisa de um vetor com as mesmas dimensões do
vetor que está sendo classificado”.

Podemos observar o funcionamento do vetor na Figura 2.

Figura 2 : Funcionamento do Merge Sort. Fonte: Wikipedia.

 9

3.3.Selection Sort.

Segundo Ronaldo (2015) " No Insertion Sort, é possível perceber uma ordenação
muito simples, já no Selection Sort, a implementação se torna ainda mais simples,
entretanto se perde muito a respeito do desempenho do algoritmo".

Segundo Ronaldo (2015)" O Selection Sort é um algoritmo que tem como principal
objetivo, passar o menor valor para a primeira posição, (dependendo da ordenação
desejada, pode ser o maior valor). Para que possa ocorrer, o algoritmo percorra todos
os elementos procurando um menor valor, só aí ele é direcionado para a primeira
posição, repetindo essa tarefa para todos os elementos".

Um pouco desse algoritmo é mostrado a baixo, na figura 3.

Figura 3: Funcionamento do Selection Sort. Fonte: Hackerearth.

 10

4.DESENVOLVIMENTO.

O objetivo deste trabalho é desenvolver um programa que busque 1000

imagens dentro de um banco de dados, jogue os dados dentro de uma lista e realize
a ordenação dela utilizando três algoritmos de ordenação diferentes, o programa
também deve mostrar o tempo que cada algoritmo levou para ordenar a mesma lista
para que possa ser analisada a performance dos algoritmos e para fazer uma
comparação entre eles.

Os algoritmos utilizados no programa foram o Bubble Sort, o Merge Sort e o

Selection Sort, cada um destes algoritmos possui seu próprio método de realizar a
ordenação dos dados tendo suas vantagens e desvantagens.

Para desenvolvimento do programa foi utilizada a linguagem de programação

Java com uso da IDE NetBeans, o SGBD utilizado para manipulação do banco de
dados foi o MY SQL.

Com o uso do MySQL foi criado um banco de dados com 3 colunas, uma para
o id, uma para o nome da imagem e uma para armazenar a imagem em si, foram
utilizadas 1000 imagens aleatórias obtidas a partir do google imagens, as imagens
utilizadas foram convertidas em Blob para que pudessem ser inseridas dentro do
banco de dados.

Podemos observar o banco com as imagens na Figura 4.

 11

Figura 4 : Dados dentro do banco.

O programa possui uma única janela, e dentro dela temos uma tabela que
recebe e mostra os dados, um botão para que seja realizada a consulta dos dados,
três botões que acionam os algoritmos de ordenação e um JLabel que recebe o tempo.

Na figura 5 podemos ver como está organizada a janela.

 12

Figura 5 : janela.

O tempo é contado pela classe de tempo, essa classe é ativada toda vez que
se realiza uma ordenação, por um método que está dentro dos botões de ordenação
.

O botão de consulta busca os dados dentro do banco de dados e joga eles em

um ArrayList, então essa lista é jogada dentro da JTable, esses dados chegam na
mesma ordem que estão no banco de dados, ou seja, completamente desrodenados

Na figura 6 podemos observar a JTable com os dados desordenados.

 13

Figura 6 : Tabela com os dados desordenados.

Os botões de ordenação pegam os dados que estão na tabela e inserem em

ArrayLists, após isso, as listas são mandadas para as classes de ordenação. Dentro
das classes de ordenação as listas vão ser inseridas nos algoritmos de ordenação,
que vão realizar o trabalho de ordenar os dados, lembrando que cada algoritmo possui
um método diferente para ordenar os dados, após passar pela ordenação o ArrayList
ordenado será jogado na tabela para ser exibida para o usuário, esses botões também
servem para ativar a contagem do tempo e inseri-lo no JLabel.

Na figura 7 podemos observar a JTable ordenada pelo algoritmo Bubble Sort.

Figura 7 : Tabela ordenada com Bubble Sort.

Na figura 8 podemos observar a tabela ordenada com o uso do Merge Sort.

 14

Figura 8 : tabela ordenada com Merge Sort.

Na figura 9 temos a tabela ordenada pelo Selection Sort.

Figura 9: tabela ordenada com Selection Sort.

Como podemos observar cada algoritmo de ordenação obteve um tempo

diferente ao ordenar as 1000 imagens, neste teste o Merge Sort foi quem ordenou
 15

mais rápido a lista, com o tempo de ordenação sendo de 15ms, em seguida vem o
Bubble Sort que levou 46ms e por ultimo temos o Selection Sort que levou 58ms para
realizar a ordenação.
 16

5.RESULTADOS E DISCUSSÃO.

O trabalho foi desenvolvido com o objetivo de implementar algoritmos de

ordenação e mostrar o tempo que eles levaram para ordenar os dados contidos na
tabela, agora serão apresentados os resultados dos testes feitos para avaliar e
comparar a eficiência de cada um dos três algoritmos de ordenação implementados.

5.1.Bubble Sort.

O Bubble Sort Segundo Ronaldo (2015) “ é um algoritmo muito simples e eficaz

no processo de ordenação dos dados, em um número determinada mente limitado de
valores. Ele se baseia na troca de valores entre posições, fazendo com que os valores
determinados borbulhem para o final do algoritmo, isso depende da forma que se
deseja ordenar, do maior para o menor, ou do menos para o maior, que possivelmente
alterna para onde os maiores números se deslocaram”.

A ordenação pelo método Bubble Sort foi desenvolvida e o resultado foi o

algoritmo de ordenação a seguir.

public ArrayList<imgb> BS(ArrayList<imgb> listBolha) {

return Bubble(listBolha);

private static ArrayList<imgb> Bubble(ArrayList<imgb>listBolha){

for(int i = 0; i < listBolha.size()-1; i++) {

for(int j=0; j<listBolha.size() - i - 1; j++){

imgb x = listBolha.get(j);

imgb y = listBolha.get(j+1);

if (x.getNome().compareToIgnoreCase(y.getNome()) >= 0){

imgb z = listBolha.get(j);
 17

listBolha.set(j,listBolha.get(j+1));

listBolha.set(j+1,z);

return listBolha;

A partir da aplicação deste algoritmo de ordenação sobre os dados da tabela,

foram obtidos os tempos de ordenação do bubble. Para obter um resultado foram
realizadas 10 vezes a ordenação com 100 dados, mais 10 vezes com 200 dados e
também 10 vezes com os 1000 dados, após esses testes, foram calculadas as médias
aritméticas com cada quantidade de dados, também foi avaliado o menor tempo entre
as 10 ordenações. Os resultados podem ser vistos abaixo na tabela 1.

BubbleSort
Elementos Média do tempo (ms) Menor tempo (ms)
100 7,7ms 3ms
200 8,2ms 4ms
1000 22,1ms 15ms
Tabela1 : Resultados obtidos com BubbleSort.

5.2.Merge Sort

Segundo Farias (2014) “A ideia básica do Merge Sort é criar uma sequência
ordenada a partir de duas outras também ordenadas. Para isso, o algoritmo Merge
Sort divide a sequência original em pares de dados, agrupa estes pares na ordem
desejada; depois as agrupa as sequências de pares já ordenados, formando uma
nova sequência ordenada de quatro elementos, e assim por diante, até ter toda a
sequência ordenada”.
 18

Para se fazer a ordenação cm o Merge Sort foi desenvolvido o código fonte a

seguir.

public ArrayList<imgb> MS(ArrayList<imgb> listMerge) {

return Merge(listMerge, 0, listMerge.size() - 1);

private static ArrayList<imgb> Merge(ArrayList<imgb> listMerge, int in, int f)

{

if (in >= f) return listMerge;

int me = (in + f) / 2; //acha o me.

Merge(listMerge, in, me);

Merge(listMerge, me + 1, f);

return MergeSort(listMerge, in, me, f);

private static ArrayList<imgb> MergeSort(ArrayList<imgb> listMerge, int in,

int me, int f) {

int i = in;

int j = me + 1;

ArrayList<imgb> lst = new ArrayList<>(f - in + 1);

while (i <= me && j <= f) {

imgb x = listMerge.get(i);

imgb y = listMerge.get(j);

if (x.getNome().compareToIgnoreCase(y.getNome()) <= 0) {

lst.add(x);

i++;
 19

}else{

lst.add(y);

j++;

while (i <= me) {

lst.add(listMerge.get(i));

i++;

while (j <= f) {

lst.add(listMerge.get(j));

j++;

for (int k = 0; k < lst.size(); k++) {

listMerge.set(k + in, lst.get(k));

return listMerge;

A partir da aplicação deste algoritmo de ordenação sobre os dados da tabela,

foram obtidos os tempos de ordenação do Merge. Após isso foi usada a mesma forma
de avaliação que com o método bolha. Os resultados podem ser vistos abaixo na
tabela 2.
 20

MergeSort
Elementos Média do tempo (ms) Menor tempo (ms)
100 4,7ms 0ms
200 5,6ms 0ms
1000 10,2ms 0ms
Tabela2 : Resultados obtidos com MergeSort.

5.3.SelectionSort.

Segundo Viana (2016) “A ordenação por seleção ou selection sort consiste em

selecionar o menor item e colocar na primeira posição, selecionar o segundo menor
item e colocar na segunda posição, segue estes passos até que reste um único
elemento. Para todos os casos (melhor, médio e pior caso) possui complexidade C(n)
= O(n²) e não é um algoritmo estável”. A seguir temos o código fonte do método
SelectionSort.

private static ArrayList<imgb> selection(ArrayList<imgb>listSelection){

for (int i = 0; i < listSelection.size()-1; i++) {

int im=i;

for (int j = i + 1; j < listSelection.size(); j++) {

imgb x = listSelection.get(j);

imgb indiceMinimo = listSelection.get(im);

if (x.getNome().compareToIgnoreCase(indiceMinimo.getNome()) <= 0) {

im = j;

imgb y = listSelection.get(im);

listSelection.set(im,listSelection.get(i));
 21

listSelection.set(i,y);

return listSelection;

Utilizando do mesmo método de avaliação que o BubbleSort e o MergeSort, o

selection sort obteve os resultados que estão na tabela 3.

SelectionSort
Elementos Média do tempo (ms) Menor tempo (ms)
100 6,6ms 2ms
200 7,2ms 4ms
1000 30,4ms 15ms
Tabela3 : Resultados obtidos com SelectionSort.

Por meio da analise dos resultados dos testes feitos podemos observar que o
método MergeSort foi o que teve um melhor desempenho em todos os 3 casos, pois
obteve os menores valores de tempo, O BubbleSort perdeu para o MergeSort em
todos os casos, porem ganhou do SelectionSort somente na ordenação de 1000
imagens nos casos de 100 e 200 imagens o método selection se saiu melhor que o
Bubble. Outra coisa que pode ser observada é que o BubbleSort e O SelectionSort
possuem o mesmo tempo mínimo de ordenação com as 1000 imagens.

Então podemos concluir dizendo que o MergeSort é o melhor algoritmo quando

se trata de desempenho em grandes quantidades de imagens, pois ele quebra o
problema em partes realiza as ordenações e monta a lista completamente ordenada,
porem tem uma implementação um pouco mais complexa e requer uma grande
quantidade de memória. O bubbleSort tem como vantagem a facilidade de ser
implementado, porem não é o muito bom com grandes quantidades de itens pois ele
percorre o vetor várias vezes, e por isso acaba demorando muito. O SelectioSort
também percorre o vetor várias vezes e por isso acaba não se dando bem com
grandes quantidades de dados, porém ele é de fácil implementação e tem um ótimo
desempenho em pequenas listas.
 22

6.CONSIDERAÇÕES FINAIS.

Com este trabalho foi possível ver o que são os algoritmos em si, e que eles
são uma parte essencial da programação, e são também muito importantes para o
desenvolvimento da mesma, vimos também sobre os algoritmos de ordenação, pra
que eles servem e o quanto eles são importantes para a programação atual, pois
graças a eles fica muito mais fácil de se organizar uma tabela que possui grandes
quantidades de itens, e isso facilita muito a realização de buscas e outras coisas.

Foi visto também a aplicação de 3 algoritmos de ordenação na prática e a

avaliação do desempenho deles, isso ajudou a perceber que alguns métodos de
ordenação possuem estruturas mais simples e outros possuem estruturas complexas,
alguns são melhores para ordenar grandes quantidades como o MergeSort e outros
são melhores para ordenar pequenas quantidades como no caso do Selection e do
Bubble, então quando for realizar a ordenação de algo deve se verificar qual método
é a melhor opção para aquele caso antes de aplica-lo.
 23

7.REFERENCIAS BIBLIOGRÁFICAS.

PEREIRA, Ana Paula – TEC MUNDO – O Que é Algoritmo, 2009. [Internet]

Disponível em: <https://www.tecmundo.com.br/programacao/2082-o-que-e-
algoritmo-.htm > . Acessado em: 21/10/2019.

ROBSON, – DEV MEDIA – Entendendo o algoritmo BubbleSort em Java,

2012. [Internet] Disponível em: <https://www.devmedia.com.br/entendendo-o-
algoritmo-bubble-sort-em-java/24812> . Acessado em: 21/10/2019.

GATTO, Elaine Cecília – EMBARCADOS - Algoritmos de Ordenação: Bubble

Sort, 2017.[Internet] Disponível em: <https://www.embarcados.com.br/algoritmos-de-
ordenacao-bubble-sort/> . Acessado em: 21/10/2019.

BRAGA, Henrique Braga –MEDIUM –Algoritmos de ordenação : Insertion

Sort, 2018. [Internet] Disponível em:
<https://medium.com/@henriquebraga_18075/algoritmos-de-
ordena%C3%A7%C3%A3o-iii-insertion-sort-bfade66c6bf1>. Acessado em:
28/10/2019.

FARIAS, Ricardo Farias –COS121 –Estrutura de dados e Algoritmos, 2014.

[Internet] Disponível em : <https://www.cos.ufrj.br/~rfarias/cos121/aula_07.html>.
Acessado em: 01/11/19.

RONALDO – DEV MEDIA – Algoritmos De Ordenação Em Java,

2015.[Internet] Disponível em: <https://www.devmedia.com.br/algoritmos-de-
ordenacao-em-java/32693> . Acessado em: 05/11/2019.
 24

8.CODIGO FONTE.

8.1.BubbleSort.

package DAO;

import BEAN.imgb;

import java.util.ArrayList;

public class OrdenacaoSelection {

public ArrayList<imgb> SS(ArrayList<imgb> listSelection) {

return selection(listSelection);

private static ArrayList<imgb> selection(ArrayList<imgb>listSelection){

for (int i = 0; i < listSelection.size()-1; i++) {

int im=i;

for (int j = i + 1; j < listSelection.size(); j++) {

imgb x = listSelection.get(j);

imgb indiceMinimo = listSelection.get(im);

if (x.getNome().compareToIgnoreCase(indiceMinimo.getNome()) <= 0) {

im = j;

imgb y = listSelection.get(im);

listSelection.set(im,listSelection.get(i));

listSelection.set(i,y);

return listSelection;
 25

8.2.MergeSort.

package DAO;

import BEAN.imgb;

import java.util.ArrayList;

public class OrdenacaoMerge {

public ArrayList<imgb> MS(ArrayList<imgb> listMerge) {

return Merge(listMerge, 0, listMerge.size() - 1);

private static ArrayList<imgb> Merge(ArrayList<imgb> listMerge, int in, int f) {

if (in >= f) return listMerge;

int me = (in + f) / 2; //acha o me.

Merge(listMerge, in, me);

Merge(listMerge, me + 1, f);

return MergeSort(listMerge, in, me, f);

private static ArrayList<imgb> MergeSort(ArrayList<imgb> listMerge, int in, int me,

int f) {

int i = in;

int j = me + 1;

ArrayList<imgb> lst = new ArrayList<>(f - in + 1);

while (i <= me && j <= f) {

imgb x = listMerge.get(i);

imgb y = listMerge.get(j);
 26

if (x.getNome().compareToIgnoreCase(y.getNome()) <= 0) {

lst.add(x);

i++;

}else{

lst.add(y);

j++;

while (i <= me) {

lst.add(listMerge.get(i));

i++;

while (j <= f) {

lst.add(listMerge.get(j));

j++;

for (int k = 0; k < lst.size(); k++) {

listMerge.set(k + in, lst.get(k));

return listMerge;

}
 27

8.3.SelectionSort.

package DAO;

import BEAN.imgb;

import java.util.ArrayList;

public class OrdenacaoSelection {

public ArrayList<imgb> SS(ArrayList<imgb> listSelection) {

return selection(listSelection);

private static ArrayList<imgb> selection(ArrayList<imgb>listSelection){

for (int i = 0; i < listSelection.size()-1; i++) {

int im=i;

for (int j = i + 1; j < listSelection.size(); j++) {

imgb x = listSelection.get(j);

imgb indiceMinimo = listSelection.get(im);

if (x.getNome().compareToIgnoreCase(indiceMinimo.getNome()) <= 0) {

im = j;

imgb y = listSelection.get(im);

listSelection.set(im,listSelection.get(i));

listSelection.set(i,y);

return listSelection;

} }