Então, hoje estou querendo dividir pelo menos meu conhecimento de um jeito de ordenação, e também, receber algumas dicas de melhoria no código, ou se teria outro modo que reduziria a complexidade de ordenar.
aqui está… xD
public class Ordena {
/**
* @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<4; i++){
for(int j = i+1; j<6; j++){
if(vetnum[i]>vetnum[j]){
aux = vetnum[i];
vetnum[i] = vetnum[j];
vetnum[j] = aux;
}
}
}
for(int i = 0; i<6; i++){
System.out.println("Vetor ordenado: "+ vetnum[i]);
}
}
}
pronto… olhem aí… e me de dicas… eu agradeço pela atenção!!!
ABRAÇOS!!
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!!!
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…
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…
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]);
}
}
}
/*
* 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();
}
}
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
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.
