ARE2_POTA1

Prévia do material em texto

Os Vetores foram gerados a partir dos algoritmos a baixos. Foi utilizado a classe Randon para gerar números aleatórios e dentro disso limitamos o maior número para 10000 e criamos a condições que nenhum número dos vetores fosse repetido.
public static int[] gerar(int n){
 int numero;
 int[]num = new int[n];
 Random r =new Random();
 for(int i=0; i<num.length; i++){
 numero =r.nextInt(10000)+1;
 for(int j=0; j<num;length; j++){
 if(numero == num[j] && j != i){
 numero = r.nextInt(10000)+1;
 }ele{
 num[i] = numero;
 }
 }
 }
 return num;
 }
Como foram adaptados os algoritmos para realizar a contagem do número de comparações;
Foram iniciadas variáveis para funcionar como contador de comparações e para isso estas variáveis foram colocadas antes de cada if ou while. O que foi desenvolvido para que cada algoritmo ordenasse os mesmos vetores que os demais;
É atribuído ao vetor "v", o método principal, o vetor gerado pelo método "gerar" e com isso todos os métodos dos algoritmos de ordenação recebem o mesmo vetor para ser ordenado.
public static void main(String[]args) thows IOException{
 //Scanner e entrada do tamanho dos veotres
 Scanner entrada =new Scanner(System.in);
 int numAleatorio;
 System.out.println("Insera o tamanho do veotr;");
 numAleatorio = entrada.nexlnt();
//classe para gerar o vetor com a quantidade de elementos escolhida
 int[] v =gerar(numAleatorio);
 System.out.pintln("\n Vetor Incial:"+ Array to String(v));
 bubbleSort(v);
 selectionsort(v);
 insertSort(v);
 heapSort(v);
 System.out.println("\nVetor Heap:"+ Array.toString(v));
 System.ou.println("--> Comparações Heap:"+ contadorheap);
 int i = 0;
 int f = v.length;
 mergeSout(v,i,f);
 System.out.println("\nVetor Merge:"+ Array.toString(v));
 System.ou.println("--> Comparações Merge:"+ contadormerge);
 quicSort(v,0,v.length - 1);
 System.ou.println("\n Vetor Quick:"+ ]array.toString(v));
 System.ou.println("--> Comparações Quick:"+ contadorquick);
}
public static int[] gerar(int n){
int numero;
 int[]num = new int[n];
 Random r =new Random();
 for(int i=0; i<num.length; i++){
 numero =r.nextInt(10000)+1;
 for(int j=0; j<num;length; j++){
 if(numero == num[j] && j != i){
 numero = r.nextInt(10000)+1;
 }ele{
 num[i] = numero;
 }
 }
 }
 return num;
 }
 
 Como propósito de conceder uma solução para certos problemas, temos algoritmos de ordenação, cada problema possui um algoritmo adequado a uma solução mais rápida e adequada, um tipo de busca e um método para organizar . Descrevendo o passo para chegar a uma solução, em alguns casos, os algoritmos de ordenação genéricos não servem para resolver e com isso as vezes precisamos altera - lo .
Ordenação por algoritmo.
Algoritmo que coloca os elementos de uma dada sequência em uma certa ordem, crescente ou decrescente. Em outras palavras. efetua sua ordenação completa ou parcial.
Insertion sort
Na ordem 1, o Insertion Sort Mostrou-se ser mais eficiente que todos os outros baseando com relação ao tempo e comparações. Já na ordem 2 foi menos eficiente do quer o Selection Sort e na ordem 3 a diferença com relação ao tempo entre o insertion e o selectio foi pequena.
Selection sort
Baseado em Passar sempre o menor valor do vetor para a primeira posição (ou o maior dependendo da ordem requerida), depois o segundo menor valor para a segunda posição e assim sucessivamente, até os últimos dois elementos.
A ordenação é escolhida um número a partir do primeiro, este número escolhido é comparado com os números a partir da sua direita, quando encontro um número menor, o número escolhido ocupa a posição de menor número encontrado, assim o número que foi encontrado passara a ser o próximo número escolhido caso contrário o número será colocado na posição do primeiro número escolhido. Vai repetido o processo até a lista ser ordenada.
Quick sort
Mais eficiente na ordenação por comparação. Ao contrário dos outros algoritmos, nele se escolhe um elemento pivô, a partir daí é organizado a lista para que todos os números anteriores a ele sejam menores que ele, ao final desse processo o número pivô já está em sua posição final. Esse tipo de algoritmo é mais eficiente em lista totalmente desordenadas, em relação aos outros no quesito de tempo. Na ordem 3 e 2 a diferença de tempo do quick sort em comparação aos outros foi muito grande.
ALGORITMO
package aps:
 import static aps.seleciotn.selectionSort
 public class apspota{
 private static int contadorquick = 0;
 public static void mains(String[] args) thorws IOException{
 //scanner e entrada do tamanho dos vetores
 int numAleatorio;
 Ssytem.out.printf(insira o tamanho do veotr:")
 numAleatorio = entrada.nextln();
 //classe para gerar o vetor com a quantidade de elementos escolhidos;
 int[] v = gerar(numAleatorio);
 System.out.printf("\nVetor Inicial:" + Arrays.toString(v));
 SelecitonSort(v);
 insertionSort(v);
 int i =0;
 int f = v.length;
 System.out.printf("\nVetor Quick: "+ Arrays.toString(v));
 System.out.printf("-->Comparações Quick:" + contadorquick);
 }
 private static void insertionSort(int[] veotr){
 int contador = 0;
 int x. j;
 for(int i = 1; i < vetor.length; i++){
 x = vetor[i];
 j = i-1;
 contador++;
 while(j>-0)&& vetor[j]>x){
 vetor[j+i]=vetor[j];
 j=j-1
 }
 vetor[j+i]=x
 }
 System.out.printf("\nVetor Insertion:" +Array.toString(vetor));
 System.out.printf("--> Comparações insertion:" + contador);
 }
 private static int quickSort(int[] vetor, int inicio, int fim){
 if(inicio < fim){
 contadorquick++;
 int posucaoPivo = separar(vetor, inicio, fim);
 quickSort(vetor, inicio, posicaoPivo -1);
 quickSort(vetor, posicaoPivo + 1, fim);
 }
 return contadorquick;
 }
 private static int separar(int[] vetor, int inicio, int fim){
 int pivo = vetor[inicio];
 int i = inicio +1, f=fim;
 while (i <=f){
 contadorquick++;
 if(vetor[i]<= pivo){
 contadorquick++;
 i++;
 }else if (pivo <vetor[f]){
 f--;
 }else{
 int
 troca = vetor[i];
 vetor[i]=vetor[f];
 vetor[f]=troca;
 i++;
 f--;
 }
 }
 vetor[inicio]=vetor[f];
 vetor[f]=pivo;
 retunr f;
 }
 public static int[] gerar(int n){
 int numero;
 int[]num = new int[]
 Random r = new Random();
 for (int i=0; i<num.length; i++){
 numero = r.next(10000) + 1;
 for(int j=0; j<num.lengh: j++){
 if(numero == num[j] && j !=i){
 numero = r.nextlnt(10000) + 1;
 }else{
 num[i]} = numero;
 }
 }
 }
 retunr num;
 }
 }
 public classe selection extends apspoya{
 public static void selecionSort(int[] vetor){
 int contadors = 0;
 for(int i = 0; i <vetor.length; i++)
 int menor = i;
 for(int j = i+1; j < vetor.length; j++){
 contadors++;
 if(vetor[j] < vetor[menor]){
 menor = j;
 }
 }
 mudar(vetor,i,menor)
 }
 System.out.printf("\nVetor Selection:" + Array.toString(vetor));
 System.out.printf("--> Comparações Selection;"+contadors);
 }
 public static void mudar(int[] vetor, int i, int menor){
 int aux = vetor[i];
 vetor[i]=
 }
Resultados
Os gráficos abaixo foram gerados com base nas médias dos valores obtidos nos algoritmos em execução.
REFERÊNCIAS 
Geeksforgeeks, Disponível em:<https://www.geeksforgeeks.org/difference-between-insertion-sort-and-selection-sort/> acessado em 9 de junho 2021;
Yourbasic , Disponívelem: https://yourbasic.org/algorithms/insertion-sort/ acessado em 9 de junho de 2021;