基本思想

冒泡排序，需要比较表中的相邻元素，如果它们是逆序的话，就交换它们的位置。重复多次之后，最终，最大的元素就"冒泡"到列表的最后一个位置。第二遍操作，将第二大元素"冒泡"到最终位置。依次执行n-1次，直到前n-1个元素到达最终位置。
冒泡排序的基本思想是：每一趟在 $n ? i + 1 (i = 1, 2, . . ., n ? 1)$ 个元素中冒泡出最大的元素，并将其作为有序序列中第 $n ? i + 1$ 个元素。
相比选择排序，冒泡排序的比较次数相当，但是冒泡排序要交换更多次数(最坏情况下，交换n*(n-1)/2次)。

伪代码实现

假设n个元素使用数组存储，冒泡排序的伪代码实现如下：

假设数组array[0...n-1]表示待排序数组
for i = 0 to n-2 then
    for j = 0 to n-i-2 then
        if array[j] > array[j+1] then
            swap(array[j], array[j+1])

该算法的输入规模是列表中元素的个数n。对于该非递归算法，其基本操作是内层循环的比较操作。其执行次数是：n-1 + n-2 + … + 1(仅需排序n-1个元素)。求和可得n*(n-1)/2。所以该算法的时间复杂度是 $O(n^2)$ 。对于该算法来说，除了依赖输入规模，还依赖数组中元素是否有序(影响数组中元素交换次数)。这里不展开讨论。
这里给出java版本实现：

public class BubbleSort {
    public void sort(int[] array) {
        if (array == null || array.length <= 1) {
            return;
        }
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    swap(array, j, j + 1);
                }
            }
        }
    }

    private void swap(int[] array, int srcSubscript, int dstSubscript) {
        if (srcSubscript == dstSubscript) {
            return;
        }
        int temp = array[srcSubscript];
        array[srcSubscript] = array[dstSubscript];
        array[dstSubscript] = temp;
    }
}