Insertion Sort

opa…
pesquisei aqui no forum ja, mais nao entendir direito o algoritmo…
fui no wikipedia, e la axei um exemplo e uma implementação dele…
conceitua-se que ele ordena a lista da esquerda para a direita…
entao tentei me baseia pelo o algoritmo q tem la de exemplo…
mais da um erro…

Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException: 1000
at Crescente.main(Crescente.java:15)

o algoritmo q eu fiz segue a seguir

[code]public class Crescente {

public static void main(String[] args) {
int x;
int num=1000;
int array []= new int [num];
boolean troca;

if(num>0){
do {
	if (array [num] < array[num-1]){  //ELE FALA QUE O ERRO ESTA AQUI!    
		troca=true;
		x=array[num];
		array[num]=array[num-1];
		array[num-1]=x;
		num=num-1;
		if(num==0)
			troca=false;
	
	}
	else
		troca=false;

	System.out.println(array[num]);
}
while(troca==false);
}
}

}
[/code]

valeuu galera!

if (array [num] < array[num-1]){

Nesse momento sua variavel num vale 1000, mas o seu array vai da posicao 0 até a 999;
Logo ele deu aquele erro, reveja sua lógica que vc consegue :slight_smile:

velhooo! rsrs
tentei ate agora e nada sai velho
da uma luz ai!

ja tentei ate coloca um num=num-1, antes do primeiro if, pra ele comecar com 999, ja que vai de 0 a 999 = 1000 posicoes…mais deu infinito, o laco nao para! rsrsrrs

e aew?

Oi.
Cara, Insertion Sort ordena a lista como você ordenaria as cartas que você recebe em um jogo de baralho (acredito eu essa ser a melhor analogia). Você recebe uma e não tem nada pra ordenar. Conforme você vai recebendo, você vai buscando a lista da esquerda para a direita para ver onde fica a carta. Dependendo de como estiver disposta a lista, a complexidade chega a ser baixa (se ela já estiver “meio” ordenada, a complexidade é baixa).

Esse seu código está meio estranho. Eu aconselho você a fazer um teste de mesa. Vai dar uma exception ali porque vai chegar em um momento em que você vai estar comparando array[0] com array[-1]. De fato, acredito que você deva repensar no método de Insertion Sort e tentar novamente. A melhor coisa, nesse caso é usar um for ou algo do gênero.

Abraço.

Não sei se aquele troca vai receber um false sempre corretamente…

Eu particularmente não gosto muito do do-while, nunca entendi ele direito, mas acho que essa tua lógica não está exatamente como o Insertion Sort pede…

Já que tu conseguiu o algoritmo, vê se ele está exatamente assim como teu código foi implementado…

Mas o que o francislon disse está certo, a tua variável num está valendo 100 na primeira vez, por isso está dando aquele ArrayIndexOutOfBounds… Se tu corrigiu isso, o erro deve ser outro agora…

eu axei esse algoritmo aqui de exemplo oh:

[code]public int valueSortInt[]= new int[90];

public void InsertionSortInt(int valor[], int pos)
{   
    int tmp;
    boolean troca;

    valueSortInt[pos] = valor[pos];

    if (pos>0) // só para controle
    {   
        do
        {
            if (valueSortInt[pos] < valueSortInt[pos-1])
            {
                troca = true;
                tmp = valueSortInt[pos];
                valueSortInt[pos] = valueSortInt[pos-1];
                valueSortInt[pos-1] = tmp;

                pos = pos-1; 
                if (pos == 0)
                    troca=false;
            }
            else
                troca=false;
        }
        while (troca == false);
    }
}[/code]

do wikipedia…tentei me baseia nele, mais aki ele eh um metodo, q recebe 2 valores, um pos q vai iguala a valueSortInt[pos] = valor[pos], e isso eu nao entendir bem…e foi ai q eu me basiei no num-1…
vlws galera!

Aqui vai mais uma forma que eu to tentando fazer…
PS: to tentando de varias formas aleatorias, rsrss

mais da erro numa linha…

[code]public class Crescente {

public static void main (String args[]){
int x;
int num = 100;
int array []=new int [num];
int i= num-1;

for(int a=0; a<=i; i++){
    array[a]=i--;
if(array[a] > array[a-1]){     // mais ele esta dando erro no -1 aqui do [a-1]
    x=array[a];
    array[a]=array[a-1];
    array[a-1]=x;
}
System.out.println(array[a]);

}

}
}[/code]

Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException: -1
at Crescente.main(Crescente.java:11)

ta ai o erro…
to tentando, to tentando, ! rsrsrss

O erro do seu segundo método é porque o a está zerado, e tu tenta pegar a posição -1, e tu sabe que o array começa em 0…

Cara… Esse código da Wikipédia tem erro…

Ele entra em loop eterno, tentei testar ele… Não vai por ele.

Eu infelizmente não posso te ajudar, porque faz tempo que não vejo esses algoritmos de ordenação…

Talvez se tu tentar 2 arrays, pega um e vai colocando em ordem no outro…

coloquei um:

int i = num -1;
e substituir os a pelos i…
mais ele entra em um laço inifinito de 0…
=
a coisa ta fea! rsrs

cara… tenta esse código aqui, também pego da Wikipédia, mas em C, sintaxe parece ser a mesma:

static void insertSort(int a[], int length) {
     int i, j, value;
 
     for(i = 1; i < length; ++i) {
         value = a[i];
         for (j = i - 1; j >= 0 && a[j] > value; --j)
             a[j + 1] = a[j];
         a[j+1] = value;
     }
 }

OOpa!
conseguir fazer crescente e decrescente meu povo!
o codigo segue ai:

[code]public class Crescente {

/**
 * @Autor Felipe Two
 */
public static void main (String args []){
	long start = System.currentTimeMillis();
	int array [] = new int [1001];
	int i, j, troca;
	
	for(i=1; i < 1000; i++){
		troca = array[i]=i;
		for(j=i-1; j>=0 && array[j] > troca; --j){
			array[j+1]= array[j];
			array[j+1]=troca;
			
		}
		}
	for(j=0;j<1000;j++){
		System.out.println(array[j]);
	}
	long delay = System.currentTimeMillis() - start;
	System.out.println("Demorou para execultar " +delay + " Milissegundos");
}

}
[/code]

[code]public class Decrescente {

/**
 * @Autor Felipe Two
 */
public static void main (String args []){
	long start = System.currentTimeMillis();
	int array [] = new int [1001];
	int i, j, troca;
	
	for(i=1; i < 1000; i++){
		troca = array[i]=i;
		for(j=i-1; j>=0 && array[j] < troca; --j){
			array[j+1]= array[j];
			array[j]=troca;
			
		}
		}
	for(j=0;j<1000;j++){
		System.out.println(array[j]);
	}
	long delay = System.currentTimeMillis() - start;
	System.out.println("Demorou para execultar " +delay + " Milissegundos");
}

}[/code]

agora eu estou tentando fazer com numeros aleatorios em ordem decrescente, mais esta imprimindo somento o primeiro aleatorio, e o resto 0, olhem o coigo ai:

[code]public class Aleatorio {

/**
 * @Autor Felipe Two
 */
public static void main (String args []){
	long start = System.currentTimeMillis();
    int array[] = new int[1001];
    int i, j, troca,k;

    for (k = 0; k < 1000; k++) {
        array[k] = (int) (Math.random() * 999);
    }

    for (i = 1; i < 1000; i++) {
        troca = array[i]=array[k];

        for (j = i - 1; j >= 0 && array[j] > troca; j--) {
            array[j + 1] = array[j];
            array[j + 1] = troca;	
        }
        
    }

    for (j = 0; j < 1000; j++) {
        System.out.println(array[j]);
    }
    long delay = System.currentTimeMillis() - start;
    System.out.println("Demorou para execultar " + delay + " Milissegundos");
}

}[/code]

valeuu! :wink:

EDITADO****

aeww conseguir fazer ele gera numeros aleatorios, mais ele nao esta imprimindo ordenado, eu usei a mesma logica do crescente, mais nao sei o porque nao imprime ordenado…

[code]public class Aleatorio {

/**
 * @Autor Felipe Two
 */
public static void main (String args []){
	long start = System.currentTimeMillis();
    int array[] = new int[1001];
    int  j, troca,k;

    for (k = 0; k < 1000; k++) {
        array[k] = (int) (Math.random() * 999);
    }

    for (k = 1; k < 1000; k++) {
        troca = array[k];

        for (j = k - 1; j >= 0 && array[j] > troca; --j) {
            array[j + 1] = array[j];
            array[j + 1] = troca;	
        }
        
    }

    for (j = 0; j < 1000; j++) {
        System.out.println(array[j]);
    }
    long delay = System.currentTimeMillis() - start;
    System.out.println("Demorou para execultar " + delay + " Milissegundos");
}

}
[/code]

EDITADO**** de novo… OBS: Eu sei, voces nao me guentam mais! HEUHehuehehuHUe

bom, eu axo que conseguir, ele ta gerando numeros aleatorios e imprimindo em ordem crescente…
to botando os codigos, que pode servi para mais alguem, que queria busca o topico sobre o insertion tambem! :wink:

[code]public class Aleatorio {

/**
 * @Autor Felipe Two
 */
public static void main (String args []){
	long start = System.currentTimeMillis();
    int array[] = new int[1001];
    int  j, troca,k;

   // for (k = 0; k < 1000; k++) {
     //   array[k] = (int) (Math.random() * 999);
    //}

    for (k = 1; k < 1000; k++) {
        troca = array[k]= 0+ (int) (Math.random()*50);

        for (j = k - 1; j >= 0 && array[j] > troca; --j) {
            array[j + 1] = array[j];
            
        }
        array[j+1] = troca;	
    }

    for (j = 0; j < 1000; j++) {
        System.out.println(array[j]);
    }
    long delay = System.currentTimeMillis() - start;
    System.out.println("Demorou para execultar " + delay + " Milissegundos");
}

}[/code]