Java 冒泡排序算法

冒泡排序的算法

• 整个数列分成两部分：前面是无序数列，后面是有序数列
• 初始状态下，整个数列都是无序的，有序数列是空
• 如果一个数列有n个元素，则至多需要n-1趟循环才能保证数列有序
• 每一趟循环可以让无序数列中最大数排到最后，（也就是说有序数列的元素个数增加1）
• 每一趟循环都从数列的第一个元素开始进行比较，依次比较相邻的两个元素，比较到无序数列的末尾即可（而不是数列的末尾）
• 如果前一个大于后一个，交换

【示例一】:冒泡排序算法

public class TestBubbleSort1{
    public static void main(String [] args){
        //定义一个无序数组
        int [] arr = {75,87,56,45,89,100,76,34,89,97};
        //排序前输出
        System.out.println("排序前");
        for(int score :arr){
            System.out.print(score+"\t");
        }
        //排序
        //大循环：n个元素排序，则至多需要n-1趟循环
        for(int i=0;i<arr.length-1;i++){
            //小循环：每一趟循环都从数列的前两个元素开始进行比较，
			//比较到数组的最后
            for(int j=0;j<arr.length-1;j++){
                //如果前一个大于后一个
                if(arr[j] > arr[j+1]){
                    //交换
                    int temp;
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        //排序后输出
        System.out.println("\n排序后");
        for(int score :arr){
            System.out.print(score+"\t");
        }
    }
}

缺点1：
每一趟比较都要比较到数组的最后，没有必要，只要比较到无序数列的最后即可

  for(int j=0;j<scoreArr.length-1;j++){	}

	    i      j < ?
      	0      < 6
   		1      < 5
    	2      < 4
    	3      < 3
    	i      j<6-i    scoreArr.length-1-i     

解决：

j<scoreArr.length-1 修改为 j<scoreArr.length-1-i .

缺点2：

不管是否有序，都要进行n-1趟循环；
如何判断有序：比较了一趟，没有发生交换

解决：

定义一个符号量flag，默认有序true；发生交换，置为false，
一趟循环结束后，根据flag的值判断是否有序；有序，退出即可；

【示例二】:完善冒泡排序算法

public class TestBubbleSort2{
    public static void main(String [] args){
        //定义一个无序数组
        int [] arr = {75,87,56,45,89,100,76,34,89,97}; 
        //排序前输出
        System.out.println("排序前");
        for(int score :arr){
            System.out.print(score+"\t");
        }
        //排序
        bubbleSort(arr);       
        //排序后输出
        System.out.println("排序后");
        for(int score :arr){
            System.out.print(score+"\t");
        }
    }    
    public static void bubbleSort(int arr[]){
        //大循环：n个元素排序，则至多需要n-1趟循环
        int temp;
        int i;
        for(i=0;i<arr.length-1;i++){
            //1. 假设有序
            boolean flag = true;
           //2.小循环：每一趟循环都从数列的前两个元素开始进行比较，
            // 比较到数组的最后
            for(int j=0;j<arr.length-1-i;j++){
                //如果前一个大于后一个
                if(arr[j] > arr[j+1]){
                    //交换               
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    //发生了交换，数组无序
                    flag = false;
                }
            }
            //3.判断是否有序，有序，退出
            if(flag){
                break;
            }
        }
        //System.out.println("\n一共进行了"+(i+1)+"趟循环");
    }
}

这篇文章到这里就结束了，感谢大佬们驻足观看，大佬们点个关注、点个赞呗~

谢谢大佬~

---

作者：香芋味的猫丶

康康你手机号在过多少网站注册过！

>>相关阅读
《Java选择排序算法》