java冒泡排序

package arithmetic;

/**
 * 冒泡算法
 * 思路：
 *      比较相邻的元素。如果第一个比第二个大，就交换他们两个。
 *      对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
 *      针对所有的元素重复以上的步骤，除了最后一个。
 *      持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
 * @author Shoulder
 *
 */
public class BubbleSort {
	public static void main(String[] args) {
		//定义所需要排序的数组
		int[] arr = new int[10];
		//生成100以内的随机数
		for(int i=0;i<10;i++)
		{
			arr[i] = (int)(Math.random()*100);
		}
		arr = sortStartArr(arr, arr.length);
		printArr(arr);
		arr = sortEndArr(arr, arr.length);
		printArr(arr);
		arr = bubbleSort(arr, arr.length);
		printArr(arr);
	}
	
	//输出数组
	public static void printArr(int arr[])
	{
		for(int i=0;i<arr.length;i++)
		{
			System.out.print(arr[i]+"\t");
		}
		System.out.println();
	}
	
	//方法，交换数组中两个数的位置
	public static void swap(int[] arr,int a,int b){
		int temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}
	
	//从前往后比较
	public static int[] sortStartArr(int[] arr,int length)
	{
		//进行length-1次比较
		for(int i=0;i<length-1;i++)
		{
			//前后两个数比较，将大的放后边，所以最后的是最大的，然后进行下次循环，最后的不用比较，所以一次获得一个最大的数
			for(int j=0;j<length-1-i;j++)
			{
				if(arr[j]>arr[j+1])
				{
					swap(arr, j, j+1);
				}
			}
		}
		return arr;
	}
	
	//从后往前比较
	public static int[] sortEndArr(int[] arr,int length)
	{
		//进行length-1次比较
		for(int i=0;i<length-1;i++)
		{
			//前后两个数比较，将小的放前边，所以最前的是最小的，然后进行下次循环，最前的不用比较，所以一次获得一个最小的数
			for(int j=length-1;j>i;j--)
			{
				if(arr[j]<arr[j-1])
				{
					swap(arr, j, j-1);
				}
			}
		}
		return arr;
	}
	
	//优化。如果一个数组是有序的，照上面的算法每次都要比较，这样对数组是多余的。改进一下，发现数组是有序的，就将后面的省去，跳出循环
	public static int[] bubbleSort(int[] arr,int length)
	{
		for(int i=0;i<length;i++)
		{
			int flag = 0;	//记录数组是否有序，0为有序，假设开始为有序	
			for(int j=length-1;j>i;j--)
			{
				if(arr[j]<arr[j-1])
				{
					swap(arr,j-1, j);
					flag  = 1;	//不是有序的，记录为1
				}
			}
			if(flag==0)		//如果有序，挑出循环
			{
				break; 
			}
		}		
		return arr;
	}
}