什么是对数器
回想一下，在刷题或者工作中，你是否遇到过一下情况：
1、在晚上找到心仪公司的面试题，尝试写出了code,但是找不到线上测试，而且你也不知道怎么测，你懵了
2、在网上做笔试，前几个测试用例都使用过了，突然来了巨大无比的测试用例，然后你的代码报错了，如此大的数据让你无从查找到底那一条数据导致的错误，你懵了
3、刚刚调优了一个功能，但是找不到测试用例数据，来测试你优化后的功能是否正确，你懵了
… … … …
面对这些情况，我们我从下手的时候，对数器就能起到作用了。那到底什么是对数器，说白了，对数期很简单。我们每完成一个功能或者算法，都会有不同的思路，而往往我们需要的是我们自认为找到了最优解的思路。假如完成一个功能我们能想到A,B两个思路，经过分析后，认为B思路是最优解的。那么我们怎么来确定这个最优解的思路到底对不对呢？我们可以随机产生数据样本，让思路A与思路B都计算并比对结果。当我们的样本数量足够大，且思路A与思路B的输出结果都一致时，我们就认为B思路是正确的。那么这个验证过程就是对数器
所以说对数器就是通过不同思路来校验最优解是否正确的过程，方法就是产生足够多的随机样本数，比对不同思路的输出是否一致，如果不一致，可以打印出来错误实验数据，针对这一条数据进行代码分析。
举例，首先先上code
code1
package net.csdn.test;
import java.util.Arrays;
public class TestDuiShuQi_MaoPaoSortCode {
public static void main(String[] args) {
//需要测试的次数
int testTime=500000;
//随机数组的长度范围
int maxLength=300;
//数组中每个数的取值范围（正负）
int maxValue=100;
//比对是否全部正确（默认是全部正确）
boolean succeed=true;
int[] errorArr=null;
for(int i=0;i<testTime;i++) {
System.out.println("*****************************测试次数："+(i+1));
int[] arr = generateRandomArray(maxLength, maxValue);
int[] copyArray = copyArray(arr);
selectSort(arr);
comparator(copyArray);
if(!isEqual(arr, copyArray)) {
succeed=false;
errorArr=arr;
break;
}
}
System.out.println(succeed?"Nice!!!":"Fucking fucked?->"+Arrays.toString(errorArr));
}
public static boolean isEqual(int[] arr,int[] copyArray) {
for(int i=0;i<arr.length;i++) {
if(arr[i]!=copyArray[i]) {
return false;
}
}
return true;
}
public static int[] generateRandomArray(int maxLength,int maxValue) {
int[] arr=new int[(int)(Math.random()*maxLength+1)];
for(int i=0;i<arr.length;i++) {
arr[i]=(int)(Math.random()*2*maxValue-maxValue);
}
return arr;
}
public static int[] copyArray(int[] arr) {
if(arr==null) {
return null;
}
int[] copyArr=new int[arr.length];
for(int i=0;i<arr.length;i++) {
copyArr[i]=arr[i];
}
return copyArr;
}
/**
* 与之比对的方法
* @param arr
*/
public static void comparator(int[] arr) {
Arrays.sort(arr);
}
public static void selectSort(int[] arr) {
if(arr==null||arr.length<2) {
return;
}
for(int i=0;i<arr.length-1;i++) {
for(int j=0;j<arr.length-(i+1);j++) {
if(arr[j]>arr[j+1]) {
swap(arr, j, j+1);
}
}
}
}
public static void swap(int[] arr,int i,int j) {
int tmp=arr[i];
arr[i]=arr[j];
arr[j]=tmp;
}
}
code1就是通过java自带的排序算法为冒泡排序创建了一个对数器，我们通过调整测试次数，随机数组的长度，随机数组的每个位置的数字，尽可能的测到边界值，并得到小概率的错误样本，通过打印这个小概率错误样本，我们接下来就可以针对性的进行代码分析，进一步优化。
二分法
去面试的时候经常会看到这样的题目：
1、在一个有序数组中找某一个数存在不存在
2、在一个有序数组中找到大于等于某个数的最左侧位置
3、在一个有序数组中找到小于等于某个数的最右侧位置
看到这样的问题，最容易想到的就是遍历整个数组，比如问题1，遍历整个数组，一个数一个数进行比较，考虑到最差的情况，数组中没有这个数字或者这个数字在最左边，那么这个算法的时间复杂度应该是O(N)。问题2和问题3也可以用这种遍历数组的方式去解决，时间复杂度也都是O(N)。
那么我们能不能换一个思路优化一下呢？我们可以使用二分法进行数据优化。什么是二分法呢？我们先来看问题1，因为数组是有序的，那么我们先看数组的(N-1)/2位置，如果该位置的数字正好等于给定数字就返回存在；如果该位置数字大于指定数字，那么我们就在0~(N-1)/2范围上继续查找；如果该位置数字小于指定数字，那么我们就在（N-1)/2 ~ (N-1)的范围上查找；查找的时候，重复上述步骤直至找到数字返回存在，或者最后剩余一个数字时还不等于指定数字返回不存在。
我们先举一个例子：在下面数组判断2是否存在
[1 ,3 ,5 ,7 ,9 ,11]
0 1 2 3 4 5
流程：
1、这个数组长度为6，我们先看（6-1）/2=2(java里int类型是向下取整)位置是否等于2，2位置是5，大于2
2、由于该位置比2大，所以看2/2=1位置上的数，这个位置上的数是3还是大于2
3、现在就该在0 ~ 1上找了，就剩0位置了，该位置是1，还是不等于2所以返回不存在
了解完流程，我们再看一下代码：
code2
package net.csdn.test;
public class TestFindNumInSortArr {
public static boolean isExit(int[] sortArr,int num) {
if(sortArr==null||sortArr.length==0) {
return false;
}
//控制左边边界
int L=0;
//控制右边边界
int R=sortArr.length-1;
while(L<R) {
int mid=L+((R-L)/2);//mid=(L+R)/2
if(sortArr[mid]==num) {
return true;
}else if(sortArr[mid]>num) {
R=mid-1;
}else {
L=mid+1;
}
}
return sortArr[L]==num;
}
}
注意代码里既然mid=L+((R-L)/2)等同于mid=(L+R)/2，那为什么不写成后面的呢？这是因为L+R可能会超出int类型的范围(-231 ~ 231-1),所以不能这么写。
看完流程和算法我们知道，每一次都需要将剩下的数组砍一半，然后再判断一下中点数字和指定数字大小，对于一个长度为N的数组，我们一共需要砍log2N次，每一次我们都是常数O(1)操作，所以时间复杂度是O(log2N)
接下来，我们看一下问题2和问题3的code
问题2：在一个有序数组中找到大于等于某个数的最左侧位置
code3
package net.csdn.test;
public class TestCode {
public static int test(int[] sortArr,int num) {
if(sortArr==null||sortArr.length==0) {
return 0;
}
//控制左边边界
int L=0;
//控制右边边界
int R=sortArr.length-1;
//记录最左位置
int index=-1;
while(L<=R) {
int mid=L+((R-L)>>1);//mid=(L+R)/2
if(sortArr[mid]>=num) {
index=mid;
R=mid-1;
}else {
L=mid+1;
}
}
return index;
}
}
code4
package net.csdn.test;
public class TestCode {
public static int test(int[] sortArr,int num) {
if(sortArr==null||sortArr.length==0) {
return 0;
}
//控制左边边界
int L=0;
//控制右边边界
int R=sortArr.length-1;
//记录最右位置
int index=-1;
while(L<=R) {
int mid=L+((R-L)>>1);//mid=(L+R)/2
if(sortArr[mid]<=num) {
index=mid;
L=mid+1;
}else {
R=mid-1;
}
}
return index;
}
}
想一下数组有序是所有问题求解使用二分查找的必要条件么？当然不是，只要能正确构建左右淘汰逻辑，就可以二分
扫一扫
1653
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
