冒泡算法

package it.cast.sort;

public class Maopao {

    /*
     * 1.1 最简单的排序算法
     * 1,在每一次内循环时，a[i]与a[j]比较（j是不断变大的， 内循环中，i的大小是不变化的，
     * 且第一个j等于i+1，当出现a[i]>a[j]时，将两个数字顺序交换位置
     *2,数字是从前边往后边进行比较
     */
    public static void Maopao1(int a[]) {
        for (int i = 0; i < a.length; i++) {

            for (int j = i + 1; j < a.length; j++) {
                if (a[i] > a[j]) {
                    // 交换数字
                    int t = a[i];
                    a[i] = a[j];
                    a[j] = t;
                }
            }
        }
    }

/*1.2 冒泡排序算法：相邻的两两关键词按照某种要求进行比较，
 * 根据比较结果进行排序，直到没有反顺结果为止。
 * 数字是从后边往前进行相互之间交换的，一直比较到内循环的i位置
 * 注意下标越界的情况
 * 例如，i=4，进行内循环（0到3之间已经排好序了，但4以及4以后的位置上的数字都比3位置的数字大），所以i=4，j=5时，
 a[5]与a[4]比较也是可以的，这样不会出现某些位置不进行比较的情况
 */    public static void Maopao2(int a[])
    {
        for (int i = 0; i < a.length; i++) {
            for (int j = a.length-1; j >i; j--) {
                if (a[j]<a[j-1]) {
                    //交换数字
                    int t=a[j];
                    a[j]=a[j-1];
                    a[j-1]=t;
                }
            }
        }
    }
    
 
/*改进的冒泡算法
*在上述的排列中，相邻比较是从后边往前进行的。当i=0时，内循环将所有的数字进行了比较。比较判断出，
*从第四个位置开始，数字的顺序恰好是我们希望得到的顺序，在这个位置我们可以停下来，可以不在进行循环。
*但在上述循环中i=3（i的大小表示数字所在的位置）以后时，数字已经有顺序了，但是循环还是不会停下来
*因此在改进的算法中，设定一个标记，当外循环的i变化到3时，整个循环将会停止下来
*但是，在现实情况下，不知道输入或者是所给的数据在哪个位置符合我们的要求，跳出循环，因此我们
*在内循环中设置一个标记
*/
 
 public static void Maopao3(int[] a){
     boolean judge=true;
     for (int i = 0; i < a.length&&judge; i++) {
        judge=false;
        for (int j=a.length-1; j>i; j--) {
            if (a[j]<a[j-1]) {
                int t=a[j];
                a[j]=a[j-1];
                a[j-1]=t;
                judge=true;
            }
        }
    }
    
 }
    public static void main(String[] args) {
        int a[] = { 1, 4, 7, 5, 6, 0, 9 };
    Maopao1(a);
    //Maopao2(a);
        //Maopao3(a);
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
    }
}