Carane Ngurutake Array ing Jawa

Ngurutake minangka salah sawijining operasi sing paling umum lan perlu ing pemrograman. Iku nuduhake urutan sawetara set unsur ing urutan tartamtu. Artikel iki babagan cara standar kanggo ngurutake array ing Jawa.

Sedhela babagan ngurutake

Dadi, ngurutake yaiku urutan sakumpulan data. Ing kasus kita, array. Tujuan ngurutake array utawa struktur data liyane yaiku supaya luwih gampang nggoleki, ngapusi, utawa ngurai data ing kumpulan. Programer kudu kerep ngurutake supaya basa pamrograman apa wae kalebu metode sing dibangun kanggo ngurutake array, dhaptar, lan struktur data sing diurutake liyane. Kanggo nggunakake cara kasebut, nelpon. Operasi kasebut disederhanakake sabisa. Biasane, cara sing dibangun dioptimalake kanthi maksimal; ing kasus paling, nggunakake kanggo proyek utawa proyek iku apike. Nanging, meh saben programmer, sajrone sinau, kudu ngetrapake algoritma ngurutake dhewe. Mula, latihan sing sampurna iki ngajari sampeyan ngerti intine pemrograman. Kajaba iku, kadhangkala sampeyan butuh cara ngurutake non-standar ing karya. Ana akeh algoritma ngurutake. Dheweke duwe kekuwatan lan kelemahane gumantung saka jinis utawa ukuran set data. Algoritma ngurutake standar kalebu ngurutake gelembung, ngurutake pilihan, ngurutake sisipan, ngurutake gabungan, lan ngurutake cepet.

Cara sing dibangun kanggo ngurutake array ing Jawa: Arrays.sort

Ayo dadi miwiti karo paling prasaja. Ana sing wis nulis cara ngurutake array ing Jawa kanggo kita. Cara iki ana ing kelas Arrays , luwih khusus java.util.Arrays . Kelas iki ngemot macem-macem cara kanggo nggarap array, kayata ngurutake lan nggoleki. Cara Arrays.sort nyedhiyakake cara sing trep kanggo ngurutake array ing Jawa, manawa ana strings, integer, utawa unsur liyane. Ana sawetara variasi saka cara Arrays.sort ing Jawa. Ing ngisor iki sawetara cara ngurutake sing umum digunakake saka kelas Arrays :

• Arrays.sort(Array) : gunakake kanggo ngurutake array saka jinis primitif utawa obyek ing urutan munggah. Iku nggunakake urutan alam saka unsur.
• Arrays.sort(Array, fromIndex, toIndex) : Cara ngurutake overloaded iki ngidini sampeyan ngurutake mung bagean saka Array sing ditemtokake dening paramèter fromIndex lan toIndex.
• Arrays.sort (Array, comparator) : iki kanggo ngurutake array obyek nggunakake komparator khusus. Komparator nemtokake urutan unsur.
• Arrays.parallelSort (Array) : Versi cara iki ngurutake Array kanthi podo karo, nggunakake macem-macem benang kanggo kinerja sing luwih apik. Iku migunani kanggo ngurutake array gedhe.
• Arrays.parallelSort (Array, fromIndex, toIndex) : Versi overloaded saka metode parallelSort ngidini ngurutake sawetara unsur tartamtu ing Array .

Dheweke ngidini sampeyan ngatur unsur kanthi cepet miturut urutan alami utawa nggunakake komparator khusus. Ayo njelajah cara iki nganggo rong conto, siji nglibatake senar.

Conto 1: Ngurutake String

Contone, kita duwe macem-macem alat musik senar: "biola", "viola", "cello", lan "bass dobel". Kita bisa nggunakake cara Array.sort kanggo ngatur abjad.

import java.util.Arrays;
//Arrays.sort example
public class StringSortExample {
    public static void main(String[] args) {
        String[] instruments = {"violin", "viola", "cello", "double bass"};

        Arrays.sort(instruments);

        System.out.println("Sorted Instruments:");
        for (String instrument : instruments) {
            System.out.println(instrument);
        }
    }
}

Output ing kene: Ing program iki, pisanan, kita ngimpor kelas java.util.Arrays kanggo entuk akses menyang cara Array.sort . Banjur kita nggawe array senar sing diarani instrumen sing ngemot jeneng alat musik. Sawise iku, kita nelpon Arrays.sort(instruments) . Dadi cara iki entuk array, ngurutake unsur kanthi urutan munggah adhedhasar urutan alami (alfabetis). Pungkasan, kita daur ulang liwat Array sing diurutake lan dicithak saben instrumen.

Conto 2: Ngurutake Integer

Coba conto liyane ing ngendi kita ngurutake array integer kanthi urutan munggah.

import java.util.Arrays;

public class IntegerSortExample {
    public static void main(String[] args) {
        int[] numbers = {8, 2, 7, 3, 1, 5};
//sort an array using Arrays.sort
        Arrays.sort(numbers);

        System.out.println("Sorted Numbers:");
        for (int number : numbers) {
            System.out.println(number);
        }
    }
}

Output: Ing kene kita nggawe array integer sing diarani angka kanthi sawetara unsur sing ora diurutake. Sabanjure, kita nelpon Arrays.sort(nomer) kanggo ngurutake array ing urutan munggah. Elinga yen cara Array.sort ngowahi array asli ing panggonan. Dadi kanggo njaga Array asli , gawe salinan sadurunge ngurutake.

Tuladha 3: urutan mudhun

Apa babagan ngurutake mudhun? Iku uga gampang karo Arrays.sort . Cukup nggunakake komparator khusus. Iki contone:

import java.util.Arrays;
import java.util.Comparator;
//Arrays.sort with custom comparator example
public class DescendingSortExample {
    public static void main(String[] args) {
        Integer[] numbers = {8, 2, 7, 3, 1, 5};
        //sort an Array using Arrays.sort
        Arrays.sort(numbers, Comparator.reverseOrder());

        System.out.println("Sorted Numbers (Descending):");
        for (int number : numbers) {
            System.out.println(number);
        }
    }
}

Output ing ngisor iki: Ing kene kita duwe sawetara integer sing jenenge nomer. Kanthi maringaken Comparator.reverseOrder () minangka argumen kapindho kanggo cara Arrays.sort , kita nemtokake komparator adat sing ngurutake unsur ing urutan mudhun. Cara Comparator.reverseOrder () ngasilake komparator sing mbalikke urutan alam saka unsur. Elinga yen ing kene, kita nggunakake kelas pambungkus Integer tinimbang jinis int primitif amarga cara Comparator.reverseOrder () mbutuhake obyek. Yen sampeyan duwe macem-macem nilai int primitif, sampeyan uga kudu ngowahi menyang obyek Integer sadurunge nggunakake pendekatan iki. Nggunakake komparator khusus, sampeyan bisa kanthi gampang ngurutake array ing urutan mudhun nggunakake cara Arrays.sort ing Jawa.

Algoritma ngurutake klasik dhewe ing Jawa

Sampeyan wis ndeleng Array ngurutake tugas yen sampeyan sinau Ilmu Komputer kanthi mandiri utawa ing universitas. Ana macem-macem algoritma ngurutake, lan kita bakal ngleksanakake sawetara ing artikel iki. Umumé, algoritma sing luwih gampang ditindakake, luwih efisien. Programer ngukur efisiensi algoritma diukur kanthi wektu operasi lan memori sing digunakake kanggo sumber daya. Iku dudu topik artikel kita, nanging kita nyebutake yen Arrays.sort ing Jawa minangka algoritma sing efektif.

Urut Gelembung

Ayo miwiti karo algoritma sing paling populer ing kalangan siswa: Bubble sort. Iku langsung: algoritma mbandhingake rong unsur lan banjur ngganti yen ana ing urutan sing salah, lan sateruse nganti pungkasan array. Pranyata unsur sing luwih cilik "ngambang" nganti pungkasan Array , kaya gelembung ing soda pop menyang ndhuwur.

public class BubbleSort {

       public static void bubbleSort(int[] myArray) {
           int n = myArray.length;
           for (int i = 0; i < n - 1; i++) {
               for (int j = 0; j < n - i - 1; j++) {
                   if (myArray[j] > myArray[j + 1]) {
                       // Swap myArray[j] and myArray[j+1]
                       int temp = myArray[j];
                       myArray[j] = myArray[j + 1];
                       myArray[j + 1] = temp;
                   }
               }
           }
       }

       public static void main(String[] args) {
           int[] arr = {18, 28, 2, 7, 90, 45};

           System.out.println("Array before sorting:");
           for (int num : arr) {
               System.out.print(num + " ");
           }

           bubbleSort(arr);

           System.out.println("\nArray after sorting:");
           for (int num : arr) {
               System.out.print(num + " ");
           }
       }
}

Ing kene metode njupuk array integer minangka input. Daur ulang njaba dadi saka 0 nganti n-1. Punika n punika ukuran array kang. Daur ulang njero mbandhingake unsur jejer. Yen pesenan salah, cara kasebut ngganti. Prosedur iki diulang nganti kabeh array wis diurutake. Mangkene output saka program kita:

Seleksi Urut

Algoritma pamilihan ngurutake array kanthi bola-bali nemokake unsur paling cilik saka bagean sing ora disortir lan dilebokake ing wiwitan. Tulisen nganggo aksara Jawa:

public class SelectionSort {
   public static void selectionSort(int[] myArray) {
       int n = myArray.length;

       for (int i = 0; i < n - 1; i++) {
           int minIndex = i;

           // Find the index of the minimum element in the unsorted part of the array
           for (int j = i + 1; j < n; j++) {
               if (myArray[j] < myArray[minIndex]) {
                   minIndex = j;
               }
           }

           // Swap the minimum element with the first element of the unsorted part
           int temp = myArray[minIndex];
           myArray[minIndex] = myArray[i];
           myArray[i] = temp;
       }
   }

   public static void main(String[] args) {
       int[] arr = {18, 28, 45, 2, 90, 7};

       System.out.println("Array before sorting:");
       for (int num : arr) {
           System.out.print(num + " ");
       }

       selectionSort(arr);

       System.out.println("\nArray after sorting:");
       for (int num : arr) {
           System.out.print(num + " ");
       }
   }
}

Mangkene output saka program kasebut: Ayo diterangno langkah demi langkah. Daur ulang njaba wiwit saka wiwitan Array menyang unsur kapindho nganti pungkasan (nganti n-1). Daur ulang iki milih saben unsur siji-siji minangka titik wiwitan saka bagean Array sing ora disortir . Ing daur ulang njaba, kita miwiti minIndex menyang indeks saiki i , kanthi nganggep minangka indeks item paling cilik ing bagean Array sing ora disortir . Daur ulang utama diwiwiti saka i + 1 lan munggah menyang unsur pungkasan saka Array . Iku nggoleki indeks saka item paling cilik ing bagean unsorted saka Array dening mbandhingaké saben unsur karo unsur minimal saiki ( arr[minIndex] ). Yen kita nemokake unsur sing luwih cilik tinimbang unsur minimal saiki, kita nganyari minIndex menyang indeks unsur minimal anyar. Sawise daur ulang internal rampung, kita nemokake indeks unsur minimal ing bagean Array sing ora diurutake . Banjur kita ngganti unsur minimal karo unsur pisanan saka bagean unsorted kanthi nggunakake temp variabel sauntara. Daur ulang njaba terus nganti kabeh unsur diurutake, mboko sithik ngluwihi bagean sing diurutake saka Array . Pungkasan, Array sing diurutake dicithak ing metode utama sadurunge lan sawise nelpon metode selectionSort .

Gabung Urut

Gabung Sort minangka algoritma divide-and-conquer sing mbagi Array kanthi rekursif dadi sub-subbarray sing luwih cilik, ngurutake, banjur nggabung kanggo entuk array sing diurutake. Gabung Urut stabil lan digunakake digunakake, utamané nalika stabilitas lan dijamin kerumitan wektu paling awon-case dibutuhake.

public class MergeSort {

      //Merge Sort array
      public static void mergeSort(int[] myArray) {
        if (myArray.length <= 1) {
            return;
        }

        int mid = myArray.length / 2;
        int[] left = new int[mid];
        int[] right = new int[myArray.length - mid];

        System.arraycopy(myArray, 0, left, 0, mid);
        System.arraycopy(myArray, mid, right, 0, myArray.length - mid);

        mergeSort(left);
        mergeSort(right);

        merge(myArray, left, right);
    }

    public static void merge(int[] arr, int[] left, int[] right) {
        int i = 0; // index for left subarray
        int j = 0; // index for right subarray
        int k = 0; // index for merged array

        while (i < left.length && j < right.length) {
            if (left[i] <= right[j]) {
                arr[k++] = left[i++];
            } else {
                arr[k++] = right[j++];
            }
        }

        while (i < left.length) {
            arr[k++] = left[i++];
        }

        while (j < right.length) {
            arr[k++] = right[j++];
        }
    }

    public static void main(String[] args) {
        int[] arr = {18, 2, 28, 7, 90, 45};

        System.out.println("Array before sorting:");
        for (int num : arr) {
            System.out.print(num + " ");
        }

        mergeSort(arr);

        System.out.println("\nArray after sorting:");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

Output ing kene yaiku: Ayo diterangake luwih tepat cara kerjane. Algoritma kasebut mbagi Array dadi rong bagean kanthi rekursif nganti kasus dasar tekan (nalika Array duwe siji utawa nol unsur). Banjur nggabungake bagian sing diurutake kanthi nggunakake metode gabungan. Cara gabungan njupuk telung array minangka input: Array asli lan subbarrays kiwa lan tengen (kiwa lan tengen). Iku mbandhingaké unsur saka subbarrays kiwa lan tengen lan merges menyang Array asli ing urutan diurutake.

Urut selipan

Insertion Sort dianggo kanthi nglebokake unsur saka bagean sing ora diurutake menyang posisi sing bener ing bagean sing diurutake. Tumindak apik kanggo set data cilik utawa data sing meh diurutake.

public class InsertionSort {
    public static void insertionSort(int[] myArray) {
        int n = myArray.length;

        for (int i = 1; i < n; i++) {
            int key = myArray[i];
            int j = i - 1;

            while (j >= 0 && myArray[j] > key) {
                myArray[j + 1] = myArray[j];
                j--;
            }

            myArray[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        int[] arr = {18, 90, 7, 28, 45, 2};

        System.out.println("Array before sorting:");
        for (int num : arr) {
            System.out.print(num + " ");
        }

        insertionSort(arr);

        System.out.println("\nArray after sorting:");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

Output saka program kaya biasane: Ing kene metode insertionSort ngetrapake algoritma Insertion Sort. Iku iterates liwat Array lan nganggep saben unsur minangka tombol. Iku mbandhingake tombol karo unsur sadurunge lan gerakane wong siji posisi ahead yen padha luwih, èfèktif nggeser unsur kanggo nggawe papan kanggo tombol ing posisi sing bener. Daur ulang njaba saka unsur kapindho ( i = 1 ) nganti unsur pungkasan Array. Daur ulang batin diwiwiti saka unsur saiki ( arr[i] ) lan mundur ( j = i-1 ) nganti nemu posisi sing bener kanggo tombol utawa tekan wiwitan Array . Ing njero daur ulang, yen unsur ( arr[j] ) luwih gedhe tinimbang tombol, dipindhah siji posisi ing ngarep ( arr[j + 1] = arr[j] ) kanggo nggawe papan kanggo tombol. Proses iki terus nganti posisi sing bener kanggo tombol ketemu. Sawise daur ulang njero rampung, tombol diselehake ing posisi sing bener ( arr[j + 1] = tombol ). Ing metode utama, conto array digawe lan dicithak sadurunge lan sawise ngurutake nggunakake metode insertionSort .

Urut cepet

Quick Sort minangka algoritma divide-and-conquer sing milih unsur poros lan partisi Array ngubengi poros. Biasane, Quick Sort luwih cepet tinimbang Merge Sort kanggo set data ukuran cilik lan medium amarga faktor konstan sing kurang.

public class QuickSort {

       public static void quickSort(int[] myArray, int low, int high) {
           if (low < high) {
               int pivotIndex = partition(myArray, low, high);
               quickSort(myArray, low, pivotIndex - 1);
               quickSort(myArray, pivotIndex + 1, high);
           }
       }

       public static int partition(int[] arr, int low, int high) {
           int pivot = arr[high];
           int i = low - 1;

           for (int j = low; j < high; j++) {
               if (arr[j] <= pivot) {
                   i++;
                   swap(arr, i, j);
               }
           }

           swap(arr, i + 1, high);
           return i + 1;
       }

       public static void swap(int[] arr, int i, int j) {
           int temp = arr[i];
           arr[i] = arr[j];
           arr[j] = temp;
       }

       public static void main(String[] args) {
           int[] arr = {18, 28, 2, 90, 7, 45};

           System.out.println("Array before sorting:");
           for (int num : arr) {
               System.out.print(num + " ");
           }

           quickSort(arr, 0, arr.length - 1);

           System.out.println("\nArray after sorting:");
           for (int num : arr) {
               System.out.print(num + " ");
           }
       }
}

Output ing kene: Dadi ing kene kita entuk telung cara kanggo ngetrapake urutan cepet. Cara quickSort njupuk telung paramèter: Array sing bakal diurutake, indeks subarray kurang, lan indeks subarray dhuwur. Kaping pisanan, mriksa yen subarray duwe luwih saka siji unsur. Yen mangkono, milih pivot nggunakake metode partisi, rekursif ngurutake subarray sadurunge poros, lan rekursif ngurutake subarray sawise poros. Cara partisi milih poros minangka unsur pungkasan saka subarray ( arr[dhuwur] ). Iku nyetel indeks pemisahan (i) kanggo indeks kurang minus 1. Iku banjur iterates saka indeks kurang kanggo indeks dhuwur - 1 lan mriksa yen saben unsur kurang saka utawa padha karo poros. Yen mangkono, swap unsur karo unsur ing indeks partisi (i) lan nambah indeks partisi. Pungkasan, ngganti unsur poros karo unsur ing indeks partisi + 1 lan ngasilake indeks partisi. Cara partisi milih poros minangka unsur pungkasan saka subarray ( arr[dhuwur] ). Iku mranata indeks pemisahan (i) kanggo indeks kurang minus 1. Iku banjur iterates saka indeks kurang kanggo indeks dhuwur - 1 lan mriksa yen saben item luwih cilik utawa padha karo poros. Yen mangkono, swap unsur karo unsur ing indeks partisi (i) lan nambah indeks partisi. Pungkasan, ngganti unsur poros karo unsur ing indeks partisi + 1 lan ngasilake indeks partisi. Metode swap minangka cara utilitas sing digunakake kanggo ngganti rong unsur ing Array . Ing cara utama , conto array digawe lan dicithak sadurunge lan sawise ngurutake nggunakake metode quickSort .

Kesimpulan

Saka artikel iki sampeyan wis ngerti carane ngurutake array ing basa Jawa. Sampeyan bisa nggunakake cara Arrays.sort sing dibangun utawa nulis implementasine dhewe saka cara ngurutake populer kayata ngurutake gelembung, nggabung urut lan liya-liyane. Sampeyan uga bisa nyoba kanggo nyerang cara ngurutake dhewe. Iku gumantung ing tugas sampeyan. Yen sampeyan kudu ngrampungake masalah ngurutake kanthi cepet, gunakake cara sing wis ditulis sadurunge. Yen sampeyan sinau pemrograman lan nyoba dadi luwih apik, luwih becik nulis sawetara cara ngurutake dhewe.