复杂数据的冒泡排序

前段时间，有个排序的功能就是做离我最近的那个，一可以想用冒泡，之前用冒泡都是简单的数据结构，一般都是数组来实现。在项目中往往不会这么简单，数据结构复杂得多。

本人在项目中使用的还不算太复杂，直接看代码把

		/**
		 * list里面放个类 ，PublishVo是个泛型类，里面继续放一个hashmap
		 * 这里排序是拿的 PublishVo里面的属性 Count 来排序
		 * 并不是 PublishVo 属性里面 publishTheme 里面的值
		 * 
		 * publishVos2为临时变量，暂时存储数据用于交换的
		 * 
		 * 这里需要说明的 list 用于交换是set（）方法 注意
		 * 
		 * 本案例在项目中拿出来的·
		 */
		List<PublishVo<HashMap<String, Object>>> publishVos2 = new ArrayList<PublishVo<HashMap<String, Object>>>();
		int size2 = publishVos.size();
		for (int i = 0; i < size2 - 1; i++) {
			for (int j = i + 1; j < size2; j++) {
				if (publishVos.get(i).getCount() < publishVos.get(j).getCount()) {
					publishVos2.add(publishVos.get(i));
					publishVos.set(i, publishVos.get(j));
					publishVos.set(j, publishVos2.get(0));
					//需要清楚里面的数据 不然第二次拿的时候值就不对了
					publishVos2.clear();
				}
			}
		}
		return publishVos;

注释都有，基本都看得懂。

package sorter;

import java.util.Comparator;

public class BubbleSorter implements Sorter {

    @Override
    public <T extends Comparable<T>> void sort(T[] list) {
        boolean swapped = true;
        for (int i = 1, len = list.length; i < len && swapped; ++i) {
            swapped = false;
            for (int j = 0; j < len - i; ++j) {
                if (list[j].compareTo(list[j + 1]) > 0) {
                    T temp = list[j];
                    list[j] = list[j + 1];
                    list[j + 1] = temp;
                    swapped = true;
                }
            }
        }
    }

    @Override
    public <T> void sort(T[] list, Comparator<T> comp) {
        boolean swapped = true;
        for (int i = 1, len = list.length; i < len && swapped; ++i) {
            swapped = false;
            for (int j = 0; j < len - i; ++j) {
                if (comp.compare(list[j], list[j + 1]) > 0) {
                    T temp = list[j];
                    list[j] = list[j + 1];
                    list[j + 1] = temp;
                    swapped = true;
                }
            }
        }
    }
    public static void main(String[] args) {
    	Integer score[] = { 67, 69,11,98, 75, 87, 89, 10, 99, 100 };
    	BubbleSorter h = new BubbleSorter();
    	h.sort(score);
    	for (int i = 0; i < score.length; i++) {
			System.out.println(score[i]);
		}
	}
}

以上有个接口

public interface Sorter {
	/**
	 * 排序
	 * 
	 * @param list
	 *            待排序的数组
	 */
	public <T extends Comparable<T>> void sort(T[] list);

	/**
	 * 排序
	 * 
	 * @param list
	 *            待排序的数组
	 * @param comp
	 *            比较两个对象的比较器
	 */
	public <T> void sort(T[] list, Comparator<T> comp);
}

还有其他方法 可以参考下

public class Sort {

	public static void main(String[] args) {
		mao1();
	}

	public static void mao() {
		int score[] = { 67, 69,11,98, 75, 87, 89, 10, 99, 100 };
		for (int i = 0; i < score.length - 1; i++) { // 最多做n-1趟排序
			// 对当前无序区间score[0......length-i-1]进行排序(j的范围很关键，这个范围是在逐步缩小的)
			for (int j = 0; j < score.length - i - 1; j++) {
				if (score[j] > score[j + 1]) { // 把小的值交换到后面
					int temp = score[j];
					score[j] = score[j + 1];
					score[j + 1] = temp;
				}
			}
			System.out.print("第" + (i + 1) + "次排序结果：");
			for (int a = 0; a < score.length; a++) {
				System.out.print(score[a] + "\t");
			}
			System.out.println("");
		}
		System.out.print("最终排序结果：");
		for (int a = 0; a < score.length; a++) {
			System.out.print(score[a] + "\t");
		}
	}
	
	
	public static void mao1() {
		int score[] = { 67, 69,11,98, 75, 87, 89, 10, 99, 100 };
		for (int i = 0; i < score.length - 1; i++) { // 最多做n-1趟排序
			for (int j = i+1; j < score.length; j++) {
				if (score[i] > score[j]) { // 把大的值交换到后面
					int temp = score[j];
					score[j] = score[i];
					score[i] = temp;
				}
			}
			System.out.print("第" + (i + 1) + "次排序结果：");
			for (int a = 0; a < score.length; a++) {
				System.out.print(score[a] + "\t");
			}
			System.out.println("");
		}
		System.out.print("最终排序结果：");
		for (int a = 0; a < score.length; a++) {
			System.out.print(score[a] + "\t");
		}
	}
}

mao的感觉好一点 直观  mao1是个人比较习惯用的一种