冒泡排序的基本实现

1.冒泡排序的基本特性
1）稳定性：稳定
2）平均时间复杂度：O(n2)
3）最小时间复杂度：O(n)
4）最大时间复杂度：O(n2)
6）空间复杂度：O(1)
2.算法描述
1）依次比较两个数的大小，如果大小顺序错误则调换两个数的位置，直到按一定的顺序排列
3.算法的实现
1）正常的实现方式

//改进前
        long time1=System.nanoTime();
        int[] list = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
        for (int i = 0; i < list.length; i++) {
            for (int j = 0; j < list.length-1-i; j++) {
                if (list[j]>list[j+1]){
                    int temp = list[j];
                    list[j] = list[j+1];
                    list[j+1] = temp;
                }
            }
        }
        System.out.println(System.nanoTime() - time1);

2）改进后（记录最后一个最大值的位子，减少后续无效的对比）

        //改进后
        int[] list1 = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
        long time2=System.nanoTime();
        int end = list1.length-1;
        while (end>0){
            int pos = 0;
            for (int i = 0; i < end; i++) {
                if (list1[i] > list1[i+1]){
                    pos = i;
                    int temp = list1[i];
                    list1[i]=list1[i+1];
                    list1[i+1] = temp;
                }
            }
            end = pos;
        }
        System.out.println(System.nanoTime() - time2);

两个方法的成果对比（改进后的明显时间更快）：
9751
2 3 4 5 15 19 26 27 36 38 44 46 47 48 50
4319
2 3 4 5 15 19 26 27 36 38 44 46 47 48 50

3）python 实现

 for i in range(len-1):
   for j in range(len-1-i):
     if a[j] > a[j+1]:
       a[j], a[j+1] = a[j+1], a[j]

4.其他：
关于java数组问题:
arraylist和linkedlist的区别
arraylist:基于动态数组的数据结构
linkedlist：基于链表的数据结构