it-swarm-id.com

menyortir bilangan bulat agar terendah ke java tertinggi

Angka-angka ini disimpan dalam variabel integer yang sama. Bagaimana cara saya menyortir bilangan bulat agar terendah ke tertinggi?

11367 
 11358 
 11421 
 11530 
 11491 
 11218 
 11789
4
user983246

Ada dua opsi, sungguh:

  1. Gunakan koleksi standar, seperti yang dijelaskan oleh Shakedown
  2. Gunakan Array.sort

Misalnya.,

int[] ints = {11367, 11358, 11421, 11530, 11491, 11218, 11789};
Arrays.sort(ints);
System.out.println(Arrays.asList(ints));

Itu tentu saja mengasumsikan bahwa Anda sudah memiliki integer sebagai array. Jika Anda perlu menguraikan yang pertama, cari String.split dan Integer.parseInt .

15
alf

Anda dapat memasukkannya ke dalam daftar dan mengurutkannya menggunakan urutan alami, seperti:

final List<Integer> list = Arrays.asList(11367, 11358, 11421, 11530, 11491, 11218, 11789);
Collections.sort( list );
// Use the sorted list

Jika angka-angka disimpan dalam variabel yang sama, maka Anda harus entah bagaimana memasukkannya ke dalam List dan kemudian memanggil sort, seperti:

final List<Integer> list = new ArrayList<Integer>();
list.add( myVariable );
// Change myVariable to another number...
list.add( myVariable );
// etc...

Collections.sort( list );
// Use the sorted list
5
Nate W.

Nah, jika Anda ingin melakukannya menggunakan algoritma. Ada banyak algoritma pengurutan di luar sana. Jika Anda tidak terlalu khawatir tentang efisiensi dan lebih banyak tentang keterbacaan dan pemahaman. Saya merekomendasikan Jenis Penyisipan. Ini adalah kode psudo, mudah untuk menerjemahkan ini ke dalam Java.

begin
    for i := 1 to length(A)-1 do
    begin
        value := A[i];
        j := i - 1;
        done := false;
        repeat
            { To sort in descending order simply reverse
              the operator i.e. A[j] < value }
            if A[j] > value then
            begin
                A[j + 1] := A[j];
                j := j - 1;
                if j < 0 then
                    done := true;
            end
            else
                done := true;
        until done;
        A[j + 1] := value;
    end;
end;
3
Suraj Kulkarni

Untuk menyortir rentang integer yang sempit, cobalah Counting sort , yang memiliki kompleksitas O(range + n), di mana n adalah jumlah item yang akan diurutkan. Jika Anda ingin mengurutkan sesuatu yang tidak terpisah, gunakan algoritma n * log (n) yang optimal ( quicksort , heapsort , mergesort ). Sortir gabungan juga digunakan dalam metode yang telah disebutkan oleh respons lain Arrays.sort. Tidak ada cara sederhana untuk merekomendasikan beberapa algoritma atau panggilan fungsi, karena ada lusinan kasus khusus, di mana Anda akan menggunakan beberapa jenis, tetapi tidak yang lain.

Jadi tolong tentukan tujuan pasti aplikasi Anda (untuk mempelajari sesuatu (mulailah dengan menyortir atau menyortir), efektivitas untuk integer (gunakan penghitungan penghitungan), efektivitas dan usabilitas untuk struktur (gunakan algoritma n * log (n)) , atau Anda hanya ingin itu entah bagaimana diurutkan - gunakan Arrays.sort :-)). Jika Anda ingin mengurutkan representasi string dari bilangan bulat, daripada Anda mungkin interrested di radix sort ....

2
malejpavouk

Ambil Input dari Pengguna dan Sortir Penyisipan. Inilah cara kerjanya:

package com.learning.constructor;

import Java.util.Scanner;



public class InsertionSortArray {

public static void main(String[] args) {    

Scanner s=new Scanner(System.in);

System.out.println("enter number of elements");

int n=s.nextInt();


int arr[]=new int[n];

System.out.println("enter elements");

for(int i=0;i<n;i++){//for reading array
    arr[i]=s.nextInt();

}

System.out.print("Your Array Is: ");
//for(int i: arr){ //for printing array
for (int i = 0; i < arr.length; i++){
    System.out.print(arr[i] + ",");

}
System.out.println("\n");        

    int[] input = arr;
    insertionSort(input);
}

private static void printNumbers(int[] input) {

    for (int i = 0; i < input.length; i++) {
        System.out.print(input[i] + ", ");
    }
    System.out.println("\n");
}

public static void insertionSort(int array[]) {
    int n = array.length;
    for (int j = 1; j < n; j++) {
        int key = array[j];
        int i = j-1;
        while ( (i > -1) && ( array [i] > key ) ) {
            array [i+1] = array [i];
            i--;
        }
        array[i+1] = key;
        printNumbers(array);
    }
}

}
0
Deepak Manktala

jika array.sort tidak memiliki apa yang Anda cari, Anda dapat mencoba ini:

package drawFramePackage;
import Java.awt.geom.AffineTransform;
import Java.util.ArrayList;
import Java.util.ListIterator;
import Java.util.Random;
public class QuicksortAlgorithm {
    ArrayList<AffineTransform> affs;
    ListIterator<AffineTransform> li;
    Integer count, count2;
    /**
     * @param args
     */
    public static void main(String[] args) {
        new QuicksortAlgorithm();
    }
    public QuicksortAlgorithm(){
        count = new Integer(0);
        count2 = new Integer(1);
        affs = new ArrayList<AffineTransform>();
        for (int i = 0; i <= 128; i++){
            affs.add(new AffineTransform(1, 0, 0, 1, new Random().nextInt(1024), 0));
        }
        affs = arrangeNumbers(affs);
        printNumbers();
    }
    public ArrayList<AffineTransform> arrangeNumbers(ArrayList<AffineTransform> list){
        while (list.size() > 1 && count != list.size() - 1){
            if (list.get(count2).getTranslateX() > list.get(count).getTranslateX()){
                list.add(count, list.get(count2));
                list.remove(count2 + 1);
            }
            if (count2 == list.size() - 1){
                count++;
                count2 = count + 1;
            }
            else{
            count2++;
            }
        }
        return list;
    }
    public void printNumbers(){
        li = affs.listIterator();
        while (li.hasNext()){
            System.out.println(li.next());
        }
    }
}
0
Nathan Nelson