জাভাতে একটি অ্যারে বাছাই করুন

Question

আমি এমন একটি প্রোগ্রাম তৈরি করার চেষ্টা করছি যা 10 টি পূর্ণসংখ্যার অ্যারে নিয়ে তৈরি করে যা এতক্ষণে এত ভাল all

যাইহোক, এখন আমি এগুলি সর্বনিম্ন থেকে সর্বোচ্চ মানের হয়ে বাছাই করতে হবে এবং তারপরে এটি স্ক্রিনে মুদ্রণ করতে হবে, আমি কীভাবে এটি করব?

(ছোট্ট একটি প্রোগ্রামের জন্য এত বেশি কোড থাকার জন্য দুঃখিত, আমি লুপগুলি দিয়ে খুব ভাল করি না, কেবল জাভা দিয়ে কাজ শুরু করেছি)

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

জাভা 8: stackoverflow.com/a/47811965/1216775

— akhil_mittal

Answer 1

লুপগুলি শিখতে খুব কার্যকর, এএসপি ব্যবহার করার সময়,

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

প্রিন্টলন এবং আপনার অ্যারের সাজানোর আগে লাইন যুক্ত করুন

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

অবশ্যই, আপনি এটি উৎপাদনে ব্যবহার করা উচিত নয় সেখানে ভাল যেমন বৃহৎ তালিকার জন্য আলগোরিদিম সম্পাদন করা হয় QuickSort বা MergeSort যার দ্বারা প্রয়োগ করা হয়Arrays.sort(array)

Comments

প্রাথমিকভাবে শিখতে বাবলসার্ট একটি ভাল অ্যালগরিদম, তবে আপনি যেমন উল্লেখ করেছেন যে কুইকসোর্ট বা মার্জসোর্ট বৃহত্তর ডেটাসেটের জন্য আরও ভাল পারফরম্যান্স করে এবং সেগুলি এ কারণে অ্যারেস.সোর্ট (অ্যারে) পদ্ধতি দ্বারা ব্যবহৃত অ্যালগরিদম। এটি উপলব্ধি করতে পারে না এমন কারও জন্য এটি উল্লেখ করার জন্য ধন্যবাদ।

— h0r53

আমি এই উত্তরটিকে অগ্রাহ্য করেছি যেহেতু এটি প্রাথমিকভাবে আরও বেশি অনুসন্ধান করা হবে এবং নতুনদের কীভাবে নিজের দ্বারা বাছাই করা ফাংশনটি প্রয়োগ করতে হবে তা জানা উচিত।

— Carmm

যেহেতু প্রাথমিক প্রশ্নটি 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 

বিঃদ্রঃ: আপনি ম্যানুয়াল নম্বরগুলি যুক্ত করার পরিবর্তে ম্যাথ.আরনডম ব্যবহার করতে পারেন। আমাকে কোডটি পরিবর্তন করতে হবে কিনা তা আমাকে জানান ...

শুভকামনা ... চিয়ার্স !!!

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

শুধু এফওয়াইআই, আপনি এখন যেকোন ধরণের অ্যারে ব্যবহার করে বাছাই করার জন্য জাভা 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

বিপরীত সমাধান আদিমদের পক্ষে কাজ করে না, দুর্ভাগ্যক্রমে। ইন্টস্ট্রিম.আরঞ্জ (০, আকার)। মানচিত্র (i -> অ্যারে [আকার-i-1])। টু অ্যারে (); আছে। আকার = অ্যারে। দৈর্ঘ্য;

— আন্দ্রেই কনস্টান্টিনভ

Answer 12

আপনি একটি int অ্যারে এর সাথে বাছাই করতে পারেন Arrays.sort( array )।

Comments

আমার প্রোগ্রামে এটি কীভাবে ব্যবহার করা যায় আমি একটি উদাহরণ পেতে পারি?

— লুকাস

Answer 13

জাভা 8 স্ট্রিমগুলি ব্যবহারের বিকল্প সরবরাহ করে যা এইভাবে সাজানোর জন্য ব্যবহার করা যেতে পারে int[] array:

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

হিসাবে উল্লেখ করেছে ডক জন্য parallelSort:

বাছাই করা অ্যালগরিদম হল একটি সমান্তরাল বাছাই-মার্জ যা অ্যারেটিকে সাব-অ্যারেগুলিতে ভেঙে দেয় যা নিজেরাই সাজানো হয় এবং তারপরে মার্জ করা হয়। সাব-অ্যারে দৈর্ঘ্য যখন ন্যূনতম গ্রানুলারিটিতে পৌঁছায়, সাব অ্যারেটি যথাযথ অ্যারে.সোর্ট পদ্ধতি ব্যবহার করে বাছাই করা হয়। যদি নির্দিষ্ট অ্যারের দৈর্ঘ্য ন্যূনতম গ্রানুলারিটির চেয়ে কম হয় তবে এটি যথাযথ অ্যারে.সোর্ট পদ্ধতি ব্যবহার করে বাছাই করা হয়। অ্যালগরিদমের জন্য একটি কার্যকারী স্থান প্রয়োজন মূল অ্যারের আকারের চেয়ে বড়। ফোরকজয়াইন সাধারণ পুলটি কোনও সমান্তরাল কাজ সম্পাদন করতে ব্যবহৃত হয়।

সুতরাং যদি ইনপুট অ্যারে গ্র্যানুলারিটির চেয়ে কম হয় (জাভা 9-এর 8192 উপাদান এবং জাভা 8-তে 4096 আমি বিশ্বাস করি), তবে parallelSort কেবল ক্রমবর্ধমান সাজানোর অ্যালগরিদমকে কল করে।

কেবলমাত্র আমরা যদি পূর্ণসংখ্য অ্যারেটিকে সাজিয়ে তুলতে চাই আমরা তুলনামূলক হিসাবে এটি ব্যবহার করতে পারি:

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

যেহেতু জাভাতে কাস্টম তুলনাকারীর সাথে আদিমগুলি বাছাই করার কোনও উপায় নেই, তাই আমাদের মধ্যবর্তী বক্সিং বা অন্য কোনও তৃতীয় পক্ষের লাইব্রেরি ব্যবহার করতে হবে যা এ জাতীয় আদি বাছাইয়ের প্রয়োগ করে।

Comments

(জাভা ১.২ থেকে) সাধারণ পদ্ধতিটি কেন ব্যবহার করবেন না: অ্যারেএস.সোর্ট (মাইআর্রে); ? জাভা স্ট্রিমের দরকার নেই।

— a_subscriber

Answer 14

আপনি অ্যারে.সোর্ট () ফাংশনটি ব্যবহার করতে পারেন ।

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

এটি কাজ করে না! প্রথম লুপটি কেবল লুপ ভেরিয়েবলগুলি (এক্স) রূপান্তর করছে এবং অ্যারের উপাদানগুলি সেট হচ্ছে না। সুতরাং, আপনি শূন্যের একটি অ্যারে বাছাই শেষ করব।

— rrufai

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

}