package util;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
public class SortUtil {
public static void main(String[] args) {
Integer[] array = new Integer[]{2, 3,0, 5, 8, 9, 7, 5,11,14, 1, 6, 8, 7, 12};
selectSort(array, false);
printAllEle(array);
}
public static <T> void printAllEle(T [] array){
System.out.println(Arrays.toString(array));
}
public static <T extends List> void printAllEle(T list){
if(list!=null&&list.size()>0){
StringBuilder b = new StringBuilder();
b.append('[');
int iMax=list.size()-1;
for (int i = 0; ; i++) {
b.append(list.get(i));
if(i==iMax){
b.append(']');
break;
}
b.append(',');
}
System.out.println(b.toString());
}else{
System.out.println("[]");
}
}
private static void swap(Object[] x, int a, int b) {
Object t = x[a];
x[a] = x[b];
x[b] = t;
}
/**
* 冒泡排序
*
* @param array
* @param asc
* true为升序,false为降序
*/
public static void bubbleSort(Integer[] array, boolean asc) {
if (asc) {
for (int i = 0; i < array.length - 1; i++) {
for (int j = 0; j < array.length - 1; j++) {
if (array[j + 1] < array[j]) {
swap(array, j + 1, j);
}
}
}
} else {
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array.length - 1; j++) {
if (array[j + 1] > array[j]) {
swap(array, j + 1, j);
}
}
}
}
}
/**
* 选择排序
* @param array
* @param asc true为升序,false为降序
*/
public static void selectSort(Integer[] array,boolean asc){
if (asc) {
for (int i = 0; i < array.length - 1; i++) {
for (int j = i + 1; j < array.length; j++) {
if (array[j] < array[i]) {
swap(array, i, j);
}
}
}
} else {
for (int i = 0; i < array.length; i++) {
for (int j = i + 1; j < array.length; j++) {
if (array[j] > array[i]) {
swap(array, i, j);
}
}
}
}
}
/**
* 插入排序
*选出后一个与之前的一个来比较，直到首端或找到正序元素（如升序时,2,3为正序,3,2为逆序）默认之前的都是排好序的，因此最少只比较一次就可以确定位置.
* 内循环发现逆序不交换，采用整体右移，直到没有逆序的时候把元素放在该位置
* @param array
* @param asc true为升序,false为降序
*/
public static void insertSort(Integer[] array,boolean asc){
int temp = 0;
int j = 1;
for (int i = 1; i < array.length; i++) {
temp = array[i];// 需要比较的单独拿出来
j = i;
if (asc) {
while (j > 0 && temp < array[j - 1]) {// 比较,若升序,后者小于前者,向前找到一个数比temp小的数,放在该数之后
array[j] = array[j - 1];// 大则挨个放后，为temp空出位置
j--;
}
} else {
while (j > 0 && temp > array[j - 1]) {
array[j] = array[j - 1];// 为temp空出位置
j--;
}
}
array[j] = temp;
}
}
/**
* 插入排序
*选出后一个与之前的一个来比较，直到首端或找到正序元素（如升序时,2,3为正序,3,2为逆序）默认之前的都是排好序的，因此最少只比较一次就可以确定位置.
* 内循环发现逆序不交换，采用整体右移，直到没有逆序的时候把元素放在该位置
* @param <T>
* @param array
* @param asc true为升序,false为降序
*/
public static void insertSort(List<Integer> list,boolean asc){
int temp=0;
int size=list.size();
int targetIndex=1;//最终应被插入的下标
int comparedIndex=1;//本次被比较的下标
for (int i = 0; i < size; i++) {
temp=list.get(i);
targetIndex=i;
comparedIndex=i;
if(asc){
while(targetIndex>0&&temp<list.get(targetIndex-1)){
list.set(targetIndex, list.get(targetIndex-1));
targetIndex--;
}
}else{
while(targetIndex>0&&temp>list.get(targetIndex-1)){
list.set(targetIndex, list.get(targetIndex-1));
targetIndex--;
}
}
if(comparedIndex!=targetIndex){//位置有改变
list.set(targetIndex, temp);
}
}
}
/**
* 希尔排序
* 插入排序的改进
* [1]将数组按间距分组
* [2]组内进行插入排序。
* [3]一次排序过后，缩小间距，继续[1],[2]的操作
* @param array
* @param asc true为升序
*/
public static void shellSort(Integer[] array,boolean asc) {
int n = array.length;
int gap = n / 2;// 步长、间距
int temp = 0;
if (asc) {// 减少判断次数
do {
// 一次组内的插入排序
for (int i = gap; i < n; i++) {// 插入排序
int j = 0;
temp = array[i];// 待插入正确位置的元素temp
for (j = i - gap; j >= 0 && temp < array[j]; j -= gap) {// 为temp元素找到不再逆序的位置
array[j + gap] = array[j];// temp<array[j] ，
// 上一个逆序，当前元素后移
}
// 退出时,若因j<0退出,则j+gap>=0，j+gap为最终位置;若temp<array[j]退出,则j+gap为最终位置
if (j + gap != i) {// 最终位置有变化
array[j + gap] = temp;// 插入到该位置
}
}
} while ((gap /= 2) >= 1);
} else {
do {
// 一次组内的插入排序
for (int i = gap; i < n; i++) {// 插入排序
int j = 0;
temp = array[i];// 待插入正确位置的元素temp
for (j = i - gap; j >= 0 && temp > array[j]; j -= gap) {// 为temp元素找到不再逆序的位置
array[j + gap] = array[j];// temp>array[j] ，
// 上一个逆序，当前元素后移
}
// 退出时,若因j<0退出,则j+gap>=0，j+gap为最终位置;若temp<array[j]退出,则j+gap为最终位置
if (j + gap != i) {// 最终位置有变化
array[j + gap] = temp;// 插入到该位置
}
}
} while ((gap /= 2) >= 1);
}
// int n = array.length;
// int gap = n/2;//步长、间距
// int temp=0;
// do {
// //一次组内的插入排序
// for (int i = gap; i < n; i++) {//插入排序
// int j=0;
// temp=array[i];//待插入正确位置的元素temp
// if(asc){
// for (j = i-gap; j >= 0&&temp<array[j] ; j -= gap) {//为temp元素找到不再逆序的位置
// array[j+gap] = array[j];// temp<array[j] ， 上一个逆序，当前元素后移
// }
// }else{
// for (j = i-gap; j >= 0&&temp>array[j] ; j -= gap) {//为temp元素找到不再逆序的位置
// array[j+gap] = array[j];// temp>array[j] ， 上一个逆序，当前元素后移
// }
// }
// //退出时,若因j<0退出,则j+gap>=0，j+gap为最终位置;若temp<array[j]退出,则j+gap为最终位置
// if(j+gap!=i){//最终位置有变化
// array[j+gap]= temp;//插入到该位置
// }
// }
// } while ((gap/=2)>=1);
}
public static void shellSort(List<Integer> list,boolean asc) {
int n = list.size();
int gap = n / 2;// 步长、间距
int temp = 0;
if (asc) {
do {
// 一次组内的插入排序
for (int i = gap; i < n; i++) {// 插入排序
int j = 0;
temp = list.get(i);// 待插入正确位置的元素temp
for (j = i - gap; j >= 0 && temp < list.get(j); j -= gap) {// 为temp元素找到不再逆序的位置
list.set(j + gap, list.get(j));// temp<array[j] ，
// 上一个逆序，当前元素后移
}
// 退出时,若因j<0退出,则j+gap>=0，j+gap为最终位置;若temp<array[j]退出,则j+gap为最终位置
if (j + gap != i) {// 最终位置有变化
list.set(j + gap, temp);// 插入到该位置
}
}
} while ((gap /= 2) >= 1);
} else {
do {
// 一次组内的插入排序
for (int i = gap; i < n; i++) {// 插入排序
int j = 0;
temp = list.get(i);// 待插入正确位置的元素temp
for (j = i - gap; j >= 0 && temp > list.get(j); j -= gap) {// 为temp元素找到不再逆序的位置
list.set(j + gap, list.get(j));// temp<array[j] ，
// 上一个逆序，当前元素后移
}
// 退出时,若因j<0退出,则j+gap>=0，j+gap为最终位置;若temp<array[j]退出,则j+gap为最终位置
if (j + gap != i) {// 最终位置有变化
list.set(j + gap, temp);// 插入到该位置
}
}
} while ((gap /= 2) >= 1);
}
}
// int n = list.size();
// int gap = n/2;//步长、间距
// int temp=0;
// do {
// //一次组内的插入排序
// for (int i = gap; i < n; i++) {//插入排序
// int j=0;
// temp=list.get(i);//待插入正确位置的元素temp
// if(asc){
// for (j = i-gap; j >= 0&&temp<list.get(j) ; j -= gap) {//为temp元素找到不再逆序的位置
// list.set(j+gap, list.get(j));// temp<array[j] ， 上一个逆序，当前元素后移
// }
// }else{
// for (j = i-gap; j >= 0&&temp>list.get(j) ; j -= gap) {//为temp元素找到不再逆序的位置
// list.set(j+gap, list.get(j));// temp>array[j] ， 上一个逆序，当前元素后移
// }
// }
// //退出时,若因j<0退出,则j+gap>=0，j+gap为最终位置;若temp<array[j]退出,则j+gap为最终位置
// if(j+gap!=i){//最终位置有变化
// list.set(j+gap,temp);//插入到该位置
// }
// }
// } while ((gap/=2)>=1);
// }
}
package shellsort;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import util.SortUtil;
public class Test{
public static void main(String[] args) {
// int[] array = new int[]{2, 3,0, 5, 8, 9, 7, 5,11,14, 1, 6, 8, 7, 15};
List<Integer> list=new ArrayList<>();
Random r=new Random();
for (int i = 0; i < 10000; i++) {
list.add(r.nextInt(10000));
}
Integer [] array=(Integer [] )list.toArray(new Integer[list.size()]);
Integer[] array2=array.clone();
Integer[] array3=array.clone();
Integer[] array4=array.clone();
SortUtil.printAllEle(array2);
long start2=System.currentTimeMillis();
SortUtil.shellSort(array2,false);
System.out.println("shellSort time consume "+(System.currentTimeMillis()-start2));
SortUtil.printAllEle(array2);
System.out.println("----------");
long start=System.currentTimeMillis();
SortUtil.insertSort(array,false);
// SortUtil.printAllEle(array);
System.out.println("insertSort time consume "+(System.currentTimeMillis()-start));
System.out.println("----------");
long start3=System.currentTimeMillis();
SortUtil.bubbleSort(array3,false);
System.out.println("bubbleSort time consume "+(System.currentTimeMillis()-start3));
// SortUtil.printAllEle(array3);
System.out.println("----------");
long start4=System.currentTimeMillis();
SortUtil.selectSort(array4,false);
System.out.println("selectSort time consume "+(System.currentTimeMillis()-start4));
long start5=System.currentTimeMillis();
Collections.sort(list);
System.out.println("Collections.sort time consume "+(System.currentTimeMillis()-start5));
}
}个人练习，欢迎指正。
参考:
http://www.cnblogs.com/jingmoxukong/p/4329079.html
http://blog.csdn.net/guanhang89/article/details/51902378