阿布学排序之冒泡排序

package com.abuge;
/**
 * 冒泡排序：
 * 设数组长度为N
 * 方法1：
 * 步骤：（升序）
 * 1、比较相邻两个数如果前面的数据大于后面的数据，则交换
 * 2、这样数组的第0-N-1个数据进行遍历后，最大的一个数据就在第N-1个位置
 * 3、N=N-1，如果N不为0，就重复执行前面两步，否则排序完成
 * 
 * 方法2：
 * 设置循环标志，如果有一趟发生了交换则将标志位置为true，否则为false，如果有一趟没有发生交换，说明排序已经完成
 * 这优化了第一次必须进行n次遍历的冗余
 * @author AbuGe
 *
 *方法3：
 *对于某一个数组，前面小部分无序，后面大部分有序，且后面都大于前半部分，则须进一步优化。如：有一个100个数的数组，仅前面
 *10个无序，后面90个已经排好序且都大于前面10个数字，那么第一趟遍历后，最后交换的位置肯定小于10，且这个位置之后的数据已经
 *有序了，记录下这个位置，第二次只要从数组头部遍历到这个位置就可以。
 */
public class BubbleSortDemo 
{
	public static void bubbleSort_1(int[] a, int n)
	{
		for(int i = 0; i < n; i++)//n次遍历
		{
			for(int j = 1; j < n - i; j++)//n - i - 1次比较
			{
				if(a[j - 1] > a[j])
				{
					swap(a, j - 1, j);
				}
				
			}
		}
	}
	
	public static void bubbleSort_2(int[] a, int n)
	{
		boolean flag = true;
		int k = n;
		while(flag)
		{
			flag = false;
			for(int i = 1; i < k; i++)//k - 1次比较
			{
				if(a[i - 1] > a[i])
				{
					swap(a, i - 1, i);
					flag = true;
				}
				
			}
			k--;//每一次遍历后有一个数放在后面，从而遍历元素减少
		}
	}
	
	public static void bubbleSort_3(int[] a, int n)
	{
		int flag = n;
		int k;
		while(flag > 0)
		{
			k = flag;//设置需要遍历的元素个数
			flag = 0;//设置退出循环标志
			for(int i = 1; i < k; i++)//k - 1次比较
			{
				if(a[i - 1] > a[i])
				{
					swap(a, i - 1, i);
					flag = i;//因为循环到k - 1,不包括k记录的值
				}
				
			}
		}
	}
	public static void swap(int[] a, int x, int y)
	{
		int tmp = a[x];
		a[x] = a[y];
		a[y] = tmp;
	}
	
	public static void main(String[] args)
	{
		int[] a = {19, 34, 25, 27, 12, 26, 30};
		int n = a.length;
		System.out.print("排序前：");

		for(int i : a)
		{
			System.out.print(i + "\t");
		}
		
		System.out.println();
		
		//bubbleSort_1(a, n);
		
		//bubbleSort_2(a, n);
		
		bubbleSort_3(a, n);
		
		
		System.out.print("排序后：");
		for(int i : a)
		{
			System.out.print(i + "\t");
		}
	}
}