Java-Programm zum Sortieren von Array-Elementen in absteigender Reihenfolge

Ein Array ist eine Sammlung desselben Datentyps, die an einem zusammenhängenden Speicherort gespeichert ist. Array ist eine Klasse im Paket java.until, die eine vordefinierte Sortierung auf statische Weise bereitstellt und keinen Rückgabewert hat. Hier ist die Syntax der unten erwähnten Methode Arrays.sort() -

public static void sort(int[] ar, int from_index, int to_index)

In der obigen Syntax haben wir

• ar – Abkürzung des Array-Namens

• from_index – Wir können dies als optionalen Parameter verwenden, wenn die Sortierung ausgeführt werden muss.

• to_index – optionaler Parameter, der den Index des Elements bereitstellt.

Dies ist ein Beispiel

Input :Array = {2, 6, 23, 98, 24, 35, 78}
Output:[98, 78, 35, 24, 23, 6, 2]

Input :Array = {1, 2, 3, 4, 5}
Output:[5, 4, 3, 2, 1]

Heute lernen wir in diesem Artikel, wie man in einer Liste vorhandene Array-Elemente mithilfe der Java-Umgebung sortiert und in absteigender Reihenfolge neu anordnet.

Algorithmus zum Sortieren von Array-Elementen in absteigender Reihenfolge:-

Hier haben wir einen möglichen Algorithmus geschrieben, mit dem wir Array-Elemente in absteigender Reihenfolge sortieren können.

• Schritt 1 – Los geht’s

• Schritt 2 – Temperatur =0 einstellen.

• Schritt 3 – Deklarieren Sie ein Array zur Speicherung der Daten.

• Schritt 4 – Initialisieren Sie das Array mit arr[] ={5, 2, 8, 7, 1}.

• Schritt 5 – Drucken Sie „Elemente des ursprünglichen Arrays“

• Schritt 6 – Deklarieren Sie eine temporäre Variable, um das Element beim Austauschen zu speichern.

• Schritt 7 – Verwenden Sie zwei for-Schleifen, um den gleichen Zweck zu erreichen.

• Schritt 8 – Wiederholen Sie i

• Schritt 9 – Verwenden Sie die erste for-Schleife, um das Element zu speichern und alle Elemente zu durchlaufen.

• Schritt 10 – if(arr[i]

  temporär = arr[i]

  arr[i]=arr[j]

  arr[j]=temp

• Schritt 11 – Verwenden Sie eine zweite for-Schleife, um sie mit den verbleibenden Elementen zu vergleichen

• Schritt 12 – Neue Zeile drucken.

• Schritt 13 – Elemente durch Vergleich und Austausch sortieren.

• Schritt 14 – Iterieren Sie mit for(i=0;i

• Schritt 15 – Zeigen Sie das aktualisierte Array als PRINT arr[i] an.

• Schritt 16 – Stopp

Syntax zum Sortieren von Array-Elementen in absteigender Reihenfolge

import java.util.*;
class Tutorialspoint071001 {
   public static void main(String[] args){
     // Initializing the array for the process
     Integer array[] = { 1, 2, 7, 16, 5,6 };

     // Sorting the array in a descending order
     Arrays.sort(array, Collections.reverseOrder());

     // Printing the elements after the process run
     System.out.println(Arrays.toString(array));
   }
}

Zu befolgende Methode

• Methode 1 – Java-Programm zum Sortieren von Elementen in absteigender Reihenfolge

• Methode 2 – Java-Programm zum Sortieren von Elementen in absteigender Reihenfolge mithilfe der temporären Funktion

• Methode 3 – Java-Programm zum Sortieren von Elementen in absteigender Reihenfolge unter Verwendung allgemeiner Logik

Java-Programm zum Sortieren von Elementen in absteigender Reihenfolge

In diesem Java-Code versuchen wir, die Logik eines Prozesses zum Sortieren von Array-Elementen in absteigender Reihenfolge aufzubauen.

Beispiel 1

import java.util.*;
public class tutorialspoint {
   public static void main(String[] args){

      // Initializing the array for the process run
      int array[] = { 1, 2, 3, 7, 5, 16 };

      // Sorting the array in ascending order if needed
      Arrays.sort(array);

      // Reversing the array for the main process
      reverse(array);

      // Printing the elements from the array
      System.out.println(Arrays.toString(array));
   }
   public static void reverse(int[] array){

      // Length of the array is mentioned here
      int n = array.length;

      // Run the process again. Swapping the first half elements with last half elements
      for (int i = 0; i < n / 2; i++) {

         // Storing the first half elements in a temp manner
         int temp = array[i];

         // Assigning the first half to the last half to get result
         array[i] = array[n - i - 1];

         // Assigning the last half to the first half to get the result
         array[n - i - 1] = temp;
      }
   }
}

Ausgabe

[16, 7, 5, 3, 2, 1]

Java-Programm zum Sortieren von Elementen in absteigender Reihenfolge mithilfe der temporären Funktion

In diesem Java-Code können wir die temporäre Funktion verwenden, um eine Logik zu erstellen, um die Elemente im Array in absteigender Reihenfolge zu sortieren.

Beispiel 2

import java.util.Scanner;
public class Descendingtutorialspountrddarb{
   public static void main(String[] args) {
      int n, temp;
      Scanner s = new Scanner(System.in);
      System.out.print("Enter no. number of elements you want in the array---->:");
      n = s.nextInt();
      int a[] = new int[n];
      System.out.println("Enter all the elements here now to run the code further ----> :");
      for (int i = 0; i < n; i++) {
         a[i] = s.nextInt();
      }
      for (int i = 0; i < n; i++) {
         for (int j = i + 1; j < n; j++) {
            if (a[i] < a[j]) {
               temp = a[i];
               a[i] = a[j];
               a[j] = temp;
            }
         }
      }
      System.out.print("Descending Order Output Is Here. Have A Look!:");
      for (int i = 0; i < n - 1; i++) {
         System.out.print(a[i] + ",");
      }
      System.out.print(a[n - 1]);
   }
}

Ausgabe

Enter no. number of elements you want in the array---->:7
Enter all the elements here now to run the code further ----> :
1
2
3
16
4
5
6
Descending Order Output Is Here. Have A Look!:16,6,5,4,3,2,1

Verwenden Sie universelle Logik, um Elemente in absteigender Reihenfolge zu sortieren

In diesem Java-Code haben wir eine Logik geschrieben, um die Elemente in einem Array mithilfe einiger allgemeiner Funktionen in absteigender Reihenfolge zu sortieren.

Beispiel 3

public class Tutorialspoint {
   public static void main(String[] args) {
      //Initialize array for the process 
      int [] arr = new int [] {16, 2022, 2001, 1997, 7}; 
      int temp = 0;

      //Displaying elements of an original array to go further
      System.out.println("Elements of original array are ---->: ");
      for (int i = 0; i < arr.length; i++) { 
         System.out.print(arr[i] + " ");
      }

      //Sort the array in descending order. Please go further
      for (int i = 0; i < arr.length; i++) { 
         for (int j = i+1; j < arr.length; j++) { 
            if(arr[i] < arr[j]) {
               temp = arr[i];
               arr[i] = arr[j];
               arr[j] = temp;
            } 
         } 
      }
      System.out.println();
      //Displaying elements of array after sorting process done.
      System.out.println("Elements of array sorted in descending order is here ---->: ");
      for (int i = 0; i < arr.length; i++) { 
         System.out.print(arr[i] + " ");
      }
   }
}

Ausgabe

Elements of original array are ---->: 
16 2022 2001 1997 7 
Elements of array sorted in descending order is here ---->: 
2022 2001 1997 16 7

Fazit

Wir haben uns ausführlich mit dem Thema Sortieren von Array-Elementen befasst. Heute verwenden wir verschiedene Sortiermethoden, um dieses Problem durch die oben erwähnte Grammatik und den oben genannten Algorithmus zu lösen. Hoffentlich haben Sie durch diesen Artikel ein umfassendes Verständnis dafür gewonnen, wie Array-Elemente in einer Java-Umgebung in absteigender Reihenfolge sortiert werden.

Das obige ist der detaillierte Inhalt vonJava-Programm zum Sortieren von Array-Elementen in absteigender Reihenfolge. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!