最近复习了下,基本算法,发现会写,但是在应用上还是不好,也就是说不知道在什么地方用什么武功最合适! 然后想写一个工具类,可以针对常用的东西进行排序,然后计算它们的效率问题:
1.首先我定义了一个接口:
/**
* 排序接口
* @author @Ran
*
*/
public interface Sort {
// 基本排序方法
public <T extends Comparable<? super T>> T[] sort(T[] t);
// 循环的次数
public long getCount();
// 操作的时间
public long getCostTime();
// 回调排序,计算时间
public <T extends Comparable<? super T>> T[] sort(Sort s,T[] t);
}
2.然后写了一个抽象的实现类(~。~这里仿照集合框架写的)
/**
* 提供了基本实现
* @author @Ran
*
* @param <T>
*/
public abstract class AbstractSort<T> implements Sort{
// 计算排序的次数
protected transient long count = 0;
// 计算排序花费的时间
protected transient long cost = 0;
public long getCount(){
return count;
}
public long getCostTime(){
return cost;
}
// 计算时间
public <T extends Comparable<? super T>> T[] sort(Sort s,T[] t){
long beginTime = System.currentTimeMillis();
s.sort(t);
cost = System.currentTimeMillis() - beginTime;
return t;
}
// 元素交换
public <T extends Comparable<? super T>> T[] swap(T[] t,int i,int j){
if(i != j){
T tem = t[i];
t[i] = t[j];
t[j] = tem;
count++;
}
return t;
}
// 比较器
public <T extends Comparable<? super T>> int commpare(T[] t,int i,int j){
int flag = t[i].compareTo(t[j]);
if ( flag > 0) {
swap(t,i,j);
}
return flag;
}
// 赋值的时候,也算做一次交换操作
public <T extends Comparable<? super T>> void setValue(T[] t,int i,int j){
t[i] = t[j];
count ++;
}
public <T extends Comparable<? super T>> void setValue(T[] t,int i,T value){
t[i] = value;
count ++;
}
@Override
public String toString() {
return "count:"+count+",cost:"+cost;
}
}
3.我们就可以对常用算法 进行操作了,假设我实现了一个 冒泡排序:Bubble
public class Test {
public static void main(String[] args) {
// 字符串会默认转正ASSIC 码,以首字母进行比较,比如a=97,相同则比较下一个
String[] t = new String[]{"4","3","2","7","1","f","ad","asd","5"};
Sort s = new Bubble();
// 需要时间久用这个,不用就直接sort
s.sort(s,t);
System.out.println("操作的次数:"+s.getCount());
System.out.println("操作的时间:"+s.getCostTime());
System.out.println("排序后结果:"+Arrays.toString(t));
System.out.println(s.toString());
}
}
小结:
1.这里仅仅对基本排序做了操作,利用了自带的Comparable 接口。当然后期我们会进行扩展,支持多 种排序方式。先把基本的搞完!
2.这里仿照JAVA 集合的写法,不好勿喷~。~内容会根据后面的进行修改,有好的建议,希望多指点