（算法）排序—冒泡排序法Java实现

（算法）排序—冒泡排序法Java实现

       对于冒泡排序法的理解思路不再过多解释，简单说就是多次循环遍历，把最大（小）值“沉到最底”以实现排序的效果。以下给出java程序：

int数组排序：

/**
	 * 普通int数组从小到大排序
	 * @param arr
	 */
	public static void sort(int[] arr) {
		int length = arr.length;
		boolean sorted = true;
		for(int j=0;j<length-1;j++) { //循环次数  每完成一次  沉入底部一个数
			sorted = true; //每一次开始  默认已经排好序
			for(int i=0;i<length-1-j;i++) {
				if(arr[i] > arr[i+1]) {
					int temp = arr[i];
					arr[i] = arr[i+1];
					arr[i+1] = temp;
					sorted = false; //还没有排好序
				}
			}
			if(sorted) { //确实已经排好序了
				break; //不再继续循环
			}
		}
	}

在这个基础上，可以再完善，引入泛型实现对非int数组的排序：

/**
	 * 数组排序(使用泛型)
	 * @param arr
	 */
	public static <T extends Comparable<T>> void sort(T[] t) {
		int length = t.length;
		boolean sorted = true; 
		for(int j=0;j<length-1;j++) {
			sorted = true; //默认已经是从小到大排列
			for(int i=0;i<length-1-j;i++) {
				if(t[i].compareTo(t[i+1]) > 0) {
					T temp = t[i];
					t[i] = t[i+1];
					t[i+1] = temp;
					sorted = false; //还不是从小到大排列
				}
			}
			if(sorted) break; //如果确实是从小到大排列，即本次循环没有交换元素，则不必进行下一次循环
		}
	}

测试排列String、Float（对象，并不是基础数据类型）：

对任意对象的排序（自定义对象重写compareTo方法即可）：

	/**
	 * 对象数组排序
	 * @param arr
	 */
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public static void sort (Object[] arr) {
		int length = arr.length;
		boolean sorted = true;
		for(int j=0;j<length-1;j++) {
			sorted = true; 
			for(int i=0;i<length-1-j;i++) {
				if(((Comparable)arr[i]).compareTo(arr[i+1]) > 0) { //强转为Comparable接口
					Object temp = arr[i];
					arr[i] = arr[i+1];
					arr[i+1] = temp;
					sorted = false; 
				}
			}
			if(sorted) { 
				break; 
			}
		}
	}

为了做测试，定义以下对象：

public class  Student implements Comparable<Student> {
	private String name;
	private int age;
	public Student(String n,int a) {
		this.name = n;
		this.age = a;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	/**
	 * 重写toString()
	 */
	@Override
	public String toString() {
		return "{name:"+name+",age:"+age+"}";
	}
	/**
	 * 重写comparaTo方法
	 * age大的为对象大
	 */
	@Override
	public int compareTo(Student o) {
		return this.age - o.getAge();
	}
}

测试结果如下：

最后，利用任意对象的排序，可实现对jdk各种容器的排序：

/**
	 * 容器的排序
	 * @param list
	 */
	@SuppressWarnings("unchecked")
	public static <T extends Comparable<T>> void sort(Collection<T> c) {
		Object arr[] = c.toArray();
		c.clear();
		sort(arr);
		for(int i=0;i<arr.length;i++) {
			c.add((T) arr[i]);
		}
	}

测试：