जावा में एक सरणी सॉर्ट करें

Question

मैं एक ऐसा प्रोग्राम बनाने की कोशिश कर रहा हूं जिसमें 10 पूर्णांक हों, जिसमें सभी का एक यादृच्छिक मूल्य हो, जो अब तक अच्छा हो।

हालाँकि, अब मुझे उन्हें निम्नतम से उच्चतम मूल्य तक क्रमबद्ध करने की आवश्यकता है और फिर इसे स्क्रीन पर प्रिंट करना होगा, मैं ऐसा करने के बारे में कैसे जाऊँगा?

(किसी प्रोग्राम के लिए इतना कोड होने के लिए क्षमा करें, छोटा, मैं लूप के साथ अच्छा नहीं हूं, बस जावा के साथ काम करना शुरू कर दिया है)

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

}

Comments

Java 8: stackoverflow.com/a/47811965/1216775

— akhil_mittal

Answer 1

लूप के बारे में जानने के लिए बहुत उपयोगी होते हैं, esp जब सरणियों का उपयोग करते हैं,

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

Answer 2

Println से पहले लाइन जोड़ें और आपकी सरणी हल हो जाती है

Arrays.sort( array );

Comments

क्या मुझे एक उदाहरण मिल सकता है कि मैं इसे अपने कार्यक्रम में कैसे उपयोग करूं?

— लुकास

Answer 3

यह आपको स्वयं को लागू करके छोरों को समझने में मदद कर सकता है। देखें बबल सॉर्ट समझना आसान है:

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

बेशक, आपको इसका उपयोग उत्पादन में नहीं करना चाहिए क्योंकि बड़ी सूचियों के लिए बेहतर प्रदर्शन करने वाले एल्गोरिदम हैं जैसे क्विकॉर्ट या मर्जसर्ट जो इसके द्वारा कार्यान्वित किया जाता है।Arrays.sort(array)

Comments

सीखने के लिए शुरुआती लोगों के लिए बबलसॉर्ट निश्चित रूप से एक अच्छा एल्गोरिथ्म है, लेकिन जैसा कि आपने बताया कि क्विकॉर्ट या मर्गेर्ट ने बड़े डेटासेट के लिए बहुत बेहतर प्रदर्शन किया है और वे इस कारण से एरेस.सोर्ट (एरे) विधि द्वारा उपयोग किए जाने वाले एल्गोरिदम हैं। यह किसी के लिए उल्लेख करने के लिए धन्यवाद, जिसे महसूस नहीं किया जा सकता है।

— hrr53

मैं इस जवाब को आगे बढ़ाता हूं क्योंकि यह शुरुआती लोगों द्वारा खोजा जाने की अधिक संभावना होगी और शुरुआती लोगों को पता होना चाहिए कि खुद के द्वारा एक प्रकार का फ़ंक्शन कैसे लागू किया जाए।

— कार्मिक

चूंकि प्रारंभिक प्रश्न 10 पूर्णांक की एक सरणी को छांटने के बारे में है, इसलिए बुलबुला छांटना पूरी तरह से स्वीकार्य है। उत्पादन या नहीं अगर कोई बड़ा इनपुट होने की उम्मीद नहीं है।

— एंड्रयू

Answer 4

Arrays.sort () पर एक नज़र डालें

Comments

क्या मुझे एक उदाहरण मिल सकता है कि मैं इसे अपने कार्यक्रम में कैसे उपयोग करूं?

— लुकास

Answer 5

मैं आलसी था और छोरों को जोड़ा

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

आपके एरे की लंबाई 10. है। आपको एक वैरिएबल ( 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 );

एक पुस्तकालय पद्धति है जो सरणियों को क्रमबद्ध करती है।

Answer 6

Arrays.sort(yourArray)

पूरी तरह से काम करेंगे

Answer 7

नीचे देखें, यह आपको आरोही और अवरोही दोनों को हल कर देगा

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 का उपयोग कर सकते हैं। अगर मुझे कोड बदलने की आवश्यकता हो तो मुझे बताएं ...

गुड लक ... चियर्स !!!

Comments

Integerजब आप उपयोग कर सकते हैं तो आपको उपयोग नहीं करना चाहिए int, क्योंकि ऐसा करने से सुस्ती आएगी।

— जोनासकज -

Answer 8

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

Answer 9

अपने कार्यक्रम में इसका उपयोग कैसे करें:

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

}

Answer 10

सिर्फ FYI करें, अब आप किसी भी प्रकार के सरणी का उपयोग करने के लिए जावा 8 नए एपीआई का उपयोग कर सकते हैं parallelSort

parallelSort थ्रेड पूल में उपलब्ध कई थ्रेड्स को सॉर्टिंग टास्क को असाइन करने के लिए जावा 7 में शुरू किए गए फोर्क / जॉइन फ्रेमवर्क का उपयोग करता है।

intसरणी को सॉर्ट करने के लिए उपयोग किए जा सकने वाले दो तरीके ,

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

Answer 11

प्राकृतिक आदेश के लिए: Arrays.sort(array)

रिवर्स ऑर्डर के लिए: Arrays.sort(array, Collections.reverseOrder());-> कलेक्शंस क्लास में यह एक स्टैटिक तरीका है जो आगे चलकर रिवर्स कंपैक्टर को वापस करने के लिए खुद के इनर क्लास को कॉल करेगा।

Comments

उलटा समाधान आदिम के लिए काम नहीं करता है, दुर्भाग्य से। IntStream.range (0, size) .map (i -> सरणी [size-i-1]) .Array (); कर देता है। size = array.length;

— आंद्रेई कॉन्स्टेंटिनोव

Answer 12

आप के साथ एक अंतर सरणी सॉर्ट कर सकते हैं Arrays.sort( array )।

Comments

क्या मुझे एक उदाहरण मिल सकता है कि मैं इसे अपने कार्यक्रम में कैसे उपयोग करूं?

— लुकास

Answer 13

जावा 8 उन धाराओं का उपयोग करने का विकल्प प्रदान करता है जिनका उपयोग निम्न प्रकार किया जा सकता है int[] array:

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

के रूप में डॉक्टर के लिए उल्लेख किया है parallelSort:

सॉर्टिंग एल्गोरिथ्म एक समानांतर सॉर्ट-मर्ज है जो सरणी को उप-सरणियों में तोड़ता है जो स्वयं को सॉर्ट किया जाता है और फिर विलय होता है। जब उप-सरणी की लंबाई न्यूनतम ग्रैन्युलैरिटी तक पहुंच जाती है, तो उप-सरणी को उपयुक्त Arrays.sort विधि का उपयोग करके सॉर्ट किया जाता है। यदि निर्दिष्ट सरणी की लंबाई न्यूनतम ग्रैन्युलैरिटी से कम है, तो इसे उपयुक्त एरेस.सॉर्ट विधि का उपयोग करके सॉर्ट किया जाता है। एल्गोरिथ्म को मूल सरणी के आकार से अधिक नहीं, एक कार्यशील स्थान की आवश्यकता होती है। किसी भी समानांतर कार्यों को निष्पादित करने के लिए ForkJoin कॉमन पूल का उपयोग किया जाता है।

इसलिए यदि इनपुट ऐरे ग्रैन्युलैरिटी (जावा 9 में 8192 एलिमेंट्स और जावा 8 मेरा मानना ​​है कि 4096) से कम है, तो parallelSortबस क्रमिक प्रकार के एल्गोरिथ्म को कॉल करता है।

यदि हम पूर्णांक सरणी को उल्टा करना चाहते हैं, तो हम निम्न प्रकार का उपयोग कर सकते हैं:

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

चूंकि जावा में कस्टम तुलनित्र के साथ प्राइमिटिव्स को सॉर्ट करने का कोई तरीका नहीं है, इसलिए हमें इंटरमीडिएट बॉक्सिंग या कुछ अन्य थर्ड पार्टी लाइब्रेरी का उपयोग करना होगा, जो इस तरह के प्राइमरी सॉर्टिंग को लागू करता है।

Comments

इस तरह से सरल विधि (जावा 1.2 से) का उपयोग क्यों न करें: Arrays.sort (myArray); ? जावा स्ट्रीम की जरूरत नहीं है।

— a_subscriber

Answer 14

आप Arrays.sort () फ़ंक्शन का उपयोग कर सकते हैं ।

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

Answer 15

सबसे प्रभावी रास्ता!

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

Comments

यह काम नहीं करता है! पहला लूप केवल लूप वैरिएबल (x) को म्यूट कर रहा है और सरणी तत्व सेट नहीं हो रहे हैं। तो, आप शून्य की एक सरणी सॉर्ट करना समाप्त करेंगे।

— 1

Answer 16

यदि आप क्विक सॉर्ट एल्गोरिथ्म का निर्माण स्वयं करना चाहते हैं और इसकी अधिक समझ है कि यह नीचे दिए गए कोड की जांच कैसे करता है:

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]

Answer 17

हम इन-ऑर्डर ट्रैवर्सल विधि का उपयोग करके क्रमबद्ध सरणी प्राप्त करने के लिए बाइनरी सर्च ट्री का भी उपयोग कर सकते हैं। कोड में नीचे बुनियादी बाइनरी सर्च ट्री का कार्यान्वयन भी है।

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

}