Ordenação de Vetor ... xD

Você não pode utilizar um Collections?

abraço!

Você poderia pesquisar por um algoritmo menos burro que o bubble sort. Como por exemplo o Merge Sort e o QuickSort.

Bom Dia…

Então, coloquei o bubble primeiro é um que estou conseguindo mandar até bem, e outra, volta e meia alguém quer saber como funciona sabe…
mais aí que está, estou tentando mandar pelo Quick … mais não conseguir desenvolver bem completamente esse algoritmo… sou novato, e meu tempo pra poder estudar no desenvolvimento de algoritmo é pouco e durante o período de trabalho sabe…

mais, mesmo assim, valeu mesmo por estarem respondendo o meu exercício!!!

Os recursivos são geralmente os mais eficientes!

Eu tenho um material na minha casa, porém, estou no serviço agora, mas você encontra fácil.
Já que tocou no assunto, não há muito empenho em melhorar o assintótico do código (reinventar a roda), existe sim, a preocupação em como o SO irá tratar isso em termos de memória e processamento, etc.

Você necessariamente precisa implementar um algoritmo de Sort?
Caso não precise, poderia fazer desta forma

import java.util.*; import javax.swing.*; public class Ordena { public static void main(String[] args) { int vetnum[] = new int[6]; for(int i=0; i<6; i++){ String num = JOptionPane.showInputDialog("Digita o valor: "); vetnum[i] = Integer.parseInt(num); } Arrays.sort(vetnum); for(int i = 0; i<6; i++){ System.out.println("Vetor ordenado: "+ vetnum[i]); } } }
Caso precise implementar, procure algo sobre ShellSort (acho que é assim que escreve) que é um algoritmo bem eficiente.
Abraços

verdade… os recursivos são mesmo os mais eficientes…
mais eu não tenho ainda muito domínio com esses algoritmos… estou tentando ver se consigo algo mais em detalhes…
é que tipo, não gosto de ficar pesquisando muito, porque as vezes, uma coisa que entendo, acaba meio que complicando quando pesquiso algo “feito” de outros…
vou tentar se consigo algo “melhor” … ou “menos burro” também… rsrsrs…

Muito obrigado por darem atenção!

Bom dia gilsonpolito,

Ow… valeu mesmo, verdade, é uma boa a dica que mandou… não necessariamente tem que ser um Sort … é que tipo, pensei que seria bacana eu colocasse esse exercício e ter uma pequena discussão. rsrsrs e teve mesmo né… rsrs…
as vezes tem gente que quer saber como é o bboble…

mais… é um jeito bem bacana né… o java passa os pacotes pronto, é só conhecer mesmo…

muito obrigado!!!

Bom,

Acabei de refazer de outro jeito, não sei se estaria correto… mais…
se puderem me corrigir… serei grato!!!

public class Ordenacao2 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        int vetnum[] = new int[6];
        int aux;
        for (int i = 0; i < 6; i++) {
            String num = JOptionPane.showInputDialog("Digita o valor: ");
            vetnum[i] = Integer.parseInt(num);
        }
        for (int i = 0; i < 6; i++) {
            System.out.println("posição : " + vetnum[i]);
        }
       
        int index_min;

        for (int i = 0; i < vetnum.length; i++) {
            index_min = i;
            for (int j = i + 1; j < vetnum.length; j++) {
                if (vetnum[j] < vetnum[index_min]) {
                    index_min = j;
                }
            }
            if (index_min != i) {
                aux = vetnum[index_min];
                vetnum[index_min] = vetnum[i];
                vetnum[i] = aux;
            }
        }


        for (int i = 0; i < 6; i++) {
            System.out.println("Vetor ordenado: " + vetnum[i]);
        }
    }
}

Abraços!!

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package javaapplication2;

import java.util.Scanner;


public class Ordenacao3 {

    void insercaoShell(int a[], int n, int f, int h) {
        int i; // Passos do algoritmo
        int j; // Índice do vetor
        int x; // Elemento a ser inserido
        for (i = f + h; i < n; i += h) {
            x = a[i];
            j = i - h;
            while (j >= f && a[j] > x) {
                a[j + h] = a[j]; // Desloca o elemento para a direita
                j -= h;
            }
            a[j + h] = x; // Insere o elemento na posição correta
        }
    }

    int pot(int x, int y) {
        return (y == 0 ? 1 : x * pot(x, y - 1));
    }

    void shellSort(int a[], int n, int k) {
        int i; // Número de segmentos
        int h; // Tamanho do incremento
        do {
            h = pot(2, k) - 1;
            for (i = 0; i < h; i++) {
                insercaoShell(a, n, i, h);
            }
            k--;
        } while (k >= 1);
    }

    public static void main(String[] args) {
        Ordenacao3 order = new Ordenacao3();
        Scanner sc = new Scanner(System.in);
        int n = 0;
        System.out.println("Tamanho do vetor: ");
        n = sc.nextInt();
        int vet[] = new int[n];
        System.out.println("Elementos: ");
        for(int i = 0; i < n; i++){
            vet[i] = sc.nextInt();
        }
        order.shellSort(vet, n, n);
        System.out.println("\n\n\nVetor Ordenado!\n");
        for(int i = 0; i<n; i++){
            System.out.print(" "+vet[i]);
        }
        System.out.println();

    }
}

Abraço!>

Ja que não domina a tecnica de recursividade, tente pelo menos usa o algoritmo Insertion sort , ele nao usa recursividade e e considerado mas rapido que o Bubble Sort

Tente aprende recursivamente , pois o resultado e bem mas eficaz e rapido

Ou use uma pilha.

Boa noite…

Muito obrigado pela ajuda novamente.
Então, como citado anteriormente, sobre pilha, eu já fiz como pilha, e sobre vetor, meio que passei batido, mais também… esse exercício eu peguei de uma prova de poscomp… e achei interessante fazer em um jeito que tem várias opções, até eu conseguir alcançar a complexidade de O(n) como pedido no exercício. Pois bem, fiz isso pra poder praticar e me organizar pessoalmente.

Muito obrigado mesmo pela atenção de todos!