Java: un tableau d'entiers sans utiliser Arrays.sort ()
Ceci est l'instruction dans l'un des exercices de notre classe Java. Avant toute chose, j'aimerais dire que je fais mes devoirs et que je ne suis pas simplement paresseux pour demander à quelqu'un sur Stack Overflow de répondre à cette question pour moi. Cet élément spécifique a été mon problème parmi tous les autres exercices parce que je me suis efforcé de trouver «l'algorithme parfait» pour cela.
Ecrivez un programme Java qui entrera 10 valeurs entières et l’affichera par ordre croissant ou décroissant. Remarque: Arrays.sort () n'est pas autorisé.
C’est le code que j’ai proposé, cela fonctionne mais il a un défaut évident. Si j'entre la même valeur deux fois ou plus, par exemple:
5, 5, 5, 4, 6, 7, 3, 2, 8, 10
Un seul des trois 5 entrés serait compté et inclus dans la sortie. Le résultat obtenu (pour l'ordre croissant) est:
2 3 4 5 0 0 6 7 8 10.
import Java.util.Scanner;
public class Exer3AscDesc
{
public static void main(String args[])
{
Scanner scan = new Scanner(System.in);
int tenNums[]=new int[10], orderedNums[]=new int[10];
int greater;
String choice;
//get input
System.out.println("Enter 10 integers : ");
for (int i=0;i<tenNums.length;i++)
{
System.out.print(i+1+"=> ");
tenNums[i] = scan.nextInt();
}
System.out.println();
//imperfect number ordering algorithm
for(int indexL=0;indexL<tenNums.length;indexL++)
{
greater=0;
for(int indexR=0;indexR<tenNums.length;indexR++)
{
if(tenNums[indexL]>tenNums[indexR])
{
greater++;
}
}
orderedNums[greater]=tenNums[indexL];
}
//ask if ascending or descending
System.out.print("Display order :\nA - Ascending\nD - Descending\nEnter your choice : ");
choice = scan.next();
//output the numbers based on choice
if(choice.equalsIgnoreCase("a"))
{
for(greater=0;greater<orderedNums.length;greater++)
{
System.out.print(orderedNums[greater]+" ");
}
}
else if(choice.equalsIgnoreCase("d"))
{
for(greater=9;greater>-1;greater--)
{
System.out.print(orderedNums[greater]+" ");
}
}
}
}
Vous pouvez trouver autant d’algorithmes de tri différents sur Internet, mais si vous voulez réparer votre propre solution, vous pouvez apporter les modifications suivantes à votre code:
Au lieu de:
orderedNums[greater]=tenNums[indexL];
vous devez faire ceci:
while (orderedNums[greater] == tenNums[indexL]) {
greater++;
}
orderedNums[greater] = tenNums[indexL];
Ce code vérifie fondamentalement si cet index particulier est occupé par un nombre similaire, puis il essaiera de trouver le prochain index libre.
Remarque: étant donné que la valeur par défaut de vos éléments de tableau triés est 0, vous devez vous assurer que 0 ne figure pas dans votre liste. sinon, vous devezamorcer votre tableau trié avec un numéro spécial que vous êtes sûrement pas dans votre liste, par exemple: Integer.MAX_VALUE
Algorithme de tri simple Tri à bulles :
public static void main(String[] args) {
int[] arr = new int[] { 6, 8, 7, 4, 312, 78, 54, 9, 12, 100, 89, 74 };
for (int i = 0; i < arr.length; i++) {
for (int j = i + 1; j < arr.length; j++) {
int tmp = 0;
if (arr[i] > arr[j]) {
tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
}
}
}
Voici une solution simple
public static void main(String[] args) {
//Without using Arrays.sort function
int i;
int nos[] = {12,9,-4,-1,3,10,34,12,11};
System.out.print("Values before sorting: \n");
for(i = 0; i < nos.length; i++)
System.out.println( nos[i]+" ");
sort(nos, nos.length);
System.out.print("Values after sorting: \n");
for(i = 0; i <nos.length; i++){
System.out.println(nos[i]+" ");
}
}
private static void sort(int nos[], int n) {
for (int i = 1; i < n; i++){
int j = i;
int B = nos[i];
while ((j > 0) && (nos[j-1] > B)){
nos[j] = nos[j-1];
j--;
}
nos[j] = B;
}
}
Et le résultat est:
Valeurs avant le tri:
12
9
-4
-1
3
dix
34
12
11
Valeurs après tri:
-4
-1
3
9
dix
11
12
12
34
Manière simple:
int a[]={6,2,5,1};
System.out.println(Arrays.toString(a));
int temp;
for(int i=0;i<a.length-1;i++){
for(int j=0;j<a.length-1;j++){
if(a[j] > a[j+1]){ // use < for Descending order
temp = a[j+1];
a[j+1] = a[j];
a[j]=temp;
}
}
}
System.out.println(Arrays.toString(a));
Output:
[6, 2, 5, 1]
[1, 2, 5, 6]
Je recommanderais de regarder Tri par sélection ou Tri par insertion si vous n'êtes pas inquiet pour la performance Peut-être que cela vous donnera des idées.
int x[] = { 10, 30, 15, 69, 52, 89, 5 };
int max, temp = 0, index = 0;
for (int i = 0; i < x.length; i++) {
int counter = 0;
max = x[i];
for (int j = i + 1; j < x.length; j++) {
if (x[j] > max) {
max = x[j];
index = j;
counter++;
}
}
if (counter > 0) {
temp = x[index];
x[index] = x[i];
x[i] = temp;
}
}
for (int i = 0; i < x.length; i++) {
System.out.println(x[i]);
}
Le tri à bulles peut être utilisé ici:
//Time complexity: O(n^2)
public static int[] bubbleSort(final int[] arr) {
if (arr == null || arr.length <= 1) {
return arr;
}
for (int i = 0; i < arr.length; i++) {
for (int j = 1; j < arr.length - i; j++) {
if (arr[j - 1] > arr[j]) {
arr[j] = arr[j] + arr[j - 1];
arr[j - 1] = arr[j] - arr[j - 1];
arr[j] = arr[j] - arr[j - 1];
}
}
}
return arr;
}
Trier les tableaux sans utiliser les fonctions intégrées à Java ...... créez un nouveau fichier en utilisant ce nom -> (Array Sorting.Java) ..... Lancer le projet et en profiter !!!
import Java.io.*;
import Java.util.Arrays;
import Java.util.Scanner;
public class ArraySorting
{
public static void main(String args[])
{
int temp=0;
Scanner user_input=new Scanner(System.in);
System.out.println("enter Size of Array...");
int Size=user_input.nextInt();
int[] a=new int[Size];
System.out.println("Enter element Of an Array...");
for(int j=0;j<Size;j++)
{
a[j]=user_input.nextInt();
}
for(int index=0;index<a.length;index++)
{
for(int j=index+1;j<a.length;j++)
{
if(a[index] > a[j] )
{
temp = a[index];
a[index] = a[j];
a[j] = temp;
}
}
}
System.out.print("Output is:- ");
for(int i=0;i<a.length;i++)
{
System.out.println(a[i]);
}
}
}
int[] arr = {111, 111, 110, 101, 101, 102, 115, 112};
/* for ascending order */
System.out.println(Arrays.toString(getSortedArray(arr)));
/*for descending order */
System.out.println(Arrays.toString(getSortedArray(arr)));
private int[] getSortedArray(int[] k){
int localIndex =0;
for(int l=1;l<k.length;l++){
if(l>1){
localIndex = l;
while(true){
k = swapelement(k,l);
if(l-- == 1)
break;
}
l = localIndex;
}else
k = swapelement(k,l);
}
return k;
}
private int[] swapelement(int[] ar,int in){
int temp =0;
if(ar[in]<ar[in-1]){
temp = ar[in];
ar[in]=ar[in-1];
ar[in-1] = temp;
}
return ar;
}
private int[] getDescOrder(int[] byt){
int s =-1;
for(int i = byt.length-1;i>=0;--i){
int k = i-1;
while(k >= 0){
if(byt[i]>byt[k]){
s = byt[k];
byt[k] = byt[i];
byt[i] = s;
}
k--;
}
}
return byt;
}
</ i>
sortie:-
ordre croissant: - 101, 101, 102, 110, 111, 111, 112, 115
ordre décroissant: - 115, 112, 111, 111, 110, 102, 101, 101