排序算法之冒泡排序

原理：比较两个相邻的元素，将值大的元素交换至右端。
每一次比较之后，最后的比较过的数中最大的。

/**
 * 冒泡排序算法.
 * 
 * @author     peiyu
 */
public class BubbleSort{

    public static List<Integer> sort(List<Integer> datas) {
        int temp = 0;
        for (int i = datas.size() - 1; i > 0; i--)
        {
            for (int j = 0; j < i; j++)
            {
                if (datas.get(j + 1)< datas.get(j))
                {
                    temp = datas.get(j);
                    datas.set(j, datas.get(j + 1));
                    datas.set(j + 1, temp);
                }
            }
            System.out.println("【第"+(datas.size()-i)+"】趟结果："+datas);
        }
        return datas;
    }

    public static void main(String[] args) {
        List<Integer> datas=new ArrayList<Integer>();
        for (int i = 0; i < 10; i++) {
            datas.add(new Random().nextInt(100));
        }
        System.out.println("【排序前】："+datas);
        sort(datas);
        System.out.println("【排序后】："+datas);
    }
}

测试结果：

【排序前】：[84, 70, 0, 17, 34, 20, 84, 46, 47, 38]
【第1】趟结果：[70, 0, 17, 34, 20, 84, 46, 47, 38, 84]
【第2】趟结果：[0, 17, 34, 20, 70, 46, 47, 38, 84, 84]
【第3】趟结果：[0, 17, 20, 34, 46, 47, 38, 70, 84, 84]
【第4】趟结果：[0, 17, 20, 34, 46, 38, 47, 70, 84, 84]
【第5】趟结果：[0, 17, 20, 34, 38, 46, 47, 70, 84, 84]
【第6】趟结果：[0, 17, 20, 34, 38, 46, 47, 70, 84, 84]
【第7】趟结果：[0, 17, 20, 34, 38, 46, 47, 70, 84, 84]
【第8】趟结果：[0, 17, 20, 34, 38, 46, 47, 70, 84, 84]
【第9】趟结果：[0, 17, 20, 34, 38, 46, 47, 70, 84, 84]
【排序后】：[0, 17, 20, 34, 38, 46, 47, 70, 84, 84]

由此可见：N个数字要排序完成，总共进行N-1趟排序，每i趟的排序次数为(N-i)次，所以可以用双重循环语句，外层控制循环多少趟，内层控制每一趟的循环次数

冒泡排序的优点：每进行一趟排序，就会少比较一次，因为每进行一趟排序都会找出一个较大值。
冒泡排序总的平均时间复杂度为：O(n2)
最好情况：O(n)