一 将一个整数数组划分为K个相等的子集问题（字节跳动面试题）
题目：给定一个整数数组 nums 和一个正整数 k，找出是否有可能把这个数组分成 k 个非空子集，其总和都相等。
示例 1：
输入： nums = [4, 3, 2, 3, 5, 2, 1], k = 4
输出： True
说明： 有可能将其分成 4 个子集（5），（1,4），（2,3），（2,3）等于总和。
注意:
1
0 < nums[i] < 10000
前提：需要先明确一个问题，一个数组能够划分出 k 个和相等子集的前提是：这个数组的平均数必须是整数。
典型的递归问题：现在总的数组中找到一个子集，再在剩下的数组元素中找到一个子集...直到所有子集都找到，结束递归。
求解步骤：
1、先求出数组的平均数 avg，如果平均数 avg 不为整数，也就是说数组的数字总和不能平均的分为 k 份，那么直接返回 false；
2、创建一个布尔数组 flag，用来记录 nums 数组中数字的状态（已用还是未用）。 temp 的作用是记录当前子集的数字总和，temp 初始为 avg ，当 temp 等于 0 时，当前这个子集也就可以确定了。index 是用来记录遍历数组时从哪个位置开始遍历，以防将前面的数字重新计算。
3、当 temp = 0 的时候，也就是新一个子集求解完，那么继续求解下一个子集，k - 1，temp 重新置为 avg；当 temp ！= 0 时，就是子集还未求解完，那么继续求解子集，继续从数组中取数字，递归求解。
4、当 k 个子集全部求解完，返回 true，如果一直求解不出，则返回 false。
public class PartitionSubSets_698 {
public static boolean canPartitionKSubSets(int[] nums, int k){
int sum = 0;
int len = nums.length;
for(int i = 0; i < len; i++){
sum += nums[i];
}
if(sum % k != 0){
// 如果平均数不是整数，直接返回false
return false;
}
int avg = sum / k;
// 用于记录数组中的数据是否已经被使用，防止重复使用
boolean[] flag = new boolean[len];
return help(nums, flag, avg, k, avg, 0);
}
/**
* 判断能否将数组nums划分为k个和相等的子集
* @param nums ：数组
* @param flag ：使用标记
* @param avg ： 平均数
* @param k ：k 个子集
* @param temp ：也是平均数，这里用作记录子集的综合，等于0时，当前子集就确定了
* @param index ：记录遍历数组时从哪个位置开始遍历，以防将前面的数字重新计算
*/
public static boolean help(int[] nums, boolean[] flag, int avg, int k, int temp, int index){
if(k == 0){
// 说明已经k个子集都已经划分完成
return true;
}
// temp等于0说明当前子集求解完毕，继续求解下一个子集，k-1，temp重置为avg，下标index也重置为0
if(temp == 0){
return help(nums, flag, avg, k - 1, avg, 0);
}
// 当前子集划分未完成
for(int i = index; i < nums.length; i++){
if(flag[i] == true){
// 如果当前数字已经被使用了，就不能再次使用了，只能使用一次
continue;
}
flag[i] = true; // 使用
// 递归调用子过程，父过程是否为true，取决于子过程的结果
if(temp - nums[i] >= 0 && help(nums, flag, avg, k, temp - nums[i], index + 1)){
return true;
}
// 如果nums[i]不能使当前子集划分成功，需要释放掉，下次划分还可以使用
flag[i] = false;
}
return false;
}
public static void main(String[] args) {
int[] nums1 = {4, 3, 2, 3, 5, 2, 1};
int[] nums2 = {4, 3, 2, 3, 5, 2, 2};
System.out.println(canPartitionKSubSets(nums1, 4));
System.out.println(canPartitionKSubSets(nums2, 4));
}
}二 旋转数组的最小数字
题目：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如数组｛3，4，5，1，2｝为 {1, 2, 3, 4, 5} 的一个旋转，该数组的最小值为1。
这道题最直观的解法并不难，从头到尾遍历一次，我们就能找到最小的元素。这种思路的时间复杂度为O(n)。但是这个思路没有利用输入的旋转数组的特性，肯定达不到面试官的要求。
我们注意到旋转之后的数组实际上可以划分为两个排序的子数组，而且前面的子数组的元素都是大于或者等于后面子数组的元素。我们还注意到最小的元素刚好是这两个子数组的分界线。在排序的数组中我们可以利用二分查找来实现O（logn)的查找。本题给出的数组在一定程度上是排序的，因此我们可以试着用二分查找的思路来寻找这个最小的元素。
以前面的例子为例，我们先把第一个指针指向第0个元素，把第二个指针指向第4个元素，如图所示。位于两个指针中间（在数组的下标是2）的数字是5，它大于第一个指针指向的数字。因此中间数字5一定位于第一个递增字数组中，并且最小的数字一定位于它的后面。因此我们可以移动第一个指针让它指向数组的中间。
此时位于这两个指针中间的数字为1，它小于第二个指针指向的数字。因此这个中间数字为1一定位于第二个递增子数组中，并且最小的数字一定位于它的前面或者它自己就是最小的数字。因此我们可以移动第二个指针指向两个指针中间的元素即下标为3的元素。
此时两个指针的距离为1，表明第一个指针已经指向了第一个递增子数组的末尾，而第二个指针指向第二个递增子数组的开头。第二个子数组的第一个数字就是最小的数字，因此第二个指针指向的数字就是我们查找的结果。
上述方法是否就一定够完美了呢？面试官会告诉你其实不然。他将提示我们再仔细分析小标leftIndex和rightIndex分别和途中P1和P2相对应）的两个数相同的情况。在前面，当着两个数相同，并且它们中间的数相同的也相同时，我们把IndexMid赋给了leftIndex，也就是认为此时最小的数字位于中间数字的后面。是不是一定一样？
我们再来看一个例子。数组｛1，0，1，1，1｝和数组｛1，1，1，0，1｝都可以堪称递增排序数组｛0，1，1，1，1｝的旋转，图2分别画出它们由最小数字分隔开的两个子数组。
这两种情况中，第一个指针和第二个指针指向的数字都是1，并且两个指针中间的数字也是1，这3个数字相同。在第一种情况中，中间数字（下标为2)位于后面是子数组；在第二种情况中，中间数字（下标为2）位于前面的子数组中。因此，当两个指针指向的数字及它们中间的数字三者相同的时候，我们无法判断中间的数字是位于前面的子数组中还是后面的子数组中，也无法移动两个指针来缩小查找的范围。此时，我们不得不采用顺序查找的方法。
综合以上各种情况的讨论，查找旋转数组的最小数字的代码实现如下所示：
public class MinNumInRotatedArray {
public int minNumInRotatedArray(int[] arr){
if(arr == null){
return -1;
}
int leftIndex = 0;
int rightIndex = arr.length - 1;
// 将midIndex初始化为leftIndex，是考虑到数组将前面0个元素搬移到后面
// 即数组本身是数组选择的一个特例，此时：最小元素即为下标为0的元素
int midIndex = leftIndex;
// 循环终止条件
while(arr[leftIndex] >= arr[rightIndex]){
if(rightIndex - leftIndex <= 1){
midIndex = rightIndex; // 右边指针是小的元素值
break;
}
// 如果leftIndex、rightIndex 和 midIndex 指向的三个数字相等，则只能使用顺序查找
midIndex = (leftIndex + rightIndex) / 2;
if(arr[leftIndex] == arr[midIndex] && arr[midIndex] == arr[leftIndex]){
return MinInOrder(arr, leftIndex, rightIndex);
}
// 每次比较，区间都会减小一半：体现了二分查找的思想
if(arr[midIndex] >= arr[leftIndex]){
// 说明：中间值在左边递增数组
leftIndex = midIndex;
}else if(arr[midIndex] <= arr[rightIndex]){
// 说明：中间值在右边递增数组
rightIndex = midIndex;
}
}
return arr[midIndex];
}
// 顺序查找
private int MinInOrder(int[] arr, int leftIndex, int rightIndex) {
int min = arr[leftIndex];
for (int i = 0; i < rightIndex; i++) {
if(min > arr[i]){
min = arr[i];
}
}
return min;
}
// 测试
public static void main(String[] args) {
MinNumInRotatedArray min = new MinNumInRotatedArray();
int[] arr = {3, 4, 5, 1, 2};
System.out.println(min.minNumInRotatedArray(arr));
int[] arr1 = {1};
System.out.println(min.minNumInRotatedArray(arr1));
int[] arr2 = {2, 2, 2, 2, 0, 1, 2};
System.out.println(min.minNumInRotatedArray(arr2));
int[] arr3 = null;
System.out.println(min.minNumInRotatedArray(arr3));
}
}三 二维数组中的查找
题目：在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。 请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
规律：
首先选取数组中右上角的数字。
如果该数字等于要查找的数字，查找过程结束。
如果该数字大于要查找的数字，剔除这个数字所在的列；
如果该数字小于要查找的数字，剔除这个数字所在的行。
也就是说如果要查找的数字不在数组的右上角，则每一次都在数组的查找范围中剔除行或者列，这样每一步都可以缩小查找范围，直到要查找的数字，或者查找范围为空。
public class FindNumAtMatrix {
public static boolean find(int[][] arr, int number){
if(arr == null){
return false;
}
// 选取数组查找范围内的右上角数字
int column = arr[0].length - 1; // 列号
int row = 0; // 行号
while(row < arr.length && column >= 0){
if(arr[row][column] == number){
return true;
}else if(arr[row][column] > number){
// 如果当前数小于查找范围的右上角元素时，
// 则说明它在查找范围的左边，删除当前列
column--;
}else{
// 如果当前数大于查找范围的右上角元素时，
// 则说明它在查找范围的下边，删除当前行
row++;
}
}
return false;
}
public static void main(String[] args) {
int[][] array = new int[4][4];
array[0][0] = 1;
array[0][1] = 2;
array[0][2] = 8;
array[0][3] = 9;
array[1][0] = 2;
array[1][1] = 4;
array[1][2] = 9;
array[1][3] = 12;
array[2][0] = 4;
array[2][1] = 7;
array[2][2] = 10;
array[2][3] = 13;
array[3][0] = 6;
array[3][1] = 8;
array[3][2] = 11;
array[3][3] = 15;
System.out.println(find(array,6));
}
}四 数组中的重复数字
题目1：找出数组中重复的数字
在一个长度为n的数组里的所有数字都在0到n-1的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。例如，如果输入长度为7的数组{2, 3, 1, 0, 2, 5, 3}，那么对应的输出是重复的数字2或者3。
解题思路：
从哈希表的思路拓展，重排数组：从头到尾依次扫描这个数组中的每个数字。当扫描到下标为 i 的数字时，首先比较这个数字 m 是不是等于器下标 i 。如果是，则接着扫描下一个数字；如果不是，则再拿它和下标为 m 位置上的元素进行比较，如果相等，则找到了一个重复的数字，因为该数字在下标为 i 和 m 的位置上都出现了；如果不相等，则就把下标为 i 的元素和 下标为 m 的元素交换，把 m 放到属于它的位置上，然后每个位置上的元素依次重复这个过程。
测试用例：
1、数组中带一个或多个重复数字；
2、数组中不包含重复的数字；
3、无效输入测试用例（空数组，数组数字越界等）。
/**
* 找出数组中任意一个重复的数字
*/
public class FindRepeatNum {
/**
* @param nums ：数组
* @param length ：数组的长度
* @param duplication ：用来记录重复元素的数组
* @return
*/
public static boolean duplicate(int nums[], int length, int[] duplication) {
if (nums == null || length <= 0) {
return false;
}
for (int a : nums) {
if (a < 0 || a >= length) {
return false;
}
}
int temp;
for (int i = 0; i < length; i++) {
// 下标为 i 位置上的元素值不为 i
while (nums[i] != i) {
// 判断下标为 nums[i] 位置上的元素值是否为 nums[i]
if (nums[nums[i]] == nums[i]) {
// 如果下标为nums[i]上的值等于nums[i]，则说明数字重复
duplication[0] = nums[i];
return true;
}
// 将下标为 i 和下标为 nums[i] 位置上的元素交换位置
temp = nums[i];
nums[i] = nums[temp];
nums[temp] = temp;
}
}
return false;
}
// 测试用例
public static void test1() {
System.out.print("test1:");
int[] a = { 1, 2, 3, 4 };
int[] dup = new int[a.length];
boolean result = duplicate(a, a.length, dup);
System.out.println(result);
}
// 测试用例
public static void test2() {
System.out.print("test2:");
int[] a = { 1, 2, 3, 4, 2};
int[] dup = new int[a.length];
boolean result = duplicate(a, a.length, dup);
System.out.println(result);
}
public static void main(String[] args) {
test1(); // false
test2(); // true
}
}代码中尽管有一个两重循环，但是每个数字最多只需要交换两次就能找到属于它的位置，因此总的时间复杂度是O(n)。另外，所有的操作步骤都是在输入数组上进行的，不需要额外分配内存，空间复杂度为O(1)。
题目2：不修改数组找出重复的数字
在一个长度为n+1的数组里的所有数字都在1~n的范围内，所以数组中至少有一个数字是重复的。请找出数组中任意一个重复的数字，但是不能修改输入的数组。例如，如果输入长度为8的数组{2,3,5,4,3,2,6,7}，那么对应的输出是重复的数字2或者3。
题目2和题目1的区别就是：不能修改输入的数组，下面提供两种解题思路。
思路1
由于不能修改输入的数组，我们可以创建一个长度为 n+1 的辅助数组，然后逐一把原数组的每个数字复制到辅助数组。如果原数组中被复制的数字是m，则把它复制到辅助数组中下标为m的位置。如果下标为m的位置上已经有数字了，则说明该数字重复了。由于使用了辅助空间，故该方案的空间复杂度是O(n)。
public class FindRepeatNum1 {
public int getDuplication(int arr[]){
int[] tempArr = new int[arr.length];
for(int i = 0; i < arr.length; i++){
if(arr[i] < 0 || arr[i] >= arr.length){
throw new IllegalArgumentException("输入参数不合法");
}else{
tempArr[i] = -1;
}
}
for(int i = 0; i < arr.length; i++){
if(tempArr[arr[i]] != arr[i]){
// 如果tempArr数组上下标为 arr[i]位置上的元素值不等于 arr[i]
tempArr[arr[i]] = arr[i];
}else{
// 相等，则说明元素重复了
return arr[i];
}
}
return -1; // 没有重复的元素
}
public static void main(String[] args) {
FindRepeatNum1 findRepeatNum = new FindRepeatNum1();
int[] arr = {2,3,5,4,3,2,6,7};
int value = findRepeatNum.getDuplication(arr);
System.out.println(value); // 3
}
}思路2
由于思路1的空间复杂度是O(n)，因此我们需要想办法避免使用辅助空间。我们可以想：如果数组中有重复的数，那么n+1个1~n范围内的数中，一定有几个数的个数大于1。那么，我们可以利用这个思路解决该问题。
我们把从1~n的数字从中间的数字m分为两部分，前面一半为1~m，后面一半为m+1~n。如果1~m的数字的数目等于m，则不能直接判断这一半区间是否包含重复的数字，反之，如果大于m，那么这一半的区间一定包含重复的数字；如果小于m，另一半m+1~n的区间里一定包含重复的数字。接下来，我们可以继续把包含重复的数字的区间一分为二，直到找到一个重复的数字。
由于如果1~m的数字的数目等于m，则不能直接判断这一半区间是否包含重复的数字，我们可以逐步减少m，然后判断1~m之间是否有重复的数，即，我们可以令m=m-1，然后再计算1~m的数字的数目是否等于m，如果等于m，再令m=m-1，如果大于m，则说明1~m的区间有重复的数，如果小于m，则说明m+1~n有重复的数，不断重复此过程。
public class FindRepeatNum3 {
public int getDuplication(int[] arr){
for(int i = 0; i < arr.length; i++){
if(arr[i] < 0 || arr[i] >= arr.length){
throw new IllegalArgumentException("参数输入不合法");
}
}
int start = 0;
int end = arr.length - 1;
int flag = 0; // 有无重复元素的标识
int middle = 0;
while(end >= start){
if(flag == 0){
middle = (end + start) / 2;
}
int count = countRange(arr, start, middle);
if(end == start){
if(count > 1){
// 说明 end 和 start 位置上的元素值相等
return start;
}else{
break;
}
}
if(count > (middle - start + 1)){
// 说明（start, middle）这个区间有重复的数
end = middle;
flag = 0;
}else if(count == (middle - start + 1)){
middle = middle - 1; // 缩小区间
if(middle < start){
// 说明(start,middle)这个区间没有重复的数
start = (start + end) / 2 + 1;
flag = 0;
}else{
flag = 1;
}
}else{
// 说明(middle+1,end)这个区间有重复的数
start = middle + 1;
flag = 0;
}
}
return -1;
}
// 统计元素值在[start,end]区间中的个数
private int countRange(int[] arr, int start, int end) {
int count = 0;
for (int i = 0; i < arr.length; i++) {
if(arr[i] >= start && arr[i] <= end){
++count;
}
}
return count;
}
// 测试
public static void main(String[] args) {
FindRepeatNum3 findRepeatNum = new FindRepeatNum3();
int[] arr = {0,3,5,4,1,2,6,7,6};
int value = findRepeatNum.getDuplication(arr);
System.out.println(value);
}
}上述代码按照二分查找的思路，如果输入长度为n的数组，那么函数countRange最多将被调用O(logn)次，每次需要O(n)的时间，因此总的时间复杂度是O(nlogn)。但是如果区间无重复的数，则时间复杂度将变为O()。
总结
从上诉分析我们可以看出，如果面试官提出不同的功能需求（找出任意一个重复的数字、找出所有重复的数字）或者性能要求（时间效率优先、空间效率优先），那么我们最终选取的算法也将不同。这也说明在面试中和面试官交流的重要性，我们一定要动手写代码之前弄清楚面试官的需求。
五 找出数组中只出现一次的那个数，其他都出现两次【字节跳动面试题】
要求：时间复杂度O(N)、空间复杂度O(1)
分析：
任何一个数字异或自己都等于 0。
如果我们从头到尾依次异或数组中的每一个数，那么最终的结果就是那个只出现一次的数字，因为其他出现两次的数字全部在异或中被抵消为 0 了。
异或运算遵循交换分配率，举个栗子：2 3 4 2 3
所有数字依次异或运算：2 xor 3 xor 4 xor 2 xor 3 = (2 xor 2) xor (3 xor 3) xor 4= 0 xor 0 xor 4 = 4
最终结果 4 就是我们要找的那个只出现一次的数字
public class FindOnlyAppearOnce {
public static int findOnlyAppearOnce(int[] arr){
if(arr == null || arr.length == 0){
return Integer.MIN_VALUE;
}
int res = arr[0];
for(int i = 1; i < arr.length; i++){
res ^= arr[i];
}
return res;
}
public static void main(String[] args) {
int[] arr = {1, 1, 2, 2, 3};
System.out.println(findOnlyAppearOnce(arr)); // 3
}
}扩展 1：
数组 A 中，除了某一个数字 x 之外，其他数字都出现了三次，而 x 出现了一次。请给出最快的方法找到 x。应该如何思考呢？
如果是两个相同的就可以利用两个相同的数异或结果为 0 来计算的，但这个题目中其他数字是出现了 3 次，因此肯定不可以再使用异或了。我们换一个角度来看，如果数组中没有 x，那么数组中所有的数字都出现了 3 次，在二进制上，每位上 1 的个数肯定也能被 3 整除。如 {1, 5, 1, 5, 1, 5} 从二进制上看有：
1：0001
5：0101
1：0001
5：0101
1：0001
5：0101
二进制第 0 位上有 6 个 1，第 2 位上有 3 个 1。第 1 位和第 3 位上都是 0 个 1，每一位上的统计结果都可以被 3 整除。而再对该数组添加任何一个数，如果这个数在二进制的某位上为 1 都将导致该位上 1 的个数不能被3整除。因此通过统计二进制上每位 1 的个数就可以推断出 x 在该位置上是 0 还是 1 了，这样就能计算出 x 了。
推广一下，所有其他数字出现 N（N >= 2）次，而一个数字出现1次都可以用这种解法来推导出这个出现 1 次的数字。
public class FindOnlyAppearOnce {
public static int findOnlyOccurOnce(int[] arr){
if(arr == null || arr.length == 0){
return Integer.MIN_VALUE;
}
int[] bits = new int[32];
// 所有位置上的元素都初始化为0
Arrays.fill(bits,0);
for(int i = 0; i < arr.length; i++){
for(int j = 0; j < 32; j++){
// 统计每个位置上1的个数
bits[j] += ((arr[i] >> j) & 1);
}
}
// 如果某个位置上1的总数不能被3整除，那么目标数一定在这个位置上
int res = 0;
for(int i = 0; i < 32; i++){
if(bits[i] % 3 != 0){
res += (1 << i);
}
}
return res;
}
}扩展：2
一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。要求时间复杂度是 O(N)，空间复杂度是 O(1)
分析：数组里包含了两个只出现一次的数字，那么所有数字依次异或的结果就是这两个只出现一次的数字的异或结果。我们要想办法利用这个异或结果，把数组分为两个子数组，一个子数组包含一个只出现一次的数字，另一个数组包含另一个只出现一次的数字。由于这两个只出现一次的数字肯定不相等，那么这个异或结果肯定不为0，也就是说在这个结果数字的二进制表示中至少就有一位为1。我们在结果数字中找到第一个为1的位的位置，记为第N位。现在我们以第N位是不是1为标准把原数组中的数字分成两个子数组，第一个子数组中每个数字的第N位都为1，而第二个子数组的每个数字的第N位都为0。
举个栗子：1 2 3 4 2 3
所有数字异或结果 = 1 xor 4
二进制表示为： 001
xor 100
_______
101
异或结果的二进制位101，第一个为1的位的位置N=1。
那么，数组所有数的二进制表示中，第N(N=1)位为1的的数为1 3 3，第N(N=1)位为0的的数为2 2 4.
这样就把原数组拆分为两个子数组，1和4被分到不同的数组中去了。然后分别在两个子数组中找只出现一次的那个数。
void FindNumsAppearOnce(int data[], int length, int &num1, int &num2)
{
if (length < 2)
return;
// get num1 ^ num2
int resultExclusiveOR = 0;
for (int i = 0; i < length; ++ i)
resultExclusiveOR ^= data[i];
// get index of the first bit, which is 1 in resultExclusiveOR
unsigned int indexOf1 = FindFirstBitIs1(resultExclusiveOR);
num1 = num2 = 0;
for (int j = 0; j < length; ++ j)
{
// divide the numbers in data into two groups,
// the indexOf1 bit of numbers in the first group is 1,
// while in the second group is 0
if(IsBit1(data[j], indexOf1))
num1 ^= data[j];
else
num2 ^= data[j];
}
}
// Find the index of first bit which is 1 in num (assuming not 0)
unsigned int FindFirstBitIs1(int num)
{
int indexBit = 0;
while (((num & 1) == 0) && (indexBit < 32))
{
num = num >> 1;
++ indexBit;
}
return indexBit;
}
// Is the indexBit bit of num 1?
bool IsBit1(int num, unsigned int indexBit)
{
num = num >> indexBit;
return (num & 1);
}
7640
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
