package cn.by.Collecion.home0820;
import java.util.Comparator;
import java.util.List;
/**
 *
 * 排序类
 */
public class Sort {
 
 
 /**
  * 根据元素的自然顺序 对指定列表按升序进行排序。列表中的所有元素都必须实现 Comparable 接口 .
  *
  * @param list  要排序的列表
  */
 public static > void sort(List 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 void sort(List list, Comparator 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 int binarySearch(List> 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 int binarySearch(List list, T key, Comparator 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;
       
 }
 
}