给老婆讲 冒泡排序，感觉挺形象的，所以记下来
2013-11-19 23:01
477 查看
首先是一个展示 List集合 的通用工具类：
然后是 普通时间复杂度为O(n^2)的一个 排序算法类，只写了一个 冒泡排序：
最后执行，很形象，眼睁睁看着一个个的泡泡浮上来
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
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 在做项目时偶尔会遇到这样的问题，有点感觉莫名其妙，也不是什么具体程序的错误，那倒时好发现。感觉无从下手，所以就从CSDN上狠搜了一下，有了感觉了之从记载下来以免看好！
- 关于mvc的一些体会，看到这一篇感觉领悟到了，所以记录下来
- ajax拖动层，保存层位置，这段代码是从网络人扒拉下来的（非XAJAX），使用类库prototype.js，感觉效果非常好
- 亲手写C冒泡排序，感觉还是很爽的。。
- 顶端 - 底端判断条件（不想记住所以写下来）
- 网上看了篇文章关于多表连接的，感觉很好，记录下来，以便日后自己学习
- http_build_query用法，感觉不错，从手册上抄下来
- 排序算法系列之（二）——冒泡排序名字最为形象的一个
- 懒了好久，感觉还是把自己不知道的都写下来，比较好……免得以后老呆故障，忘记了
- 在网上找了一些Jquery弹出窗口，感觉不错记录下来。
- Zxing里面的东西，在拍照时设置相机参数 会用到，所以记下来（日记）
- 读兔八哥的blog下来的感觉
- 在CSDN一哥们的Blog中发现一句话感觉深有感触,记录下来先--
- 老婆的驾照要下来了，形容下我此刻的心情
- 让人郁闷了好久的问题，终于解决了，之前网上也看到一些解决方法，但大多没有解决问题，所以记录下来，以供参考之用（ADO Could Not Find The Specified Provider）
- 一个超时的题，本是想用Java学调试的,写辛苦了，所以抄下来
- N年时间下来读书的感觉差异
- 一个正则的写法，之前老忘记所以决定记下来
- 所以也别执着于自己的感觉 尤其是悲观的感觉
- 使用cgitb来简化异常调试(记录下来，感觉很有用)