Sortir array di Jawa

Saya mencoba membuat program yang terdiri dari 10 integer yang semuanya memiliki nilai acak, sejauh ini bagus.

Namun, sekarang saya perlu mengurutkannya dari nilai terendah ke nilai tertinggi dan kemudian mencetaknya di layar, bagaimana saya melakukannya?

(Maaf karena memiliki begitu banyak kode untuk program sekecil itu, saya tidak begitu baik dengan loop, baru mulai bekerja dengan Java)

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

}

Loop juga sangat berguna untuk dipelajari, terutama saat menggunakan array,

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

Tambahkan Baris sebelum println dan array Anda akan diurutkan

Arrays.sort( array );

Ini dapat membantu Anda memahami loop dengan menerapkan sendiri. Lihat Bubble sort mudah dimengerti:

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

Tentu saja, Anda tidak boleh menggunakannya dalam produksi karena ada algoritma berkinerja lebih baik untuk daftar besar seperti QuickSort atau MergeSort yang diimplementasikan olehArrays.sort(array)

Lihatlah Arrays.sort ()

Saya malas dan menambahkan loop

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

Array Anda memiliki panjang 10. Anda perlu satu variabel ( i) yang mengambil nilai dari 0hingga 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 );

Merupakan metode perpustakaan yang mengurutkan array.

Arrays.sort(yourArray)

akan melakukan pekerjaan dengan sempurna

Lihat di bawah, itu akan memberi Anda diurutkan naik dan turun keduanya

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

Output akan menjadi

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 

Catatan: Anda dapat menggunakan Math.ranodm alih-alih menambahkan nomor manual. Beri tahu saya jika saya perlu mengubah kode ...

Semoga Sukses ... Ceria !!!

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

Berikut ini cara menggunakannya di program Anda:

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

}

hanya FYI, Anda sekarang dapat menggunakan Java 8 API baru untuk menyortir semua jenis array menggunakan parallelSort

parallelSort menggunakan Fork / Gabung kerangka kerja yang diperkenalkan di Java 7 untuk menetapkan tugas penyortiran ke beberapa utas yang tersedia di kumpulan utas.

dua metode yang dapat digunakan untuk mengurutkan intarray,

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

Untuk pesanan alami: Arrays.sort(array)

Untuk Pesanan terbalik: Arrays.sort(array, Collections.reverseOrder());-> Ini adalah metode statis di kelas Koleksi yang selanjutnya akan memanggil kelas dalam dirinya sendiri untuk mengembalikan Pembanding terbalik.

Anda dapat mengurutkan array int Arrays.sort( array ).

Java 8 menyediakan opsi untuk menggunakan stream yang dapat digunakan untuk mengurutkan int[] arraysebagai:

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

Seperti disebutkan dalam dokumen untuk parallelSort:

Algoritma pengurutan adalah pengurutan paralel yang memecah array menjadi sub-array yang diurutkan sendiri dan kemudian digabungkan. Ketika panjang sub-array mencapai granularity minimum, sub-array diurutkan menggunakan metode Arrays.sort yang sesuai. Jika panjang array yang ditentukan kurang dari granularity minimum, maka diurutkan menggunakan metode Array.sort yang sesuai. Algoritma ini membutuhkan ruang kerja yang tidak lebih besar dari ukuran array asli. Kumpulan umum ForkJoin digunakan untuk menjalankan tugas paralel apa pun.

Jadi jika array input kurang dari granularity (8192 elemen di Java 9 dan 4096 di Java 8 saya percaya), maka parallelSortcukup memanggil algoritma pengurutan berurutan.

Kalau-kalau kita ingin membalikkan mengurutkan array integer kita dapat menggunakan komparator sebagai:

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

Karena Java tidak memiliki cara untuk mengurutkan primitif dengan komparator kustom, kita harus menggunakan tinju menengah atau perpustakaan pihak ketiga lainnya yang mengimplementasikan penyortiran primitif tersebut.

Anda dapat menggunakan fungsi Arrays.sort () .

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

CARA YANG PALING EFEKTIF!

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

Jika Anda ingin membuat sendiri algoritma Urutkan cepat dan lebih memahami cara kerjanya periksa kode di bawah ini:

1- Buat kelas sortir

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- Kirim array Anda yang tidak disortir ke Quicksortkelas

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

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

Kami juga dapat menggunakan pohon pencarian biner untuk mendapatkan array yang diurutkan dengan menggunakan metode traversal in-order. Kode juga memiliki implementasi pohon pencarian biner dasar di bawah ini.

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

}