Program Java untuk mengisih elemen tatasusunan dalam susunan menurun

Susun atur ialah himpunan jenis data yang sama yang disimpan di beberapa lokasi memori bersebelahan. Array ialah kelas dalam pakej java.until yang menyediakan pengisihan yang dipratentukan secara statik dan tidak mempunyai nilai pulangan. Ini ialah sintaks kaedah Arrays.sort() yang disebut di bawah -

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

Dalam sintaks di atas, kita ada

• ar - Singkatan nama tatasusunan

• from_index - Kita boleh menggunakan ini sebagai parameter pilihan di mana pengisihan perlu dijalankan.

• to_index - parameter pilihan yang menyediakan indeks elemen.

Ini adalah contoh

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]

Hari ini dalam artikel ini, kita akan belajar cara mengisih elemen tatasusunan yang terdapat dalam senarai dan menyusun semulanya dalam tertib menurun menggunakan persekitaran Java.

Algoritma untuk menyusun elemen tatasusunan dalam tertib menurun:-

Di sini kami telah menulis kemungkinan algoritma yang mana kami boleh mengisih elemen tatasusunan dalam tertib menurun.

• Langkah 1 - Mulakan

• Langkah 2 - Tetapkan suhu =0.

• Langkah 3 - Isytihar tatasusunan untuk menyimpan data.

• Langkah 4 - Mulakan tatasusunan menggunakan arr[] ={5, 2, 8, 7, 1}.

• Langkah 5 - Cetak "Unsur Susunan Asal"

• Langkah 6 - Isytiharkan pembolehubah sementara untuk menyimpan elemen semasa bertukar.

• Langkah 7 - Gunakan dua gelung untuk mencapai tujuan yang sama.

• Langkah 8 - Ulang untuk i

• Langkah 9 - Gunakan gelung untuk pertama untuk menyimpan elemen dan lelaran melalui semua elemen.

• Langkah 10 - jika(arr[i]

  sementara = arr[i]

  arr[i]=arr[j]

  arr[j]=temp

• Langkah 11 - Gunakan satu saat untuk gelung untuk membandingkan dengan elemen yang tinggal

• Langkah 12 - Cetak baris baharu.

• Langkah 13 - Isih elemen mengikut perbandingan dan pertukaran.

• Langkah 14 - Lelaran menggunakan untuk(i=0;i

• Langkah 15 - Paparkan tatasusunan yang dikemas kini sebagai CETAK arr[i].

• Langkah 16 - Berhenti

Sintaks untuk mengisih elemen tatasusunan dalam tertib menurun

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

Kaedah untuk diikuti

• Kaedah 1 - Program Java untuk mengisih elemen dalam tertib menurun

• Kaedah 2 - Program Java untuk mengisih elemen dalam susunan menurun menggunakan fungsi temp

• Kaedah 3 - Program Java untuk mengisih elemen dalam tertib menurun menggunakan logik biasa

Program Java untuk mengisih elemen dalam tertib menurun

Dalam kod Java ini, kami cuba membina logik proses menyusun elemen tatasusunan dalam tertib menurun.

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

Output

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

Program Java untuk mengisih elemen dalam tertib menurun menggunakan fungsi temp

Dalam kod Java ini, kita boleh menggunakan fungsi temp untuk membina logik untuk mengisih elemen dalam tatasusunan dalam tertib menurun.

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

Output

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

Gunakan logik universal untuk mengisih unsur dalam tertib menurun

Dalam kod Java ini, kami telah menulis logik untuk mengisih elemen dalam tatasusunan dalam susunan menurun dengan menggunakan beberapa fungsi biasa.

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

Output

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

Kesimpulan

Kami telah mempelajari tentang pengasingan elemen tatasusunan secara terperinci. Hari ini kami menggunakan pelbagai kaedah pengisihan untuk menyelesaikan masalah ini melalui tatabahasa dan algoritma yang dinyatakan di atas. Mudah-mudahan, melalui artikel ini anda telah mendapat pemahaman yang luas tentang cara menyusun elemen tatasusunan dalam susunan menurun menggunakan persekitaran Java.

Atas ialah kandungan terperinci Program Java untuk mengisih elemen tatasusunan dalam susunan menurun. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!