冒泡排序、选择排序、插入排序、快速排序思想及Java代码

冒泡排序

依次比较数组相邻两个元素的大小，如果前一个比后一个大就交换两个元素的位置，这样可以做到把最大的数移动到数组的末端，然后下一轮将遍历的范围缩小，可以看把除最后一个元素之外的元素看作一个小数组进行交换，以此循环，最终可以得到排好序的数组。

public static void maopao(int[] arr){
    for(int j = 0;j<arr.1ength-1;j++){
        if(arr[j] > arr[j+1]){
            int temp = arr[j];
            arr[j] = arr[j+1];
            arr[j+1] = temp;
        }
    }
}

选择排序

先找数组中最小的，和第一个元素交换，然后找后面最小的，和第二个交换.....

思考两个问题:1.如何找到最小的数据 2.找到最小的数据和谁交换

创建一个temp临时空间，把第一个数存进去，然后往后遍历，然后遇到比它小的，把这个数赋给temp，然后接着遍历，遇到更小的接着覆盖....以此循环，遍历到的数直接和temp比较就行，还需要知道最小值的位置，否则无法交换

第一轮会把第一个数定了，第二轮定第二个数...

其实每次找的是剩下的那几个数里的最小值，所以每次min=arr[j]就行（j是就是需要找的剩下的数里面的第一个数的位置，min就是临时空间temp）

public static void select(int[] arr) {
    for(int i=0;i<arr.length-1;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;
            }
        }
        arr[index]=arr[i];
        arr[i]=min;
    }
}

插入排序

先把第一个和第二个比，第二个如果比第一个小，插入到第一个的前面，然后前两个作为一个数组和第三个比,然后他三个排序（第三个数插入到某个位置使有序），然后前三个数和第四个比.......

实际上不可能直接插入，所以要有一个临时空间temp，要排序的下一个数和前面一个一个比过去，只要比已排序部分的数字小，数组的元素就统一后移（覆盖，移到这个数的位置了都），最后temp赋给应该在的地方

一个一个 比过去，temp是正在比较的那个数（上图中就是3）

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

快排

快排的基本思想：将第一个数作为基准数，定义两个游标（i、j），分别指向最左边数据和最右边的数据

eg:

 让j先去动，找比当前基准数小的数据，i去找比当前基准数大的数据，j--，i++,谁找到就停下，然后i指向的和j指向的数据互换，然后继续找，就会相遇，将基准数和相遇的数发生互换

 

   第一轮完成，基准数左边都比基准数小，右边都比它大，例如此时，第一轮结束后5的左边都比5小，右边都比5大（一组有正数和负数所组成的无序数据，用最快的方式让正数在前，负数在后，只需要一轮的快排就行）

第一轮代码：

public static void quickSort(int[] arr,int left,int right){
    int base = arr[left]; //当前基准数
    int i = left;
    int j = right;
    while (i !=j){
        while (arr[j] >= base && i<j){
            j--;
        }
        while (arr[i] <= base && i<j){
            i++;
        }
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    //基准数和相遇的数进行位置互换
    arr[left] = arr[i];
    arr[i] = base;
}

 代码实现时发现，第一轮结束，i和j都还在5那，可以用递归，只要左边也执行这个逻辑，右边也执行这个逻辑，执行完再继续拆分,待排序列被分成两个区:[left,i-1],[j+1,right],重复步骤可以使所有分区中的记录都有序，则排序成功

 完整代码：

public static void quickSort(int[] arr,int left,int right){
    if(left >= right){
        return;
    }
    int base = arr[left]; //当前基准数
    int i = left;
    int j = right;
    while (i !=j){
        while (arr[j] >= base && i<j){
            j--;
        }
        while (arr[i] <= base && i<j){
            i++;
        }
        if(i<j){
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
    //基准数和相遇的数进行位置互换
    arr[left] = arr[i];
    arr[i] = base;

    quickSort(arr,left,i-1);
    quickSort(arr,i+1,right);
}