Java的四种基本排序

import java.util.Random;

/**
* Created by Nazir Abu on 2015/7/21.
* 排序算法包括：插入排序，希尔排序，简单选择，冒泡
*/
public class SortAlgorithm {

/**
 * 插入排序个人版
 *
 * @param a
 */
static void myInsertSort(int[] a) {
    int temp = 0;
    for (int i = 0; i < a.length; i++) {
        for (int j = 0; j < i; j++) {
            if (a[i] < a[j]) {
                temp = a[i];
                for (int k = i; k > j; k--) {
                    a[k] = a[k - 1];
                }
                a[j] = temp;
            }
        }
    }
}

/**
 * 插入排序优化版
 *
 * @param a
 */
static void myBestInsertSort(int[] a) {
    int temp = 0;
    for (int i = 1; i < a.length; i++) {
        int j = i - 1;
        temp = a[i];
        for (; j >= 0 && temp < a[j]; j--) {
            a[j + 1] = a[j];//如果a[i]前面的数字大于啊a[i]，则将前面的数字往后面移，再看更前面的数字
        }
        a[j + 1] = temp;//最后一次运行的时候，j减去了1，所以此时加上1
    }
}

/**
 * 希尔排序
 *
 * 就是先设置路径长度，即每个元素之间的间隔
 * 然后按照间隔可以分成相应的分组
 * 然后对每一组的数据进行上面的插入排序
 *
 * @param a
 */
static void shellSort(int[] a) {
    double d1 = a.length;
    int temp = 0;
    while (true) {
        d1 = Math.ceil(d1 / 2);
        int d = (int) d1;
        for (int x = 0; x < d; x++) {
            for (int i = x + d; i < a.length; i = i + d) {
                int j = i - d;
                temp = a[i];
                for (; j >= 0 && temp < a[j]; j = j - d) {
                    a[j + d] = a[j];
                }
                a[j + d] = temp;
            }
        }
        if (d == 1) {
            break;
        }
    }
}

/**
 * 简单选择排序
 *
 * @param a
 */
static void sampleSelectSort(int[] a) {
    for (int i = 0; i < a.length; i++) {
        for (int j = i; j < a.length; j++) {
            if (a[j] < a[i]) {
                a[i] = a[i] ^ a[j];
                a[j] = a[i] ^ a[j];
                a[i] = a[i] ^ a[j];
            }
        }
    }
}

/**
 * 冒泡排序，即每次从最后面的一个数字开始与其前面相邻的一个数字比较大小，如果小于
 * 前面的数字，则进行交换，交换之后，指针前移一个单位，再次进行上述操作，直至此轮比较完成
 * 完成之后，数组的第一个元素就是最小的，因此进行第二轮，同上述操作，只不过这次只需要比较到第二个元速
 * 即可，因为第一个元素已为最小
 *
 * @param a
 */
static void bubbleSort(int[] a) {
    int len = a.length;
    for (int i = 0; i < len - 1; i++) {
        for (int j = 0; j < len - i - 1; j++) {
            if (a[len - j - 1] < a[len - j - 1 - 1]) {
                a[len - j - 1] = a[len - j - 1] ^ a[len - j - 1 - 1];
                a[len - j - 1 - 1] = a[len - j - 1] ^ a[len - j - 1 - 1];
                a[len - j - 1] = a[len - j - 1] ^ a[len - j - 1 - 1];
            }
        }
    }
}

/**
 * 打乱算法
 *
 * @param ia
 */
static void shuffleArray(int[] ia) {
    Random random = new Random();
    //依次和最后一个数字进行交换，交换之后指向最后一个数字的的指针向前移，最后一个数字改变
    for (int i = 0; i < ia.length - 1; i++) {
        int m = random.nextInt(ia.length - 1 - i);
        int temp = ia[m];
        ia[m] = ia[ia.length - 1 - i];
        ia[ia.length - 1 - i] = temp;
    }
}

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

public static void main(String[] args) {
    int[] a = {49, 38, 65, 97, 76, 13, 27, 49, 78, 34, 12, 64, 5, 4, 62, 99, 98, 54, 56, 17, 18, 23, 34, 15, 35, 25, 53, 51};
    //MyBestInsertSort(a);
    //ShellSort(a);
    //SampleSelectSort(a);
    bubbleSort(a);
    printNumber(a);
}

}