简单排序总结

冒泡排序

代码： j 为内层循环 i 代表排序轮数排序，轮数为数组 length - 1, 因为最后剩余一个值不用排序 一定为最小元素。内层比较相邻的两个元素 当 a[j] > a[j + 1] 进行交换

　　第一轮 i = 0 ; j 从 1-> a.length

　　第二轮 i = 1 ; j 从 2-> a,length -1 (因为第一层排序最大值已经找出，所以最后一个值不用排序)

　　第三轮......

　　第length -1 轮

package sort_test;

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

 折半快速排序

　　创建一个基准元素 所有元素和其进行比对，两个指针记录左右两边比对数据位置

　　1. 从右向左比对

　　　　右侧元素 > 基准 交换 再进行左侧比对

　　2.从左向右比对

　　　　左侧元素 < 基准元素 交换 再进行右侧比对

　　参照 https://www.cnblogs.com/hjy9420/p/5032309.html

package sort_test;

public class quick_sort {
    public static void main(String[] args) {
        int[] a = { 1, 10, 2, 3, 4, 5, 6, 3, 30, 17, 14 };
        int start = 0;
        int end = a.length - 1;
        quickSort(a, start, end);
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
    }

    public static void quickSort(int[] a, int low, int high) {
        int start = low;
        int end = high;
        int key = a[low];

        while (end > start) {
            // 从后往前比较
            // 如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较
            while (end > start && a[end] >= key) {
                end--;
            }
            if (a[end] <= key) {
                int temp = a[end];
                a[end] = a[start];
                a[start] = temp;
            }
            // 从前往后比较
            // 如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置
            while (end > start && a[start] <= key) {
                start++;
            }
            if (a[start] >= key) {
                int temp = a[start];
                a[start] = a[end];
                a[end] = temp;
            }
            // 此时第一次循环比较结束，关键值的位置已经确定了。
            // 左边的值都比关键值小，右边的值都比关键值大，但是两边的顺序还有可能是不一样的，进行下面的递归调用
        }
        // 递归
        // 左边序列。第一个索引位置到关键值索引-1
        if (start > low) {
            quickSort(a, low, start - 1);
        }
        // 右边序列。从关键值索引+1到最后一个
        if (end < high) {
            quickSort(a, end + 1, high);
        }
    }
}