Java에서 배열 정렬

Java에서 배열 정렬

저는 10개의 정수로 이루어진 프로그램을 만들려고 합니다. 모두 랜덤한 값을 가지고 있고, 지금까지도 좋습니다.

다만, 최저치부터 최고치 순서로 정렬해, 화면에 인쇄할 필요가 있습니다만, 어떻게 하면 좋을까요?

(프로그램에 코드가 너무 많아서 죄송합니다.루프를 잘 못해서 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] );        

}

루프는 특히 어레이를 사용할 때 매우 유용합니다.

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

println과 어레이가 정렬되기 전에 행을 추가합니다.

Arrays.sort( array );

스스로 실장함으로써 루프를 이해하는 데 도움이 될 수 있습니다.자세한 내용은 버블 정렬을 참조하십시오.

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

QuickSort나 MergeSort와 같은 대규모 목록에 대해 보다 뛰어난 성능을 발휘하는 알고리즘이 구현되어 있기 때문에 물론 프로덕션에서 이 알고리즘을 사용하면 안 됩니다.Arrays.sort(array)

Arrays.sort()를 확인합니다.

나는 게을러서 루프를 더했다.

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

열 번하나 합니다.i )의 값을 취합한 것입니다.0로로 합니다.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 );

배열을 정렬하는 라이브러리 메서드입니다.

Arrays.sort(yourArray)

그 일을 완벽하게 해낼 것이다

순서의 : ★★★★★★★★★★★★★★★★★★★★★★★★★:Arrays.sort(array)

" " " " 의 :Arrays.sort(array, Collections.reverseOrder());-- > 이를 더욱 합니다.-- > Collections는 Collections를 반환한다.이 메서드는 자신의 내부 클래스를 호출하여 역컴퍼레이터를 반환합니다.

아래를 참조하면 오름차순과 내림차순으로 정렬됩니다.

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

출력은 다음과 같습니다.

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 

주의: 수동 번호를 추가하는 대신 Math.ranodm을 사용할 수 있습니다.코드를 변경해야 할 경우 알려 주십시오.

행운을 빈다...건배!!!

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

은 int로 할 수 .Arrays.sort( array ).

프로그램에서의 사용 방법은 다음과 같습니다.

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

}

8의 API를 사용하여 임의의 할 수 되었습니다.parallelSort

parallelSort는 Java 7에서 도입된 Fork/Join 프레임워크를 사용하여 스레드 풀에서 사용 가능한 여러 스레드에 정렬 태스크를 할당합니다.

「」의 정렬에 할 수 int 스위칭,

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

Java 8은 스트림을 사용하여 정렬할 수 있는 옵션을 제공합니다.int[] array같이요.

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

에 대해서는 문서에서 설명한 바와 같이parallelSort:

정렬 알고리즘은 배열을 정렬된 후 병합되는 하위 배열로 분할하는 병렬 정렬 병합입니다.하위 배열 길이가 최소 입도에 도달하면 해당 어레이를 사용하여 하위 배열이 정렬됩니다.정렬 방식지정된 배열의 길이가 최소 세분도보다 작을 경우 적절한 배열로 정렬됩니다.정렬 방식알고리즘에는 원래 어레이 크기 이하의 작업 공간이 필요합니다.ForkJoin 공통 풀은 병렬 작업을 실행하는 데 사용됩니다.

따라서 입력 배열이 세분화되지 않은 경우(Java 9에서는 8192개 요소, Java 8에서는 4096개 요소),parallelSort단순히 순차 정렬 알고리즘을 호출합니다.

정수 배열을 역순으로 정렬하려는 경우 비교기를 다음과 같이 사용할 수 있습니다.

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

Java는 커스텀 컴퍼레이터로 프리미티브를 정렬할 방법이 없기 때문에 이러한 프리미티브 정렬을 구현하는 중간 박싱이나 다른 서드파티 라이브러리를 사용해야 합니다.

Arrays.sort() 함수를 사용할 수 있습니다.

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

어레이를 인쇄하기 전에, 다음의 조작을 실시해 주세요.

Arrays.sort(array);

주의:- 어레이 클래스를 Import하려면 다음 명령을 사용합니다.

import java.util.Arrays;

Quick Sort 알고리즘을 직접 구축하여 그 구조를 더 잘 이해하려면 다음 코드를 확인하십시오.

1- 정렬 클래스 만들기

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 - 정렬되지 않은 어레이 전송처: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 - 출력

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

또한 순서대로 트래버설 방식을 사용하여 정렬된 배열에 바이너리 검색 트리를 사용할 수도 있습니다.이 코드에는 아래 기본 바이너리 검색 트리도 구현되어 있습니다.

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

}

가장 효과적인 방법!

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

Arrays.sort() 메서드는 스레드 세이프가 아닙니다.어레이가 싱글톤의 속성으로 멀티 스레드 환경에서 사용되는 경우 정렬 코드를 동기화된 블록에 넣거나 어레이 복사본을 생성하여 해당 복사본을 주문해야 합니다(어레이 구조만 같은 개체를 사용하여 내부에 복사).

예를 들어 다음과 같습니다.

 int[] array = new int[10];
 ...
 int[] arrayCopy = Arrays.copyOf(array , array .length);
 Arrays.sort(arrayCopy);
 // use the arrayCopy;
 

언급URL : https://stackoverflow.com/questions/8938235/sort-an-array-in-java