冒泡排序案例，鸡尾酒排序

注意比较第一个数和第二数!

1.冒泡排序（BubbleSort）

概念：依次比较相邻的两个数，将小数放在前面，大数放在后面；第一趟可得到：将最大数放到最后一位，第二趟可得到：将第二大的数放到倒数第二位，如此下去，重复以上过程，直至最终完成排序。
由于排序过程中，总是将小数往前放，大数往后放，相当于气泡往上升，所以称作冒泡排序。

思路：用二重循环实现，外循环变量设为i，内循环变量设为j。如果数组里有10个数，外循环重复9次，内循环依次重复9，8，…，1次。每次进行比较的两个元素都是与内循环j有关的，它们可以分别用a[j]和a[j+1]标识，i的值依次为1,2,…,9，对于每一个i, j的值依次为1,2,…10-i。

public class Test {
    public static void main(String[] args) {
        int[] arr = {6, 3, 8, 2, 9, 1};

        //外层循环控制排序趟数
        for (int i = 0; i < arr.length - 1; i++) {
            //内层循环控制每一趟排序多少次
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[i]) {
                    // 第2个位置的数
                    int temp = arr[j];
                    //把第一个位置的数给第二个位置上
                    arr[j] = arr[i];
                    //给第一个位置赋值
                    arr[i] = temp;
                }
            }
        }

        System.out.print("排序后数组为：");
        for (int i : arr) {
            System.out.print(i);
        }

        System.out.print("排序后数组为：");
        for (int i = 0; i < arr.length ; i++) {
            System.out.print(arr[i]);
        }
      }
     }

2.鸡尾酒排序

概念：也就是定向冒泡排序，也叫搅拌排序、来回排序。

鸡尾酒排序等于冒泡排序的轻微变形，不同的地方在于从低到高然后从高到低，而冒泡排序则仅从低到高去比较序列里的每个元素。他可以得到比冒泡排序稍微好一点的效能，原因是冒泡排序只从一个方向进行比对(由低到高)，每次循环只移动一个项目。

以序列(2,3,4,5,1)为例，鸡尾酒排序只需要访问两次（升序降序各一次）次序列就可以完成排序，但如果使用冒泡排序则需要四次。

思路：

鸡尾酒排序的过程为：

（1）先对数组从左到右进行冒泡排序（升序），则最大的元素去到最右端；

（2）再对数组从右到左进行冒泡排序（降序），则最小的元素去到最左端。以此类推，依次改变冒泡的方向，并不断缩小未排序元素的范围。

public class TestSort {

    public static void main(String[] args) {
        int[] s = {1,2,33,4,5};
        CocktailSort(s);
        for (int i : s) {
            System.out.println(i);
        }
    }
    static void CocktailSort(int[] arr) {
        int i, temp, left = 0, right = arr.length - 1;
        while (left < right) {
            for (i = left; i < right; i++) {
                if (arr[i] > arr[i + 1]) {
                    temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                }
            }
            right--;
            for (i = right; i > left; i--) {
                if (arr[i - 1] > arr[i]) {
                    temp = arr[i];
                    arr[i] = arr[i - 1];
                    arr[i - 1] = temp;
                }
            }
            left++;
        }
    }
}

3.ArrayList冒泡排序

public class TestSort {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList();
        list.add(1);
        list.add(12);
        list.add(13);
        list.add(14);
        list.add(5);
        Collections.sort(list);
        for (int i = 0; i < list.size() - 1; i++) {
            for (int j = i + 1; j < list.size(); j++) {
                if (list.get(i) > list.get(j)) {
                }
            }
        }
        System.out.println(list);
        System.out.println("***********************");
        for (int i = 0; i < list.size() - 1; i++) {
            for (int j = i + 1; j < list.size(); j++) {
                if (list.get(i) > list.get(j)) {
                    int temp = list.get(j);
                    list.set(j, list.get(i));
                    list.set(i, temp);
                }
            }
        }
        for (Integer integer : list) {
            System.out.println(integer);
        }
    }
}