冒泡排序优化

import java.util.Arrays;

/*冒泡排序的思想：比较相邻的两个数，如果前一个比后一个大，则将其交换位置。*/

public class BubbleSort {
    public static void main(String[] args) {
		int [] number ={4,58,11,34,88,45};	
	/*	6 是number的长度*/
		Bubble1(number,6);
		
        for(int i=0;i<6;i++)
        {
        	System.out.print(number[i]+" ");        	
        }
   }
    //第一种方法完全就是按照冒泡排序的定义来写的
    //代码完全没有经过优化
    public static void Bubble1(int[] a,int n){
        int i,j;
        for(i=0;i<n-1;i++){
            for(j=1;j<n-i;j++){
                if(a[j-1]>a[j]){
                    swap(a,j-1,j);
                    //int k;
                    //k=a[j-1];
                    //a[j-1]=a[j];
                    //a[j]=k;
            }
        }
    }
   }
   //第二种方法代码优化一下 写一个标志位,如果一趟下来发生交换则标志为true，如果未发生交换，为false
    //则代表排序已完成
    public void Bubble2(int[]a,int n){
        int u,v;
        boolean flag;
        flag=true;
        while(flag){
            flag=false;
            for(u=0;u<n-1;u++){
                for(v=1;v<n-u;v++){
                    if(a[v-1]>a[v])
                        swap(a,v-1,v);
                }
                flag=false;
            }
            }

    }
//第三种方法，如果有一个50个数的数组，仅前面10个数是无序的，后面40个数是有序的，并且大于前面10个数，那么
    //第一次排序后，最后发生交换的位置必小于10，且这个位置之后的数据必定是有序的，记录下这个位置后，
    //以后遍历就从头到这个位置就可以了
    public void Bubble3(int[]a,int n){
        int p,q;
        int flag1=n;
        while(flag1>0){
            q=flag1;
            flag1=0;
            for(p=1;p<q;p++){
                if(a[p-1]>a[p])
                    swap(a,p-1,p);
                flag1=p;
            }
        }
    }
    public static void swap(int a[],int p,int q ){
        int k;
        k=a[p];
     a[p]=a[q];
        a[q]=k;

    }  
    

}