喝咖啡休息#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的功能以及如何在没有反向函数的情况下优化代码。希望这对将来的人有帮助！