Java Algoritmo de ordenação em JAVA

[Izaac Baptista]

Boa noite, estou tentando dificuldade com esse exercício de lógica. será que alguém consegue me dar uma luz?

 

Segue o código...

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.InputMismatchException;
import java.util.Scanner;

public class Ordenacao {
    
    public static void main(String[] parametros) {
    //O programa deverá receber uma lista de valores de um arquivo de texto, 
    //onde esta lista não terá uma determinação de quantidade fixa, 
    //podendo variar de arquivo para arquivo. 
    //Após, deverá ser alocado os valores dentro da estrutura de Array 
    //(não poderão ser aplicadas Collections para solução), 
    //e realizada a ordenção dos valores, imprimindo em tela os passos ocorridos desta ordenação. 
    //Após, deverá ser utilizado uma Collection para o recebimento dos mesmos valores, 
    //de maneira que estes valores já estejam ordenados. 
    //Ao final, deverá ser impresso em tela o valor ordenado do Array e da Collection, 
    //garantindo que estejam iguais, e deverá ser exportado em um arquivo de texto esses valores.

    //lendo o arquivo desordenado
        try {
            BufferedReader buffer = new BufferedReader(new FileReader("ordenacao.txt"));
    //salvando o arquivo num array
            int[] desordenado = new int[desordenado];
    //ordenando o array com BUBBLE SORT
        while (desordenado == 1)
        {
            desordenado = 0;        
            for (int i = 0; i <= 3; i++)
            {
                if (int numero[i] > numero[i + 1])
                {
                    desordenado = 1;
                    int aux = numero[i];
                    numero[i] = numero[i + 1];
                    numero[i + 1] = aux;
                }
            }
        }
        } catch (IOException exception) {
            System.out.println(exception.getMessage());
        }
    //salvando o array ordenado no novo arquivo
        try {
            BufferedWriter buffer = new BufferedWriter(new FileWriter("ordenacao1.txt"));
            int ordenado = "";
    //imprimindo o novo arquivo ordenado
            System.out..println(ordenado)
            }
            buffer.close();
        } catch (IOException exception) {
            System.out.println(exception.getMessage());
        }
    }
}

 

[AdrianoSiqueira]

Eu cheguei nesse algoritmo:

package aslib;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.regex.Pattern;

public class ASLibTest {

    public static void main(String[] args) {
        File arquivoDesordenado = new File("arquivo.txt");
        File arquivoOrdenado = new File("ordenado.txt");

        int[] valores = lerDados(arquivoDesordenado);

        ordenar(valores);
        escreverDados(arquivoOrdenado, valores);
    }

    private static int[] lerDados(File arquivo) {
        Pattern pattern = Pattern.compile("\\d");

        StringBuilder buffer = new StringBuilder();
        String[] auxiliar;
        int[] resultado;

        try (BufferedReader reader = new BufferedReader(new FileReader(arquivo))) {
            String linha;

            /*
             * Lê os dados do arquivo adicionando apenas as linhas numéricas no
             * buffer (um número por linha).
             */
            while ((linha = reader.readLine()) != null) {
                if (pattern.matcher(linha).matches()) {
                    buffer.append(linha).append("\n");
                } else {
                    System.out.println("[ A ]: Ignorando linha corrompida: '" + linha + "'");
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        /*
         * Passa os dados do buffer para um vetor auxiliar de strings, em
         * seguida passa para o vetor correto de int.
         */
        auxiliar = buffer.toString().split("\n");
        resultado = new int[auxiliar.length];

        for (int i = 0; i < auxiliar.length; i++) {
            resultado[i] = Integer.parseInt(auxiliar[i]);
        }

        return resultado;
    }

    private static void escreverDados(File arquivo, int[] valores) {
        StringBuilder buffer = new StringBuilder();

        for (int i : valores) {
            buffer.append(i).append("\n");
        }

        try (BufferedWriter writer = new BufferedWriter(new FileWriter(arquivo))) {
            writer.write(buffer.toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void ordenar(int[] valores) {
        for (int i = 0; i < valores.length; i++) {
            for (int j = 0; j < valores.length - 1; j++) {
                if (valores[j] > valores[j + 1]) {
                    int temp = valores[j];
                    valores[j] = valores[j + 1];
                    valores[j + 1] = temp;
                }
            }
        }
    }
}

Ficou um tanto longo, mas funciona.

[Izaac Baptista]

atualizando...

 

consegui ler o arquivo já criado, mas não consigo salvar ele num array pra ordenar...

 

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Sample {
    public static void main(String[] args) throws IOException {
        //lendo o arquivo 
        try {
            BufferedReader buffer = new BufferedReader(new FileReader("ordena.txt"));
            String linha = "";
            do {
                linha = buffer.readLine();
                System.out.println(linha);
            } while (linha != null);
            buffer.close();
        } catch (FileNotFoundException e) {
            System.out.println("ordena.txt não encontrado");
        }   
    }
}

 

[Izaac Baptista]

Consegui chegar nesse algoritmo. 

 

import java.util.List;
import java.util.Scanner;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;


public class ordenacao{
    public static void main(String[] args) {
        ArrayList<Integer> vet = new ArrayList<Integer>();
        int AntValor = 0;
        int i = 0;

        try{
            BufferedReader leitura = new BufferedReader(new FileReader("VetorDesordenado.txt"));
            String value = "";
            while (true){
                if(value != null)
                {
                    //System.out.println(value);
                    if(value != "")
                    {
                        int valorInteiro = Integer.parseInt(value);
                        vet.add(valorInteiro);                    
                    }
                }else
                    break;
                    
                value = leitura.readLine();
            }
            leitura.close();
        } catch (IOException exception){
            System.out.println("Erro de exceção I/O: " + exception.getMessage());
        }

        for(i = 0; i < vet.size(); i++){
            System.out.println("Valor Fora da ordem: " + vet.get(i));
        }
        System.out.println(" ");
            
        int PenultValor = vet.size()-1;

        for(i = 0; i<vet.size(); i++){
            for(int j = 0; j<PenultValor; j++){
                if(vet.get(j) > vet.get(j+1))
                {
                    AntValor = vet.get(j);
                    int ProxValor = vet.get(j+1);
                    vet.set(j, ProxValor);
                    vet.set(j+1, AntValor);
                }
            }
        }

        for(i = 0; i<vet.size(); i++){
            System.out.println("Valor na Ordem: "+vet.get(i));
        }

        try{
            BufferedWriter escrita = new BufferedWriter(new FileWriter("VetorOrdenado.txt"));
            
            for(i = 0; i<vet.size(); i++){
                int digitadoInt = vet.get(i);

                String digitado = Integer.toString(digitadoInt);
                // Scanner in = new Scanner(System.in);
                // digitado = in.nextLine();

                escrita.append(digitado + "\n");
                escrita.newLine();
                //in.close();
            }
            escrita.close();
        } catch (IOException exception){
            System.out.println("Erro de exceção I/O: " + exception.getMessage());
        }        

        System.out.println("Novo arquivo de texto gerado com os números ordenados! VetorOrdenado.txt");

    }
    
}