算法每日一练：冒泡排序/插入排序

冒泡排序是将一无序排列的数组序列进行从大到小或者从小到大进行排序

工作原理：对数组进行每一轮中每一个元素进行大小比较，并将较大的元素进行后置(位置交换),

假设数组元素总共n个，则需要进行n-1轮大小比较

第1轮  找出最大的

第2轮  找出次大的

........

第n轮  找出次n大的

原理很好理解

private static void bubbleSort(int[] nums2) {
    int temp;
    int count=1;
    for(int i=0,size=nums2.length;inums2[j+1]){
                System.out.println("第"+count+"次排序"+nums2[j]+"和"+nums2[j+1]+"交换位置");
                temp=nums2[j];
                nums2[j]=nums2[j+1];
                nums2[j+1]=temp;
            }else{
                System.out.println("第"+count+"次排序"+nums2[j]+"和"+nums2[j+1]+"不交换位置");
            }
            count++;
        }
    }
    System.out.println(Arrays.toString(nums2));
}

测试代码：

public static void main(String[] args) {
   int[] nums2={10,321,54,70,18,49};
   bubbleSort(nums2);
}

测试结果：

第1轮1次排序10和321
第1次排序10和321不交换位置
第1轮2次排序321和54
第2次排序321和54交换位置
第1轮3次排序321和70
第3次排序321和70交换位置
第1轮4次排序321和18
第4次排序321和18交换位置
第1轮5次排序321和49
第5次排序321和49交换位置
第2轮6次排序10和54
第6次排序10和54不交换位置
第2轮7次排序54和70
第7次排序54和70不交换位置
第2轮8次排序70和18
第8次排序70和18交换位置
第2轮9次排序70和49
第9次排序70和49交换位置
第3轮10次排序10和54
第10次排序10和54不交换位置
第3轮11次排序54和18
第11次排序54和18交换位置
第3轮12次排序54和49
第12次排序54和49交换位置
第4轮13次排序10和18
第13次排序10和18不交换位置
第4轮14次排序18和49
第14次排序18和49不交换位置
第5轮15次排序10和18
第15次排序10和18不交换位置

[10, 18, 49, 54, 70, 321]

从日志来看符合原理预期，第一轮比较的次数最多，依次将最大的找出来，循环如此

最终按着从小到大的顺序将数组重排序

冒泡排序性能不是最优，如果找到某个元素直接插入指定位置占位，然后再一次比较不是更好么

因此就引入了插入排序，我觉得叫替换排序或者叫占位排序更好理解

工作原理：依次取出第i个元素的前面一个元素temp同当前第i个curInt进行比较，如果大于它，则将该元素占位j+1个位置,然后再将该元素的前面的元素同当前第i个curInt进行比较，这里面有点递归的味道，为了就是把前面更大的元素进行和当前的curInt比较，然后后置

{10,321,54,70,18,49}

第一轮 curInt->321,temp->10,不符合temp>curInt

第二轮 curInt->54,temp->321,符合temp>curInt,则将54的下标占位值替换为321

......

第n轮 curInt->49,temp->54,如何temp>curInt,则将49的下标占位值替换为54

private static void insertSort(int[] nums2) {
    int count=1;
    for(int i=1,size=nums2.length;i=0 && nums2[j]>curInt){
            System.out.println("第"+count+"次排序"+nums2[j]+"比"+curInt+"大,插入j+1位置");
            nums2[j+1]=nums2[j];
            j--;
        }
        nums2[j+1]=curInt;
    }
    System.out.println(Arrays.toString(nums2));
}

测试代码：

public static void main(String[] args) {
    int[] nums={1,3,5,7,8,9};
    insertSort(nums2);
}

测试结果：

第1轮1次排序,默认最大的数10
第2轮2次排序,默认最大的数321
第3次排序321比54大,插入j+1位置
第3轮3次排序,默认最大的数321
第4次排序321比70大,插入j+1位置
第4轮4次排序,默认最大的数321
第5次排序321比18大,插入j+1位置
第5次排序70比18大,插入j+1位置
第5次排序54比18大,插入j+1位置
第5轮5次排序,默认最大的数321
第6次排序321比49大,插入j+1位置
第6次排序70比49大,插入j+1位置
第6次排序54比49大,插入j+1位置
[10, 18, 49, 54, 70, 321]、

这样看来插入排序的排序次数8次，要比上面的冒泡排序少将近一半，如果量级足够都，性能会更加优