排序算法（冒泡排序，选择排序，插入排序，快速排序）

冒泡排序

相邻的数据两两比较，小的放前面，大的放后面

package seach;

public class A04_BubbleDemo1 {
    public static void main(String[] args) {
        int[] arr = {2,4,3,1,6,8,9,5};
        //外循环：表示我要执行多少论 如果有n个数据，那么执行n-轮
        for (int j = 0 ; j<arr.length-1;j++) {
            //内循环：每一轮中我如何比较数据并找到当前最大值
            //-1为了防止越界
            //-j:提高效率
            for (int i = 0; i < arr.length - 1-j; i++) {
                if(arr[i] > arr[i+1]){
                    int temp = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = temp;
                }
            }
        }
        printArr(arr);
    }

    private static void printArr(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

选择排序

从0索引开始，拿着每一个索引上的元素跟后面的元素依次比较，小的放前面，大的放后面，以此类推。

package seach;

public class A05_SelectionDemo {
    public static void main(String[] args) {
        int[] arr = {2, 4, 5, 3, 1};
        //j表示这一轮中，拿着哪个索引上的数据跟后面的数据进行比较并交换
        for (int j = 0; j < arr.length - 1; j++) {
            //拿着j跟j后面的数据进行比较交换
            for (int i = 1 + j; i < arr.length; i++) {
                if (arr[j] > arr[i]) {
                    int temp = arr[j];
                    arr[j] = arr[i];
                    arr[i] = temp;
                }
            }
        }
        printArr(arr);
    }

    private static void printArr(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

插入排序

将0索引的元素到N索引的元素看做是有序的，把N+1索引的元素到最后一个当成是无序的。遍历无序的数据，将遍历到的元素插入有序序列中适当的位置，如遇到相同数据，插在后面。N的范围:0~最大索引

package seach;

public class A06_InsertDemp {
    public static void main(String[] args) {
        int[] arr = {3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};
        int startIndex = -1;
        for (int i = 0; i < arr.length - 1; i++) {
            if(arr[i]>arr[i+1]){
                startIndex = i + 1;
                break;
            }
        }
        for (int i = startIndex; i < arr.length; i++) {
            int j = i;
            while (j > 0 && arr[j] < arr[j-1]){
                int temp = 0;
                temp = arr[j];
                arr[j] = arr[j-1];
                arr[j-1] = temp;
                j--;
            }

        }
        printArr(arr);
    }
    private static void printArr(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

快速排序

递归算法：指的是方法中调用方法本身的现象

递归算法作用：把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算

书写两个核心：

1.找出口，什么时候不调用方法

2.找规则：如何把大问题转化为规模较小的问题

快速排序第一轮

把0索引的数字作为基准数，确定基准数在数组中正确的位置比基准数小的全部在左边，比基准数大的全部在右边，

package seach;

public class A07_QuickSortDemo {
    public static void main(String[] args) {
        int[] arr ={6,1,2,7,9,3,4,5,10,8};
        quicksort(arr,0,arr.length-1);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
    public static void quicksort(int[] arr,int i,int j){
        int start = i;
        int end = j;
        if(start > end){
            return;
        }
        int basenumber = arr[i];
        while (start != end){
            while (true){
                if(end <= start || arr[end] < basenumber){
                    break;
                }
                end--;
            }
            while (true){
                if(end <= start || arr[start] > basenumber){
                    break;
                }
                start++;
            }
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }
        int temp = arr[i];
        arr[i] = arr[start];
        arr[start] = temp;
        //确定左边顺序
        quicksort(arr,i,start-1);
        //确定右边顺序
        quicksort(arr,start+1,j);
    }
}

将排序范围中的第一个数字作为基准数，再定义两个变量start，(endstart从前往后找比基准数大的，end从后往前找比基准数小的。找到之后交换start和end指向的元素，并循环这一过程，直到start和end处于同一个位置，该位置是基准数在数组中应存入的位置，再让基准数归位。

归位后的效果:基准数左边的，比基准数小基准数右边的，比基准数大