Java'da bir dizi sıralama

Şimdiye kadar iyi bir rasgele değeri olan 10 tamsayı bir dizi oluşan bir program yapmaya çalışıyorum.

Ancak, şimdi bunları en düşükten en yüksek değere doğru sıralamak ve sonra ekrana yazdırmak zorundayım, bunu nasıl yapabilirim?

(Küçük bir program için çok fazla koda sahip olduğum için üzgünüm, döngülerle o kadar iyi değilim, sadece Java ile çalışmaya başladım)

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

}

Döngüler de öğrenmek için çok faydalıdır, esp Dizileri kullanırken,

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'den önce Satırı ekleyin ve diziniz sıralanır

Arrays.sort( array );

Kendinizi uygulayarak döngüleri anlamanıza yardımcı olabilir. Kabarcık türünü anlamak kolaydır:

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

Tabii ki, üretimde kullanmamalısınız, çünkü büyük listeler için daha iyi performans gösteren algoritmalar QuickSort veya MergeSort .Arrays.sort(array)

Arrays.sort () ' a bir göz atın

Tembeltim ve döngüler ekledim

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

Kişisel dizi tek bir değişken (gerek 10 bir uzunluğa sahiptir ideğerleri alır) 0için 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 );

Dizileri sıralayan bir kütüphane yöntemidir.

Arrays.sort(yourArray)

işi mükemmel yapacak

Aşağıya bakın, her ikisi de artan ve azalan sıralama verir

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

Çıktı

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 

Not: Manuel numaralar eklemek yerine Math.ranodm'u kullanabilirsiniz. Kodu değiştirmem gerekiyorsa bana bildirin ...

İyi Şanslar ... Şerefe !!!

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

Bunu programınızda nasıl kullanacağınız aşağıda açıklanmıştır:

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

}

sadece FYI, artık herhangi bir dizi türünü sıralamak için Java 8 yeni API'sını kullanabilirsiniz. parallelSort

parallelSort sıralama havuzunda kullanılabilen birden çok iş parçacığına sıralama görevlerini atamak için Java 7'de sunulan Fork / Join çerçevesini kullanır.

intdiziyi sıralamak için kullanılabilecek iki yöntem ,

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

Doğal sipariş için: Arrays.sort(array)

Ters Sıralama için: Arrays.sort(array, Collections.reverseOrder());-> Bu, ters sınıf Karşılaştırıcısı döndürmek için kendi iç sınıfını çağıran Koleksiyonlar sınıfında statik bir yöntemdir.

Bir int dizisini ile sıralayabilirsiniz Arrays.sort( array ).

Java 8 , şu şekilde sıralamak için kullanılabilen akışları kullanma seçeneği sunar int[] array:

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

Belirtildiği gibi doc için parallelSort:

Sıralama algoritması, diziyi kendileri sıralanan ve daha sonra birleştirilen alt dizilere ayıran paralel bir sıralama birleştirme işlemidir. Alt dizi uzunluğu minimum bir ayrıntı düzeyine ulaştığında, alt dizi uygun Arrays.sort yöntemi kullanılarak sıralanır. Belirtilen dizinin uzunluğu minimum ayrıntı düzeyinden küçükse, uygun Arrays.sort yöntemi kullanılarak sıralanır. Algoritma, orijinal dizinin boyutundan büyük olmayan bir çalışma alanı gerektirir. ForkJoin ortak havuzu, paralel görevleri yürütmek için kullanılır.

Dolayısıyla, girdi dizisi ayrıntı düzeyinin altındaysa (Java 9'da 8192 öğe ve Java 8'de 4096 öğe olduğuna inanıyorum), o zaman parallelSort sıralı sıralama algoritmasını çağırır.

Tamsayı dizisini tersine sıralamak istiyorsak karşılaştırıcıyı şu şekilde kullanabiliriz:

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

Java'nın ilkelleri özel karşılaştırıcı ile sıralamanın bir yolu olmadığından, ara kutuyu veya bu tür ilkel sıralamayı uygulayan başka bir üçüncü taraf kitaplığını kullanmamız gerekir.

Arrays.sort () işlevini kullanabilirsiniz .

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

EN ETKİLİ BİR YOL!

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

Hızlı sıralama algoritmasını kendiniz oluşturmak ve nasıl çalıştığını daha iyi anlamak istiyorsanız aşağıdaki kodu kontrol edin:

1- Sıralama sınıfı oluşturma

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- Sıralanmamış dizinizi Quicksortsınıfa gönderin

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- Çıktı

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

Sıralı dizi yöntemi kullanarak sıralı dizi elde etmek için ikili arama ağacını da kullanabiliriz. Kod ayrıca aşağıdaki temel ikili arama ağacının uygulanmasına sahiptir.

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

}