排序算法

递归排序和快速排序等

import java.util.ArrayList;
import java.util.List;

public class QuickSortTest {

	
	public static void main(String[] args) {
		List<Integer> list = new ArrayList<Integer>();
		list.add(50);
		list.add(58);
		list.add(1);
		list.add(10);
		list.add(5);
		list.add(20);
		list.add(40);
		list.add(50);
		list.add(99);
		System.out.println(sort(list));
		System.out.println("count1=" +count1);
		int[] array = new int[9];
		array[0] = 50;
		array[1] = 58;
		array[2] = 1;
		array[3] = 10;
		array[4] = 5;
		array[5] = 20;
		array[6] = 40;
		array[7] = 50;
		array[8] = 99;
		array = sort(array, 0, array.length - 1);
		for (int i : array) {
			System.out.println(i);
		}
		System.out.println("count2=" +count2);
		
	}
	
	public static Integer count1 = 0;
	public static Integer count2 = 0;
	/**
	 * 	实现快速排序,但是不是很好,有一个same的集合出现了
	 * 
	 * 快速排序的优化

对于基准位置的选取一般有三种方法：固定切分，随机切分和三取样切分。固定切分的效率并不是太好，随机切分是常用的一种切分，效率比较高，最坏情况下时间复杂度有可能为O(N2).对于三数取中选择基准点是最理想的一种。
	 * @param list
	 * @return
	 */
	
	/**
	 * 以下是简单的递归排序
	 * @param list
	 * @return
	 */
	public static  <T extends Comparable<T>> List<T> sort(List<T> list){
		count1 ++;
		if (null != list && list.size() >= 2) {
			T coin = list.get(list.size()/2);
			List<T> small = new ArrayList<T>();
			List<T> larger =  new ArrayList<T>();
			List<T> same =  new ArrayList<T>();
			for (int i = 0; i < list.size(); i++) {
				T object = list.get(i);
				int result = object.compareTo(coin);
				if (result == 1) {
					larger.add(list.get(i));
				}else if (result == -1) {
					small.add(object);
				}else {
					same.add(object);
				}
			}
			sort(small);
			sort(larger);
			list.clear();
			list.addAll(small);
			list.addAll(same);
			list.addAll(larger);
			}
		return list;
	}
	
	
	
	public static int partition(int []array,int lo,int hi){
        //固定的切分方式
        int key=array[lo];
        while(lo<hi){
            while(array[hi]>=key&&hi>lo){//从后半部分向前扫描
                hi--;
            }
            array[lo]=array[hi];
            while(array[lo]<=key&&hi>lo){//从前半部分向后扫描
                lo++;
            }
            array[hi]=array[lo];
        }
        array[hi]=key;
        return hi;
    }
	
	public static int partition2(int []array,int lo,int hi){
        //三数取中
        int mid=lo+(hi-lo)/2;
        if(array[mid]>array[hi]){
            swap(array[mid],array[hi]);
        }
        if(array[lo]>array[hi]){
            swap(array[lo],array[hi]);
        }
        if(array[mid]>array[lo]){
            swap(array[mid],array[lo]);
        }
        int key=array[lo];
        
        while(lo<hi){
            while(array[hi]>=key&&hi>lo){
                hi--;
            }
            array[lo]=array[hi];
            while(array[lo]<=key&&hi>lo){
                lo++;
            }
            array[hi]=array[lo];
        }
        array[hi]=key;
        return hi;
    }
    
    public static void swap(int a,int b){
        int temp=a;
        a=b;
        b=temp;
    }
    
    public static int[] sort(int[] array,int lo ,int hi){
    	count2 ++;
        if(lo>=hi){
            return array;
        }
        int index=partition(array,lo,hi);
        sort(array,lo,index-1);
        sort(array,index+1,hi); 
        return array;
    }
    
}