Sắp xếp một mảng trong Java

Tôi đang cố gắng tạo ra một chương trình bao gồm một mảng gồm 10 số nguyên mà tất cả đều có giá trị ngẫu nhiên, cho đến nay vẫn tốt.

Tuy nhiên, bây giờ tôi cần sắp xếp chúng theo thứ tự từ giá trị thấp nhất đến cao nhất và sau đó in nó lên màn hình, làm thế nào để tôi làm như vậy?

(Xin lỗi vì có quá nhiều mã cho một chương trình nhỏ, tôi không giỏi với các vòng lặp, mới bắt đầu làm việc với 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] );        

}

Vòng lặp cũng rất hữu ích để tìm hiểu về, đặc biệt Khi sử dụng mảng,

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

Thêm dòng trước khi println và mảng của bạn được sắp xếp

Arrays.sort( array );

Nó có thể giúp bạn hiểu các vòng lặp bằng cách thực hiện chính mình. Xem Bubble sort rất dễ hiểu:

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

Tất nhiên, bạn không nên sử dụng nó trong sản xuất vì có được thực hiện tốt hơn các thuật toán cho các danh sách lớn như Sắp xếp nhanh hoặc Mergesort được thực hiện bởiArrays.sort(array)

Hãy xem Arrays.sort ()

Tôi đã lười biếng và thêm các vòng lặp

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

Mảng của bạn có độ dài 10. Bạn cần một biến ( i) lấy các giá trị từ 0đến 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 );

Là một phương pháp thư viện sắp xếp các mảng.

Arrays.sort(yourArray)

sẽ hoàn thành công việc một cách hoàn hảo

Xem bên dưới, nó sẽ cung cấp cho bạn sắp xếp tăng dần và giảm dần cả

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

Đầu ra sẽ là

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 

Lưu ý: Bạn có thể sử dụng Math.ranodm thay vì thêm số thủ công. Hãy cho tôi biết nếu tôi cần thay đổi mã ...

Chúc may mắn ... Chúc mừng !!!

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

Đây là cách sử dụng cái này trong chương trình của bạn:

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

}

chỉ FYI, bây giờ bạn có thể sử dụng API mới của Java 8 để sắp xếp bất kỳ loại mảng nào bằng cách sử dụng parallelSort

parallelSort sử dụng khung Fork / Tham gia được giới thiệu trong Java 7 để gán các tác vụ sắp xếp cho nhiều luồng có sẵn trong nhóm luồng.

hai phương thức có thể được sử dụng để sắp xếp intmảng,

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

Đối với trật tự tự nhiên: Arrays.sort(array)

Đối với thứ tự đảo ngược: Arrays.sort(array, Collections.reverseOrder());-> Đây là một phương thức tĩnh trong lớp Bộ sưu tập, nó sẽ tiếp tục gọi một lớp bên trong của chính nó để trả về một Bộ so sánh ngược.

Bạn có thể sắp xếp một mảng int với Arrays.sort( array ).

Java 8 cung cấp tùy chọn sử dụng các luồng có thể được sử dụng để sắp xếp int[] arraynhư:

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

Như đã đề cập trong doc cho parallelSort:

Thuật toán sắp xếp là một sự hợp nhất sắp xếp song song, phá vỡ mảng thành các mảng con được tự sắp xếp và sau đó được hợp nhất. Khi độ dài của mảng con đạt đến độ chi tiết tối thiểu, mảng con được sắp xếp bằng phương pháp Arrays.sort thích hợp. Nếu độ dài của mảng được chỉ định nhỏ hơn độ chi tiết tối thiểu, thì nó được sắp xếp bằng phương pháp Arrays.sort thích hợp. Thuật toán yêu cầu một không gian làm việc không lớn hơn kích thước của mảng ban đầu. Nhóm chung ForkJoin được sử dụng để thực hiện bất kỳ tác vụ song song nào.

Vì vậy, nếu mảng đầu vào nhỏ hơn độ chi tiết (8192 phần tử trong Java 9 và 4096 trong Java 8 tôi tin), thì parallelSortchỉ cần gọi thuật toán sắp xếp tuần tự.

Chỉ trong trường hợp chúng ta muốn đảo ngược sắp xếp mảng số nguyên, chúng ta có thể sử dụng bộ so sánh như:

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

Do Java không có cách nào để sắp xếp các nguyên thủy với bộ so sánh tùy chỉnh, chúng tôi phải sử dụng quyền anh trung gian hoặc một số thư viện bên thứ ba khác thực hiện sắp xếp nguyên thủy như vậy.

Bạn có thể sử dụng hàm Arrays.sort () .

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

CÁCH HIỆU QUẢ NHẤT!

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

Nếu bạn muốn tự mình xây dựng thuật toán sắp xếp nhanh và hiểu rõ hơn về cách thức hoạt động của nó, hãy kiểm tra mã dưới đây:

1- Tạo lớp sắp xếp

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- Gửi mảng chưa sắp xếp của bạn đến Quicksortlớp

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- Đầu ra

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

Chúng ta cũng có thể sử dụng cây tìm kiếm nhị phân để nhận mảng được sắp xếp bằng cách sử dụng phương thức truyền tải theo thứ tự. Mã này cũng đã thực hiện cây tìm kiếm nhị phân cơ bản bên dưới.

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

}