用泛型的sort与binarySearch方法
package cn.by.Collecion.home0820;
import java.util.Comparator;
import java.util.List;
/**
*
*
排序类
*/
public class Sort {
/**
*
根据元素的自然顺序
对指定列表按升序进行排序。列表中的所有元素都必须实现
Comparable
接口
.
*
* @param list
要排序的列表
*/
public static <T extends Comparable<? super T>> void sort(List<T> list) {
/**
*
主要用于提前结束比较
,
即如果一趟中没有一个元素交换，
则后面还没有进行的趟也不用进行了。
*/
int exchange;
//
临时交换变量
T temp;
int length = list.size();
for (int i = 0; i < length - 1; i++) {
exchange = 0; //
初始值为
0
for (int j = length - 1; j > i; j--) {
T after = list.get(j);
T front = list.get(j - 1);
if (after.compareTo(front) < 0) {
temp = list.get(j);
list.set(j, front);
list.set(j - 1, temp);
exchange = 1; //
如有交换则更改为
1
}
}
//
提前结束
if (exchange == 0)
return;
}
}
/**
*
根据指定比较器产生的顺序对指定列表进行排序。
*
* @param list
要排序的列表
* @param c
确定列表顺序的比较器。
null
值指示应该使用元素的自然顺序。
*/
public static <T> void sort(List<T> list, Comparator<? super T> c) {
/**
*
主要用于提前结束比较
,
即如果一趟中没有一个元素交换，
则后面还没有进行的趟也不用进行了。
*/
int exchange;
//
临时交换变量
T temp;
if (c != null) {//
比较器不为空
int result;
for (int i = 0; i < list.size() - 1; i++) {
exchange = 0; //
初始值为
0
for (int j = list.size() - 1; j > i; j--) {
T after = list.get(j);
T front = list.get(j - 1);
result = c.compare(after, front);
//
比较
if (result < 0) {
temp = list.get(j);
list.set(j, front);
list.set(j - 1, temp);
exchange = 1; //
如有交换则更改为
1
}
}
//
提前结束
if (exchange == 0)
return;
}
}
//
比较器为空时
,
应该使用元素的自然顺序
int length = list.size();
for (int i = 0; i < length - 1; i++) {
exchange = 0; //
初始值为
0
for (int j = length - 1; j > i; j--) {
T after = list.get(j);
T front = list.get(j - 1);
Comparable com = (Comparable) after;
if (com.compareTo(front) < 0) {
temp = list.get(j);
list.set(j, front);
list.set(j - 1, temp);
exchange = 1; //
如有交换则更改为
1
}
}
//
提前结束
if (exchange == 0)
return;
}
}
}
package cn.by.Collecion.home0820;
import java.util.Comparator;
import java.util.List;
public class BinarySearch {
/**
*
使用二分搜索法搜索指定列表，以获得指定对象。
* @param list
要搜索的列表
* @param key
要搜索的键
* @return
如果搜索键包含在列表中，则返回搜索键的索引
,
否则
*
返回
(-(
插入点
) - 1)
。插入点
被定义为将
*
键插入列表的那一点：
*
即第一个大于此键的元素索引；如果列表中的所有元素
都小于指定的键，
*
则为
list.size()
。注意，这保证了当且仅当此键被找到时
,
返回的值将
>= 0
。
*/
public static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key) {
int low = 1;
int high = list.size();
int mid;
int result;
while (low <= high) {
mid = (low + high) / 2;
//
第一个比较元素为
list.get(mid - 1),
注意
if
判断时的符号
result = list.get(mid - 1).compareTo(key);
if (result == 0) {
return mid;
} else if (result > 0) {
high = mid - 1;
} else {
low = mid + 1;
}
}
//
没找到
return -low;
}
/**
*
使用二分搜索法搜索指定列表，以获得指定对象。
* @param list
要搜索的列表
* @param key
要搜索的键
* @param c
排序列表的比较器。
null
值指示应该使用元素的自然顺序。
* @return
如果搜索键包含在列表中，则返回搜索键的索引，否则返回
* (-(
插入点
) - 1)
。插入点
被定义为将
键插入列表的那一点：即第一个大于
*
此键的元素索引；如果列表中的所有元素
都小于指定的键，则为
list.size()
。
*
注意，这保证了当且仅当此键被找到时，
返回的值将
>= 0
。
*/
public static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c) {
int low = 1;
int high = list.size();
int mid;
int result;
if( c != null) {//
比较器不为空
while (low <= high) {
mid = (low + high) / 2;
// System.out.println("mid="+mid);
//
第一个元素为
key
，注意
if
判断时的符号
result = c.compare(key, list.get(mid - 1));
if (result == 0)
return mid;
else if (result < 0) {
high = mid - 1;
// System.out.println("high="+high);
} else {
low = mid + 1;
// System.out.println("low="+low);
}
}
//
没找到
return -low;
}
//
比较器为空时，使用元素的自然顺序比较
while (low <= high) {
mid = (low + high) / 2;
//
第一个比较元素为
list.get(mid - 1)
Comparable com = (Comparable)list.get(mid - 1);
result = com.compareTo(key);
if (result == 0) {
return mid;
} else if (result > 0) {
high = mid - 1;
} else {
low = mid + 1;
}
}
//
没找到
return -low;
}
}