刚经历某互联网公司第一轮面试，面试题为三道编程题，三十分钟内完成，完成两道，剩余一道由于时间不够所以就写出了思路，在这里做一个记录。具体算法思想见代码注解。

数组操作，求：交集、并集、差集

import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

/**
 * 数组操作，求：交集、并集、差集
 *
 * 在能够表达算法思想的前提下尽量简化一下情况，所以这里就假定数组内元素不重复
 */
public class ArrayOperation {

    @Test
    public void test() {
        int[] arr1 = new int[]{1,3,6,9,8};
        int[] arr2 = new int[]{1,3,6,11,10};
        // 排序测试
        sort(arr1,0,arr1.length - 1);
        sort(arr2,0,arr2.length - 1);

        // 交集
        List<Integer> intersectionResult = intersection(arr1,arr2);
        // 并集
        List<Integer> unionResult = union(arr1,arr2);
        // 差集
        List<Integer> differenceResult = difference(arr1,arr2);
    }

    /**
     * 快排
     *
     * 思路：挖坑填数+分治法
     */
    private void sort(int[] arr,int low,int high) {
        if (low >= high) {
            return;
        }
        int left = low,right = high;
        int movedVal = arr[left];
        while (left < right) {
            while (left < right && arr[right] >= movedVal) {
                right--;
            }
            arr[left] = arr[right];
            while (left < right && arr[left] <= movedVal) {
                left++;
            }
            arr[right] = arr[left];
        }
        arr[left] = movedVal;
        sort(arr,low,left - 1);
        sort(arr,left + 1,high);
    }

    /**
     * 交集
     *
     * 思路：将两个有序数组遍历，相等则加入结果中，不等较小值的数组索引加1，直到任意一个数组遍历完成
     */
    private List<Integer> intersection(int[] arr1,int[] arr2) {
        sort(arr1,0,arr1.length - 1);
        sort(arr2,0,arr2.length - 1);
        List<Integer> result = new ArrayList<>();
        int index1 = 0,index2 = 0;
        int len1 = arr1.length,len2 = arr2.length;
        while (index1 < len1 && index2 < len2) {
            if (arr1[index1] == arr2[index2]) {
                result.add(arr1[index1]);
                index1++;
                index2++;
            } else if (arr1[index1] > arr2[index2]) {
                index2++;
            } else {
                index1++;
            }
        }
        return result;
    }

    /**
     * 并集
     *
     * 思路：依次遍历两个数组，相等索引数据加入到结果中一次，两个索引同时加1，不相等的将较小值加入结果同时索引加1；当任意一个数组遍历完后，将另一个数组剩余元素添加进结果；
     */
    private List<Integer> union(int[] arr1,int[] arr2) {
        int len1 = arr1.length,len2 = arr2.length;
        sort(arr1,0,len1 - 1);
        sort(arr2,0,len2 - 1);
        int index1 = 0,index2 = 0;
        List<Integer> result = new ArrayList<>();
        while (index1 < len1 && index2 < len2) {
            if (arr1[index1] == arr2[index2]) {
                result.add(arr1[index1]);
                index1++;
                index2++;
            } else if (arr1[index1] > arr2[index2]) {
                result.add(arr2[index2]);
                index2++;
            } else {
                result.add(arr1[index1]);
                index1++;
            }
        }
        while (index1 < len1) {
            result.add(arr1[index1]);
            index1++;
        }
        while (index2 < len2) {
            result.add(arr2[index2]);
            index2++;
        }
        return result;
    }

    /**
     * 差集
     *
     * 思路：依次遍历两个数组，值相等索引同时加1忽略相同值；不同值加入较小值并将索引加1，直到任意一个数组遍历完成；然后将另一个素组中剩余元素加进结果中。
     */
    private List<Integer> difference(int[] arr1,int[] arr2) {
        int len1 = arr1.length,len2 = arr2.length;
        int index1 = 0,index2 = 0;
        List<Integer> result = new ArrayList<>();
        while (index1 < len1 && index2 < len2) {
            if (arr1[index1] == arr2[index2]) {
                index1++;
                index2++;
            } else if (arr1[index1] > arr2[index2]) {
                result.add(arr2[index2]);
                index2++;
            } else {
                result.add(arr1[index1]);
                index1++;
            }
        }
        while (index1 < len1) {
            result.add(arr1[index1]);
            index1++;
        }
        while (index2 < len2) {
            result.add(arr2[index2]);
            index2++;
        }
        return result;
    }
}

求一个数组中的连续子列表的最大和

import org.junit.Test;

/**
 * 求一个数组中的连续子列表的最大和
 */
public class SubListSum {

    @Test
    public void test() {
        int[] arr = new int[]{1,2,3,6,7,8,5,6};
        // 测试结果 21
        int sum = subListSum(arr);
    }

    /**
     * 思路：使用动态规划
     * 初始dp[0] = arr[0]
     * 如果arr[i] = arr[i - 1],则dp[i] = dp[i - 1] + arr[i]
     * 否则dp[i] = arr[i]
     */
    private int subListSum(int[] arr) {
        int[] dp = new int[arr.length];
        dp[0] = arr[0];
        int sum = dp[0];
        for (int i = 1;i < arr.length;i++) {
            if (arr[i] == arr[i - 1] + 1) {
                dp[i] = dp[i - 1] + arr[i];
            } else {
                dp[i] = arr[i];
            }
            sum = Math.max(sum,dp[i]);
        }
        return sum;
    }
}

求元素首次出现下标

import java.util.ArrayList;
import java.util.List;

/**
 * 一个可能多次重复元素的数组，然后找出给定值首次出现的下标，如果未出现返回-1
 */
public class FirstSubscript {

    /**
     * 整体思路：将元素和对应下标组成一对，不断的插入一个列表中生成一个有序列表，然后查询的时候使用二分查找
     *
     * 进阶思路：将元素和对应小标组成一对，维护一个红黑树，使用红黑树进行插入和查找
     */
    public static void main(String[] args) {
        int[] arr = new int[]{1,1,2,1,2,2,7,8,9,9,8,7};
        FirstSubscript fs = new FirstSubscript(arr);
        // 7首次出现下标 6
        int result1 = fs.queryFirstIndex(7);
        // 20未出现 -1
        int result = fs.queryFirstIndex(20);
    }

    private List<Entry> list = new ArrayList<>();

    public FirstSubscript(int[] arr) {
        for (int i = 0;i < arr.length;i++) {
            int val = arr[i];
            int li = 0;
            while (li < list.size() && list.get(li).val < val) {
                li++;
            }
            if (li >= list.size() || list.get(li).val != val) {
                if (li >= list.size()) {
                    list.add(new Entry(val,i));
                } else {
                    list.set(li,new Entry(val,i));
                }
            }
        }
    }

    /**
     * list进行二分查找
     */
    private int queryFirstIndex(int val) {
        int left = 0,right = list.size() - 1;
        while (left <= right) {
            int mid = (left + right) / 2;
            int tempVal = list.get(mid).val;
            if (tempVal == val) {
                return list.get(mid).index;
            } else if (tempVal > val) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        return -1;
    }

    private class Entry {
        int val;
        int index;

        Entry(int val,int index) {
            this.val = val;
            this.index = index;
        }
    }
}