java 快速排序 优化 以及扩展到对象 List 集合

=========基础======

package sss;

import java.util.Arrays;
import java.util.Random;

/**
 * @version 1.0
 *
 * @author DongXiang
 * 
 * @action  快速排序优化： 可以扩展到对象排序
 * 
 * @time 2017年7月18日下午2:22:59
 * 
 */
public class QuickSort {
	public static int partition(int[] array, int lo, int hi) {
		// 三数取中
		int mid = lo + (hi - lo) / 2;
		if (array[mid] > array[hi]) {//若m大于 h ，则 m 和 h 交换
			swap2(array,mid,hi);
		}
		if (array[lo] > array[hi]) {//若l大于 h ，则 l 和 h 交换
			swap2(array,lo,hi);
		}
		if (array[mid] > array[lo]) {//若m大于 l ，则m 和 l 交换 error
			swap2(array,mid,lo);
		}
		int key = array[lo];//l

		while (lo < hi) {//l-index= key && hi > lo) {// 找出l-h之间小的 > 大的 位置
				hi--;
			}
			array[lo] = array[hi];//把小的赋给低的，
			while (array[lo] <= key && hi > lo) {
				lo++;
			}
			array[hi] = array[lo];
		}
		array[hi] = key;
		return hi;
	}
	
	public static void swap2(int[]array,int a, int b) {
		System.out.println("a = "+a+";b = "+b+";array="+Arrays.toString(array));
		int temp = array[a];
		array[a] = array[b];
		array[b] = temp;
		System.out.println("a = "+a+";b = "+b+";array="+Arrays.toString(array));
	}

// 插入算法 start===================
		public static void insertSort(int[] arr) {
			int i, j;
			int n = arr.length;
			int target;

			// 假定第一个元素被放到了正确的位置上
			// 这样，仅需遍历1 - n-1
			for (i = 1; i < n; i++) {
				j = i;
				target = arr[i];

				while (j > 0 && target < arr[j - 1]) {
					arr[j] = arr[j - 1];
					j--;
				}

				arr[j] = target;
			}
		}
// 插入算法 end===================
	public static void quickSort(int[] array, int lo, int hi) {//0-max Index
		if (lo >= hi) {
			return;
		}
		int index = partition(array, lo, hi);
		quickSort(array, lo, index - 1);
		quickSort(array, index + 1, hi);
	}

	
	/**快速排序在序列中元素很少时，效率将比较低，不然插入排序，因此一般在序列中元素很少时使用插入排序，这样可以提高整体效率。
	 * @param array
	 * @param lo 第一个基准值的位置：
	 * @param hi 第二基准值的位置：lo0) {
				flag=true;
			}
		}
		System.out.println(sb);
		System.out.println(flag);
		System.out.println("=================");
		quickUpdate(arryRandom, 0, arryRandom.length-1);
		System.out.println("=================");
		
		 sb=new StringBuffer();
		 flag=false;
		for (int i = 0; i < arryRandom.length; i++) {
			sb.append(arryRandom[i]+"\t");
			if ((i+1)%50==0) {
				sb.append("\n");
			}
			if (((i+1)0) {
				flag=true;
			}
		}
		System.out.println(sb);
		System.out.println(flag);
	}


}

===========扩展到List对象====

package sss;

import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.Random;

/**
 * @version 1.0
 *
 * @author DongXiang
 * 
 * @action  快速排序优化： 可以扩展到对象排序
 * 
 * @time 2017年7月18日下午2:22:59
 * 
 */
public class QuickSort2List {
	public static > int partition(List arrayList, int lo, int hi) {
		// 三数取中
		int mid = lo + (hi - lo) / 2;
		if (arrayList.get(mid).iComparable(arrayList.get(hi))>0) {
//		if (arrayList[mid] > arrayList[hi]) {
			
			swap2(arrayList,mid, hi);
//			swap(arrayList[mid], arrayList[hi]);
		}
		if (arrayList.get(lo).iComparable(arrayList.get(hi))>0) {
//		if (arrayList[lo] > arrayList[hi]) {
			
			swap2(arrayList,lo, hi);
//			swap(arrayList[lo], arrayList[hi]);
		}
		if (arrayList.get(mid).iComparable(arrayList.get(lo))>0) {
//		if (arrayList[mid] > arrayList[lo]) {

			swap2(arrayList,mid, lo);
//			swap(arrayList[mid], arrayList[lo]);
		}
		System.out.println("arrayListTTT =  "+arrayList);
		
		E key = arrayList.get(lo);
		System.out.println("E-key="+key);
//		int key = arrayList[lo];

		while (lo < hi) {
			while (arrayList.get(hi).iComparable(key) >= 0 && hi > lo) {
//			while (arrayList[hi] >= key && hi > lo) {
				hi--;
			}
			arrayList.set(lo, arrayList.get(hi));
//			arrayList[lo] = arrayList[hi];
			while (arrayList.get(lo).iComparable(key)<=0 && hi > lo) {
//			while (arrayList[lo] <= key && hi > lo) {
				lo++;
			}
			arrayList.set(hi, arrayList.get(lo));
//			arrayList[hi] = arrayList[lo];
		}
		arrayList.set(hi, key);
//		arrayList[hi] = key;
		return hi;
	}
	
	public static >  void swap2(List arrayList, int a,int b) {//进行两个对象的值，进行交换；实际
		System.out.println(String.format(Locale.getDefault(),
				"arrayList[%d]=%s;arrayList[%d]=%s",
				a,arrayList.get(a),b,arrayList.get(b)));
		
		E keyT = arrayList.get(a);
		arrayList.set(a, arrayList.get(b));//arrayList.add(index, element);
		arrayList.set(b, keyT);
		
		System.out.println(String.format(Locale.getDefault(), 
				"arrayList[%d]=%s;arrayList[%d]=%s", 
				a,arrayList.get(a),b,arrayList.get(b)));
	}
	
// 插入算法 start===================
		public static >  void insertSort(List arrayList) {
			int i, j;
			int n = arrayList.size();
			E target;

			// 假定第一个元素被放到了正确的位置上
			// 这样，仅需遍历1 - n-1
			for (i = 1; i < n; i++) {
				j = i;
				target = arrayList.get(i);

				while (j > 0 && target.iComparable(arrayList.get(j - 1))<0 ) {
//				while (j > 0 && target < arr[j - 1]) {
					arrayList.set(j, arrayList.get(j- 1));
//					arr[j] = arr[j - 1];
					j--;
				}
				arrayList.set(j,target);
//				arr[j] = target;
			}
		}
// 插入算法 end===================
	public static > void quickSort(List arrayList, int lo, int hi) {
		if (lo >= hi) {
			return;
		}
		int index = partition(arrayList, lo, hi);
		quickSort(arrayList, lo, index - 1);
		quickSort(arrayList, index + 1, hi);
	}
	/**快速排序在序列中元素很少时，效率将比较低，不然插入排序，因此一般在序列中元素很少时使用插入排序，这样可以提高整体效率。
	 * @param array
	 * @param lo 第一个基准值的位置：
	 * @param hi 第二基准值的位置：lo>  void quickUpdate(List arrayList, int lo, int hi) {
		if (hi - lo + 1 < 10) {
			insertSort(arrayList);
		} else {
			quickSort(arrayList, lo, hi);
		}
	}
	
	public static void main(String[] args) {
		List arryRandom=new ArrayList();
		QObj tq=null;
		int tempSize=11;
		Random random=new Random();
		for (int i = 0; i < tempSize; i++) {
			tq=new QObj();
			tq.setName("张三"+i);
			tq.setAge(random.nextInt(100+1));
			arryRandom.add(tq);
		}
		StringBuffer sb=new StringBuffer();
		boolean flag=false;
		for (int i = 0; i < arryRandom.size(); i++) {
			sb.append(arryRandom.get(i)+"\t");
			if ((i+1)%1==0) {
				sb.append("");
			}
			if (((i+1)0) {
				flag=true;
			}
		}
		System.out.println(sb);
		System.out.println(flag);
		System.out.println("======================");
		quickUpdate(arryRandom, 0, arryRandom.size()-1);
		System.out.println("======================");
		
		sb=new StringBuffer();
		flag=false;
		for (int i = 0; i < arryRandom.size(); i++) {
			sb.append(arryRandom.get(i)+"\t");
			if ((i+1)%1==0) {
				sb.append("");
			}
			if (((i+1)0) {
				flag=true;
			}
		}
		System.out.println(sb);
		System.out.println(flag);
	}


	public interface  IComparable{
		
		public int iComparable(T other);
	}
}

其中使用的对象：

package sss;

import sss.QuickSort2List.IComparable;

/**
 * @version 1.0
 *
 * @author DongXiang
 * 
 * @action 对象
 * 
 * @time 2017年7月18日下午5:23:49
 * 
 */
public class QObj implements IComparable{
	
	private String name=null;
	private int age=0;
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}



	@Override
	public String toString() {
		return "QObj [name=" + name + ", age=" + age + "]\n";
	}

	@Override
	public int iComparable(QObj other) {
		
		
		return this.getAge()-other.getAge();
	}

}