冒泡排序

参考了 白话经典算法系列之一 冒泡排序的三种实现

冒泡排序的算法和实现很简单。

以从小到大为例。

一组数，从头开始，拿出一个依次和之后每一个比较，如果前一个大于后一个，则交换顺序，直到循环完。

另外一个一种是，两两比较，把最大的沉到最后一个位置。

    /**
     * 从头到尾遍历，和之后的比较
     * @param arr
     */
    private static void bubbleSort(int[] arr){
        int i,j;
        for(i=0;i<arr.length-1;i++){
            for(j=i+1;j<arr.length;j++){
                if(arr[i] > arr[j]){
                    swap(arr,i,j);
                }
            }
        }
    }

    /**
     *
     * @param arr
     * @param i the index which value will be exchanged with index j
     * @param j
     */
    private static void swap(int[] arr,int i, int j){
        int t=arr[i];
        arr[i]=arr[j];
        arr[j]=t;
    }

    /**
     * 两两比较
     * @param arr
     */
    private static void bubbleSort2(int[] arr){
        int i,j;
        int size = arr.length;
        for(i=0;i<size;i++){ //i的值表示已排序的个数，不是数组下标,每排序一个数，都将最大的放到最右边
            for(j=1;j<size-i;j++){ //j的值可认为是数组下标
                if(arr[j-1] > arr[j]){
                    swap(arr,j-1,j);
                }
            }
        }
    }

    /**
     * 设置一个标志flag,当遍历了一趟却没有交换时flag设为false，显然已经排序结束
     * @param arr
     */
    private static void bubbleSort3(int[] arr){
        int j,k=arr.length;
        boolean flag = true;
        while (flag){
            flag = false;
            for(j=1;j<k;j++){
                if(arr[j-1] > arr[j]){
                    swap(arr,j-1,j);
                    flag = true;
                }
            }
            k--;
        }
    }

    /**
     * 两两比较，如果有1000个数，只有前10个是无序的,增加一个标志位，最大比较到标志位处
     * @param arr
     */
    private static void bubbleSort4(int[] arr){
        int i,k;
        k = arr.length;
        while(k>1){
            System.out.print(k + ",");
            int size = k;
            k = 0;
            for(i=1;i<size;i++){
                if(arr[i-1] > arr[i]){
                    swap(arr,i-1,i);
                    k = i;
                }
            }
        }
    }