1、排序
排序：所谓排序就是使一连串记录，按照其中某个或某个关键字的大小，递增或递减的排列起来的操作。
稳定性：假定在待排序记录序列中存在有多个具有相同关键字的记录，若经过排序这些记录的相对次序保持不变，即原序列中，r[i]=r[j],且r[i]在r[j]之前，而在排序后的序列中，r[i]仍然在r[j]之前，则称这种算法是稳定的；否则不稳定
内部排序：数据元素全部放在内存中的排序
外部排序：数据元素太多不能同时放在内存中，根据排序过程要求不能在内外存之间移动数据的排序
以下是常见排序算法的实现
2、插入排序
*基本思想：直接插入排序是一种简单的插入排序，其基本思想是，把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列
(1)首先看第一个数，将数组划分为有序和无序，-----首先看第一个数2，一个数必然有序，所以将2划分为有序，后面都是无序
(2)无序部分的首个插入到有序部分，-----取出无序部分的首个，在有序部分从后向前进行比较，插入到合适位置
(3)重复第二部直到无序部分去拿不插入有序序列，-----8也是依次比较就可以插入
3就需要多次比较，注意是多次比较，直接插入，不是比较一次就插入一次（与冒泡不同）
*首先要有两个元素去比较，让i=1，j=i-1;
*记录i下标的值
*j下标的值与temp去比较，如果j下标的值比temp大，把j下标的值移动到j+1位置 j--
*最后把temp放在j+1的位置
2.1、直接插入排序特性总结：
*元素集合越接近有序，直接插入排序算法的时间效率越高
*时间复杂度：O(n^2)
*空间复杂度：O(1)
稳定性：稳定
/**
* 插入排序
* 时间复杂度O(n^2),已经有序的情况下为O(n)
* 空间复杂度O(1)
* 稳定性：稳定
* @param array
*/
public static void insertSort(int[] array){
for (int i = 0; i < array.length; i++) {
//保存i下标的值
int temp=array[i];
//指定j下标为i-1
int j=i-1;
//一直遍历到数组开头
while(j>=0){
//比较i和j位置的值，如果j下标的值小于i下标的值，说明有序
if(array[j]<=array[i]){
break;
}
//移动j的值到j+1
array[j+1]=array[i];
j--;
}
//把temp的值放到j+1
array[j+1]=temp;
}
}
//测试插入排序运行时间
public static void TestInsertSort(int[] array){
//记录开始时间
long begin=System.currentTimeMillis();
insertSort(array);
//记录结束时间
long end=System.currentTimeMillis();
System.out.println("插入排序耗时--->"+(end-begin));
}3、希尔排序：
希尔排序又称缩小增量法。希尔排序的基本思想是：把记录下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量的逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件就恰好分成一组，算法终止
3.1、希尔排序算法特性总结
*希尔排序是对直接插入排序算法的优化
*当gap！=1时都是预排序，目的是让数组更接近于有序。当gap=1时，数组已经接近有序了，这样就会很快。这样整体而言就会达到优化的效果
*希尔排序的时间复杂度不好计算，因为gap的取值方法有很多，导致很难去计算，因此希尔排序的时间复杂度都不固定
*稳定性：不稳定
/**
* 希尔排序
* 时间复杂度：O(N^1.25)~O(N^1.5)
* 稳定性:不稳定
* 空间复杂度O(1)
* @param array
*/
public static void shellSort(int[] array){
//1、确定gap的值
int gap=array.length;
//2、开始循环
while(gap>0){
shell(array,gap);
gap/=2;
}
}
private static void shell(int[] array, int gap) {
//从gap位置进行遍历
for (int i = gap; i <array.length ; i++) {
//用temp保存i的值
int temp=array[i];
//内层循环之前，先定义j的值
int j=i-gap;
//开始循环
while(j>=0){
//比较j和i的值
if(array[j]<=array[i]){
break;
}
//移动j的值到j+gap
array[j+gap]=array[j];
j-=gap;
}
//最后将temp放到对应位置
array[j+gap]=temp;
}
}
//测试插入排序运行时间
public static void TestShellSort(int[] array){
//记录开始时间
long begin=System.currentTimeMillis();
shellSort(array);
//记录结束时间
long end=System.currentTimeMillis();
System.out.println("希尔排序耗时--->"+(end-begin));
}4、选择排序
每一次从待排序的数据元素中选取最小的或最大的一个元素，，存放在序列的其实位置，直到全部待排序的数据元素排完
4.1、直接选择排序的特性总结
*直接选择排序非常好理解，但是效率不是很高，实际中应用很少
*时间负责度O(n^2)
*空间复杂度O(1)
*稳定性：不稳定
/**
* 直接选择排序1
* 时间复杂度:O(n^2)
* 空间复杂度O(1)
* 稳定性：不稳定
* @param array
*/
public static void selectSort1(int[] array){
//1、从0下标开始往后遍历
for (int i = 0; i < array.length; i++) {
//2、记录最小值下标，默认最小值下标是i
int minIndex=i;
//3、从i+1下标开始往后遍历
for (int j = i+1; j < array.length; j++) {
//4、如果还能够找到比minIndex还小的值，更新下标
if(array[j]<array[minIndex]){
minIndex=j;
}
}
//5、交换minIndex和i的元素
swap(array,minIndex,i);
}
}
//交换数组元素
private static void swap(int[] array, int minIndex, int i) {
int temp=array[minIndex];
array[minIndex]=array[i];
array[i]=temp;
}
//测试直接选择排序1运行时间
public static void TestSelectSort1(int[] array){
//记录开始时间
long begin=System.currentTimeMillis();
selectSort1(array);
//记录结束时间
long end=System.currentTimeMillis();
System.out.println("直接选择排序1耗时--->"+(end-begin));
}
4.2算法优化-一次遍历同时找到最大值和最小值
/**
* 直接选择排序2
* 时间复杂度:O(n^2)
* 空间复杂度:O(1)
* 稳定性:不稳定
* @param array
*/
public static void selectSort2(int[] array){
//1、定义数组边界
int left=0;
int right=array.length-1;
//进入循环
while(left<right){
//2、定义最小值和最大值下标
int minIndex=left;
int maxIndex=left;
for (int i = left+1; i <right; i++) {
//3、如果i下标的值比最小值下标的值还小，那么更新最小值下标
if(array[i]<array[minIndex]){
minIndex=i;
}
//4、如果i下标的值比最大值下标的值还大，那么更新最大值下标
if(array[i]>array[maxIndex]){
maxIndex=i;
}
}
//5、每次遍历完之后，left和minIndex交换
if(left!=minIndex){
swap(array,left,minIndex);
}
//6、修正最小值和最大值重复交换的问题
if(left==maxIndex){
maxIndex=minIndex;
}
//7、right和maxIndex交换
if(right!=maxIndex){
swap(array,right,maxIndex);
}
//8、移动left和right
left++;
right--;
}
}
//测试直接选择排序2运行时间
public static void TestSelectSort2(int[] array){
//记录开始时间
long begin=System.currentTimeMillis();
selectSort2(array);
//记录结束时间
long end=System.currentTimeMillis();
System.out.println("直接选择排序2耗时--->"+(end-begin));
}5、堆排序
堆排序是指利用堆这种数据结构所设计的一种排序算法，它是选择排序的一种，它是通过堆来进行选择数据。排升序要建大堆，排降序要建小堆
（1）根据数组创建堆
（2）按照删除元素的逻辑，第一个下标的元素最后一个下标的元素交接
（3）从根节点向下调整这棵二叉树
（4）从后一个节点一调排序到根节点
/**
* 堆排序
* 时间复杂度:O(nlog(n))
* 空间复杂度:O(1)
* 稳定性:不稳定
* @param array
*/
public static void HeapSort(int[] array){
//1、首先要建一个堆
creatHeap(array);
//2、确定终止下标
int end=array.length;
while(end>=0){
//3、首尾交换
swap(array,0,array.length-1);
//4、向下调整
shiftDown(array,0,end);
//5、修正end的值
end--;
}
}
private static void shiftDown(int[] array, int parent, int length) {
//定义左孩子节点
int child=2*parent+1;
//循环处理，判断是否越界
while(child<parent){
//判断是否有右孩子节点
if(child+1<length){
//判断左右孩子的大小,右孩子节点大，就选右孩子节点下标
if(array[child]<array[child+1]){
child++;
}
}
//孩子节点与父节点进行比较
if(array[child]<=array[parent]){
break;
}
//交换父子下标值
swap(array,parent,child);
//重置父子节点下标
parent=child;
child=2*parent+1;
}
}
/**
* 建堆
* @param array
*/
private static void creatHeap(int[] array) {
//找到最后一个不为0的节点
for (int parent = (array.length-2)/2; parent>=0 ; parent--) {
shiftDown(array,parent,array.length);
}
}
//测试堆排序运行时间
public static void TestHeapSort(int[] array){
//记录开始时间
long begin=System.currentTimeMillis();
HeapSort(array);
//记录结束时间
long end=System.currentTimeMillis();
System.out.println("堆排序耗时--->"+(end-begin));
}6、冒泡排序
重复扫描待排序序列，并比较每一对相邻的元素，当该队元素顺序不正确时的进行交换。一直重复这个过程，直到没有任何两个元素可以交换，叫表明完成了排序
6.1、冒泡排序特性总结：
*冒泡排序是一种非常容易理解的排序
*时间复杂度：O(N^2)
*空间复杂度：O(1)
*稳定性：稳定
/**
* 冒泡排序
* 时间复杂度:O(n^2)
* 空间复杂度:O(1)
* 稳定性:稳定
* @param array
*/
public static void bubbleSort(int[] array){
for (int i = 0; i < array.length-1; i++) {
boolean flag=false;
for (int j = i; j <array.length-1 ; j++) {
if(array[j]>=array[j+1]){
swap(array,j,j+1);
//如果交换了数组元素下标，flag置反
flag=true;
}
}
//没有参与比较，说明已经有序了
if(!flag){
break;
}
}
}
//测试堆排序运行时间
public static void TestBubbleSort(int[] array){
//记录开始时间
long begin=System.currentTimeMillis();
bubbleSort(array);
//记录结束时间
long end=System.currentTimeMillis();
System.out.println("冒泡排序耗时--->"+(end-begin));
}7、快速排序
任取待排序序列中的某元素作为基准值，按照该排序码将待排序序列集合分割成两个子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后左右子序列重复该过程，直到所有元素都排列到相应的位置
(1)它是一个运用了二叉树结构进行的一排序，那么就要分割左右区段
(2)要有一个基准值，这个基准值左边都是小于这个值的元素，右边都是大于这个值的元素
重点;如何去找这个基准值
*首先让left=0，right=array.length-1
*以left下标的值为默认基准值
*right向左移动，找到比基准值小的停下来
*left向右移动，找到比基准值大的停下来
*left与right交换
*当left与right相遇的时候，让提前记录好的基准与相遇点进行交换
*返回相遇点的下标，这个下标就是基准
/**
* 快速排序
* 时间复杂度:O(N*logN)
* 空间复杂度:O(logN)
* 稳定性:不稳定
* @param array
*/
public static void quickSort(int[] array){
quickProcessSort(array,0,array.length-1);
}
private static void quickProcessSort(int[] array, int left, int right) {
//1、终止条件
if(left<right){
return;
}
//============用插入法优化树的倒数低N层===============
if(right-left<5){
InsertSort(array,left,right);
return;
}
//=============三数取中法优化栈溢出问题===============
int middle=middleValue(array,left,right);
//与left交换
swap(array,left,middle);
//2、在区段中找基准
int point=partitionHoare(array,left,right);//Hoare找基准
//int point=partitionHole(array,left,right);//挖坑法找基准
//int point= partitionPoint(array,left,right);//快慢指针法
//3、根据基准处理左区段跟右区段
quickProcessSort(array ,left,point-1);
quickProcessSort(array,point+1,right);
}
//测试快速排序运行时间
public static void TestQuickSort(int[] array){
//记录开始时间
long begin=System.currentTimeMillis();
quickSort(array);
//记录结束时间
long end=System.currentTimeMillis();
System.out.println("快速排序耗时--->"+(end-begin));
}
7.1、挖坑法找基准
*left下标的值当作基准值，这时left的位置就空出来了
*right向左移动，找到比基准值还要小的值，放到left位置
*left向右移动，找到比基准值还要大的值，放到right位置
*当left和right相遇时，把之前记录的基准值放到相遇的下标
*返回相遇点下标，这就是基准的下标
private static int partitionHole(int[] array, int left, int right) {
//默认基准值下标为left
int pointValue=array[left];
//left和right不相遇循环
while(left<right){
//从右边找比基准值更小的
if(left<right&&array[right]>=pointValue){
//right向左移
right--;
}
//把right下标放到left下标上面
array[left]=array[right];
//从左边找比基准值更大的
if(left<right&&array[left]<=pointValue){
//left右移
left++;
}
//把left下标放到right下标上面
array[right]=array[left];
}
//当left和right下标相遇时，将基准值放到相遇点
array[left]=pointValue;
//返回基准值
return left;
}7.2、快慢指针法找基准
/**
* 快慢指针法找基准值
* @param array
* @param left
* @param right
* @return
*/
private static int partitionPoint(int[] array, int left, int right) {
//定义两个变量
int prev=left;
int current=left+1;
while(current<right){
//current下标的值小于基准值
if(array[current]<array[left]){
prev++;
if(array[current]!=array[prev]){
swap(array,current,prev);
}
}
//current向后移动
current++;
}
//遍历完成之后，prev与基准下标交换
swap(array,left,prev);
//返回prev下标
return prev;
}7.3、Hoare法找基准
/**
* Hoare找基准值
* @param array
* @param left
* @param right
* @return
*/
private static int partitionHoare(int[] array, int left, int right) {
//1、默认left为基准值
int pointValue=array[left];
//2、记录基准值的下标
int pointIndex=left;
//left和right不相遇时进行循环处理
while(left<right){
//让right向右移动，找到比right小的停下来，注：必须先右移而不能先左移
while(left<right&&array[right]>=pointValue){
//移动right下标
right--;
}
//让left向左移动，找到比left大的停下来，注：等号不能省略
while(left<right&&array[left]<=pointValue){
//移动left下标
left++;
}
//交换left和right的值
swap(array,left,right);
}
//更新基准值为相遇值
swap(array,left,pointIndex);
//返回相遇点的下标
return left;
}
7.4、解决栈溢出问题-三数取中法
*以数组最左边和最右边的值作为基准
*根据最左边和最右边的下标，找到数组中间的下标
*以左下标、中间下标和右下标对应的值，在这三个值中找到中间大小的那个值
/**
* 三数取中法
* 解决快速排序中栈溢出问题
* @param array
* @param left
* @param right
* @return
*/
private static int middleValue(int[] array, int left, int right) {
//找出数组中间下标
int mid=(left+right)/2;
//开始处理核心逻辑
if(array[left]<array[right]){
//left下标值小于right下标值
if(array[mid]<array[left]){
//中间的值比最小的还要小，返回left
return left;
}else if(array[mid]>array[right]){
//中间的值比最大的还要大，返回right
return right;
}else{
//中间值在left和right中间，返回mid
return mid;
}
}else{
//left下标值大于right下标值
if(array[mid]>array[left]){
//中间值比最大的还要大，返回left
return left;
}else if(array[mid]<array[right]){
//中间值比最小的还要小，返回right
return right;
}else{
//中间值在left和right中间，返回mid
return mid;
}
}
}7.5、用插入法优化树的倒数低N层
/**
* 针对数组的某一个区段，插入排序
* @param array
* @param left
* @param right
*/
private static void InsertSort(int[] array, int left, int right) {
for (int i = left+1; i <right ; i++) {
//保存i的值
int temp=array[i];
//内层循环,先指定j的下标为i-1
int j=i-1;
//一直遍历到数组开头
while(i>left){
//如果i下标的值小于temp,说明前面都有序
if(array[i]<temp){
break;
}
//移动j的值到j+1位置
array[j+1]=array[j];
i--;
}
//把temp的值放到i+1位置
array[i+1]=temp;
}
}8、快速排序--迭代
/**
* 快速排序迭代法
* 迭代的方式，快速排序
* @param array
*/
public static void quickSort2(int[] array){
quickProcessSort2(array,0,array.length-1);
}
private static void quickProcessSort2(int[] array, int left, int right) {
//1、定义一个栈用来记录左右区段的左右下标值
Stack<Integer> stack=new Stack<>();
//===========2、用插入排序优化，树的倒数N层开始===========
if(right-left+1<=5){
swap(array,left,right);
return;
}
//===========用插入排序优化，树的倒数N层完成===========
//=============3、三数取中法优化栈溢出问题===============
int middle=middleValue(array,left,right);
//与left交换
swap(array,left,middle);
//4、在区段中找基准
int point=partitionHoare(array,left,right);//Hoare找基准
//5、左右区段分别入栈
if(left+1<point){
//入栈左下标
stack.push(left);
//入栈右下标
stack.push(point-1);
}
if(right-1>point){
//入栈右区段
//入栈左下标
stack.push(point+1);
//入栈右下标
stack.push(right);
}
while(!stack.isEmpty()){
//根不为空，继续分解
//先取出两个元素
//1、第一个元素赋给right
right=stack.pop();
//2、第二个元素赋给left
left=stack.pop();
//3、三数取中
middle=middleValue(array,left,right);
swap(array,middle,left);
//4、找基准
point=partitionHoare(array,left,right);
//5、左右区段分别入栈
if(left+1<point){
//入栈左下标
stack.push(left);
//入栈右下标
stack.push(point-1);
}
if(right-1>point){
//入栈右区段
//入栈左下标
stack.push(point+1);
//入栈右下标
stack.push(right);
}
}
}
//测试快速排序-迭代运行时间
public static void TestQuickSort2(int[] array){
//记录开始时间
long begin=System.currentTimeMillis();
quickSort2(array);
//记录结束时间
long end=System.currentTimeMillis();
System.out.println("快速排序--递归耗时--->"+(end-begin));
}
9、归并排序
归并排序是建立在归并操作上一种有效的排序算法，该算法采用分治法的一个典型应用，，将已经有序的子序列合并，得到完全有序的序列；即先使每一个子序列有序，再使子序列段间有序。若将两个有序表合并称为一个有序表，称为二路归并。
/**
* 归并排序
* 时间复杂度：O(N*logN)
* 空间复杂度：O(N)
* 稳定性：稳定
* @param array
*/
public static void mergeSort(int[] array){
int left=0;
int right=array.length;
mergeSortProcess(array,left,right);
}
private static void mergeSortProcess(int[] array, int left, int right) {
//1、终止条件
if(left>=right){
return;
}
//2、找中间下标
int mid=(left+right)/2;
//3、开始递归,分解左右区段
mergeSortProcess(array,left,mid);
mergeSortProcess(array,mid+1,right);
//4、合并过程
merge(array,left,mid,right);
}
private static void merge(int[] array, int left, int mid, int right) {
//定义一个临时数组
int[] temp=new int[right-left+1];
//定义临时数组下标
int index=0;
//确定每一个小数组的起始下标
int start1=left;
int end1=mid;
int start2=mid+1;
int end2=right;
//归并排序，在归并的时候完成排序
while(start1<end1&&start2<end2){
//判断两个数组元素的大小
if(array[start1]<array[start2]){
//将start1下标加入到新数组中
array[index++]=array[start1++];
}else{
array[index++]=array[start2++];
}
}
//循环结束后，其中一个数组已经为空，将剩下的数组元素加入到临时数组中
while(start1<=end1){
temp[index++]=array[start1++];
}
while(start2<=end2){
temp[index++]=array[start2++];
}
//将临时数组排好序的元素放到array中
for (int i = 0; i < temp.length; i++) {
array[i+left]=temp[i];
}
}
// 测试快速排序
private static void testMergeSort (int [] array) {
// 记录开始时间
long begin = System.currentTimeMillis();
mergeSort(array);
// 记录结束时间
long end = System.currentTimeMillis();
System.out.println("归并排序耗时：" + (end - begin));
}9.1归并排序迭代法
/**
* 归并排序迭代法
* @param array
*/
public static void mergeSortItr(int[] array){
//定义步长从1开始
int gap=1;
//开始循环
while(gap<=array.length){
for (int i = 0; i < array.length; i+=2*gap) {
//确定左中右下标
int left=i;
int mid=i+gap-1;
int right=mid+gap;
//修正right和mid的值，防止越界
if(mid>array.length){
mid=array.length-1;
}
if(right>array.length){
right=array.length-1;
}
//归并
merge(array,left,mid,right);
}
//增大gap的值
gap*=2;
}
}
//测试归并排序-迭代
public static void TestMergeSortItr(int[] array){
//记录开始时间
long begin=System.currentTimeMillis();
mergeSortItr(array);
//记录结束时间
long end=System.currentTimeMillis();
System.out.println("归并排序-迭代法耗时"+(end-begin));
}9.2、归并排序特性总结
*归并排序的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘外排序问题
*时间复杂度：O(N*logN)
*空间复杂度：O(N)
*稳定性：稳定
10、计数排序
计数排序是一种非比较排序，其核心是将序列中的元素作为键存储在额外数组空间中，而该元素的个数作为值存储在数组空间中，通过遍历该数组排序
适用于：
*序列中最大值和最小值之间的差值不能过大，这主要是防止建立数组时造成内存的浪费
*序列中存在的元素时整数，因为我们使用的时该元素作为键存储在额外的数组空间中，如果不是整数，不能作为键
步骤：
(1)从无序数组中取出最大值max，新建一个长度为max+1的数组
(2)遍历无序数组，取其中元素作为新建数组的索引，存在一个则新数组该索引所在的值自增
(3)遍历数组，当存在不为0的元素，取该元素的索引放入最终数组，并且该元素字键，直到为0，返回最终数组
/**
* 计数排序
* 时间复杂度:O(N+K)
* 空间复杂度:O(K)
* 稳定性:稳定
* @param array
*/
public static void countSort(int[] array){
int minValue=array[0];
int maxValue=minValue;
//1、遍历数组，找到最大值和最小值
for (int i = 0; i < array.length; i++) {
if(array[i]<minValue){
minValue=array[i];
}
if(array[i]>maxValue){
maxValue=array[i];
}
}
//2、创建一个数组，确认容量是maxValue-minValue+1
int[] countArray=new int[maxValue-minValue+1];
//3、再次遍历数组记录到对应元素的个数
for (int i = 0; i < array.length; i++) {
int index=array[i]-minValue;
countArray[index]++;
}
//4、遍历计数数组
int index=0;
for (int i = 0; i < countArray.length; i++) {
//根据计数数组对应下标的值,输出N个元素到原数组
while(countArray[i]>0){
int value=i+minValue;
array[index]=value;
countArray[i]--;
index++;
}
}
}
//测试计数排序
public static void TestCountSort(int[] array){
//记录开始时间
long begin=System.currentTimeMillis();
countSort(array);
//记录结束时间
long end=System.currentTimeMillis();
System.out.println("归并排序-迭代法耗时"+(end-begin));
}11、测试类
//---------构造数组---------
//定义一个默认容量
private static final int CAPACITY=1000_000;
/**
* 构造一个有序数组
* @return
*/
public static int[] intitInorderArray(){
//初始化一个数组
int[] array=new int[CAPACITY];
for (int i = 0; i <array.length ; i++) {
array[i]=i;
}
return array;
}
/**
* 构造一个无序数组
* @return
*/
public static int[] intitUniorderArray(){
Random random=new Random();
int[] array=new int[CAPACITY];
for (int i = 0; i < array.length; i++) {
array[i]= random.nextInt(CAPACITY);
}
return array;
}
public static void main(String[] args) {
// System.out.println(Arrays.toString(intitInorderArray()));
// System.out.println(Arrays.toString(intitUniorderArray()));
System.out.println("数组长度"+CAPACITY);
System.out.println("---有序数组---");
TestShellSort(intitUniorderArray());
//TestInsertSort(intitInorderArray());
//TestSelectSort1(intitInorderArray());
//TestSelectSort2(intitInorderArray());
//TestHeapSort(intitInorderArray());
TestBubbleSort(intitInorderArray());
TestQuickSort(intitInorderArray());
TestQuickSort2(intitInorderArray());
TestMergeSortItr(intitInorderArray());
TestMergeSortItr(intitInorderArray());
TestCountSort(intitInorderArray());
System.out.println("---无序数组---");
int[] unorderArray=intitUniorderArray();
TestShellSort(Arrays.copyOf(unorderArray,unorderArray.length));
//TestInsertSort(Arrays.copyOf(unorderArray,unorderArray.length));
//TestSelectSort1(Arrays.copyOf(unorderArray,unorderArray.length));
//TestSelectSort2(Arrays.copyOf(unorderArray,unorderArray.length));
TestHeapSort(Arrays.copyOf(unorderArray,unorderArray.length));
//TestBubbleSort(Arrays.copyOf(unorderArray,unorderArray.length));
TestQuickSort(Arrays.copyOf(unorderArray,unorderArray.length));
TestQuickSort2(Arrays.copyOf(unorderArray,unorderArray.length));
TestMergeSortItr(Arrays.copyOf(unorderArray,unorderArray.length));
TestMergeSortItr(Arrays.copyOf(unorderArray,unorderArray.length));
TestCountSort(Arrays.copyOf(unorderArray,unorderArray.length));
}运行结果
