排序算法练习

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