java中排序算法的实现（一）

    转载请注明出处：http://blog.youkuaiyun.com/xiaojimanman/article/details/17681605

     从今天起，开始写java中关于排序算法的实现。

     这篇就先只介绍快速排序和冒泡排序在java中的一个实现方法，其中快速排序采用递归实现；冒泡排序采用了for循环和递归两种实现方式。

 /**  
 *@Description:  排序算法   
 */ 
package cn.lulei.util;  

import java.util.Comparator;
import java.util.List;
  
public class SortUtil {

	/**
	 * @param sortArray
	 * @param start 数组的起始位置
	 * @param end 数组的结束位置
	 * @param c 比较器
	 * @Date: 2013-12-30  
	 * @Author: lulei  
	 * @Description: 快速排序
	 */
	public static <T> void quickSort(List<T> list, int start, int end, Comparator<? super T> c){
		if (list == null || start < 0 || end > (list.size() - 1) || end == start) {
			return; //参数有误，直接返回
		}
		int i = start;
		int j = end;
		//一趟
		while (i < j) {
			//右侧扫描
			while ((i < j) && (c.compare(list.get(i), list.get(j)) <= 0)){
				j--;
			}
			//右侧扫描到比第一个比key小的交换
			if (i < j){
				T temp = list.get(i);
				list.set(i, list.get(j));
				list.set(j, temp);
			}
			//左侧扫描
			while ((i < j) && (c.compare(list.get(i), list.get(j)) < 0)){
				i++;
			}
			//左侧扫描到比第一个比key大的交换
			if (i < j){
				T temp = list.get(i);
				list.set(i, list.get(j));
				list.set(j, temp);
			}//右、左一轮结束，下一轮继续
		}
		//一趟结束
		//下面是递归调用快速排序
		if (i - start > 1) {
			quickSort(list, start, i - 1, c);
		}
		if (end - i > 1) {
			quickSort(list, i + 1, end, c);
		}
	}
	
	/**
	 * @param list
	 * @param c
	 * @Date: 2013-12-30  
	 * @Author: lulei  
	 * @Description: 快速排序
	 */
	public static <T> void quickSort(List<T> list, Comparator<? super T> c){
		if (list == null) {
			return;
		}
		quickSort(list, 0, list.size() - 1, c);
	}
	
	/**
	 * @param list
	 * @param end
	 * @param c
	 * @Date: 2013-12-30  
	 * @Author: lulei  
	 * @Description: 冒泡排序，递归实现方式
	 */
	public static <T> void bubbleSortRes(List<T> list, int end, Comparator<? super T> c) {
		if (list == null || end < 1){
			return;
		}
		end = end > (list.size() - 1) ? (list.size() - 1) : end;
		//一趟
		int i = 0;
		while (i < end) {
			if (c.compare(list.get(i), list.get(i + 1)) > 0) {
				T temp = list.get(i);
				list.set(i, list.get(i + 1));
				list.set(i + 1, temp);
			}
			i++;
		}
		//一趟结束
		//递归调用冒泡排序
		bubbleSortRes(list, end - 1, c);
	}
	
	/**
	 * @param list
	 * @param c
	 * @Date: 2013-12-30  
	 * @Author: lulei  
	 * @Description: 冒泡排序，for循环实现
	 */
	public static <T> void bubbleSortFor(List<T> list, Comparator<? super T> c){
		if (list == null){
			return;
		}
		for (int i = 1; i < list.size(); i++){//标识第几趟
			for (int j = 0; j < list.size() - i; j++){
				if (c.compare(list.get(j), list.get(j + 1)) > 0){
					T temp = list.get(j);
					list.set(j, list.get(j + 1));
					list.set(j + 1, temp);
				}
				//一趟结束
			}
			//排序结束
		}
	}
	
	/**
	 * @param list
	 * @param c
	 * @Date: 2013-12-30  
	 * @Author: lulei  
	 * @Description: 冒泡排序
	 */
	public static <T> void bubbleSort(List<T> list, Comparator<? super T> c) {
		if (list == null){
			return;
		}
		bubbleSort(list, c, true);
	}
	
	/**
	 * @param list
	 * @param c 比较器
	 * @param rec 是否采用递归实现
	 * @Date: 2013-12-30  
	 * @Author: lulei  
	 * @Description: 冒泡排序
	 */
	public static <T> void bubbleSort(List<T> list, Comparator<? super T> c, boolean rec) {
		if (list == null){
			return;
		}
		if (rec) {
			bubbleSortRes(list, list.size(), c);
		} else {
			bubbleSortFor(list, c);
		}
	}
}

     当然这两种排序算法中还有很多可以优化的部分，在以后的文章中，将会给出对应的优化结果。