wake-up-neo.com

Java: Sortieren eines ganzzahligen Arrays ohne Verwendung von Arrays.sort ()

Dies ist die Anweisung in einer der Übungen in unserer Java-Klasse. Vor allem möchte ich sagen, dass ich 'meine Hausaufgaben mache', und ich bin nicht einfach nur faul, jemanden von Stack Overflow zu fragen, der mir dies antwortet. Dieser spezielle Punkt war bei allen anderen Übungen mein Problem, da ich mich bemüht habe, den "perfekten Algorithmus" dafür zu finden.

Schreiben Sie ein Java-Programm, das 10 Ganzzahlwerte eingibt und in aufsteigender oder absteigender Reihenfolge angezeigt wird. Hinweis: Arrays.sort () ist nicht zulässig.

Dies ist der Code, den ich mir ausgedacht habe, er funktioniert, hat aber einen offensichtlichen Fehler. Wenn ich denselben Wert zweimal oder mehr eingebe, beispielsweise:

5, 5, 5, 4, 6, 7, 3, 2, 8, 10

Nur eine der drei eingegebenen 5 wird gezählt und in die Ausgabe aufgenommen. Die Ausgabe, die ich bekomme (für die aufsteigende Reihenfolge) ist: 

2 3 4 5 0 0 6 7 8 10.

import Java.util.Scanner;

public class Exer3AscDesc
{
    public static void main(String args[])
    {
        Scanner scan = new Scanner(System.in);
        int tenNums[]=new int[10], orderedNums[]=new int[10];
        int greater;
        String choice;

        //get input
        System.out.println("Enter 10 integers : ");
        for (int i=0;i<tenNums.length;i++)
        {
            System.out.print(i+1+"=> ");
            tenNums[i] = scan.nextInt();
        }
        System.out.println();

        //imperfect number ordering algorithm
        for(int indexL=0;indexL<tenNums.length;indexL++)
        {
            greater=0;
            for(int indexR=0;indexR<tenNums.length;indexR++)
            {
                if(tenNums[indexL]>tenNums[indexR])
                {
                    greater++;
                }
            }
            orderedNums[greater]=tenNums[indexL];
        }

        //ask if ascending or descending
        System.out.print("Display order :\nA - Ascending\nD - Descending\nEnter your choice : ");
        choice = scan.next();

        //output the numbers based on choice
        if(choice.equalsIgnoreCase("a"))
        {
            for(greater=0;greater<orderedNums.length;greater++)
            {
                System.out.print(orderedNums[greater]+" ");
            }
        }
        else if(choice.equalsIgnoreCase("d"))
        {
            for(greater=9;greater>-1;greater--)
            {
                System.out.print(orderedNums[greater]+" ");
            }
        }
    }
}
8
ransan32

Im Internet gibt es so viele verschiedene Sortieralgorithmen. Wenn Sie jedoch Ihre eigene Lösung reparieren möchten, können Sie folgende Änderungen in Ihrem Code vornehmen:

Anstatt:

 orderedNums[greater]=tenNums[indexL];

sie müssen das tun:

while (orderedNums[greater] == tenNums[indexL]) {
     greater++;
}
orderedNums[greater] = tenNums[indexL];

Dieser Code prüft im Grunde, ob der betreffende Index mit einer ähnlichen Nummer belegt ist, und versucht dann, den nächsten freien Index zu finden.

Hinweis: Da der Standardwert in Ihren sortierten Array-Elementen 0 ist, müssen Sie sicherstellen, dass 0 nicht in Ihrer Liste enthalten ist. Andernfalls müssen Sie eingeben, um Ihr sortiertes Array mit einer speziellen Nummer zu initiieren, von der Sie sicher sind, dass __. nicht in Ihrer Liste enthalten ist. Beispiel: Integer.MAX_VALUE

5
mhshams

Einfacher Sortieralgorithmus Blasensortierung :

public static void main(String[] args) {
    int[] arr = new int[] { 6, 8, 7, 4, 312, 78, 54, 9, 12, 100, 89, 74 };

    for (int i = 0; i < arr.length; i++) {
        for (int j = i + 1; j < arr.length; j++) {
            int tmp = 0;
            if (arr[i] > arr[j]) {
                tmp = arr[i];
                arr[i] = arr[j];
                arr[j] = tmp;
            }
        }
    }
}
19
Yoga

Hier ist eine einfache Lösung

public static void main(String[] args) {        
        //Without using Arrays.sort function
        int i;
        int nos[] = {12,9,-4,-1,3,10,34,12,11};
        System.out.print("Values before sorting: \n");
        for(i = 0; i < nos.length; i++)
            System.out.println( nos[i]+"  ");               
        sort(nos, nos.length);
        System.out.print("Values after sorting: \n");       
        for(i = 0; i <nos.length; i++){
            System.out.println(nos[i]+"  ");
        }
    }

    private static void sort(int nos[], int n) {
     for (int i = 1; i < n; i++){
          int j = i;
          int B = nos[i];
          while ((j > 0) && (nos[j-1] > B)){
            nos[j] = nos[j-1];
            j--;
          }
          nos[j] = B;
        }
    }

Und die Ausgabe ist:

Werte vor dem Sortieren: 

12
9
-4
-1
3
10
34
12
11 

Werte nach der Sortierung: 

-4
-1
3
9
10
11
12
12
34

2
Gopinath

Einfacher Weg : 

int a[]={6,2,5,1};
            System.out.println(Arrays.toString(a));
             int temp;
             for(int i=0;i<a.length-1;i++){
                 for(int j=0;j<a.length-1;j++){
                     if(a[j] > a[j+1]){   // use < for Descending order
                         temp = a[j+1];
                         a[j+1] = a[j];
                         a[j]=temp;
                     }
                 }
             }
            System.out.println(Arrays.toString(a));

    Output:
    [6, 2, 5, 1]
    [1, 2, 5, 6]

Ich würde empfehlen, Selection Sort oder Insertion Sort anzusehen, wenn Sie sich nicht zu sehr um die Leistung sorgen. Vielleicht gibt Ihnen das ein paar Ideen.

1
awolfe91
int x[] = { 10, 30, 15, 69, 52, 89, 5 };
    int max, temp = 0, index = 0;
    for (int i = 0; i < x.length; i++) {
        int counter = 0;
        max = x[i];
        for (int j = i + 1; j < x.length; j++) {

            if (x[j] > max) {
                max = x[j];
                index = j;
                counter++;
            }

        }
        if (counter > 0) {
            temp = x[index];
            x[index] = x[i];
            x[i] = temp;
        }
    }
    for (int i = 0; i < x.length; i++) {
        System.out.println(x[i]);
    }
0
Narendra

Blasensortierung kann hier verwendet werden:

 //Time complexity: O(n^2)
public static int[] bubbleSort(final int[] arr) {

    if (arr == null || arr.length <= 1) {
        return arr;
    }

    for (int i = 0; i < arr.length; i++) {
        for (int j = 1; j < arr.length - i; j++) {
            if (arr[j - 1] > arr[j]) {
                arr[j] = arr[j] + arr[j - 1];
                arr[j - 1] = arr[j] - arr[j - 1];
                arr[j] = arr[j] - arr[j - 1];
            }
        }
    }

    return arr;
}
0
realPK

Array-Sortierung ohne eingebaute Funktionen in Java ...... Erstellen Sie einfach eine neue Datei mit diesem Namen -> (Array Sorting.Java) ..... Führen Sie das Projekt aus und genießen Sie es !!!!!

    import Java.io.*;
    import Java.util.Arrays;
    import Java.util.Scanner;
    public class ArraySorting 
    {
    public static void main(String args[])
    {
      int temp=0;   
      Scanner user_input=new Scanner(System.in);
       System.out.println("enter Size of Array...");
    int Size=user_input.nextInt();

    int[] a=new int[Size];
    System.out.println("Enter element Of an Array...");
    for(int j=0;j<Size;j++)
    {
        a[j]=user_input.nextInt();
    }     
    for(int index=0;index<a.length;index++)
    {
        for(int j=index+1;j<a.length;j++)
        {
             if(a[index] > a[j] ) 
             {
                 temp = a[index];
                 a[index] = a[j];
                 a[j] = temp;
             }
        }
    }
    System.out.print("Output is:- ");
    for(int i=0;i<a.length;i++)
    {
        System.out.println(a[i]);
    }

}
}
0
Adeel Asghar

int[] arr = {111, 111, 110, 101, 101, 102, 115, 112};

/* for ascending order */

System.out.println(Arrays.toString(getSortedArray(arr)));
/*for descending order */
System.out.println(Arrays.toString(getSortedArray(arr)));

private int[] getSortedArray(int[] k){  

        int localIndex =0;
        for(int l=1;l<k.length;l++){
            if(l>1){
                localIndex = l;
                while(true){
                    k = swapelement(k,l);
                    if(l-- == 1)
                        break;
                }
                l = localIndex;
            }else
                k = swapelement(k,l);   
        }
        return k;
    }

    private int[] swapelement(int[] ar,int in){
        int temp =0;
        if(ar[in]<ar[in-1]){
            temp = ar[in];
            ar[in]=ar[in-1];
            ar[in-1] = temp;
        }

        return ar;
    }

private int[] getDescOrder(int[] byt){
        int s =-1;
        for(int i = byt.length-1;i>=0;--i){
              int k = i-1;
              while(k >= 0){
                  if(byt[i]>byt[k]){
                      s = byt[k];
                      byt[k] = byt[i];
                      byt[i] = s;
                  }
                  k--;
              }
           }
        return byt;
    }

</ i>

ausgabe:-
aufsteigende Reihenfolge: - 101, 101, 102, 110, 111, 111, 112, 115


absteigende Reihenfolge: 115, 112, 111, 111, 110, 102, 101, 101

0
Shubham Gaur