一、冒泡排序

冒泡排序：就是每次两两比较，将大值（小值）放后面，遍历一次后，最后一个是肯定是最大的（最小的），然后去除最后一个值，将剩下的按照相同的方法继续遍历，知道只剩下一个值。

public static void main(String[] args) {
    int arr[] = {8,5,3,2,7};
    for(int i =0; i < arr.length ; i++){
        for(int j = 0 ; j < arr.length - i -1 ; j++){
            if(arr[j] > arr[j + 1]){
                int temp = arr[j + 1];
                arr[j + 1] = arr[j];
                arr[j] = temp;
            }
        }
    }
    for(int k = 0 ; k <  arr.length ; k++){
        System.out.println(arr[k]);
    }
}

二、选择排序

选择排序：把第一个数值假设为最小的数，然后遍历比较找出真实最小的数，记录这个数的下标，然后将假设的最小的数与真实最小的数交换位置。

再按照相同的方法比较后面的值。

public static void main(String[] args) {
    int arr[] = {8,5,3,2,7};
    for (int i = 0; i < arr.length; i++) {
        int min = arr[i];
        int index = i;
        for (int j = i + 1; j <  arr.length; j++) {
            if(min > arr[j]){
                min = arr[j];
                index = j;
            }
        }
        int temp = arr[i];
        arr[i] = min;
        arr[index] = temp;
    }
    for(int k = 0 ; k <  arr.length ; k++){
        System.out.println(arr[k]);
    }
}

三、插入排序

插入排序顾名思义，就是要把数字插进去比较大小，也就是将一个数值和有顺序的数列中的值比较，得到一个新的有序数列比较的时候，如果要插入的数值小于比较的值，那就继续和有序数列前面的值比较，知道插入的数值大于比较的值，大于后，还没有比较的值也就不用继续比较了，因为本来就是有序的数列。

public static void main(String[] args) {
    int arr[] = {8,5,3,2,7};

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

    for(int k = 0 ; k <  arr.length ; k++){
        System.out.println(arr[k]);
    }
}

四、希尔排序

希尔排序其实就是对插入排序的改进，也就是分组的插入排序，就是将待排序的序列分为了分成小组，小组内的数据都是在原序列的基础上根据步长增量设置的，然后对这个小组进行排序，然后缩小不畅增量继续进行上述操作，知道步长增量为1，这时候数据顺序只需要在进行一下小调整就完成了。

public static void main(String[] args) {
    int arr[] = {8,5,3,2,7,4,1,12,14,11,65,34};

    for(int i = arr.length /2 ; i > 0 ;i /=2){
        for (int j = i; j < arr.length; j++) {
            //j控制无序端的起始位置
            for (int k = j; k > 0  && k - i >= 0; k -= i) {
                if (arr[k] < arr[k - i]) {
                    int temp = arr[k - i];
                    arr[k - i] = arr[k];
                    arr[k] = temp;
                } else {
                    break;
                }
            }
        }
    }

    for(int k = 0 ; k <  arr.length ; k++){
        System.out.println(arr[k]);
    }
}

五、快速排序

快速排序就是：设置第一个值为中间值，小于这个值的放在这个值的左边，大于的放在右边，完成后

然后将第一步分好的左右两边分别再进行比较

一直到不能比较为止。

   public static void main(String[] args) {
        int arr[] = {8,5,3,2,7,4,1,12,14,11,65,34};

        int low = 0;
        int hight = arr.length - 1;
        quickSort(arr,low,hight);
        for(int k = 0 ; k <  arr.length ; k++){
            System.out.println(arr[k]);
        }
    }

    private static void quickSort(int[] arr, int low, int hight) {
        //如果两个指针在位置相同，也就是只有一个元素，直接退出。
        if(hight - low < 1){
            return;
        }
        boolean flag = true;  //low<hight就为true,

        int start = low;
        int end = hight;

        //中间值为 低指针的第一个值
        int midValue = arr[low];

        while (true){
            if(flag){
                if(arr[hight] > midValue){
                    hight--;
                }else if(arr[hight] < midValue){
                    arr[low] = arr[hight];
                    low ++;
                    flag = false;
                }
            }else {
                if(arr[low] < midValue){
                    low ++;
                }else if(arr[low] > midValue){
                    arr[hight] = arr[low];
                    hight --;
                    flag = true;
                }
            }
            if(low == hight){
                arr[low] = midValue;
                break;
            }
        }
        quickSort(arr, start, low -1);
        quickSort(arr, low + 1, end);


    }

六、归并排序

归并排序：选择相邻两个数组成一个有序序列。

选择相邻的两个有序序列组成一个新的有序序列。

一直重复上一步，直到全部组成一个有序序列。

public static void main(String[] args) {
    int arr[] = {8,5,3,2,7,4,1,12,14,11,65,34};

    int start = 0;
    int end = arr.length - 1;
    mergeSort(arr,start,end);
    for(int k = 0 ; k <  arr.length ; k++){
        System.out.println(arr[k]);
    }
}

private static void mergeSort(int[] arr, int start, int end) {
    if(end - start > 0){
        mergeSort(arr, start, (start + end) / 2);
        mergeSort(arr, (start + end) / 2 + 1, end);

        int left = start;
        int right = (start + end) / 2 + 1;

        //每个小单位的排序结果
        int index = 0;

        int[] result = new int[end - start + 1];

        while (left <= (start + end) / 2 && right <= end){
            if(arr[left] <= arr[right]){
                result[index] = arr[left];
                left ++;
            }else {
                result[index] = arr[right];
                right ++;
            }
            //移动小单位记录的下标
            index ++;
        }

        while (left <= (start + end) / 2 || right <= end){
            if(left <= (start + end) / 2){
                result[index] = arr[left];
                left++;
            }else {
                result[index] = arr[right];
                right ++;
            }
            index ++;
        }

        for (int i = start; i <= end ; i++) {
            arr[i] = result[i - start];
        }

    }
}