喝咖啡休息#110。我們解決如何找到數組中第三大數字的問題。Java 中的字串反轉

如何找出數組中第三大的數

來源：Dev.to 我們有一個問題要解決： 給你一個未排序的整數陣列。如何找出數組中第三大的數？注意：數組中同時包含重複值和負值，如果數組長度增加 N 倍，則此程式碼也應該有效。 Java中給出了解決方案：

範例 1：具有負值的未排序數組

輸入：[87, 99, -14, 05, 46, 54] 代碼：

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

    }
}

結論： 解釋：

1. 如上所述，數組用正值和負值初始化。

2. 我們初始化變數來分別儲存最大、第二大和第三大的值。注意：變數初始化為 0 是為了一種特殊情況：如果第三個最大元素不在陣列中，則傳回 0。

3. 我們重複循環 N（數組的長度）多次以找到三個最大值。

4. 如果條件是將最大的值賦給第二個大值並在陣列中初始化一個新的大值。

   第一個elseif條件是將第二個大值指派給第三個大值，並在陣列中初始化一個新的第二個大值。

   第二個elseif條件是指派數組中的第三個大值。

5. 最後，我們列印變數。

範例 2：具有負值和重複值的未排序數組

輸入：[77, 101, 95, 14, 05, 46, -47, 94, 00, 95, 52, 86, 36, -54, 94, 89] 代碼：

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

結論： 說明：兩個程式碼中使用的偽代碼是相同的，範例 2 中唯一的差異是我們使用的是 LinkedHashSet。它是一個 Java 集合，我們在其中儲存唯一的對象，從而刪除數組中的重複值。

另一個解決方案：

我們可以使用冒泡排序演算法（從低到高排序）對數組進行排序並找到數組的最大值。輸入：[87, 99, 14, 05, 46, 54] 代碼：

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

}

結論：

Java 中的字串反轉

來源： Dev.to

Java程式使用StringBuilder反轉字串

說明： 字串是 Java 中的對象，內部由字元陣列支援。字串是不可變的，因為陣列是不可變的（禁止修改）。每次對行進行更改時，都會建立一個新行。在我們的例子中，我們使用的是可變的StringBuilder。注意：我們也可以使用StringBuffer類別。代碼：

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

    }

}

結論： 定序：

1. 創建String類別的物件並初始化它。

2. 建立字串生成器類別的物件。

3. 使用內建字串產生器 append()和reverse()函數。

4. 列印字串生成器物件。

Java程式不使用內建函數Stringreverse()來反轉字串

方法一

說明：toCharArray()函數用於將此字串轉換為字元陣列。之後，我們將使用for迴圈以相反的順序遍歷每個字元並取得每個字元的輸出。代碼：

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

    }

}

結論： 定序：

1. 創建String類別的物件並初始化它。

2. 建立一個字元數組並使用String物件呼叫toCharArray()函數。

3. 為臨時變數建立一個String物件。

4. 反向重複for循環，以相反的順序取得每個字元。

5. 將每個字元連接到一個Temp變數。

6. 輸入溫度。

方法2

說明：使用for循環，我們以相反的順序列印了一個字串。另一方面，charAt(index)方法傳回任何給定索引處的字元。每次迭代後將連接該字元以更改字串變數。代碼：

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

    }

}

結論： 定序：

1. 創建String類別的物件並初始化它。

2. 為臨時變數建立一個String物件。

3. 以相反的順序重複for循環，以相反的順序取得每個字元。

4. 透過呼叫charAt()函數將每個字元連接到Temp變數中。

5. 我們打印Temp。

特別注意：您可能熟悉反向函數，但這裡的目標是探索StringBuilder的功能以及如何在沒有反向函數的情況下最佳化程式碼。希望這對未來的人有幫助！