Sortuj tablicę w Javie

Próbuję stworzyć program składający się z tablicy 10 liczb całkowitych, z których wszystkie mają losową wartość, jak na razie dobrze.

Jednak teraz muszę posortować je w kolejności od najniższej do najwyższej wartości, a następnie wydrukować na ekranie, jak mam to zrobić?

(Przepraszam, że mam tyle kodu dla tak małego programu, nie radzę sobie zbyt dobrze z pętlami, właśnie zacząłem pracować z Javą)

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

}

Pętle są również bardzo przydatne do nauki, szczególnie podczas korzystania z tablic,

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

Dodaj linię przed println, a twoja tablica zostanie posortowana

Arrays.sort( array );

Może pomóc ci zrozumieć pętle, implementując się. Zobacz Sortowanie bąbelkowe jest łatwe do zrozumienia:

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

Oczywiście nie należy go używać w środowisku produkcyjnym, ponieważ istnieją lepsze algorytmy dla dużych list, takich jak QuickSort lub MergeSort, które są implementowane przezArrays.sort(array)

Spójrz na Arrays.sort ()

Byłem leniwy i dodałem pętle

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

Twoja tablica ma długość 10. Potrzebujesz jednej zmiennej ( i), która przyjmuje wartości od 0do 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 );

To metody biblioteczne, które sortują tablice.

Arrays.sort(yourArray)

wykona pracę doskonale

Zobacz poniżej, to da ci posortowane zarówno rosnąco, jak i malejąco

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

Wyjście będzie

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 

Uwaga: Możesz użyć Math.ranodm zamiast ręcznego dodawania liczb. Daj mi znać, jeśli muszę zmienić kod ...

Powodzenia ... Na zdrowie !!!

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

Oto jak tego użyć w swoim programie:

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

}

Po prostu do Twojej wiadomości, możesz teraz używać nowego interfejsu API Java 8 do sortowania dowolnego typu tablic przy użyciu parallelSort

parallelSort wykorzystuje strukturę Fork / Join wprowadzoną w Javie 7 do przypisywania zadań sortowania do wielu wątków dostępnych w puli wątków.

dwie metody, których można użyć do sortowania inttablicy,

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

Do naturalnego porządku: Arrays.sort(array)

Odwrotna kolejność: Arrays.sort(array, Collections.reverseOrder());-> Jest to metoda statyczna w klasie Collections, która dalej wywoła własną klasę wewnętrzną, aby zwrócić odwrotny komparator.

Możesz sortować tablicę int za pomocą Arrays.sort( array ).

Java 8 umożliwia korzystanie ze strumieni, które można wykorzystać do sortowania int[] array:

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

Jak wspomniano w dokumencie dla parallelSort:

Algorytm sortowania to równoległe scalanie sortowania, które dzieli tablicę na tablice podrzędne, które same są sortowane, a następnie łączone. Gdy długość podtablicy osiągnie minimalną szczegółowość, podtablica jest sortowana przy użyciu odpowiedniej metody Arrays.sort. Jeśli długość określonej tablicy jest mniejsza niż minimalna szczegółowość, jest ona sortowana przy użyciu odpowiedniej metody Arrays.sort. Algorytm wymaga przestrzeni roboczej nie większej niż rozmiar oryginalnej tablicy. Wspólna pula ForkJoin służy do wykonywania równoległych zadań.

Więc jeśli tablica wejściowa jest mniejsza niż ziarnistość (8192 elementów w Javie 9 i 4096 w Javie 8, jak sądzę), to parallelSort po prostu wywołuje algorytm sortowania sekwencyjnego.

Na wypadek gdybyśmy chcieli odwrócić sortowanie tablicy liczb całkowitych, możemy skorzystać z komparatora jako:

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

Ponieważ Java nie ma możliwości sortowania prymitywów za pomocą niestandardowego komparatora, musimy użyć pośredniego boksu lub innej biblioteki innej firmy, która implementuje takie prymitywne sortowanie.

Możesz użyć funkcji Arrays.sort () .

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

NAJBARDZIEJ EFEKTYWNY SPOSÓB!

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

Jeśli chcesz samodzielnie zbudować algorytm szybkiego sortowania i lepiej zrozumieć, jak to działa, sprawdź poniższy kod:

1- Utwórz klasę sortowania

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- Wyślij swoją niesortowaną tablicę na Quicksortzajęcia

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- Wyjście

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

Możemy również użyć drzewa wyszukiwania binarnego, aby uzyskać posortowaną tablicę za pomocą metody przechodzenia w kolejności. Kod ma również implementację podstawowego drzewa wyszukiwania binarnego poniżej.

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

}