冒泡排序

　　冒泡排序是最基本，最简单的排序算法。 比如现在有一个表（可能是数组，也有可能是其他的数据结构），表中有若干项数据，随机排列，现在要让它按照数据数值的大小递增排序。用冒泡排序的基本算法思路如下： 

　　重复对表中相邻的两项进行比较， 如果它们不是按照规定排序的就交换它们的位置。假设等待排序的表有 n 项。冒泡排序法将从比较（可能会互换）第 n 项和 第 n-1 项开始。 然后，它将考虑第 n-1 项和第 n-2 项之间的关系， 并且继续向列表的前面移动， 知道列表的第 1 和第 2 项进行比较（可能会互换）。 可以看出， 通过一遍排序， 最小的表项将被移动到表的最前面。 因此， 重复 n-1 遍后就完成了整个表的排序。 （如果观察算法的工作过程，那么就会看到小的表项像气泡一样冒到了列表的前面）

　　我们先思考并写出冒泡排序法的伪代码，然后编写代码就容易很多了。 

　　----------------------------------------------------

　　给 N 赋值为 1. 表示列表的第一项。

　　while (N 的 值 <= 列表的长度 n - 1)

　　　　// 以下的步骤使得列表的第 N 项得到最小值 (此最小值是从第N项到最后项范围内的最小值，因为第 N 项之前已经排好序了)。 

　　　　P 赋值为 n; 

　　　　while (P > N)

　　　　　　if (第 P 项 < 第 P-1 项)

　　　　　　　　交换第 P 项和 第 P-1 项的值。

　　　　P = P + 1;

　　N = N + 1; 

     根据伪代码写出 java 代码， 这里列表用数组代替。 

public class BubbleSort 
{
    public static void main(String[] args) 
    {
        int n = 0;
        int p;
        int[] array = {1, 21, 8, 7, 68, 5, 20, 3, 22, 55, 99};
        
        while (n < array.length - 1)     //n 的取值从数组第一项~倒数第二项。 
        {
            p = array.length - 1;   // p 指向数组最后一项。  
            while (p > n) 
            {
                if (array[p] < array[p - 1])  //使得 array[p - 1] 小于 array[p]. 
                {
                    int temp = array[p - 1]; 
                    array[p - 1] = array[p];
                    array[p] = temp;  
                }
                p = p - 1; 
            }
            n = n + 1; 
        }
        
        //打印 数组。 
        for (int i = 0; i < array.length; i++)
        {
            System.out.print(array[i] + " ");
        }
    }
}

　　while 语句没有 for 循环语句通用，但是写伪代码的时候 while 更直观一些。 写代码可以将 while 替换成 for 循环，显得更紧凑一点。 第二点是用模块化思想封装一些过程，修改代码如下： 

public class BubbleSort
{
    public static void main(String[] args) 
    {
        int[] array = {1, 21, 8, 37, 68, 35, 20, 3, 22, 55, 99};
        
        bubbleSort(array);
        
        //打印 数组。 
        for (int i = 0; i < array.length; i++)
        {
            System.out.print(array[i] + " ");
        }
    }
    
    public static void bubbleSort (int[] array) 
    {
        int n, p; 
        for (n = 0; n < array.length - 1; n++)
        {
            for (p = array.length - 1; p > n; p--) 
            {
                if (array[p] < array[p - 1])  //使得 array[p - 1] 小于 array[p]. 
                {
                    exchange(array, p, p - 1);
                }
            }
        }
    }
    
    private static void exchange(int[] array, int i, int j)
    {
        int temp = array[i]; 
        array[i] = array[j]; 
        array[j] = temp;  
    }
}

　　上面的 exchange 方法封装了交换数组的两个位置的数值的过程。 注意实参 array 传给形参 array 的是数组的首项地址， 因此 exchange 方法实际上是交换了实参的两个表项的值。 这个正是我们想要的结果。