day3 test02

package day3;

public class test02 {
	public static void main(String args[])
	{
		int[] arr = {38,12,1,189,456,237,98,199,7};
		System.out.println("排序前：");
		listArr(arr);
		
		System.out.println("选择排序后：");
		selectSort(arr);
		listArr(arr);
		
		
		System.out.println("冒泡排序后：");
		bubbleSort(arr);
		listArr(arr);
	
		System.out.println("插入排序后：");
		insertSort(arr);
		listArr(arr);
	}
	
	/*选择排序
	思路：
	1.定义一个循环，控制要排列的次数，每次搞定一个最大数
		假设用i来代表每次最大数摆放的位置，i的取值：0~length-2
	2.定义一个变量pos记住最大数所在的位置，定义一个变量max记住最大数
		max初始值为i位置的元素,pos初始值为i
	3.定义一个内层循环，用于遍历数组找最大数
		假设i位置的最大，找出i+1~length-1里面最大的比i还大的
		遍历数组，如果有比max大的，将值给max，同时用pos记住该元素的角标
	4.让最大数和i位置的元素交换
	*/
	static void selectSort(int[] arr)
	{
		//456,12,1,189,38,237,98,199,7
		for(int i=0; i<arr.length-1; i++)	//i: 1
		{
			int pos = 0;	// pos:4
			int max = arr[0];	//max:456
			//找最大数
			for(int j=0; j<arr.length-i; j++)	//j:8
			{
				if(arr[j]>max)	//
				{
					max = arr[j];
					pos = j;
				}
			}
			exchange(arr, arr.length-i-1, pos);
		}
	}
	
	/*冒泡排序
	思路：
	1.定义一个外层循环，每次搞定一个最小数，i为最小数的位置，i的取值：0~length-2
	2.定义一个内层循环，从数组的末尾开始向前冒泡，直到i+1的位置和i位置的元素进行完冒泡
		j的取值：length-1~i+1
	
	*/
	static void bubbleSort(int[] arr)
	{
		for(int i=0; i<arr.length-1; i++)
		{
			for(int j=arr.length-1; j>i; j--)
			{
				if(arr[j]<arr[j-1])
					exchange(arr, j, j-1);
			}
		}
	}
	
	/*插入排序
	思路：
	1.外层循环，每次搞定一个数(i)的位置，i的取值：1~length-1
	2.内层循环，让第i个数不断和前面的数比较，小就换位置，直到遇上前面一个元素比它还小就停
			还有，如果此元素被换到了第0个位置，也要停
	*/
	static void insertSort(int[] arr)
	{
		for(int i=1; i<arr.length; i++)
		{
			int pos = i;	//pos记住被插入的元素的角标
			while(pos>0&&arr[pos]<arr[pos-1])
			{
				exchange(arr, pos, pos-1);
				pos--;
			}
		}
	}
	
	//交换数组两个元素的位置
	static void exchange(int[] arr, int pos1, int pos2)
	{
		int temp = arr[pos1];
		arr[pos1] = arr[pos2];
		arr[pos2] = temp;
	}
	
	//输出数组的元素
	static void listArr(int[] arr)
	{
		StringBuffer sb = new StringBuffer();
		for(int i=0; i<arr.length; i++)
			sb.append(arr[i] + ",");
		sb.delete(sb.length()-1, sb.length());
		System.out.println(sb);
	}
}