内部排序算法之冒泡排序

冒泡排序:
它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。
这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端,故名。

在要排序的一组数中,对当前还未排好序的范围内的全部数,自上而下对相邻的两个数依次进行比较和调整,让较大的数往下沉,较小的往上冒。即:每当两相邻的数比较后发现它们的排序与排序要求相反时,就将它们互换。

冒泡排序算法的运作如下:(从后往前)

1.比较相邻的元素。如果第一个比第二个大,就交换他们两个。
2.对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。
3.针对所有的元素重复以上的步骤,除了最后一个。
4.持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。

这里写图片描述

原理是临近的数字两两进行比较,按照从小到大或者从大到小的顺序进行交换,

这样一趟过去后,最大或最小的数字被交换到了最后一位,

然后再从头开始进行两两比较交换,直到倒数第二位时结束,其余类似看例子

这里图片描述了该进行多少趟循环(n-1);

排序需要很多趟,每一趟里面有很多次

这就说明了有外部循环与内部循环
外部循环:进行的趟数的循环
内部循环:进行的交换位置次数的循环

每一趟冒出一个最大的数,放到最后面(?????如何做到的,通过相邻元素比较,交换位置)

第一趟循环把数组的最大元素冒泡到最后一个位置

第二趟循环,不在检查数组最后一个元素,不改变,
把数组第二大数放在倒数第二位置

每一趟循环都把当前最大元素放在数组的合适位置中
n-1趟后,算法完成了所有元素排序

每趟该进行多少次循环–交换位置次数
每一趟确定了一个最大元素后就不在理会那个位置(观察图片)
第一趟有0个元素确定位置,要进行n-1次交换位置(3个元素要交换2次位置)
第二趟有一个元素确定了位置,要进行n-2次交换位置(比第一趟少一次,比第一趟少一个元素移动)

每一趟要进行n-i次位置变换(默认是从1开始数起)i是要进行的趟数
示例:

例子为从小到大排序,

原始待排序数组| 6 | 2 | 4 | 1 | 5 | 9 |

第一趟排序(外循环)

第一次两两比较6 > 2交换(内循环)

交换前状态| 6 | 2 | 4 | 1 | 5 | 9 |

交换后状态| 2 | 6 | 4 | 1 | 5 | 9 |

第二次两两比较,6 > 4交换

交换前状态| 2 | 6 | 4 | 1 | 5 | 9 |

交换后状态| 2 | 4 | 6 | 1 | 5 | 9 |

第三次两两比较,6 > 1交换

交换前状态| 2 | 4 | 6 | 1 | 5 | 9 |

交换后状态| 2 | 4 | 1 | 6 | 5 | 9 |

第四次两两比较,6 > 5交换

交换前状态| 2 | 4 | 1 | 6 | 5 | 9 |

交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

第五次两两比较,6 < 9不交换

交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |

交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

第二趟排序(外循环)

第一次两两比较2 < 4不交换

交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |

交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

第二次两两比较,4 > 1交换

交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |
交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

第三次两两比较,4 < 5不交换

交换前状态| 2 | 1 | 4 | 5 | 6 | 9 |
交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

第四次两两比较,5 < 6不交换

交换前状态| 2 | 1 | 4 | 5 | 6 | 9 |

交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

第三趟排序(外循环)

第一次两两比较2 > 1交换

交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

第二次两两比较,2 < 4不交换

交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |
交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

第三次两两比较,4 < 5不交换

交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |
交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

第四趟排序(外循环)无交换

第五趟排序(外循环)无交换

排序完毕,输出最终结果1 2 4 5 6 9

例子引自经典排序算法 - 冒泡排序Bubble sort

时间复杂度
若文件的初始状态是正序的,一趟扫描即可完成排序。所需的关键字比较次数和记录移动次数均达到最小值:
这里写图片描述
所以,冒泡排序最好的时间复杂度为
O(n)
若初始文件是反序的,需要进行n-1
趟排序。每趟排序要进行n-i
次关键字的比较(1≤i≤n-1),且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下,比较和移动次数均达到最大值:
这里写图片描述
冒泡排序的最坏时间复杂度为
O(n²)
综上,因此冒泡排序总的平均时间复杂度为
O(n²)

算法稳定性
冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较,交换也发生在这两个元素之间。所以,如果两个元素相等,我想你是不会再无聊地把他们俩交换一下的;如果两个相等的元素没有相邻,那么即使通过前面的两两交换把两个相邻起来,这时候也不会交换,所以相同元素的前后顺序并没有改变,所以冒泡排序是一种稳定排序算法。

Java代码实现:

package javastudy;

public class BubbleSort {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int A[]={6,2,4,1,5,9};
        System.out.println("冒泡排序前的数组:");
        show(A);
        bubble(A);
        System.out.println("冒泡排序后的数组:");
        show(A);        
    }
    private static void show(int[] A) {
        for(int i=0;i<A.length;i++){
            System.out.print(A[i]+" ");
        }
        System.out.println();
    }
    public static void bubble(int[] A){
        for(int i=0;i<=A.length-2;i++){//外部循环
            for(int j=0;j<=A.length-2-i;j++){//内部循环
                if(A[j]>A[j+1]){//比较两个元素的大小,如果前一个大,则交换
                    int temp=A[j];
                    A[j]=A[j+1];
                    A[j+1]=temp;

                }
            }
        }
    }

}

一个小技巧:
Java中若需要重写的代码多且要重复使用多次,可利用重构,把这些重复的代码组成一个函数,需要时调用即可
例如上面的show函数

1.选中需要重复代码部分
2.右键选Refactor
3.refactor中选Extract Method
4.写上函数名即可

冒泡排序优化
思想1:当遇到一趟里面(内部循环)每一相邻相隔两个元素都不需要交换位置,证明排序已经排好了,下面的剩余的趟数就不需要在进行了

Java代码:

package javastudy;

public class BubbleSort {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int A[]={6,2,4,1,5,9};
        System.out.println("冒泡排序前的数组:");
        show(A);
        bubble(A);
        System.out.println("冒泡排序后的数组:");
        show(A);        
    }
    private static void show(int[] A) {
        for(int i=0;i<A.length;i++){
            System.out.print(A[i]+" ");
        }
        System.out.println();
    }
    public static void bubble(int[] A){
        for(int i=0;i<=A.length-2;i++){//外部循环
            boolean flag=false;
            for(int j=0;j<=A.length-2-i;j++){//内部循环

                if(A[j]>A[j+1]){//比较两个元素的大小,如果前一个大,则交换
                    int temp=A[j];
                    A[j]=A[j+1];
                    A[j+1]=temp;
                    flag=true;//只要执行过一次内部循环的交换位置,flag就是true
                }

            }
            if(!flag)//只有内部循环交换位置一次都没有执行过才会跳出
            {
                break;
            }
        }
    }

}

冒泡排序优化
思想二:
每一次冒泡可以找出最大元素,也可以通过同样道理找最小元素,如果排序时,通过冒泡找最大元素放在最后,和冒泡找出最小元素,一次排序可以确定这次的最大最小元素,从而使排序趟数几乎减少一半

    public static void bubble_2(int[]A){
        int low=0;
        int high=A.length-1;//low和high确定了n个元素
        int temp,j;
        while(low<high){
            for(j=low;j<high;j++){//正向冒泡,找出最大值
                if(A[j]>A[j+1]){
                    temp=A[j];
                    A[j]=A[j+1];
                    A[j+1]=temp;
                }
            }
            high--;//最后一位确定了,就前移

            for(j=high;j>low;j--){//反向冒泡,找出最小值
                if(A[j]<A[j-1]){
                    temp=A[j];
                    A[j]=A[j-1];
                    A[j-1]=temp;
                }               
            }
            low++;//第一位确定了就,后移
        }//j的起始位置是low和high的原因是每进行一趟都可以确定一个最大最小元素,然后通过high--;与low++忽略上一次的最大最小元素,减少循环次数,for循环中的判断条件也是如此
    }
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值