笔试编程（一） | 二分查找、数组相关

最近有小伙伴在公众号后台留言需要准备一些面试相关的文章，其实在面试相关的文章准备笔者早有打算。在春节后，笔者会针对大数据领域相关的求职面试准备一些面试题，同时分享一些面试经验，希望能帮助到大家。

今天先分享一些笔试中经常遇到的一些编程题，包括解题思路和代码实现，下图是本次分享的大纲：

二分查找法

二分查找又称折半查找, 它是一种效率较高的查找方法。前提：（1）必须采用顺序存储结构（2）必须按关键字大小有序排列 

原理：将数组分为三部分，依次是中值（所谓的中值就是数组中间位置的那个值）前，中值，中值后，将要查找的值和数组的中值进行比较，若小于中值则在中值前面找，若大于中值则在中值后面找，等于中值时直接返回。然后依次是一个递归过程，将前半部分或者后半部分继续分解为三部分。

public class BinarySearch {
    //循环实现二分查找
    public static int binarySearch(int[] arr, int x) {
        int low = 0;
        int high = arr.length - 1;
        while (low <= high) {
            int middle = (low + high) / 2;
            if (x == arr[middle]) {
                return middle;
            } else if (x < arr[middle]) {
                high = middle - 1;
            } else {
                low = middle + 1;
            }
        }

        //无法查到数据
        return -1;
    }

    //递归实现二分查找
    public static int binarySearch(int[] dataset, int data, int beginIndex, int endIndex) {
        int midIndex = (beginIndex + endIndex) / 2;
        if (data < dataset[beginIndex] || data > dataset[endIndex] || beginIndex > endIndex) {
            return -1;
        }
        if (data < dataset[midIndex]) {
            return binarySearch(dataset, data, beginIndex, midIndex - 1);
        } else if (data > dataset[midIndex]) {
            return binarySearch(dataset, data, midIndex + 1, endIndex);
        } else {
            return midIndex;
        }
    }

    public static void main(String[] args) {
        int[] arr = {6, 12, 33, 87, 90, 97, 108, 561};
        System.out.println("循环查找：" + (binarySearch(arr, 87) + 1));
        System.out.println("递归查找" + binarySearch(arr, 3, 87, arr.length - 1));
    }
}

常见的数组相关编程题

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<Integer> nums = new ArrayList<Integer>();

        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<Character> 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<min,则min=next
 **/
public static void t4(int[] arr) {
    if (arr != null) {
        int length = arr.length;

        if (length == 1) {
            System.out.println("the max num and min num both are: " + arr[0]);
        } else {
            int max = 0;
            int min = 0;
            for (int i = 0; i < length; i++) {
                int num = arr[i];

                if (i == 0) {
                    max = num;
                    min = num;
                } else {
                    if (num > 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<String> 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<Integer> 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<Integer> res = new ArrayList<>();
        ArrayList<Integer> 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;
        }

    }
}

---

关注微信公众号：大数据学习与分享，获取更对技术干货