Przerwa kawowa #110. Rozwiązujemy problem znalezienia trzeciej co do wielkości liczby w tablicy. Odwróć ciąg w Javie

Jak znaleźć trzecią co do wielkości liczbę w tablicy

Źródło: Dev.to Mamy problem do rozwiązania: Dostajesz nieposortowaną tablicę liczb całkowitych. Jak znaleźć trzecią co do wielkości liczbę w tablicy? Uwaga: Tablica zawiera zarówno zduplikowane wartości, jak i wartości ujemne, a także ten kod powinien zadziałać, jeśli długość tablicy wzrośnie N razy. Rozwiązanie podano w Javie:

Przykład 1: Nieposortowana tablica z wartościami ujemnymi

Wejście: [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);

    }
}

Wniosek: Wyjaśnienie:

1. Jak wspomniano powyżej, tablica jest inicjowana zarówno wartościami dodatnimi, jak i ujemnymi.

2. Inicjujemy zmienne, aby przechowywać odpowiednio największą, drugą co do wielkości i trzecią co do wielkości wartość. Uwaga: Zmienne są inicjowane na 0 w jednym specjalnym przypadku: jeśli trzeci element maksymalny nie znajduje się w tablicy, zwróci 0.

3. Powtarzamy pętlę N (długość tablicy) kilka razy, aby znaleźć trzy największe wartości.

4. Jeśli warunkiem jest przypisanie największej wartości drugiej dużej wartości i zainicjowanie nowej dużej wartości w tablicy.

   Pierwszy warunek elseif polega na przypisaniu drugiej dużej wartości trzeciej dużej wartości i zainicjowaniu nowej, drugiej dużej wartości w tablicy.

   Drugi warunek elseif polega na przypisaniu trzeciej dużej wartości w tablicy.

5. Na koniec drukujemy zmienne.

Przykład 2: Nieposortowana tablica z wartościami ujemnymi i zduplikowanymi

Wejście: [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);
    }
}

Wniosek: Objaśnienie: Pseudokod użyty w obu kodach jest taki sam, jedyną różnicą w przykładzie 2 jest to, że używamy LinkedHashSet. Jest to kolekcja Java, w której przechowujemy unikalne obiekty, co skutkuje usunięciem zduplikowanych wartości w tablicy.

Inne rozwiązanie:

Możemy użyć algorytmu sortowania bąbelkowego (sortowanie od najniższego do najwyższego rzędu), aby posortować tablicę i znaleźć największą wartość tablicy. Wejście: [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);
    }

}

Wniosek:

Odwróć ciąg w Javie

Źródło: Dev.to

Program Java do odwracania ciągu za pomocą StringBuilder

Objaśnienie: Łańcuchy to obiekty w Javie, które są wewnętrznie wspierane przez tablicę znaków. Ciągi są niezmienne, ponieważ tablice są niezmienne (zamknięte na modyfikację). Za każdym razem, gdy wprowadzasz zmiany w wierszu, tworzony jest nowy wiersz. W naszym przypadku używamy StringBuilder , który jest zmienny. Uwaga: Możemy także użyć klasy 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);

    }

}

Wniosek: Sekwencjonowanie:

1. Utwórz obiekt klasy String i zainicjuj go.

2. Utwórz obiekt klasy konstruktora ciągów znaków .

3. Użyj wbudowanych funkcji tworzenia ciągów znaków append() i Reverse() .

4. Wydrukuj obiekt konstruktora ciągów .

Program Java do odwracania ciągu znaków bez użycia wbudowanej funkcji String Reverse()

Metoda 1

Objaśnienie: Funkcja toCharArray() służy do konwertowania tego ciągu znaków na tablicę znaków. Następnie użyjemy pętli for , aby przejść przez każdy znak w odwrotnej kolejności i uzyskać wynik dla każdego znaku. 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);

    }

}

Wniosek: Sekwencjonowanie:

1. Utwórz obiekt klasy String i zainicjuj go.

2. Utwórz tablicę znaków i wywołaj funkcję toCharArray() z obiektem String .

3. Utwórz obiekt String dla zmiennej tymczasowej.

4. Powtórz pętlę for w odwrotnej kolejności, aby uzyskać każdy znak w odwrotnej kolejności.

5. Połącz każdy znak w zmienną Temp .

6. Wpisz Temp .

Metoda 2

Objaśnienie: Używając pętli for , wydrukowaliśmy ciąg znaków w odwrotnej kolejności. Z drugiej strony metoda charAt(index) zwraca znak o dowolnym indeksie. Znak będzie łączony po każdej iteracji w celu zmiany zmiennej łańcuchowej. 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);

    }

}

Wniosek: Sekwencjonowanie:

1. Tworzenie obiektu klasy String i inicjowanie go.

2. Utwórz obiekt String dla zmiennej tymczasowej.

3. Powtarzanie pętli for w odwrotnej kolejności, aby uzyskać każdy znak w odwrotnej kolejności.

4. Połącz każdy znak w zmienną Temp , wywołując funkcję charAt() .

5. Drukujemy Temp .

Uwaga specjalna: Być może znasz funkcję odwrotną, ale celem tutaj jest poznanie możliwości StringBuilder i sposobów optymalizacji kodu bez funkcji odwrotnej. Mam nadzieję, że pomoże to komuś w przyszłości!