java1000万数据排序_对1000w 长度的数据排序

import java.util.Arrays;

import java.util.Random;

public class Sort {

//分片数组长度为多少时,开始排序

public final static int SORT_NUM = 50;

//数组的长度

public final static int ARRAY_NUM = 10000000;

public static void main(String[] args) {

//声明数组长度

int[] array = new int[ARRAY_NUM];

//生成随机数据

for (int j = 0; j < ARRAY_NUM; j++) {

array[j] = new Random().nextInt(Integer.MAX_VALUE);

}

//复制数组,采用JDK自带排序

int[] arrayCopy = new int[ARRAY_NUM];

System.arraycopy(array, 0, arrayCopy, 0, ARRAY_NUM);

//数据少的时候可以看看初始化结果,数据量大,ecplise直接就崩溃了。

//System.out.println("init :"+Arrays.toString(array));

long time1 = System.currentTimeMillis();

sort(array,0,array.length);

long time2 = System.currentTimeMillis();

//System.out.println(Arrays.toString(array));

System.out.println(time2 - time1);

Arrays.sort(arrayCopy);

long time3 = System.currentTimeMillis();

System.out.println(time3 - time2);

}

public static void sort(int[] array,int begin,int end){

//若排序部门长度小于SORT_NUM

if(end - begin<=SORT_NUM){

//循环排序部分的元素

for (int i = begin+1; i < end; i++) {

//查找当前元素的位置

int index = findIndex(array[i], begin, i - 1, array);

//获取当前元素

int value = array[i];

//数组移位

System.arraycopy(array, index, array, index + 1, i - index);

//将当前数组插入到合适的位置

array[index] = value;

}

return;

}

//作为中间轴参数使用

int temp = array[begin];

//获取当前的位置

int currentIndex = begin;

int left =begin;

int right=end-1;

while(left

//向右比较

for(;left < right;right--){

if(left < right && array[right]

swap(array,currentIndex,right);

currentIndex = right;

left++;

break;

}

}

//向左比较

for(;left < right;left++){

if(left < right && array[left]>temp){

swap(array,currentIndex,left);

currentIndex = left;

right--;

break;

}

}

}

//左侧排序

sort(array,begin,currentIndex+1);

//右侧排序

sort(array,currentIndex+1,end);

}

public static void swap(int[] array,int index1,int index2){

int temp = array[index1];

array[index1] = array[index2];

array[index2] = temp;

}

//二分查找排序

public static int findIndex(int thisval, int from, int to, int[] sortArray) {

int index = 0;

//当左侧数据大于当前数据,返回from的索引

if (sortArray[from] >= thisval) {

index = from;

return index;

}

//当右侧数据小于当前数据,返回index后面的索引

if (sortArray[to] <= thisval) {

index = to + 1;

return index;

}

if (to - from == 1) {

return to;

}

//获取from和to的中间值

int middle = (to - from) / 2 + from;

//判断当前值在左侧还是右侧

if (sortArray[middle] >= thisval) {

//左侧

return findIndex(thisval, from, middle, sortArray);

} else {

//右侧

return findIndex(thisval, middle, to, sortArray);

}

}

}