工厂模式 选择排序 冒泡排序 线性插入法和快速排序（出自jdk实例宝典）

package factory;

public interface ISortNumber {
 public int[] sortASC(int[] intArray);
}

 

package factory;
/**
 * 冒泡排序法
 * @author Administrator
 *
 */
public class BubbleSort implements ISortNumber{
 public BubbleSort(){
  System.out.println("这是冒泡排序法");
 }
 public int[] sortASC(int[] intArray) {
  if(intArray == null){
   return null;
  }
  int[] srcDatas = (int[])intArray.clone();
  boolean changePosition = true;//标示是否交换了数组中元素位置
  int comparedTimes = 0;//标示比较的次数
  int maxComparedTimes = srcDatas.length - 1;//标示排序过程中最多可能交换的次数
  //如果已经发生的比较次数还没有达到最大次数，而且此前交换过元素位置，则继续
  while((comparedTimes < maxComparedTimes) && changePosition){
   for(int i = 0; i < (maxComparedTimes-comparedTimes); i++){
    changePosition = false;
    if(srcDatas[i] > srcDatas[i+1]){
     swqp(srcDatas, i, i+1);
     changePosition = true;
    }
   }
   comparedTimes++;
  }
  return srcDatas;
 }
 
 private void swqp(int[] data,int src, int dest){
  int temp = data[src];
  data[src] = data[dest];
  data[dest] = temp;
 }
}

package factory;
/**
 * 线性插入排序法
 * @author Administrator
 *
 */
public class LinearInsertSort implements ISortNumber{
 public LinearInsertSort(){
  System.out.println("这是线性插入排序法");
 }
 public int[] sortASC(int[] intArray) {
  if(null == intArray){
   return null;
  }
  int[] srcDatas = intArray.clone();
  int size = srcDatas.length;
  int temp = 0;
  int index = 0;
  //假定第一个数字已经排好了序列，所以i是从1开始而不是从0开始
  for(int i = 1; i < size; i++){
   temp = srcDatas[i];
   index = i;
   while((index > 0) && (temp < srcDatas[index-1])){
    //移动index后面的数字
    srcDatas[index] = srcDatas[index - 1];
    index--;
   }
   srcDatas[index] = temp;
  }
  return srcDatas;
 }

}

package factory;
/**
 * 快速排序
 * @author Administrator
 *
 */
public class QuickSort implements ISortNumber{
 public QuickSort(){
  System.out.println("这是快速排序法");
 }
 /*快速排序*/
 public int[] sortASC(int[] intArray) {
  if(intArray == null){
   return null;
  }
  int[] srcDatas = (int[])intArray.clone();
  return quickSort(srcDatas, 0, srcDatas.length - 1);
 }
 /*采用分治递归的方法实现快速排序法*/
 private int[] quickSort(int[] srcDatas, int first, int last){
  if(first < last){
   int pos = partition(srcDatas, first, last);
   quickSort(srcDatas, first, pos - 1);
   quickSort(srcDatas, pos + 1, last);
  }
  return srcDatas;
 }
 /*寻找数组的分治点
  * 根据数组的第一个数分治，把比数组第一个数大的往后排，把比数组第一个数小的往前排
 */
 private int partition(int[] srcDatas, int first, int last){
  int temp = srcDatas[first];
  int pos = first;
  for(int i = first + 1; i <= last; i++){
   if(srcDatas[i] < temp){
    pos++;
    swap(srcDatas, pos, i);
   }
  }
  swap(srcDatas, first, pos);
  return pos;
 }
 private void swap(int[] data,int src, int dest){
  int temp = data[src];
  data[src] = data[dest];
  data[dest] = temp;
 }
}

package factory;
/**
 * 选择排序法
 * @author Administrator
 *
 */
public class SelectionSort implements ISortNumber{
 public SelectionSort(){
  System.out.println("这是选择排序法");
 }
 public int[] sortASC(int[] intArray) {
  if(intArray == null){
   return null;
  }
  //因为java的参数传递是采用引用传值方式，在排序的过程中需要该变数组元素的顺序，也就是改变了参数数组
  //所以为了保证输入参数的值不变，这里采用了数组的clone方法，直接克隆一个数组
  int[] srcDatas = (int[])intArray.clone();
  int size = srcDatas.length;
  //从头遍历数组元素
  for(int i = 0; i < size; i++){
   //遍历下标为i之后的元素
   for(int j = i; j < size; j++){
    //如果数组前面的值比后面的值大，则交换位置
    if(srcDatas[i] > srcDatas[j]){
     swqp(srcDatas, i, j);
    }
   }
  }
  return srcDatas;
 }
 private void swqp(int[] data,int src, int dest){
  int temp = data[src];
  data[src] = data[dest];
  data[dest] = temp;
 }
}

package factory;
/**
 * 工厂模式
 * @author Administrator
 *
 */
public class Factory {
 //各种排序方法的命令标示
 public static final String SELECTION_SORT = "selection";
 public static final String BUBBLE_SORT = "bubble";
 public static final String LINEARINSERT_SORT = "liner";
 public static final String QUICK_SORT = "quick";
 
 public static ISortNumber getOrderNumber(String id){
  if(SELECTION_SORT.equals(id)){
   return new SelectionSort();
  }else if(BUBBLE_SORT.equals(id)){
   return new BubbleSort();
  }else if(LINEARINSERT_SORT.equals(id)){
   return new LinearInsertSort();
  }else if(QUICK_SORT.equals(id)){
   return new QuickSort();
  }else{
   return null;
  }
 }
 /**
  * 输出整型数组
  */
 public static void printIntArray(int[] array){
  if(array != null){
   for(int i = 0; i < array.length;i++){
    System.out.print(array[i]+ " ");
   }
   System.out.println();
  }
 }
 public static void main(String[] args) {
  int[] intarray = new int[] {6,1,3,5,4};
  System.out.println("排序前的数组是：");
  printIntArray(intarray);
  System.out.println("用选择排序法对数组进行降序排序后的结果");
  int[] orderArray = Factory.getOrderNumber(Factory.SELECTION_SORT).sortASC(intarray);
  printIntArray(orderArray);
  
  System.out.println("用冒泡排序法对数组进行升序排序后的结果");
  orderArray = Factory.getOrderNumber(BUBBLE_SORT).sortASC(intarray);
  printIntArray(orderArray);
  
  System.out.println("用线性插入排序法对数组进行升序排序后的结果");
  orderArray = Factory.getOrderNumber(LINEARINSERT_SORT).sortASC(intarray);
  printIntArray(orderArray);
  
  System.out.println("用快速排序法对数组进行升序排序后的结果");
  orderArray = Factory.getOrderNumber(QUICK_SORT).sortASC(intarray);
  printIntArray(orderArray);
 }
}