2013.12.15

来源：互联网发布：王克勤记者知乎编辑：程序博客网时间：2024/05/21 18:41

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

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

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);        }}

0 0