给老婆讲 冒泡排序，感觉挺形象的，所以记下来

首先是一个展示 List集合 的通用工具类：

package mz.ds.sort.utils;

import java.util.List;

public class ListShowUtils {
	private static final String HEADER ="####";
	private static final String DEFAULT_SEPERATOR ="\t";
	private static final int DEFAULT_FROM =0;
	private static final int DEFAULT_COLS =10;
	private static final int DEFAULT_COLS_NONE =Integer.MAX_VALUE;
	private static final int DEFAULT_NONE_MARK =Integer.MAX_VALUE;
	
	
	/**
	 * 按照默认设置 输出数据源List
	 * @param list
	 */
	public static void showList(List<? extends Object> list) {
		showList(list, DEFAULT_SEPERATOR, DEFAULT_FROM, list.size(), DEFAULT_COLS, DEFAULT_NONE_MARK);
	}
	
	/**
	 * 按照给定的分隔符输出数据
	 * 
	 * @param list 数据源集合
	 * @param seperator 分隔符
	 */
	public static void showList(List<? extends Object> list, String seperator) {
		showList(list, seperator, DEFAULT_FROM, list.size(), DEFAULT_COLS, DEFAULT_NONE_MARK);
	}
	
	/**
	 * 按照给的分隔符输出数据，同时每行最多输出cols个数据
	 * 
	 * @param list
	 * @param seperator
	 * @param cols
	 */
	public static void showList(List<? extends Object> list, String seperator, int cols) {
		showList(list, DEFAULT_SEPERATOR, DEFAULT_FROM, list.size(), cols, DEFAULT_NONE_MARK);
	}
	
	/**
	 * 将数据输出到一行中，将位置为mark的数据进行标记[Data[mark]]
	 * 
	 * @param list 数据源集合
	 * @param mark 要标记数据在集合中的位置
	 */
	public static void showList(List<? extends Object> list, int mark) {
		showList(list, DEFAULT_SEPERATOR, DEFAULT_FROM, list.size(),  DEFAULT_COLS_NONE, mark);
	}
	
	/**
	 * 展现List集合中的数据
	 * 
	 * @param list 			数据源集合
	 * @param seperator		分隔符
	 * @param from 			从哪里开始 从list.get(from)开始输出
	 * @param len  			输出多少个 若不够则只输出存在的对象
	 * @param cols 			每行输出多少个对象 即每行的列数
	 * @param mark 			在哪一位上设置标志输出 例如 1 2 [3] 4 5, 其中3则为标志输出的样式
	 */
	public static void showList(List<? extends Object> list, String seperator, int from, int len, int cols, int mark) {
		// 保证不越界
		len =(list.size() -from) >= len ? len : list.size();
		
		System.out.println(HEADER);
		
		for (int i=from; i <len; ++i) {
			String out =list.get(i).toString();
			// 是否加标志
			if (i == mark) {
				out ="[" +out +"]";
			}
			// 是否该换行
			if ((i +1) %cols ==0 || (i +1) == len) {
				out =out +"\n";
			} else {
				out =out +seperator;
			}
			System.out.print(out);
		}
	}
}

然后是 普通时间复杂度为O(n^2)的一个 排序算法类，只写了一个 冒泡排序：

package mz.ds.sort;

import java.util.ArrayList;
import java.util.List;

import mz.ds.sort.utils.ListShowUtils;

/**
 * 普通O(n^2)排序算法
 * 冒泡排序、插入排序、选择排序
 * 
 * @param <T>
 */
public class NormalSort<T extends Comparable<T>> {
	private List<T> list;
	
	public NormalSort(List<T> list) {
		this.list =list;
	}
	
	/**
	 * 冒泡排序
	 */
	public List<T> bublesort() {
		if (list == null || list.size() ==0) {
			return null;
		}
		int swapCount =0;
		for (int i=0; i <list.size(); ++i) {
			boolean isOk =true;
			// 开始冒泡
			for (int j =list.size()-1; j >i; --j) {
				if (list.get(j-1).compareTo(list.get(j)) >0) {
					T t =list.get(j);
					list.set(j, list.get(j-1));
					list.set(j-1, t);
					// 告诉主循环 还有可能再排序
					isOk =false;
					
					// 为了方便观察
					++swapCount;
					System.out.println("第" +swapCount +"次冒泡 ...");
					ListShowUtils.showList(list, j-1);
				}
			}
			// 上次遍历是否确定已经排序完成
			if (isOk) {
				System.out.println("排序结束 ...");
				break;
			}
		}
		return list;
	}

	
	/**
	 * 测试用的Main
	 */
	public static void main(String[] args) {
		List<Integer> sortList =new ArrayList<Integer>();
		for (int i=0; i<10; ++i) {
			sortList.add((int)(Math.random()*70));
		}
		System.out.println("数据源List：");
		ListShowUtils.showList(sortList);
		// 测试 冒泡排序
		NormalSort<Integer> sortObj =new NormalSort<Integer>(sortList);
		List<Integer> sortedList =sortObj.bublesort();
		ListShowUtils.showList(sortedList);
	}
}

最后执行，很形象，眼睁睁看着一个个的泡泡浮上来

数据源List：
####
49	66	20	26	67	54	3	48	52	20
第1次冒泡 ...
####
49	66	20	26	67	54	3	48	[20]	52
第2次冒泡 ...
####
49	66	20	26	67	54	3	[20]	48	52
第3次冒泡 ...
####
49	66	20	26	67	[3]	54	20	48	52
第4次冒泡 ...
####
49	66	20	26	[3]	67	54	20	48	52
第5次冒泡 ...
####
49	66	20	[3]	26	67	54	20	48	52
第6次冒泡 ...
####
49	66	[3]	20	26	67	54	20	48	52
第7次冒泡 ...
####
49	[3]	66	20	26	67	54	20	48	52
第8次冒泡 ...
####
[3]	49	66	20	26	67	54	20	48	52
第9次冒泡 ...
####
3	49	66	20	26	67	[20]	54	48	52
第10次冒泡 ...
####
3	49	66	20	26	[20]	67	54	48	52
第11次冒泡 ...
####
3	49	66	20	[20]	26	67	54	48	52
第12次冒泡 ...
####
3	49	[20]	66	20	26	67	54	48	52
第13次冒泡 ...
####
3	[20]	49	66	20	26	67	54	48	52
第14次冒泡 ...
####
3	20	49	66	20	26	67	[48]	54	52
第15次冒泡 ...
####
3	20	49	66	20	26	[48]	67	54	52
第16次冒泡 ...
####
3	20	49	[20]	66	26	48	67	54	52
第17次冒泡 ...
####
3	20	[20]	49	66	26	48	67	54	52
第18次冒泡 ...
####
3	20	20	49	66	26	48	67	[52]	54
第19次冒泡 ...
####
3	20	20	49	66	26	48	[52]	67	54
第20次冒泡 ...
####
3	20	20	49	[26]	66	48	52	67	54
第21次冒泡 ...
####
3	20	20	[26]	49	66	48	52	67	54
第22次冒泡 ...
####
3	20	20	26	49	66	48	52	[54]	67
第23次冒泡 ...
####
3	20	20	26	49	[48]	66	52	54	67
第24次冒泡 ...
####
3	20	20	26	[48]	49	66	52	54	67
第25次冒泡 ...
####
3	20	20	26	48	49	[52]	66	54	67
第26次冒泡 ...
####
3	20	20	26	48	49	52	[54]	66	67
排序结束 ...
####
3	20	20	26	48	49	52	54	66	67