Rehat kopi #110. Kami menyelesaikan masalah bagaimana untuk mencari nombor ketiga terbesar dalam tatasusunan. Balikkan rentetan dalam Java

Bagaimana untuk mencari nombor ketiga terbesar dalam tatasusunan

Sumber: Dev.to Kami mempunyai masalah untuk diselesaikan: Anda diberi tatasusunan integer yang tidak diisih. Bagaimana untuk mencari nombor ketiga terbesar dalam tatasusunan? Nota: Tatasusunan mengandungi nilai pendua dan nilai negatif, dan juga kod ini harus berfungsi jika panjang tatasusunan meningkat sebanyak N kali. Penyelesaian diberikan dalam Java:

Contoh 1: Tatasusunan tidak diisih dengan nilai negatif

Input: [87, 99, -14, 05, 46, 54] Kod:

public class ThirdLargestNumInArray {

    public static void main(String[] args) {

        /*
         * unsorted Array with duplicate and negative values
         */
        Integer arr[] = { 87, 99, -14, 05, 46, 54 };

        /* Variable initialization */
        int largest = 0, secondLargest = 0, thirdLargest = 0;

        /* Condition to find */
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > largest) {
                /*
                 * if condition is true assign large value to second large value
                 */
                secondLargest = largest;

                /* assign new large value */
                largest = arr[i];

            } else if (arr[i] > secondLargest) {
                /*
                 * if condition is true assign second large value to third large value
                 */
                thirdLargest = secondLargest;

                /* assign new second large value */
                secondLargest = arr[i];

            } else if (arr[i] > thirdLargest) {
                /*
                 * if condition is true the third largest value will be assigned
                 */
                thirdLargest = arr[i];
            }
        }

        /* Print the values */
        System.out.println("Largest = " + largest);
        System.out.println("Second Largest = " + secondLargest);
        System.out.println("Third Largest = " + thirdLargest);

    }
}

Kesimpulan: Penjelasan:

1. Seperti yang dinyatakan di atas, tatasusunan dimulakan dengan nilai positif dan negatif.

2. Kami memulakan pembolehubah masing-masing untuk menyimpan nilai terbesar, kedua terbesar dan ketiga terbesar. Nota: Pembolehubah dimulakan kepada 0 untuk satu kes khas: jika elemen maksimum ketiga tiada dalam tatasusunan, ia akan mengembalikan 0.

3. Kami mengulangi gelung N (panjang tatasusunan) beberapa kali untuk mencari tiga nilai terbesar.

4. Jika syaratnya adalah untuk menetapkan nilai terbesar kepada nilai besar kedua dan memulakan nilai besar baharu dalam tatasusunan.

   Syarat elseif pertama adalah untuk menetapkan nilai besar kedua kepada nilai besar ketiga dan memulakan nilai besar kedua baharu dalam tatasusunan.

   Syarat elseif ke-2 adalah untuk menetapkan nilai besar ketiga dalam tatasusunan.

5. Akhirnya, kami mencetak pembolehubah.

Contoh 2: Tatasusunan tidak diisih dengan nilai negatif dan pendua

Input: [77, 101, 95, 14, 05, 46, -47, 94, 00, 95, 52, 86, 36, -54, 94, 89] Kod:

import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;

public class ThirdLargestNumInSet {

    public static void main(String[] args) {

        /*
         * unsorted Array with duplicate and negative values
         */
        Integer arr[] = { 77, 101, 14, 05, 46, -47, 94, 00, 95, 52, 86, 36, -54, 94, 89 };

        /* Variable initialization */
        int largest = 0, secondLargest = 0, thirdLargest = 0;

        /*
         * using LinkedHashSet - Map to remove duplication in Array
         */
        Set<Integer> newSet = new LinkedHashSet<>();

        for (int i = 0; i < arr.length; i++) {
            newSet.add(arr[i]);
        }

        /* Condition to find */
        for (Integer i : newSet) {
            if (i > largest) {
                /*
                 * if condition is true assign large value to second large value
                 */
                secondLargest = largest;

                /* assign new large value */
                largest = i;

            } else if (i > secondLargest) {
                /*
                 * if condition is true assign second large value to third large value
                 */
                thirdLargest = secondLargest;

                /* assign new second large value */
                secondLargest = i;

            } else if (i > thirdLargest) {
                /*
                 * if condition is true the third largest value will be assigned
                 */
                thirdLargest = i;
            }
        }

        /* Print the values */
        System.out.print("Largest = " + largest);
        System.out.print("\nSecond Largest = " + secondLargest);
        System.out.print("\nThird Largest = " + thirdLargest);
    }
}

Kesimpulan: Penjelasan: Kod pseudo yang digunakan dalam kedua-dua kod adalah sama, satu-satunya perbezaan dalam contoh 2 ialah kami menggunakan LinkedHashSet. Ia adalah koleksi Java di mana kami menyimpan objek unik yang mengakibatkan mengalih keluar nilai pendua dalam tatasusunan.

Penyelesaian lain:

Kita boleh menggunakan algoritma isihan gelembung (mengisih daripada tertib terendah ke tertinggi) untuk mengisih tatasusunan dan mencari nilai terbesar tatasusunan. Input: [87, 99, 14, 05, 46, 54] Kod:

import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;

public class Main {

    public static void bubblesort(Integer[] arr) {

        int n = arr.length;
        int temp;

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

            }
        }

    }

    public static void main(String[] args) {

        Integer[] arr = { 87, 99, 14, 05, 46, 54 };

        bubblesort(arr);

        System.out.print("array after sorting : ");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }

        int n = arr.length;

        int max = arr[n - 3];
        System.out.println("\n3rd largest value: " + max);
    }

}

Kesimpulan:

Balikkan rentetan dalam Java

Sumber: Dev.to

Program Java untuk membalikkan rentetan menggunakan StringBuilder

Penjelasan: Rentetan ialah objek dalam Java yang disokong secara dalaman oleh pelbagai aksara. Rentetan tidak berubah kerana tatasusunan tidak berubah (ditutup kepada pengubahsuaian). Setiap kali anda membuat perubahan pada baris, baris baharu dibuat. Dalam kes kami, kami menggunakan StringBuilder yang boleh berubah. Nota: Kami juga boleh menggunakan kelas StringBuffer . Kod:

public class ReverseStringBuilder {

    public static void main(String[] args) {

        /* String is immutable */
        String name = "Palindrome";

        /* Create StringBuilder(mutable) object */
        StringBuilder s1 = new StringBuilder();

        /* Using append() and reverse() in StringBuilder */
        s1.append(name);
        s1 = s1.reverse();

        /* Print the reverse */
        System.out.println(s1);

    }

}

Kesimpulan: Urutan:

1. Buat objek kelas String dan mulakan ia.

2. Cipta objek kelas pembina rentetan .

3. Gunakan fungsi pembina rentetan terbina dalam append() dan reverse() .

4. Cetak objek pembina rentetan .

Program Java untuk membalikkan rentetan tanpa menggunakan fungsi terbina dalam String reverse()

Kaedah 1

Penjelasan: Fungsi toCharArray() digunakan untuk menukar rentetan ini kepada tatasusunan aksara. Selepas ini, kami akan menggunakan gelung for untuk melalui setiap aksara dalam susunan terbalik dan mendapatkan output untuk setiap aksara. Kod:

public class Reverse {

    public static void main(String[] args) {

        /* String is immutable */
        String name = "Palindrome";

        /* Using toCharArray() function */
        char[] ch = name.toCharArray();

        /* Temp string */
        String rev = "";

        /* Iterating for loop in reverse to store */
        for (int i = ch.length - 1; i >= 0; i--) {
            /* Concatenating Strings */
            rev += ch[i];
        }

        /* Print the reverse */
        System.out.println(rev);

    }

}

Kesimpulan: Urutan:

1. Buat objek kelas String dan mulakan ia.

2. Buat tatasusunan aksara dan panggil fungsi toCharArray() dengan objek String .

3. Buat objek String untuk pembolehubah sementara.

4. Ulangi gelung for secara terbalik untuk mendapatkan setiap aksara dalam susunan terbalik.

5. Gabungkan setiap aksara ke dalam pembolehubah Temp .

6. Taip Temp .

Kaedah 2

Penjelasan: Menggunakan gelung for , kami mencetak rentetan dalam susunan terbalik. Sebaliknya, kaedah charAt(index) mengembalikan aksara pada mana-mana indeks tertentu. Watak akan digabungkan selepas setiap lelaran untuk menukar pembolehubah rentetan. Kod:

public class ReverseCharAt {

    public static void main(String[] args) {

        /* String is immutable */
        String name = "Palindrome";

        /* Temp string */
        String rev = "";

        /* Iterating for loop in reverse to store */
        for (int i = name.length() - 1; i >= 0; i--) {
            /* Concatenating Strings */
            rev = rev + name.charAt(i);
        }

        /* Print the reverse */
        System.out.println(rev);

    }

}

Kesimpulan: Urutan:

1. Mencipta objek kelas String dan memulakannya.

2. Buat objek String untuk pembolehubah sementara.

3. Mengulang gelung for dalam susunan terbalik untuk mendapatkan setiap aksara dalam susunan terbalik.

4. Gabungkan setiap aksara ke dalam pembolehubah Temp dengan memanggil fungsi charAt() .

5. Kami mencetak Temp .

Nota Khas: Anda mungkin biasa dengan fungsi songsang, tetapi matlamat di sini adalah untuk menerokai keupayaan StringBuilder dan cara anda boleh mengoptimumkan kod anda tanpa fungsi songsang. Harap ini membantu seseorang pada masa hadapan!