首先是一个展示 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