优化的快速排序Java实现，有一块元素个数小于k后采用插入排序

import java.util.ArrayList;

public class Test_3 {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
// int len = 20;

// display(array);
for (int len = 10; len <= 100; len = len + 10) {
ArrayList<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < 10000000; i++) {
list.add((int) (Math.random() * 10000000));
}

int[] array = new int[list.size()];
for (int j = 0; j < list.size(); j++) {
array[j] = list.get(j);
}
//display(array);

System.out.println("数组长度为：" + array.length+"      k的值是:"+len);

long startMili = System.currentTimeMillis();// 当前时间对应的毫秒数
System.out.println("开始优化的快速排序时刻： " + startMili);
// quciksort_optimization(array, 0, array.length - 1, len);
optimization(array,len);

long endMili = System.currentTimeMillis();

System.out.println("结束优化的快速排序时刻：" + endMili);
System.out.println("总耗时为：" + (endMili - startMili) + "毫秒");
System.out.println("----------------------------");
//display(array);
}

// display(array);
}// /main

private static void optimization(int A[], int k) {

quciksort_optimization(A, 0, A.length - 1, k);
insertsort(A);

}

private static void quciksort_optimization(int A[], int left, int right,
int k) {

if (right - left + 1 < k) {
return;
}

if (left < right) {
int pivot = partition(A, left, right);
quciksort_optimization(A, left, pivot - 1, k);
quciksort_optimization(A, pivot + 1, right, k);

}

}

private static int partition(int A[], int left, int right) {
int pivotkey = A[left];
while (left < right) {

while (left < right && A[right] >= pivotkey)
--right; // ///右边的比枢轴大，继续往前遍历
A[left] = A[right];// //右边比枢轴小，左右互换元素
while (left < right && A[left] <= pivotkey)
++left;// ////左边的比枢轴小，继续往后遍历
A[right] = A[left];// ////左边的比枢轴大，左右互换元素

}
A[left] = pivotkey;// //左右位置相等即使枢轴的位置
return left;

}

private static void swap(int p, int q) {

int t = 0;
t = p;
p = q;
q = t;
}

private static void insertsort(int A[]) {

for (int j = 1; j <= A.length - 1; j++) {
int key = A[j];
int i = j - 1;
while (i >= 0 && A[i] > key) {

A[i + 1] = A[i];
i = i - 1;

}
A[i + 1] = key;

}

}

private static void display(int A[]) {
for (int i = 0; i < A.length; i++) {
System.out.println(A[i]);
}
}

}
//快速排序：
// 数组长度为：10000000
// 开始快速排序时刻： 1446723864757
// 结束快速排序时刻：1446723867102
// 总耗时为：2345毫秒

/////优化的快速排序：
//数组长度为：10000000      k的值是:10
//开始优化的快速排序时刻： 1446726839501
//结束优化的快速排序时刻：1446726841377
//总耗时为：1876毫秒
//----------------------------
//数组长度为：10000000      k的值是:20
//开始优化的快速排序时刻： 1446726843666
//结束优化的快速排序时刻：1446726845513
//总耗时为：1847毫秒
//----------------------------
//数组长度为：10000000      k的值是:30
//开始优化的快速排序时刻： 1446726846975
//结束优化的快速排序时刻：1446726848772
//总耗时为：1797毫秒
//----------------------------
//数组长度为：10000000      k的值是:40
//开始优化的快速排序时刻： 1446726855090
//结束优化的快速排序时刻：1446726856874
//总耗时为：1784毫秒
//----------------------------
//数组长度为：10000000      k的值是:50
//开始优化的快速排序时刻： 1446726858666
//结束优化的快速排序时刻：1446726860424
//总耗时为：1758毫秒
//----------------------------
//数组长度为：10000000      k的值是:60
//开始优化的快速排序时刻： 1446726863576
//结束优化的快速排序时刻：1446726865359
//总耗时为：1783毫秒
//----------------------------
//数组长度为：10000000      k的值是:70
//开始优化的快速排序时刻： 1446726868394
//结束优化的快速排序时刻：1446726870170
//总耗时为：1776毫秒
//----------------------------
//数组长度为：10000000      k的值是:80
//开始优化的快速排序时刻： 1446726874756
//结束优化的快速排序时刻：1446726876569
//总耗时为：1813毫秒
//----------------------------
//数组长度为：10000000      k的值是:90
//开始优化的快速排序时刻： 1446726883414
//结束优化的快速排序时刻：1446726885212
//总耗时为：1798毫秒
//----------------------------
//数组长度为：10000000      k的值是:100
//开始优化的快速排序时刻： 1446726886845
//结束优化的快速排序时刻：1446726888655
//总耗时为：1810毫秒
//----------------------------