Ik probeer een programma te maken dat bestaat uit een array van 10 gehele getallen die allemaal een willekeurige waarde hebben, so far so good.
Nu moet ik ze echter sorteren van de laagste naar de hoogste waarde en ze vervolgens op het scherm afdrukken, hoe moet ik dat doen?
(Sorry dat ik zoveel code heb voor zo’n klein programma, ik ben niet zo goed met loops, ik ben net begonnen met Java te werken)
public static void main(String args[])
{
int [] array = new int[10];
array[0] = ((int)(Math.random()*100+1));
array[1] = ((int)(Math.random()*100+1));
array[2] = ((int)(Math.random()*100+1));
array[3] = ((int)(Math.random()*100+1));
array[4] = ((int)(Math.random()*100+1));
array[5] = ((int)(Math.random()*100+1));
array[6] = ((int)(Math.random()*100+1));
array[7] = ((int)(Math.random()*100+1));
array[8] = ((int)(Math.random()*100+1));
array[9] = ((int)(Math.random()*100+1));
System.out.println(array[0] +" " + array[1] +" " + array[2] +" " + array[3]
+" " + array[4] +" " + array[5]+" " + array[6]+" " + array[7]+" "
+ array[8]+" " + array[9] );
}
Antwoord 1, autoriteit 100%
Lussen zijn ook erg handig om over te leren, vooral bij het gebruik van arrays,
int[] array = new int[10];
Random rand = new Random();
for (int i = 0; i < array.length; i++)
array[i] = rand.nextInt(100) + 1;
Arrays.sort(array);
System.out.println(Arrays.toString(array));
// in reverse order
for (int i = array.length - 1; i >= 0; i--)
System.out.print(array[i] + " ");
System.out.println();
Antwoord 2, autoriteit 95%
Voeg de regel toe voor println en je array wordt gesorteerd
Arrays.sort( array );
Antwoord 3, autoriteit 20%
Het kan je helpen loops te begrijpen door jezelf te implementeren. Zie Bellen sorteren is gemakkelijk te begrijpen:
public void bubbleSort(int[] array) {
boolean swapped = true;
int j = 0;
int tmp;
while (swapped) {
swapped = false;
j++;
for (int i = 0; i < array.length - j; i++) {
if (array[i] > array[i + 1]) {
tmp = array[i];
array[i] = array[i + 1];
array[i + 1] = tmp;
swapped = true;
}
}
}
}
Je moet het natuurlijk niet in productie gebruiken, aangezien er beter presterende algoritmen zijn voor grote lijsten zoals QuickSortof MergeSortdie worden geïmplementeerd door Arrays.sort(array)
Antwoord 4, autoriteit 11%
Bekijk Arrays.sort()
Antwoord 5, autoriteit 10%
Ik was lui en heb de loops toegevoegd
import java.util.Arrays;
public class Sort {
public static void main(String args[])
{
int [] array = new int[10];
for ( int i = 0 ; i < array.length ; i++ ) {
array[i] = ((int)(Math.random()*100+1));
}
Arrays.sort( array );
for ( int i = 0 ; i < array.length ; i++ ) {
System.out.println(array[i]);
}
}
}
Je array heeft een lengte van 10. Je hebt één variabele nodig (i) die de waarden van 0tot 9neemt.
for ( int i = 0 ; i < array.length ; i++ )
^ ^ ^
| | ------ increment ( i = i + 1 )
| |
| +-------------------------- repeat as long i < 10
+------------------------------------------ start value of i
Arrays.sort( array );
Is een bibliotheekmethode die arrays sorteert.
Antwoord 6, autoriteit 8%
Arrays.sort(yourArray)
zal het werk perfect doen
Antwoord 7, autoriteit 4%
Voor natuurlijke volgorde: Arrays.sort(array)
Voor omgekeerde volgorde: Arrays.sort(array, Collections.reverseOrder());— > Het is een statische methode in de klasse Collections die verder een innerlijke klasse van zichzelf zal aanroepen om een omgekeerde comparator te retourneren.
Antwoord 8, autoriteit 3%
Zie hieronder, het geeft je gesorteerd oplopend en aflopend zowel
import java.util.Arrays;
import java.util.Collections;
public class SortTestArray {
/**
* Example method for sorting an Integer array
* in reverse & normal order.
*/
public void sortIntArrayReverseOrder() {
Integer[] arrayToSort = new Integer[] {
new Integer(48),
new Integer(5),
new Integer(89),
new Integer(80),
new Integer(81),
new Integer(23),
new Integer(45),
new Integer(16),
new Integer(2)
};
System.out.print("General Order is : ");
for (Integer i : arrayToSort) {
System.out.print(i.intValue() + " ");
}
Arrays.sort(arrayToSort);
System.out.print("\n\nAscending Order is : ");
for (Integer i : arrayToSort) {
System.out.print(i.intValue() + " ");
}
Arrays.sort(arrayToSort, Collections.reverseOrder());
System.out.print("\n\nDescinding Order is : ");
for (Integer i : arrayToSort) {
System.out.print(i.intValue() + " ");
}
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
SortTestArray SortTestArray = new SortTestArray();
SortTestArray.sortIntArrayReverseOrder();
}}
Uitgang is
General Order is : 48 5 89 80 81 23 45 16 2
Ascending Order is : 2 5 16 23 45 48 80 81 89
Descinding Order is : 89 81 80 48 45 23 16 5 2
Opmerking: U kunt Math.RANODM gebruiken in plaats van handmatige nummers toe te voegen. Laat me weten of ik de code moet veranderen …
Veel geluk … proost !!!
9, Autoriteit 3%
int[] array = {2, 3, 4, 5, 3, 4, 2, 34, 2, 56, 98, 32, 54};
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array.length; j++) {
if (array[i] < array[j]) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
}
10, Autoriteit 3%
Hier is hoe dit in uw programma te gebruiken:
public static void main(String args[])
{
int [] array = new int[10];
array[0] = ((int)(Math.random()*100+1));
array[1] = ((int)(Math.random()*100+1));
array[2] = ((int)(Math.random()*100+1));
array[3] = ((int)(Math.random()*100+1));
array[4] = ((int)(Math.random()*100+1));
array[5] = ((int)(Math.random()*100+1));
array[6] = ((int)(Math.random()*100+1));
array[7] = ((int)(Math.random()*100+1));
array[8] = ((int)(Math.random()*100+1));
array[9] = ((int)(Math.random()*100+1));
Arrays.sort(array);
System.out.println(array[0] +" " + array[1] +" " + array[2] +" " + array[3]
+" " + array[4] +" " + array[5]+" " + array[6]+" " + array[7]+" "
+ array[8]+" " + array[9] );
}
Antwoord 11, autoriteit 3%
ter info, u kunt nu Java 8 nieuwe API gebruiken voor het sorteren van elk type array met behulp van parallelSort
parallelSortgebruikt het Fork/Join-framework dat in Java 7 is geïntroduceerd om de sorteertaken toe te wijzen aan meerdere threads die beschikbaar zijn in de threadpool.
de twee methoden die kunnen worden gebruikt om intarray te sorteren,
parallelSort(int[] a)
parallelSort(int[] a,int fromIndex,int toIndex)
Antwoord 12, autoriteit 2%
Je kunt een int-array sorteren met Arrays.sort( array ).
13
U kunt arrays.sort () gebruiken functie.
sort() method is a java.util.Arrays class method.
Declaration : Arrays.sort(arrName)
14
Meest effectieve manier!
public static void main(String args[])
{
int [] array = new int[10];//creates an array named array to hold 10 int's
for(int x: array)//for-each loop!
x = ((int)(Math.random()*100+1));
Array.sort(array);
for(int x: array)
System.out.println(x+" ");
}
15
Als u zelf het Quick Sort-algoritme wilt bouwen en meer begrip hebt van hoe het werkt, controleert u de onderstaande code:
1- Maak Sorteerklasse
class QuickSort {
private int input[];
private int length;
public void sort(int[] numbers) {
if (numbers == null || numbers.length == 0) {
return;
}
this.input = numbers;
length = numbers.length;
quickSort(0, length - 1);
}
/*
* This method implements in-place quicksort algorithm recursively.
*/
private void quickSort(int low, int high) {
int i = low;
int j = high;
// pivot is middle index
int pivot = input[low + (high - low) / 2];
// Divide into two arrays
while (i <= j) {
/**
* As shown in above image, In each iteration, we will identify a
* number from left side which is greater then the pivot value, and
* a number from right side which is less then the pivot value. Once
* search is complete, we can swap both numbers.
*/
while (input[i] < pivot) {
i++;
}
while (input[j] > pivot) {
j--;
}
if (i <= j) {
swap(i, j);
// move index to next position on both sides
i++;
j--;
}
}
// calls quickSort() method recursively
if (low < j) {
quickSort(low, j);
}
if (i < high) {
quickSort(i, high);
}
}
private void swap(int i, int j) {
int temp = input[i];
input[i] = input[j];
input[j] = temp;
}
}
2- Stuur uw ongesorteerde array naar de klasse Quicksort
import java.util.Arrays;
public class QuickSortDemo {
public static void main(String args[]) {
// unsorted integer array
int[] unsorted = {6, 5, 3, 1, 8, 7, 2, 4};
System.out.println("Unsorted array :" + Arrays.toString(unsorted));
QuickSort algorithm = new QuickSort();
// sorting integer array using quicksort algorithm
algorithm.sort(unsorted);
// printing sorted array
System.out.println("Sorted array :" + Arrays.toString(unsorted));
}
}
3- Uitvoer
Unsorted array :[6, 5, 3, 1, 8, 7, 2, 4]
Sorted array :[1, 2, 3, 4, 5, 6, 7, 8]
Antwoord 16
We kunnen ook een binaire zoekboom gebruiken om gesorteerde arrays te krijgen met behulp van de in-order traversal-methode. De code heeft ook de implementatie van een basis binaire zoekboom hieronder.
class Util {
public static void printInorder(Node node)
{
if (node == null) {
return;
}
/* traverse left child */
printInorder(node.left);
System.out.print(node.data + " ");
/* traverse right child */
printInorder(node.right);
}
public static void sort(ArrayList<Integer> al, Node node) {
if (node == null) {
return;
}
/* sort left child */
sort(al, node.left);
al.add(node.data);
/* sort right child */
sort(al, node.right);
}
}
class Node {
Node left;
Integer data;
Node right;
public Node(Integer data) {
this.data = data;
}
public void insert(Integer element) {
if(element.equals(data)) {
return;
}
// if element is less than current then we know we will insert element to left-sub-tree
if(element < data) {
// if this node does not have a sub tree then this is the place we insert the element.
if(this.left == null) {
this.left = new Node(element);
} else { // if it has left subtree then we should iterate again.
this.left.insert(element);
}
} else {
if(this.right == null) {
this.right = new Node(element);
} else {
this.right.insert(element);
}
}
}
}
class Tree {
Node root;
public void insert(Integer element) {
if(root == null) {
root = new Node(element);
} else {
root.insert(element);
}
}
public void print() {
Util.printInorder(root);
}
public ArrayList<Integer> sort() {
ArrayList<Integer> al = new ArrayList<Integer>();
Util.sort(al, root);
return al;
}
}
public class Test {
public static void main(String[] args) {
int [] array = new int[10];
array[0] = ((int)(Math.random()*100+1));
array[1] = ((int)(Math.random()*100+1));
array[2] = ((int)(Math.random()*100+1));
array[3] = ((int)(Math.random()*100+1));
array[4] = ((int)(Math.random()*100+1));
array[5] = ((int)(Math.random()*100+1));
array[6] = ((int)(Math.random()*100+1));
array[7] = ((int)(Math.random()*100+1));
array[8] = ((int)(Math.random()*100+1));
array[9] = ((int)(Math.random()*100+1));
Tree tree = new Tree();
for (int i = 0; i < array.length; i++) {
tree.insert(array[i]);
}
tree.print();
ArrayList<Integer> al = tree.sort();
System.out.println("sorted array : ");
al.forEach(item -> System.out.print(item + " "));
}
}
Antwoord 17
Houd er rekening mee dat de Arrays.sort()-methode niet thread-safeis: als uw array een eigenschap is van een singleton en wordt gebruikt in een omgeving met meerdere threads, moet u de sorteercode in een gesynchroniseerd blok, of maak een kopie van de array en bestel die kopie (alleen de arraystructuur wordt gekopieerd, met dezelfde objecten erin).
Bijvoorbeeld:
int[] array = new int[10];
...
int[] arrayCopy = Arrays.copyOf(array , array .length);
Arrays.sort(arrayCopy);
// use the arrayCopy;
Antwoord 18
Doe gewoon het volgende voordat u de array afdrukt:-
Arrays.sort(array);
Opmerking:-
je moet de arrays-klasse importeren door te zeggen:-
import java.util.Arrays;