一、快速排序

算法思想：

用左右两个指针和一个基准数进行操作，不断递归分而治之。

亲自制作了个动画来形象的演示：

快速排序算法动画演示

（演示动画和快速排序PPT下载：百度云，提取码：q7h1）

代码如下：

public class QuickSort {
    public static int[] sort(int[] array) {
        if (null == array) {
            return null;
        }
        return QuickSort.sortd(array, 0, array.length - 1);
    }
    

    public static int[] sortd(int[] array, int left, int right) {
        if (left < right) {
            int point = QuickSort.getLocation(array, left, right);
            sortd(array, left, point - 1);
            sortd(array, point + 1, right);
        }
        return array;
    }


    public static int getLocation(int[] array, int left, int right ) {
        int tmp = array[left];
        while (left < right) {
            while (left < right && array[right] >= tmp) {
                right--;
            }
            array[left] = array[right];
            while (left < right && array[left] <= tmp) {
                left++;
            }
            array[right] = array[left];
        }
        array[left] = tmp;
        return left;
    }
}

测试：

		int[] array = new int[]{5, 3, 2, 4, 6, 4, 7, 3, 1, 6};
        System.out.println(Arrays.toString(QuickSort.sort(array)));

二、选择排序

算法思想：

1.在一个长度为 N 的无序数组中，第一次遍历 n-1 个数找到最小的和第一个数交换。
2.第二次从下一个数开始遍历 n-2 个数，找到最小的数和第二个数交换。
3.重复以上操作直到第 n-1 次遍历最小的数和第 n-1 个数交换，排序完成。
*
代码如下：*

public class SelectSort {
    public static int[] sort(int[] array) {
        if (null == array) {
            return null;
        }

        int length = array.length;
        for (int i = 0; i < length; i++) {
            int minPoint = i;
            for (int j = i; j < length; j++) {
            	//<为升序，>为降序
                if (array[j] < array[minPoint]) {
                    minPoint = j;
                }
            }
            int temp = array[i];
            array[i] = array[minPoint];
            array[minPoint] = temp;
        }
        return array;
    }
}

测试：

		int[] array = new int[]{5, 3, 2, 4, 6, 4, 7, 3, 1, 6};
        System.out.println(Arrays.toString(SelectSort.sort(array)));

三、冒泡排序

算法思想：

1.比较相邻两个数据如果。第一个比第二个大，就交换两个数

2.对每一个相邻的数做同样第一步的工作，这样从开始一队到结尾一队在最后的数就是最大的数。

3.针对所有元素上面的操作，除了最后一个。

4.重复1~3步骤，知道顺序完成。

代码如下：

public class BubbleSort {
    public static int[] sort(int[] array) {
        if (null == array) {
            return null;
        }
        int length = array.length;
        for (int i = 0; i < length; i++) {
            for (int j = 0; j <  length -i- 1; j++) {
            	//>为升序，<为降序
                if (array[j] > array[j + 1]) {
                    int temp = array[j + 1];
                    array[j + 1] = array[j];
                    array[j] = temp;
                }
            }
        }
        return array;
    }
}

测试：

		int[] array = new int[]{5, 3, 2, 4, 6, 4, 7, 3, 1, 6};
        System.out.println(Arrays.toString(BubbleSort.sort(array)));

四、插入排序

算法思想：

1.从数组的第二个数据开始往前比较，即一开始用第二个数和他前面的一个比较，如果符合条件（比前面的大或者小，自定义），则让他们交换位置。

2.然后再用第三个数和第二个比较，符合则交换，但是此处还得继续往前比较，比如有 5个数8，15，20，45, 17,17比45小，需要交换，但是17也比20小，也要交换，当不需要和15交换以后，说明也不需要和15前面的数据比较了，肯定不需要交换，因为前面的数据都是有序的。

3.重复步骤二，一直到数据全都排完。

代码如下：

public class InsertSort {
    //array[j] >= array[i]为降序，改为<=则为升序
    public static int[] sort(int[] array) {
        if (null == array) {
            return null;
        }
        for (int i = 1; i < array.length; i++) {
            for (int j = 0; j <= i; j++) {
                //>=为升序，<=为降序
                if (array[j] >= array[i]) {
                    int temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                }
            }
        }
        return array;
    }
}