算法__雞尾酒排序

雞尾酒排序：雞尾酒排序是冒泡排序的升級，冒泡排序在第一輪比較完之後，會從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;

        }
}