双向冒泡排序算法

冒泡排序算法是一种较为简单的并且稳定的排序算法,该算法的时间复杂度最好为O(n),最差时为O(n^2),需要的空间复杂度为O(1)。

这里的算法稳定性是指 经过排序后,各元素仍然能保持它们在排序之前的相对次序,就称该算法是稳定的,反之,则为不稳定的。

例如,一组数排序前是a1,a2,a3,a4,a5,其中a2=a4,经过某种排序后a1,a2,a4,a3,a5,则说明这种排序是稳定的,因为a2排序前后都在a4前面;若排序的结果是a1,a4,a2,a3,a5,则该排序就不是稳定的了。——摘自《Java程序员面试笔试宝典》

一种较为常见的冒泡排序算法如下:

 1     /**
 2      * 冒泡排序
 3      * @param data 输入为一个待排序的整形数组
 4      */
 5     public static int[] bubbleSort(int[] data){
 6         int size = data.length;
 7         for(int i=0;i<size-1;i++){
 8             for(int j=0;j<size-1-i;j++){
 9                 if(data[j]>data[j+1]){
10                     int temp = data[j];
11                     data[j] = data[j+1];
12                     data[j+1] = temp;
13                 }
14             }
15         }
16         return data;
17     }

可以看出,经典的冒泡排序是选择从一端开始,通过比较相邻元素大小并交换次序的。实际上对冒泡排序加以改进,从两端进行排序,也就是所谓的“双向冒泡排序”,可以有更好的效率。如果按照排序结果从小到大输出,可以按照“较大气泡从左到右移动,较小气泡从右到左移动”来实现双向冒泡排序的效果;一种实现代码(Java版)如下:

 1 /**
 2      * 双向冒泡排序
 3      * @param num
 4      */
 5     public static int[] doubleBuddleSort(int[] num){
 6         int left=0,right = num.length-1;
 7         while(left<right){
 8             //较大气泡从左边向右边移动
 9             for(int i=left+1;i<=right;i++){
10                 if(num[left]>num[i]){
11                     int temp = num[left];
12                     num[left] = num[i];
13                     num[i] = temp;
14                 }
15             }
16             left++;
17             
18             //较小气泡从右边向左边移动
19             for(int i=right-1;i>=left;i--){
20                 if(num[i]>num[right]){
21                     int temp = num[right];
22                     num[right] = num[i];
23                     num[i] = temp;
24                 }
25             }
26             right--;
27         }
28         
29         return num;
30     }

 

    原文作者:JiaJoa
    原文地址: https://www.cnblogs.com/JiaJoa/p/7777482.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞