Ajudem!Ordenar array dentro de arquivo.txt + análise de tempo e trocas, bubblesort, selectionsort, insertionsort, quicksort

8 de setembro de 2019 4 respostas

vitorgab 8 de setembro de 2019

Pessoal me ajudem! Sei pouco ou quase nada em Java, minha grade da faculdade está toda bagunçada pois tive que me transferir e tive que pegar algumas matérias de semestres mais avançados.

Se alguem puder me ensinar ate por chamada de video me mande um email: [email removido]
ou deixe seu contato pfvr, muito obrigado!

O prof. passou a seguinte tarefa:

Roteiro:
I) Construa uma função/método que gere uma sequência de N números inteiros
aleatórios, armazenando estes valores, na ordem de geração, num vetor recebido
como parâmetro.
II) Construa uma função/método que recebendo um vetor de inteiros com N
posições, armazene em um arquivo texto (definido por parâmetro), os valores de
suas células.
III) Implemente cada uma das funções/métodos correspondentes aos métodos de
ordenação: bubblesort, selectionsort, insertionsort, quicksort
IV) Construa uma aplicação que:
a. Permita ao usuário selecionar o tamanho de vetor a ser utilizado.
b. Gere um vetor de teste usando a função/método desenvolvido no item I.
c. Salve o seu conteúdo num arquivo texto, usando a função/método
desenvolvido no item II.
d. Permita ao usuário submeter o vetor de teste à ordenação, selecionado o
método desejado, apresentando ao final o vetor ordenado.
e. Permita ao usuário submeter o vetor de teste à ordenação por cada um dos
métodos de ordenação estudados, apresentando ao final: a quantidade de
comparações feitas, a quantidade de trocas de valores executadas e o tempo
total de execução em cada caso.
V) Utilize sua aplicação para gerar um conjunto de vetores de teste com tamanhos
variáveis e avalie os resultados obtidos:
a. Comparando a execução de cada método com relação à variação do tamanho
do vetor
b. Comparando o desempenho dos diferentes métodos em termos do número
médio de comparações, trocas e tempo de execução.

4 Respostas

wldomiciano 8 de set. de 2019 1 like

É uma tarefa e tanto! Com relação aos 2 primeiros items, vc poderia fazer assim:

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.Random;

public class Main {
    public static void generateRandomNumbers(int[] array, int n) {
        for (int number: new Random().ints(n, 0, 100).toArray()) array[--n] = number;
    }

    public static void writeToFile(int[] array, String filename) {
        try {
            Files.writeString(Path.of(filename), Arrays.toString(array));
        } catch (IOException e) {
            System.err.printf("Os dados não foram salvos: %s\n", e.getMessage());
        }
    }

    public static void main(String... args) {
        int n = 10;
        int[] array = new int[n];

        generateRandomNumbers(array, array.length);
        writeToFile(array, "dados.txt");

        System.out.println(Arrays.toString(array));
    }
}

vitorgab 8 de set. de 2019 1 like

Aqui tem todos os Sortings necessários que consegui

public class SortingFuncitons {

//BUBBLESORTs

public static double BubbleSort(int array[])

{

double tempoInicial = System.currentTimeMillis();

int order;

int size = array.length;

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

{

for(int b =0; b < size-1-i; b++)

{

if(array[b] > array[b+1])
	            {
	                order = array[b];
	                array[b] = array[i+1];
	                array[b+1] = order;
	            }   	       
            }	        
        }
      double tempoFinal = System.currentTimeMillis();  
      return (tempoFinal - tempoInicial)/1000;
	}
 /*=========================================*/
 
//SELECTIONSORT 
 public static double SelectionSort(int array[])
 {		
	 double tempoInicial = System.currentTimeMillis();
	   int order;
	   int size = array.length;
       for(int i = 0; i < size-1; i++) 
	   {
	         for(int b = i + 1; b < size; b++)
		     {
	        	 
				     if(array[i] > array[b])
				     {
				         order = array[i];
				         array[i] = array[b];
				         array[b] = order;
				     }    
		      }
       }
           
     double tempoFinal = System.currentTimeMillis();
     return (tempoFinal - tempoInicial)/1000;
 }		
 /*=========================================*/
 
//INSERTIONSORT 
 public static void InsertionSort(int array[]) 
 {
	int order, size = array.length,t;
	for(int i = 1; i < size; i++)
	{
        order = array[i];
		t = i-1;
		while(t>=0 && order < array[t])
		{
			array[t+1] = array[t];
			t--;
			array[t+1] = order;
	    }
	}
 }
 
 /*=========================================*/
 
 //QUICKSORT WITH RECURSION
 public static void QuickSort(int h[]) {
		QuickSort(h, 0, h.length-1 );
	}
 public static void QuickSort(int h[], int i, int s){
	int e=i, d=s;
	int item =h[((e+d)/2)];
	while(e<=d){
		while(h[e] < item)e++;
		while(h[d] > item)d--;
		if(e <= d){
			int aux;
			aux = h[e];
			h[e] = h[d];
			h[d] = aux;
			d--;
			e++;
		}
	}
	if(d-i>0) QuickSort(h, i, d);
	if(s-e>0) QuickSort(h, e, s);
 }

}

vitorgab 8 de set. de 2019

Vlw @wldomiciano
agora Precisava de ajuda com os tempos e comparações e trocas ;/

wldomiciano 8 de set. de 2019

Não sei se seu métodos estão corretos, mas vc poderia fazer só umas modificações para mostrar os dados que o exercicio pede, assim:

Primeiro vc cria uma classe pra representar as informações:

class Info {
    String metodo;
    int trocas;
    double tempo;

    Info(String metodo, int trocas, double tempo) {
        this.metodo = metodo;
        this.trocas = trocas;
        this.tempo = tempo;
    }

    static void print(Info... infos) {
        System.out.println("Método               | Trocas | Tempo");

        for (Info i: infos) {
            System.out.printf("%-20s | %-6d | %f", i.metodo, i.trocas, i.tempo);
        }
    }
}

E aí vc a usa assim (só modifiquei um dos métodos, vc tem que modifcar os outros):

public static Info SelectionSort(int[] array) {
    double tempoInicial = System.currentTimeMillis();

    int trocas = 0;
    int order;
    int size = array.length;
    for (int i = 0; i < size - 1; i++) {
        for (int b = i + 1; b < size; b++) {
            if (array[i] > array[b]) {
                trocas++;
                order = array[i];
                array[i] = array[b];
                array[b] = order;
            }
        }
    }

    double tempo = (System.currentTimeMillis() - tempoInicial) / 1000.0;

    System.out.println("Selection Sort");
    System.out.printf("Array ordenado: %s\n", Arrays.toString(array));
    System.out.printf("Trocas: %s\n", trocas);
    System.out.printf("Tempo: %f\n", tempo);

    return new Info("Selection Sort", trocas, tempo);
}

E no main, vc teria algo como isso:

Info i1 = SelectionSort(array);
Info i2 = BubbleSort(array);
Info i3 = InsertionSort(array);
Info i4 = QuickSort(array);

Info.print(i1, i2, i3, i4);

Criado 8 de setembro de 2019

Ultima resposta 8 de set. de 2019

Respostas 4

Participantes 2

4 Respostas

Topicos relacionados