Java常见的数组相关笔试编程题

1.对正整数进行分解质因数

// 如传入100, 打印出2*2*5*5

/** 思路:
 *      首先找到一个最小的质数i
 *      1. 如果这个质数恰等于num, 则说明分解质因数的过程已经结束, 打印出即可
 *      2. 如果num > i, 但num能被i整除, 则打印出i的值, 并用num除以i的商, 作为新的正整数num, 重复执行第一步
 *      3. 如果num不能被i整除, 则用i+1作为i的值, 重复执行第一步
 **/
public static void t0(int num) {
    for (int i = 2; i <= num; i++) {
        while (num != i) {
            if (num % i == 0) {
                System.out.print(i + "*");
                num = num / i;
            } else {
                break;
            }
        }
    }
    System.out.println(num);
}

2.在一个给定的从1到100的整型数组中，快速找到缺失的数字

/**思路:
 *      1. 首先对集合进行升序排序
 *      2. 在没有确实数字的情况下, `排序后`相邻间的两数字差值应为1, 需要处理的是差值大于1的 [差值为1和差值为0的不需要处理]
 *
 * @param arr 正整数数组 如int[] list = {1, 10, 4, 2, 8, 3, 2, 13};
 **/
public static void t1(int[] arr) {
    if (arr != null) {
        ArrayList nums = new ArrayList();

        int length = arr.length;

        if (length == 1) {
            System.out.println(nums);
        }

        Arrays.sort(arr);

        for (int i = 0; i < length; i++) {
            if (i != length - 1) {
                int now = arr[i];
                int step = arr[i + 1] - now;
                if (step > 1) {
                    int x = 0;
                    while (x < step - 1) {//注意临界值的处理
                        x++;
                        nums.add(now + x);
                    }
                }
            }
        }
        System.out.println(nums);
    }
}

3.对字符串进行中的数字进行正序排序，并且字符串中字母的位置不变

//如，43a6f9d8, 输出34a6f8d9

/**思路:
 *      1. 先遍历字符串取出其中的数字放进一个集合, 然后对集合进行正序排序
 *      2. 再次遍历字符串, 遇到字符为数字的, 取出数字字符集合numChars中的第一个元素(索引j=0)放在此位置, 并对numChars下一个取出的元素索引定位为j++
 **/
public static String t3(String str) {
    if (StringUtils.isBlank(str)) {
        return str;
    }

    ArrayList numChars = new ArrayList<>();
    char[] chars = str.toCharArray();

    for (int i = 0; i < chars.length; i++) {
        char c = chars[i];
        if (Character.isDigit(c)) {
            numChars.add(c);
        }
    }
    Collections.sort(numChars);

    StringBuilder builder = new StringBuilder();
    for (int i = 0, j = 0; i < chars.length; i++) {
        char c = chars[i];
        if (Character.isDigit(c)) {
            builder.append(numChars.get(j));
            j++;
        } else {
            builder.append(c);
        }
    }

    return builder.toString();
}

4.在一个未排序的整型数组中, 找到最大和最小的数字

// 如，int[] list = {-2, 1, 99, 10, 4, 2, -1, 8, 3, 2, 13, 0}；输出max: 99 ; min: -2

/**思路:
 *      1. 初始化最大数字max和最小数字min为数组中第一个元素
 *      2. 将max和数组中"下一个"元素next比较, 如果next>max, 则max=next
 *      3. 将min和数组中"下一个"元素next比较, 如果next max) {
                        max = num;
                    }

                    if (num < min) {
                        min = num;
                    }
                }
            }
            System.out.println("max num is: " + max + " ; min num is: " + min);
        }
    }
}

5.一个整型数组中，找到一个所有成对的数字，满足它们的和等于一个给定的数字

//如，int[] arr = {-2, 1, 99, 10, 4, 2, -1, 8, 3, 2, 13}, sum为3; 找出 -1和4, 1和2即可;
//如，int[] arr = {1, 1, 2, 3, 3, 1, 2, 0, 0}, sum为3; 找出1和2, 3和0即可
public static void t5_0(int[] arr, int sum) {
    if (arr != null) {
        int length = arr.length;

        Arrays.sort(arr);

        HashSet set = new HashSet<>();

        for (int i = 0, j = length - 1; i < j; ) {
            int tmpSum = arr[i] + arr[j];
            if (tmpSum == sum) {
                //如果只获取其中一对元素和等于sum直接return
                //return arr[i] + "+" + arr[j] + "=" + sum;

                //如果是获取所有并且不重复可以采取这种
            set.add(arr[i] + "+" + arr[j] + "=" + sum);
                
                //避免进入死循环
            i++;
            j--;
            
            } else if (tmpSum < sum) {
                i++;
            } else {
                j--;
            }
        }

        System.out.println(set);
    }
}

6.如果一个数组包含多个重复元素，找到这些重复的数字

//如，int[] arr = {1, 1, 2, 3, 3, 4, 2, 0, 0}；输出0,1,2,3即可
public static void t6(int[] arr) {
    if (arr != null) {
        int length = arr.length;

        Arrays.sort(arr);

        HashSet res = new HashSet<>();
        for (int i = 0; i < length; i++) {
            if (i != length - 1) {
                int now = arr[i];
                int next = arr[i + 1];
                if (now == next) {
                    res.add(now);
                }
            }
        }

        System.out.println(res);
    }
}

7.Java 实现从一个给定数组中删除重复元素

//如，int[] arr = {1, 1, 2, 3, 3, 4, 2, 0, 0}；输出 4
public static void t7(int[] arr) {
    if (arr != null) {
        int length = arr.length;

        Arrays.sort(arr);

        ArrayList res = new ArrayList<>();
        ArrayList repeatNums = new ArrayList<>();

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

            if (i != length - 1) {
                int next = arr[i + 1];
                if (now == next) {
                    repeatNums.add(now);
                }
            }
        }

        res.removeAll(repeatNums);

        System.out.println(res);
    }
}

8.Java实现数组反转

public static Object t8(int[] arr) {
    if (arr != null) {
        // 可以采用t8_t方法比较通用
        //t8_t(arr, 0, arr.length);

        int i = 0;
        for (int j = arr.length - 1; j > i; ++i) {
            int tmp = arr[j];
            arr[j] = arr[i];
            arr[i] = tmp;
            --j;
        }

    }

    return ArrayUtils.toString(arr);
}

private static void t8_t(int[] arr, int startIndexInclusive, int endIndexExclusive) {
    if (arr != null) {
        int i = startIndexInclusive < 0 ? 0 : startIndexInclusive;

        for (int j = Math.min(arr.length, endIndexExclusive) - 1; j > i; ++i) {
            int tmp = arr[j];
            arr[j] = arr[i];
            arr[i] = tmp;
            --j;
        }

    }
}