**鸡尾酒排序**，也就是**定向冒泡排序**，**雞尾酒攪拌排序**，**攪拌排序**（也可以視作選擇排序的一種變形），**漣漪排序**，**來回排序**或**快乐小時排序**，是冒泡排序的一種变形。此演算法与冒泡排序的不同處在於排序時是以双向在序列中進行排序。

伪代码
---

将一个序列由小到大进行排序：

```
**function** cocktail_sort(list, list_length){ // the first element of list has index 0
    bottom = 0;
    top = list_length - 1;
    swapped = true; 
    **while**(swapped == true) // if no elements have been swapped, then the list is sorted
    {
        swapped = false; 
        **for**(i = bottom; i < top; i = i + 1)
        {
            **if**(list[i] > list[i + 1])  // test whether the two elements are in the correct order
            {
                swap(list[i], list[i + 1]); // let the two elements change places
                swapped = true;
            }
        }
        // decreases top the because the element with the largest value in the unsorted
 // part of the list is now on the position top 
        top = top - 1; 
        **for**(i = top; i > bottom; i = i - 1)
        {
            **if**(list[i] < list[i - 1]) 
            {
                swap(list[i], list[i - 1]);
                swapped = true;
            }
        }
        // increases bottom because the element with the smallest value in the unsorted 
 // part of the list is now on the position bottom 
        bottom = bottom + 1;  
    }
}
```

与冒泡排序不同的地方
----------

鸡尾酒排序等於是冒泡排序的輕微變形。不同的地方在於從低到高然後從高到低，而冒泡排序則僅從低到高去比較序列裡的每個元素。他可以得到比冒泡排序稍微好一點的效能，原因是冒泡排序只從一個方向進行比對（由低到高），每次循環只移動一個項目。

以序列（2,3,4,5,1）為例，鸡尾酒排序只需要訪問一次序列就可以完成排序，但如果使用冒泡排序則需要四次。但是在亂數序列的狀態下，鸡尾酒排序與冒泡排序的效率与其他众多排序算法相比均比较低。

實作範例
----

### C语言

```
void cocktail\_sort(int arr[], int len) {
 int i, left = 0, right = len - 1;
 int temp;
 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++;
 }
}

```

### C++

```
template<typename T> //整數或浮點數皆可使用,若要使用物件(class)時必須設定大於(>)的運算子功能
void cocktail\_sort(T arr[], int len) {
 int j, left = 0, right = len - 1;
 while (left < right) {
 for (j = left; j < right; j++)
 if (arr[j] > arr[j + 1])
 swap(arr[j], arr[j + 1]);
 right--;
 for (j = right; j > left; j--)
 if (arr[j - 1] > arr[j])
 swap(arr[j - 1], arr[j]);
 left++;
 }
}

```

### Rust

```
fn cocktail\_sort<T: PartialOrd>(arr: &mut [T]) {
 let mut bottom: usize = 0;
 let mut top = arr.len() - 1;
 let mut swapped = true;

 while swapped {
 swapped = false;
 for i in bottom..top {
 if arr[i] > arr[i+1] {
 arr.swap(i, i+1);
 swapped = true;
 }
 }

 top -= 1;
 for j in ((bottom + 1)..=top).rev() {
 if arr[j] < arr[j - 1] {
 arr.swap(j, j - 1);
 swapped = true;
 }
 }
 bottom += 1;
 }
}

```

### JAVA

```
public static void cocktail\_sort(int[] arr) { 
 int i, left = 0, right = arr.length - 1;
 int temp;
 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++;
 }
}

```

### JavaScript

```
Array.prototype.cocktail\_sort = function() {
 var i, left = 0, right = this.length - 1;
 var temp;
 while (left < right) {
 for (i = left; i < right; i++)
 if (this[i] > this[i + 1]) {
 temp = this[i];
 this[i] = this[i + 1];
 this[i + 1] = temp;
 }
 right--;
 for (i = right; i > left; i--)
 if (this[i - 1] > this[i]) {
 temp = this[i];
 this[i] = this[i - 1];
 this[i - 1] = temp;
 }
 left++;
 }
};

```

### PHP

```
function swap(&$x, &$y) {
	$t = $x;
	$x = $y;
	$y = $t;
}
function cocktail\_sort(&$arr) {//php的陣列視為基本型別，所以必須用傳參才能修改原陣列
	$left = 0;
	$right = count($arr) - 1;
	while ($left < $right) {
		for ($j = $left; $j < $right; $j++)
			if ($arr[$j] > $arr[$j + 1])
				swap($arr[$j], $arr[$j + 1]);
		$right--;
		for ($j = $right; $j > $left; $j--)
			if ($arr[$j - 1] > $arr[$j])
				swap($arr[$j - 1], $arr[$j]);
		$left++;
	}
}

```

### Python 2.7

```
def cocktail\_sort(l):
    l\_len = len(l)
    for i in range(l\_len, 0, -1):
        rem\_i\_l\_len = abs(i - l\_len)
        isNeedContinue = False
        obverse\_count = len(l[rem\_i\_l\_len : i-1])
        reverse\_count = len(l[rem\_i\_l\_len + 1 : i-1])
        
        for j in range(obverse\_count):
            if l[j] > l[j + 1]:
                l[j], l[j + 1] = l[j + 1], l[j]
                isNeedContinue = True
        # you can print this to observe the whole process
        # print l
        
        for j in range(reverse\_count, 0, -1):
            if l[j] < l[j - 1]:
                l[j], l[j - 1] = l[j - 1], l[j]
                isNeedContinue = True
        # you can print this to observe the whole process
        # print l
        
        if isNeedContinue:
            continue
        else:
            return
  
        
if \_\_name\_\_ == '\_\_main\_\_':
    sample\_list = [6,5,4,3,2,100]
    cocktail\_sort(sample\_list)
    print(sample\_list)

```

### Python 3.10

```
def cocktail\_sort(arr: list, bottom: int = None, top: int = None):
    if not bottom and not top:
        bottom, top = 0, len(arr) - 1

    if bottom == top or bottom > top:
        return

    swapped: bool = False
    for i in range(bottom, top):
        if arr[i] > arr[i + 1]:
            arr[i + 1], arr[i] = arr[i], arr[i + 1]
            swapped = True

    for i in range(top - 1, bottom, -1):
        if arr[i] < arr[i - 1]:
            arr[i - 1], arr[i] = arr[i], arr[i - 1]
            swapped = True

    if not swapped:
        return

    cocktail\_sort(arr, bottom + 1, top - 1)

if \_\_name\_\_ == '\_\_main\_\_':
    sample\_list = [3, 7, 5, 1, 6, 4, 8, 2]
    cocktail\_sort(sample\_list)
    print(sample\_list)

```

### Golang

```
func cocktailSort(arr []int) {
 left := 0
 right := len(arr) - 1

 for left < right {
 for i := left; i < right; i++ {
 if arr[i] > arr[i+1] {
 arr[i], arr[i+1] = arr[i+1], arr[i]
 }
 }
 right--

 for i := right; i > left; i-- {
 if arr[i-1] > arr[i] {
 arr[i-1], arr[i] = arr[i], arr[i-1]
 }
 }
 left++
 }
}

```

  

### Julia (程式語言)

```
# Julia Sample : CocktailSort

function CocktailSort(A)
 isordered, lo, hi = false, 1, length(A)
 
 while !isordered && hi > lo
 isordered = true
 
 for i=lo+1:hi
 if A[i] < A[i-1]
 A[i-1], A[i] = A[i], A[i-1]
 isordered = false
 end
 end
 
 hi -= 1
 
 if isordered || hi ≤ lo 
 break 
 end

 for i in hi:-1:lo+1
 if A[i-1] > A[i]
 A[i-1], A[i] = A[i], A[i-1]
 isordered = false
 end
 end
 lo += 1
 end
 return A
end

# Main Code
A = [16,586,1,31,354,43,3]
println(A) # Original Array
println(CocktailSort(A)) # Cocktail Sort Array

```

複雜度
---

鸡尾酒排序最糟或是平均所花費的次數都是O(n^{2})，但如果序列在一開始已經大部分排序過的話，會接近O(n)。

外部連結
----

* Java source code and an animated demo of cocktail sort (called bi-directional bubble sort) and several other algorithms
* Implementations of cocktail sort in several different programming languages

|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 

| * 
* 论
* 编
排序算法 |
| --- |
|  |
| 理论 | 
* 計算複雜性理論
* 大O符号
* 全序关系
* 数据结构术语列表
* 原地算法
* 稳定性
* 比较排序
* 自适应排序（英语：）
* 排序网络（英语：）
* 整数排序（英语：）
* X+Y排序（英语：）
* 量子排序（英语：）

 |
|  |
| 交换排序 | 
* 冒泡排序
* 鸡尾酒排序
* 奇偶排序
* 梳排序
* 侏儒排序
* 快速排序
* 慢速排序
* 臭皮匠排序
* Bogo排序

 |
|  |
| 选择排序 | 
* 选择排序
* 堆排序
* 平滑排序（英语：）
* 笛卡尔树排序（英语：）
* 锦标赛排序（英语：）
* 圈排序（英语：）
* 弱堆排序（英语：）

 |
|  |
| 插入排序 | 
* 插入排序
* 希尔排序
* 伸展排序
* 二叉查找树排序
* 图书馆排序
* 耐心排序

 |
|  |
| 归并排序 | 
* 归并排序
* 梯级归并排序（英语：）
* 振荡归并排序（英语：）
* 多相归并排序（英语：）

 |
|  |
| 分布排序 | 
* 美国旗帜排序（英语：）
* 珠排序
* 桶排序
* 爆炸排序（英语：）
* 计数排序
* 比較計數排序
* 插值排序
* 鸽巢排序
* 相邻图排序（英语：）
* 基数排序
* 闪电排序（英语：）

 |
|  |
| 并发排序 | 
* 双调排序器（英语：）
* Batcher归并网络
* 两两排序网络（英语：）

 |
|  |
| 混合排序 | 
* 塊排序（英语：）
* Tim排序
* 内省排序
* Spread排序（英语：）
* 归并插入排序（英语：）

 |
|  |
| 其他 | 
* 拓撲排序
* 煎餅排序
* 意粉排序（英语：）

 |

 |

|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 

| * 
* 论
* 编
算法 |
| --- |
|  |
| 排序 | 

|  |  |
| --- | --- |
| 比较排序 | 
* 冒泡排序
* 选择排序
* 插入排序
* 希尔排序
* 快速排序
* 归并排序
* 堆排序
* 鸡尾酒排序
* 梳排序
* 侏儒排序
* 图书馆排序
* 内省排序
* 奇偶排序

 |
|  |
| 线性时间排序 | 
* 鸽巢排序
* 基数排序
* 計數排序
* 桶排序

 |
|  |
| 并行排序 | 
* 排序网络（英语：）
* Batcher归并网络

 |
|  |
| 不实用的 | 
* Bogo排序
* 臭皮匠排序

 |
|  |
| 图 | 
* 拓撲排序

 |

 |
|  |
| 搜索 | 

|  |  |
| --- | --- |
| 列表 | 
* 线性搜索
* 二分搜索
* 插值搜尋

 |
|  |
| 树・图 | 
* 广度优先搜索
	+ 最良優先搜索（英语：）
	+ 均一开销搜索
	+ A\*
* 深度优先搜索
	+ 迭代深化深度优先搜索
	+ 深度限制搜索（日语：）
	+ 双向搜索
* 分枝限定法（英语：）

 |
|  |
| 字符串 | 
* KMP算法
* 博耶-穆尔字符串搜索算法
* AC自动机算法
* 拉宾-卡普算法
* bitap算法

 |

 |
|  |
| 最短路问题 | 
* 戴克斯特拉算法
* 贝尔曼-福特算法
* A\*搜尋演算法
* Floyd-Warshall算法

 |
|  |
| 最小生成树 | 
* 普林姆算法
* 克鲁斯克尔演算法

 |
|  |
| 最大流最小割 | 
* 福特-富尔克森算法
* 埃德蒙兹-卡普算法
* 迪尼茨算法

 |
|  |
| 线性规划 | 
* 单纯形法
* 卡马卡尔算法（英语：）

 |
|  |
| 順序統計量 | 
* 选择算法
* 中位数的中位数（英语：）

 |
|  |
| 種類 | 
* 精确算法
* 近似算法
* 随机化算法

 |
|  |
| 其他 | 
* 分治法
* 动态规划
* 贪心算法

 |
|  |
| **Category:算法** |

 |