冒泡排序，选择排序

冒泡排序

package paixu;
/**
 * 
 * @author asus
 *冒泡排序-------交换排序的一种 
 *这个方式将两个相临的数子进行比较
 *行为像冒泡一样较大的数向上  较小的数向下
 *复杂度为O(n*n)
 */
public class MaoPao {
	public int[] sort(int[] values){
		for (int i = 0; i < values.length-1; i++) {
			for (int j = 0; j < values.length-1-i; j++) {
				if(values[j]>values[j+1]){
					int index=values[j];
					values[j]=values[j+1];
					values[j+1]=index;
				}
			}
		}
		return values;
	}
	public static void main(String[] args) {
		MaoPao maoPao = new MaoPao();
		int[] values ={4,3,2,1} ;
		int[] sort = maoPao.sort(values);
		for (int i : sort) {
			System.out.println(i);
		}
	}
}

选择排序

package paixu;
/**
 * 
 * @author asus
 *选择排序 
 *指的是将一列数字中最小的数字找出最小的
 *平均时间复杂度为O（n*n）
 */
public class Sort{
	//判断最小的值
	//conmpareTo 来判断两个对象的大小值  
	public static boolean less(Comparable a,Comparable b){
		return a.compareTo(b)<0;
	}
	/**
	 * 将传来的数组对象两两进行交换
	 * @param a  传进来的数组
	 * @param v  交换数组的一个数组下标
	 * @param m  交换数组的一个数组下标
	 */
	public static void exch(Comparable[] a,int v,int m){
		Comparable t=a[v];
		a[v]=a[m];
		a[m]=t;
	}
	/**
	 * 遍历数组
	 * @param a  数组
	 */
	public static void show(Comparable[] a){
		for (int i = 0; i < a.length; i++) {
			System.out.println(a[i]);
		}
	}
}

package paixu;
/**
 * 选择排序
 * @author asus
 *每次选择一个最小的值将他与第一个，第二个，第三个。。。。。进行交换
 *
 */
public class XuanZe extends Sort{
	
	public void sort(Comparable[] a){
		int n=a.length;//数组长度
		for (int i = 0; i < n; i++) {
			//将a[i]和a[i+1,i+2....n]中最小的进行交换
			int min=i;//最小元素的索引
			for (int j = i+1; j <n; j++) {
				if(Sort.less(a[j],a[min])){
					min=j;
				}
				Sort.exch(a, i, min);
			}
			
		}
	}
	public static void main(String[] args) {
		Comparable[] a = {6,5,23,665,121,23};
		XuanZe xz=new XuanZe();
		xz.sort(a);
		xz.show(a);
		
	}
}