排序高级之交换排序_鸡尾酒排序

简介:

鸡尾酒排序,也就是定向冒泡排序鸡尾酒搅拌排序搅拌排序 (也可以视作选择排序的一种变形), 涟漪排序来回排序 or 快乐小时排序, 是冒泡排序的一种变形。此算法冒泡排序的不同处在于排序时是以双向在序列中进行排序。


与冒泡排序不同的地方:

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

以序列(2,3,4,5,1)为例,鸡尾酒排序只需要访问一次序列就可以完成排序,但如果使用冒泡排序则需要四次。 但是在乱数序列的状态下,鸡尾酒排序与冒泡排序的效率都很差劲。


最差时间复杂度  O(n^2)
最优时间复杂度 O(n)
平均时间复杂度   O(n^2)


鸡尾酒排序动态图:



代码分析:

[html]  view plain  copy
 print ?
  1. package com.baobaotao.test;  
  2. /**  
  3.  * 排序研究  
  4.  * @author benjamin(吴海旭)  
  5.  * @email benjaminwhx@sina.com / 449261417@qq.com  
  6.  *  
  7.  */  
  8. public class Sort {  
  9.       
  10.     /**  
  11.      * 经典鸡尾酒排序  
  12.      * @param array 传入的数组  
  13.      */  
  14.     public static void cocatailSort(int[] array) {  
  15.         int length = array.length ;  
  16.         //来回循环length/2次  
  17.         for(int i=0;i<length/2;i++) {  
  18.             for(int j=i;j<length-i-1;j++) {  
  19.                 if(array[j] > array[j+1]) {  
  20.                     swap(array, j, j+1) ;  
  21.                 }  
  22.             }  
  23.             for(int j=length-i-1;j>i;j--) {  
  24.                 if(array[j] < array[j-1]) {  
  25.                     swap(array, j-1, j) ;  
  26.                 }  
  27.             }  
  28.             printArr(array) ;  
  29.         }  
  30.     }  
  31.       
  32.     /**  
  33.      * 鸡尾酒排序(带标志位)  
  34.      * @param array 传入的数组  
  35.      */  
  36.     public static void cocatailSortFlag(int[] array) {  
  37.         int length = array.length ;  
  38.         boolean flag1,flag2 = true ;  
  39.         //来回循环length/2次  
  40.         for(int i=0;i<length/2;i++) {  
  41.             flag1 = true ;  
  42.             flag2 = true ;  
  43.             for(int j=i;j<length-i-1;j++) {  
  44.                 if(array[j] > array[j+1]) {  
  45.                     swap(array, j, j+1) ;  
  46.                     flag1 = false ;  
  47.                 }  
  48.             }  
  49.             for(int j=length-i-1;j>i;j--) {  
  50.                 if(array[j] < array[j-1]) {  
  51.                     swap(array, j-1, j) ;  
  52.                     flag2 = false ;  
  53.                 }  
  54.             }  
  55.             if(flag1 && flag2) {  
  56.                 break ;  
  57.             }  
  58.             printArr(array) ;  
  59.         }  
  60.     }  
  61.       
  62.     /**  
  63.      * 按从小到大的顺序交换数组  
  64.      * @param a 传入的数组  
  65.      * @param b 传入的要交换的数b  
  66.      * @param c 传入的要交换的数c  
  67.      */  
  68.     public static void swap(int[] a, int b, int c) {  
  69.         int temp = 0 ;  
  70.         if(b < c) {  
  71.             if(a[b] > a[c]) {  
  72.                 temp = a[b] ;  
  73.                 a[b] = a[c] ;  
  74.                 a[c] = temp ;   
  75.             }  
  76.         }  
  77.     }  
  78.       
  79.     /**  
  80.      * 打印数组  
  81.      * @param array  
  82.      */  
  83.     public static void printArr(int[] array) {  
  84.         for(int c : array) {  
  85.             System.out.print(c + " ");  
  86.         }  
  87.         System.out.println();  
  88.     }  
  89.       
  90.     public static void main(String[] args) {  
  91.         int[] number={11,95,45,15,78,84,51,24,12} ;  
  92.         int[] number2 = {11,95,45,15,78,84,51,24,12} ;  
  93.         cocatailSort(number) ;  
  94.         System.out.println("*****************");  
  95.         cocatailSortFlag(number2) ;  
  96.     }  
  97. }  

结果分析:

[html]  view plain  copy
 print ? 在CODE上查看代码片 派生到我的代码片
  1. 11 12 45 15 78 84 51 24 95   
  2. 11 12 15 24 45 78 51 84 95   
  3. 11 12 15 24 45 51 78 84 95   
  4. 11 12 15 24 45 51 78 84 95   
  5. *****************  
  6. 11 12 45 15 78 84 51 24 95   
  7. 11 12 15 24 45 78 51 84 95   
  8. 11 12 15 24 45 51 78 84 95   

可见鸡尾酒排序排序的次数比普通冒泡排序要少很多。只需要4次,用了改进版的标志位鸡尾酒排序仅需要3次就可以完成排序。


转载请注明:http://blog.csdn.net/benjamin_whx/article/details/42456279

目录
相关文章
|
7月前
|
搜索推荐
【数据结构常见七大排序(三)上】—交换排序篇【冒泡排序】And【快速排序】
【数据结构常见七大排序(三)上】—交换排序篇【冒泡排序】And【快速排序】
【数据结构常见七大排序(三)上】—交换排序篇【冒泡排序】And【快速排序】
|
7月前
|
搜索推荐 测试技术
【数据结构常见七大排序(一)】—插入排序篇【直接插入排序】And【希尔排序】
【数据结构常见七大排序(一)】—插入排序篇【直接插入排序】And【希尔排序】
|
9月前
|
搜索推荐
排序——交换排序
排序——交换排序
64 0
|
9月前
|
机器学习/深度学习
数据结构实验之排序二:交换排序
数据结构实验之排序二:交换排序
|
算法
排序篇(三)----交换排序
排序篇(三)----交换排序
60 0
|
算法 搜索推荐 测试技术
【数据结构】 七大排序详解(壹)——直接插入排序、希尔排序、选择排序、堆排序
【数据结构】 七大排序详解(壹)——直接插入排序、希尔排序、选择排序、堆排序
|
算法
排序(3)之交换排序
今天小编给大家带来交换排序的内容,对于交换排序中的快速排序在理解上会相对困难一点,小编这里会配合图片给大家细细讲解。那么现在就开始我们今天的主题。
93 0
|
存储 搜索推荐 算法
八大排序之交换排序与计数排序 1
八大排序之交换排序与计数排序
108 0
|
机器学习/深度学习 算法 API
算法排序5——归并排序&分治思想
算法排序5——归并排序&分治思想
138 0
算法排序5——归并排序&分治思想
|
算法 API 索引
算法排序6——快速排序(分治思想)
对于左侧的数组数据,又可以取一个分界值,将该部分数据分成左右两部分,同样在左边放置较小值,右边放置较大值。右侧的数组数据也可以做类似处理
150 0
算法排序6——快速排序(分治思想)

热门文章

最新文章