排序算法（可直接执行的代码）

collection类默认使用的是归并排序或者及其变种

package cn;

import java.util.*;

public class SortCollection {


    public static void main(String[] args) {

        Integer[] demoList = new Integer[]{50, 12, 65, 43, 2, 13, 9, 7, 96, 15, 3};
        SortCollection sortCollection = new SortCollection();

        // 选择排序
        sortCollection.chooseSort(demoList);

        // 冒泡排序
        sortCollection.bubbleSort(demoList);

        // 插入排序
        sortCollection.insertSort(demoList);

        // 快速排序
        sortCollection.quickSort(demoList);

    }


    /**
     * 选择排序
     * 直接找到最小的值，然后进行变更
     */
    public void chooseSort(Integer[] demoList) {

        Integer[] target = deepCopy(demoList);

        int temp;

        for (int i = 0; i < target.length - 1; i++) {
            temp = i;
            for (int j = i + 1; j < target.length; j++) {
                if (target[temp] > target[j]) {
                    temp = j;
                }
            }

            int data = target[i];
            target[i] = target[temp];
            target[temp] = data;
        }

        printList(target);
    }

    /**
     * 冒泡排序
     */
    public void bubbleSort(Integer[] demoList) {

        Integer[] target = deepCopy(demoList);

        int temp;

        for (int i =0; i< target.length - 1; i++) {
            for (int j = i + 1; j < target.length; j++) {
                if (target[i] > target[j]) {
                    temp = target[j];
                    target[j] = target[i];
                    target[i] = temp;
                }
            }
        }

        printList(target);
    }

    /**
     * 插入排序
     * 从后面往前进行排序，
     */
    public void insertSort(Integer[] demoList) {
        Integer[] target = deepCopy(demoList);

        for (int i=1;i<demoList.length;i++) {
            int temp = target[i];
            int index = i;
            for (int j = i -1; j >=0; j--) {
                if (temp < target[j]) {
                    target[j + 1] = target[j];
                    index--;
                } else {
                    break;
                }
            }
            target[index] = temp;
        }

        printList(target);
    }

    /**
     * 快速排序
     * 采取的分治算法
     *
     * @param demoList
     */
    private void quickSort(Integer[] demoList) {

        Integer[] target = deepCopy(demoList);

        quickCompare(target, 0, target.length - 1);

        printList(target);
    }

    /**
     * 快速排序递归内容
     */
    private void quickCompare(Integer[] target, int start, int end) {

        if (start > end) {
            return;
        }

        Integer base = target[start];
        int baseIndex = start;
        int endIndex = end;

        while (start < end) {
            // 从右往左
            while (base <= target[end] && start < end) {
                end--;
            }

            while (base >= target[start] && start < end) {
                start++;
            }

            // 交换两边的值
            if (start < end) {
                Integer temp = target[start];
                target[start] = target[end];
                target[end] = temp;
            }

        }

        Integer temp = target[start];
        target[start] = base;
        target[baseIndex] = temp;

        quickCompare(target, baseIndex, start - 1);
        quickCompare(target, start + 1, endIndex);
    }

    /**
     * 生成拷贝，避免影响后续测试结果
     */
    public Integer[] deepCopy(Integer[] source) {
        Integer[] target = new Integer[source.length];
        System.arraycopy(source, 0, target, 0, source.length);
        return target;
    }

    /**
     * 打印
     */
    public void printList(Integer[] source) {
        for (Integer integer : source) {
            System.out.print(integer + ",");
        }
        System.out.println();
    }
}