package test105;

/*
 * 冒泡排序的三种解以及选择排序
 */
public class Demo {
	public static void main(String args[]) {
		int[] Array={3,2,1,4,2,5,8};
		int[] reverseArray=bubbleSort1.reverse(Array);
		for(int i:reverseArray) {
			System.out.print(i+",");
		}
		System.out.println();
		//bubbleSort1.rank(Array);
		//bubbleSort2.sort2(Array, 7);
		bubbleSort3.sort3(reverseArray, 7);
		for(int i:reverseArray) {
			System.out.print(i+",");
		}
		System.out.println();
		selectSort.toSmall(Array);
		for(int i:Array) {
			System.out.print(i+" ");
		}
		System.out.println();
		selectSort.toBig(Array);
		for(int i:Array) {
			System.out.print(i+" ");
		}
		
	}
	
}
package test105;

public class bubbleSort1 {
	public static int[] reverse(int []list) {
		int []result=new int[list.length];
		for(int i=0,j=result.length-1;i<list.length;i++,j--) {
			result[j]=list[i];
		}
		return result;
	}
	public static int[] rank(int[]list) {
		int n=0,m=0;
		for(int i=0;i<list.length-1;i++) {
			for(int j=0;j<list.length-i-1;j++) {
				if(list[j]>list[j+1]) {
					int a=list[j];
					list[j]=list[j+1];
					list[j+1]=a;
					n++;
				}
			}
			m+=n;
		}
		System.out.println(m);
		return list;
	}

}
package test105;

/*
 * 如果对于一个本身有序的序列，或序列后面一大部分都是有序的序列，采用第一种方法会浪费很多的时间开销
 * 这里设置一个标志flag，如果这一趟发生了交换，则为true，否则为false。所以如果有一趟没有发生交换，
 * 说明排序已经完成
 */
public class bubbleSort2 {
	public static void sort2(int []a,int n) {//表示数组a[]和n个元素
		int i,k=n;
		boolean flag=true;//发生了交换就为true，没发生就为false,第一个判断时必须标志为true
		while(flag) {
			flag=false;//每次开始排序前，都设置flag为未排序过
			for(i=0;i<k-1;i++) {
				if(a[i]>a[i+1]) {
					int temp=a[i];
					a[i]=a[i+1];
					a[i+1]=temp;
					flag=true;//表示交换过数据
				}
			}
			k--;//减小一次排序的尾边界
		}
		
	}

}
package test105;

/*
 * 现在有一个包含1000个数的数组，仅前面100个无序，后面900个都已排好序且都大于前面100个数字，
 * 那么在第一趟遍历后，最后发生交换的位置必定小于100，且这个位置之后的数据必定已经有序了，
 * 也就是这个位置以后的数据不需要再排序了，于是记录下这位置，第二次只要从数组头部遍历到这个位置就可以了。
 */
public class bubbleSort3 {
	public static void sort3(int []a,int n) {
		int j,k;
		int flag=n;
		while (flag>0) {
			k=flag;//k来记录遍历的尾边界
			flag=0;//每次开始排序前，都设置flag为未排序过
			for(j=0;j<n-1;j++) {
				if(a[j]>a[j+1]) {
					int temp=a[j];
					a[j]=a[j+1];
					a[j+1]=temp;
					flag=j;//表示交换过数据，并且记录最新的尾边界
				}
			}
		}
	}

}

//选择排序
package test105;

public class selectSort {
	public static int[] toSmall(int[] a) {//从小到大排序
		for(int i=0;i<a.length-1;i++) {//遍历数组出最后一个的其他所有数，因为最后的对象没有与之可以相比较的数
			for(int j=i+1;j<a.length;j++) {
				/*遍历数组里没有排序的所有数，并与上一个数进行比较
				 * j=i+1是因为自身一定等于自身，所以相比没有意义
				 * 与前面已经排好序的数再比较也没有意义
				 */
				if(a[j]<a[i]) {
					int temp=a[j];
					a[j]=a[i];
					a[i]=temp;
				}
			}
		}
		return a;
	}
	public static int[] toBig(int []a) {//从大到小排序
		for(int i=0;i<a.length-1;i++) {
			for(int j=i+1;j<a.length;j++) {
				if(a[j]>a[i]) {
					int temp=a[j];
					a[j]=a[i];
					a[i]=temp;
				}
			}
		}
		return a;
	}

}

//插入排序
public class insertSort {
	public static void iSort(int []a) {
		int insertNote;//标识要插入的数据
		for(int index=1;index<a.length;index++)	{
			int leftIndex=index-1;//从数组的第二个元素开始循环，将数组中的元素插入
			insertNote=a[index];//设置数组中的第2个元素为第一次循环要插入的数据
			while (leftIndex>=0 && insertNote<a[leftIndex]) {
				a[leftIndex+1]=a[leftIndex];//如果要插入的元素小于左索引位的元素，那么就将左索引位元素向后移动
				leftIndex--;
			}
			a[leftIndex+1]=insertNote;//直到要插入的元素不小于第leftIndex个元素，将要插入的数据插入到数组
		}
	}
}