算法__鸡尾酒排序

鸡尾酒排序：鸡尾酒排序是冒泡排序的升级，冒泡排序在第一轮比较完之后，会从0位继续比较；鸡尾酒排序是在第一轮排序完之后从尾部往前比较。举个例子：

2

3

4

5

6

7

8

1

冒泡排序：

              第一轮：1. 2和3比较，不交换；

                            2. 2和4比较，不交换；

                            3. 4和5比较，不交换；

                            4. 5和6比较，不交换；

                            5. 6和7比较，不交换；

                            6. 7和8比较，不交换；

                            7. 8和1比较，8和1交换

2

3

4

5

6

7

1

8

             第二轮：1. 2和3比较，不交换

                            ...

                           6. 7和1比较，交换

2

3

4

5

6

1

7

8

 除了1，其他位置是有序的。但是冒泡排序得循环几轮比较。

 

鸡尾酒排序：1. 第一轮和冒泡排序

2

3

4

5

6

7

1

8

                     2. 第二轮从右开始比较

                        1. 7和1比较，1和7交换

2

3

4

5

6

1

7

8

                        2. 6和1比较，6和1交换

2

3

4

5

1

6

7

8

                        3. 5和1比较，5和1交换

2

3

4

1

5

6

7

8

                        4. 4和1比较，4和1交换

2

3

1

4

5

6

7

8

                        5. 3和1比较，3和1交换

2

1

3

4

5

6

7

8

                        6. 2和1比较，2和1交换

1

2

3

4

5

6

7

8

                     3. 第三轮从0向右，判断没有需要交换的说明已经排序好了。

鸡尾酒排序优点：对于这种很大一块区域是有序的比冒泡优化了好多。

 

代码如下：

public void CockTailSort(int arry[]) {
        int size = arry.length / 2;
        //是否已经排好序
        boolean isHadSort;
        //左边的排好序的最右端
        int leftPosition = 0;
        int firstPostion = 0;
        //右边的排序的最左端
        int rightPosition = arry.length - 1;
        int lastPostion = arry.length - 1;

        for (int i = 0; i < size; i++) {
            isHadSort = true;
            //从左向右排序
            for (int j = firstPostion; j < lastPostion; j++) {
                if (arry[j] > arry[j + 1]) {
                    arry[j] ^= arry[j + 1];
                    arry[j + 1] ^= arry[j];
                    arry[j] ^= arry[j + 1];

                    rightPosition = j;
                    isHadSort = false;
                }
            }

            if (isHadSort)
                break;
            lastPostion = rightPosition;
            isHadSort = true;

            for (int z = lastPostion; z > firstPostion; z--) {
                if (arry[z] < arry[z - 1]) {
                    arry[z] ^= arry[z - 1];
                    arry[z - 1] ^= arry[z];
                    arry[z] ^= arry[z - 1];

                    leftPosition = z;
                    isHadSort = false;
                }
            }

            if (isHadSort)
                break;
            firstPostion = leftPosition;

        }
}