如何写一个对数器

写一个比较对数器:

• 1.有一个你想要测得方法a;
• 2.实现一个绝对正确但复杂度不好的方法b,
• 3.实现一个比对方法
• 4.把方法a和方法b比对很多次来验证方法a是否正确
• 5.如果有一个样本是的比对出错，打印样本分析是哪个方法出错
• 6.当样本数量足够多且比对依然正确时，可以确定方法a已经正确

package Sort_learning;

import java.util.Arrays;

import javax.annotation.processing.Generated;
import javax.swing.text.DefaultEditorKit.CopyAction;

public class DuiShuQi {
	//写一个绝对正确的排序方法
	public static void rightMathod(int[] arr) {
		//Math.random() -> double [0,1]
		//(int)((size+1)*Math.random()) -> [0,size]整数
		//size = 6;size + 1 = 7;
		//Math.random() -> int
		//生成长度随机数组
		Arrays.parallelSort(arr);
	}
	//for test
	//随机发生器：产生的数组长度和大小都是随机的
	 public static int[] generateRandomArray(int size, int value) {
		int[] arr = new int[(int)((size + 1)*Math.random())];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (int) ((value + 1) * Math.random() - (int)(value * Math.random()));
			
		}
		return arr;
	}
	 public static void main(String[] args) {
		int testTime = 500000;//检测500000份样本
		int size = 10;
		int value = 100;
		boolean succeed = true;
		for(int i = 0; i < testTime; i++) {
			int[] arr1 = generateRandomArray(size, value);
			int[] arr2 = copyArray(arr1);
			int[] arr3 = copyArray(arr1);
			bubbleSort(arr1);//你想要检测的方法
			insertionSort(arr1);//你想要检测的方法
			rightMathod(arr2);//绝对正确的方法
			if(!isEqual(arr1, arr2)) {
				succeed = false;
				printArray(arr3);//如果不正确，输出不正确的数组
				break;
			}
		}
		System.out.println(succeed ? "Nice!" : "Fucking fucked!");//如果检测的方法正确，输出“Nice！”，否则，输出“Fucking fucked!”
		int[] arr = generateRandomArray(size, value);
		printArray(arr);
	}
	
	
	public static void insertionSort(int[] arr) {
		if(arr == null || arr.length < 2) {
			return;
		}
		for (int i = 1; i < arr.length ; i++) {     //注意：要从i=1开始插入，最终要把最后一个元素都插入
			for(int j = i -1; j >= 0 && arr[j] > arr[j+1]; j--) {
				
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				
			}
		}
	}
	public static void printArray(int[] arr) {
		if(arr == null) {
			return;
		}
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i] + " ");
		}
		
	}
	public  static boolean isEqual(int[] arr1, int[] arr2) { 
	    //根据是否为空集进行讨论
		if((arr1 == null && arr2 != null || (arr1 != null && arr2 == null)))
			return false;
		if(arr1 == null && arr2 == null)
			return true;
		//两者都非空时，首先考察长度，再考察对应的元素是否相等	
		if(arr1.length != arr2.length) 
			return false;
		for(int i = 0; i < arr1.length; i++) {
			if(arr1[i] != arr2[i]) 
				return false;
		}
		return true;
	}
	public static void bubbleSort(int[] arr) {
		for (int i = 1; i < arr.length-1; i++) {      //与插入排序不同，最后一次循环只剩下一个元素，就不需要对比啦！
			for (int j = 0; j < arr.length-i ; j++) {
				if(arr[j] > arr[j+1]) {
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
					
			}
			}
				
		}
			
			
	//数组的复制
	private static int[] copyArray(int[] arr) {
	//根据是否为空集进行讨论
		if(arr == null) {
			return null;
		}
		int[] res = new int[arr.length];   // 产生一个与arr数组相同长度、相同类型的数组空间
		for (int i = 0; i < arr.length; i++) {
			res[i] = arr[i];               //循环复制就OK啦！
		}
		return res;
	}
}

parallelSort

parallelSort是java8中新出的一种排序API，这是一种并行排序，Arrays.parallelSort使用了Java7的Fork/Join框架使排序任务可以在线程池中的多个线程中进行，Fork/Join实现了一种任务窃取算法，一个闲置的线程可以窃取其他线程的闲置任务进行处理。代码如下：

public static void parallelSort(int[] a, int fromIndex, int toIndex) {
    rangeCheck(a.length, fromIndex, toIndex);
    int n = toIndex - fromIndex, p, g;
    if (n <= MIN_ARRAY_SORT_GRAN ||
        (p = ForkJoinPool.getCommonPoolParallelism()) == 1)
        DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
    else
        new ArraysParallelSortHelpers.FJInt.Sorter
            (null, a, new int[n], fromIndex, n, 0,
             ((g = n / (p << 2)) <= MIN_ARRAY_SORT_GRAN) ?
             MIN_ARRAY_SORT_GRAN : g).invoke();
}

运行结果如下：

觉得写得不错的，点个关注，再点个赞，与你分享更多干货。