2013.12.15

* 实现了基于插入排序&“三项取中”划分的快速排序；

* “三项取中”划分带来的好处：

    1：一定程度上避免了基本有序源数组导致的快速排序性能劣化的情况；

    2： low，center，high三个元素已经排好，故不用将low，high加入循环，一定程度上减少了比较次数；

    3： 消除了循环内l<h的判断，因为不会出现一直low++/high--而出现的越界情况；

* 使用“三项取中”划分的快速排序不能处理只有2/3个元素的数组，并且对多数据排序的时候，小划分（~=3）要使用手动排序；

* 快速排序的效率 N*logN；

* 基数排序实际上的效率与快速排序相近都是N*logN，但是需要两倍于快速排序的空间；

* 实现了基于链表的基数排序。此排序中使用的栈有deleteFirst()，insertFirst()方法，较大的数后进入站，正向遍历栈组中的所有数据，会导致大数先出栈，所以应该反向遍历栈组并从后插入数组；

* 实现了基于pivot的中位数查找；

基于“三项取中”划分&小划分（9）插入排序的快速排序算法@java/DataStructure/unit7

import java.util.*;

public class TestQuickSort2{
        public static void main(String [] args){
                Random rand=new Random(47);
                int [] iArr=new int [100];
                for(int i=0; i<100; i++) iArr[i]=rand.nextInt(100);
                System.out.println(Arrays.toString(iArr));
                quickSort(0, iArr.length-1, iArr);
                System.out.println(Arrays.toString(iArr));
        }

        public static int partition(int low, int high, int [] iArr){
                int l=low+1, h=high-1, c=(low+high)/2, pivot=c, t;
                if(iArr[low]>iArr[c]){t=iArr[low]; iArr[low]=iArr[c]; iArr[c]=t;}
                if(iArr[c]>iArr[high]){t=iArr[c]; iArr[c]=iArr[high]; iArr[high]=t;}
                while(l<h){
                        while(iArr[h]>pivot){
                                h--;
                        }
                        iArr[l]=iArr[h];
                        while(iArr[l]<=pivot){
                                l++;
                        }
                        iArr[h]=iArr[l];
                }
                iArr[l]=pivot;
                return l;
        }

        public static void insertSort(int low, int high, int [] iArr){
                int t, j;
                for(int i=low+1; i<=high; i++){
                        if(iArr[i]<iArr[i-1]){
                                t=iArr[i];
                                j=i-1;
                                for(; j>=0 && t<iArr[j]; j--) iArr[j+1]=iArr[j];
                                iArr[j+1]=t;
                        }
                }
        }

        public static void quickSort(int low, int high, int [] iArr){
                int size=high-low+1;
                if(size<10) insertSort(low, high, iArr);
                else{
                        int ptr=partition(low, high, iArr);
                        quickSort(low, ptr-1, iArr);
                        quickSort(ptr+1, high, iArr);
                }
        }
}

基于链表的基数排序@java/DataStructure/unit7

import java.util.*;

public class TestRadixSort{
        public static void main(String [] args){
                Random rand=new Random(47);
                int [] iArr=new int [100];
                for(int i=0; i<iArr.length; i++) iArr[i]=rand.nextInt(1000);
                System.out.println(Arrays.toString(iArr));
                radixSort(iArr, 3);
                System.out.println(Arrays.toString(iArr));
        }
        
        public static void radixSort(int [] iArr, int digit){
                int l=iArr.length, t=1;
                int [] tArr=new int [iArr.length];
                LinkListX [] lArr=new LinkListX[10];
                for(int i=0; i<10; i++) lArr[i]=new LinkListX();
                for(int i=0; i<digit; i++){
                        for(int j=0; j<l; j++){
                                if(iArr[j]<t) lArr[0].insertFirst(iArr[j]);
                                else lArr[(iArr[j]/t)%10].insertFirst(iArr[j]);
                        }
                        int k=l-1;
                        for(int j=9; j>=0; j--){
                                while(!lArr[j].isEmpty()){
                                        iArr[k--]=lArr[j].deleteFirst().iData;
                                }
                        }
                        t*=10;
                }
        }
}

基于pivot的中位数查找@java/DataStructure/unit7

import java.util.*;

public class TestCenterValue{
        public static void main(String [] args){
                Random rand=new Random(47);
                int [] iArr= new int [11];
                for(int i=0; i<11; i++) iArr[i]=rand.nextInt(100);
                System.out.println(Arrays.toString(iArr));
                findCenterValue(0, iArr.length-1, iArr);
        }

        public static int patition(int low, int high, int [] iArr){
                int l=low, h=high, pivot=iArr[low];
                while(l<h){
                        while(l<h && iArr[h]>pivot){
                                h--;
                        }
                        iArr[l]=iArr[h];
                        while(l<h && iArr[l]<=pivot){
                                l++;
                        }
                        iArr[h]=iArr[l];
                }
                iArr[l]=pivot;
                return l;
        }

        public static void findCenterValue(int low, int high, int [] iArr){
                int p=patition(low, high, iArr);
                if(iArr.length/2==p){System.out.println("The Center Value is "+iArr[p]); return;}
                else if(p>iArr.length) findCenterValue(low, p-1, iArr);
                else findCenterValue(p+1, high, iArr);
        }
}