Sortieren Sie ein Array in Java

Ich versuche ein Programm zu erstellen, das aus einem Array von 10 Ganzzahlen besteht, die alle einen zufälligen Wert haben, soweit so gut.

Jetzt muss ich sie jedoch in der Reihenfolge vom niedrigsten zum höchsten Wert sortieren und dann auf den Bildschirm drucken. Wie würde ich vorgehen?

(Tut mir leid, dass ich so viel Code für ein so kleines Programm habe, ich bin nicht so gut mit Schleifen, habe gerade angefangen, mit Java zu arbeiten)

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] );        

}

Schleifen sind auch sehr nützlich, um mehr darüber zu erfahren, insbesondere bei der Verwendung von 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();

Fügen Sie die Zeile vor dem Drucken hinzu, und Ihr Array wird sortiert

Arrays.sort( array );

Es kann Ihnen helfen, Schleifen zu verstehen, indem Sie sich selbst implementieren. Siehe Blasensortierung ist leicht zu verstehen:

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;
            }
        }
    }
}

Natürlich sollten Sie es nicht in der Produktion verwenden, da es leistungsfähigere Algorithmen für große Listen wie QuickSort oder MergeSort gibt, die von implementiert werdenArrays.sort(array)

Schauen Sie sich Arrays.sort () an

Ich war faul und fügte die Schleifen hinzu

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]);
        }
    }
}

Ihr Array hat eine Länge von 10. Sie benötigen eine Variable ( i), die die Werte von 0bis annimmt 9.

for ( int i = 0  ; i < array.length ;   i++ ) 
       ^               ^                   ^
       |               |                   ------  increment ( i = i + 1 )
       |               |
       |               +-------------------------- repeat as long i < 10
       +------------------------------------------ start value of i


Arrays.sort( array );

Ist eine Bibliotheksmethode, die Arrays sortiert.

Arrays.sort(yourArray)

wird den Job perfekt machen

Siehe unten, es gibt Ihnen sortiert aufsteigend und absteigend beide

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();
}}

Ausgabe wird sein

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 

Hinweis: Sie können Math.ranodm verwenden, anstatt manuelle Nummern hinzuzufügen. Lassen Sie mich wissen, wenn ich den Code ändern muss ...

Viel Glück ... Prost !!!

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;
        }
    }
}

So verwenden Sie dies in Ihrem Programm:

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] );        

}

Nur zu Ihrer Information, Sie können jetzt die neue Java 8-API zum Sortieren aller Arten von Arrays verwenden parallelSort

parallelSort verwendet das in Java 7 eingeführte Fork / Join-Framework, um die Sortieraufgaben mehreren im Thread-Pool verfügbaren Threads zuzuweisen.

die beiden Methoden, mit denen das intArray sortiert werden kann:

parallelSort(int[] a)
parallelSort(int[] a,int fromIndex,int toIndex)

Für natürliche Ordnung: Arrays.sort(array)

Für umgekehrte Reihenfolge: Arrays.sort(array, Collections.reverseOrder());-> Es handelt sich um eine statische Methode in der Collections-Klasse, die eine innere Klasse von sich selbst aufruft, um einen umgekehrten Komparator zurückzugeben.

Sie können ein int-Array mit sortieren Arrays.sort( array ) .

Java 8 bietet die Möglichkeit, Streams zu verwenden, die wie folgt sortiert int[] arraywerden können:

int[] sorted = Arrays.stream(array).sorted().toArray(); // option 1
Arrays.parallelSort(array); //option 2

Wie in doc erwähnt für parallelSort:

Der Sortieralgorithmus ist eine parallele Sortierzusammenführung, bei der das Array in Unterarrays unterteilt wird, die selbst sortiert und dann zusammengeführt werden. Wenn die Länge des Unterarrays eine minimale Granularität erreicht, wird das Unterarray mit der entsprechenden Methode Arrays.sort sortiert. Wenn die Länge des angegebenen Arrays kleiner als die minimale Granularität ist, wird es mit der entsprechenden Arrays.sort-Methode sortiert. Der Algorithmus benötigt einen Arbeitsbereich, der nicht größer als die Größe des ursprünglichen Arrays ist. Der gemeinsame ForkJoin-Pool wird zum Ausführen paralleler Aufgaben verwendet.

Wenn also das Eingabearray weniger als granular ist (8192 Elemente in Java 9 und 4096 in Java 8, glaube ich), dann parallelSort einfach der sequentielle Sortieralgorithmus aufgerufen.

Nur für den Fall, dass wir das Integer-Array umgekehrt sortieren möchten, können wir den Komparator wie folgt verwenden:

int[] reverseSorted = IntStream.of(array).boxed()
                        .sorted(Comparator.reverseOrder()).mapToInt(i -> i).toArray();

Da Java keine Möglichkeit hat, Grundelemente mit einem benutzerdefinierten Komparator zu sortieren, müssen wir Intermediate-Boxing oder eine andere Bibliothek von Drittanbietern verwenden, die eine solche primitive Sortierung implementiert.

Sie können die Funktion Arrays.sort () verwenden.

sort() method is a java.util.Arrays class method.          
Declaration : Arrays.sort(arrName)

WIRKSAMSTER WEG!

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+" ");
}

Wenn Sie den Quick-Sort-Algorithmus selbst erstellen und besser verstehen möchten, wie er funktioniert, überprüfen Sie den folgenden Code:

1- Sortierklasse erstellen

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- Senden Sie Ihr unsortiertes Array an die QuicksortKlasse

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- Ausgabe

Unsorted array :[6, 5, 3, 1, 8, 7, 2, 4] 
Sorted array :[1, 2, 3, 4, 5, 6, 7, 8]

Wir können auch einen binären Suchbaum verwenden, um ein sortiertes Array mithilfe der Traversal-Methode in der Reihenfolge zu erhalten. Der Code enthält auch die Implementierung eines grundlegenden binären Suchbaums.

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 + " "));
}

}}