冒泡排序的三种方法

冒泡排序是很简单的，原理就不说了，但是简单的东西也可以搞得复杂。那么下面是三种实现方法：

package Sort;
/*排序算法的耗时体现 一在于数值比较，二在于数据交换，比较比交换更耗时。

冒泡排序的比较次数为N*N/2，交换次数随机情况下为N*N/4  */
public class BubbleSort {
	private long[] a;
	private int elmentN;
	public BubbleSort(int max){
		a=new long[max];
		elmentN=0;
	}
	
	public void insert(long elment){
		a[elmentN]=elment;
		elmentN++;
	}
	public void display(){
		for(int i=0;i<elmentN;i++){
			System.out.print(a[i]+", ");
			
		}
		System.out.println();
	}
	

//第一种方法，经典方法，每次将剩余数字中最大的数字放到后面
	public void bubbleSort(){
		int i,j;
		for(i=elmentN-1;i>=1;i--){
			for(j=0;j<i;j++){
				if(a[j]>a[j+1]){
					swap(j,j+1);
				}
			}
			display();
		}
		
	}

//方法二 优化  在每次遍历交换时，如果发现该趟排序没有发生交换，则停止，数组已经有序
	public void bubbleSort2(){
		int k=elmentN-1;
		boolean flag=true;
		while(flag){
			flag=false;
			for(int i=0;i<k;i++){
				
				if(a[i]>a[i+1]){
					swap(i,i+1);
					
					flag=true;
				}
			
			}
			k--;
		}
	}

//方法三 再次优化  在每趟排序过程中，记录交换的位置，下一次遍历只要遍历到上一次最后的交换位置即可
	void bubbleSort3()  
	{  
	    int j, k;  
	    int flag;  
	      
	    flag = elmentN;  
	    while (flag > 0)  
	    {  
	        k = flag;  
	        flag = 0;  
	        for (j = 1; j < k; j++)  
	            if (a[j - 1] > a[j])  
	            {  
	                swap(j-1, j);  
	                flag = j;  
	            }  
	    }  
	}  
	private void swap(int elment1,int elment2){
		long temp=a[elment1];
		a[elment1]=a[elment2];
		a[elment2]=temp;
	}
	
	
	
	
	
	public static void main(String args[]){
		BubbleSort bs=new BubbleSort(10);
		bs.insert(656);
		bs.insert(541);
		bs.insert(231);
		bs.insert(63);
		bs.insert(21);
		
		bs.bubbleSort3();
		System.out.println(bs.elmentN);
		bs.display();
	}
}