数据结构--希尔排序和快速排序

/*希尔排序：对插入排序的改进，其排序是按照一个增量序列来进行
 *增量序列的个数就是排序的趟数。在任意增量K下，保证a[i]<=a[i+k]
 *该算法的效率和增量需序列的选择有很大关系。
 *增量序列一般规则：h = 3h + 1;
 *希尔排序的效率总体比简单排序的好。
 * */
public class ShellSort {

    public static void main(String[] args) {
        int[] list = {6,9,2,3,5,50,30,8,7,4,23,12};
        displayList(list);
        shellSort(list);
        displayList(list);
    }
    
    public static void shellSort(int[] arr){
        int inner,outer;
        int temp;
        int h = 1;
        while(h <= arr.length / 3){
            h = h * 3 + 1;
        }
        //外循环控制排序趟数
        while(h > 0){ 
            //控制每个增量的循环
            for(outer = h; outer < arr.length; outer++){
                temp = arr[outer];
                inner = outer;
                
                while(inner > h - 1 && arr[inner - h] >= temp){
                    arr[inner] = arr[inner - h];
                    inner = inner - h;
                }
                arr[inner] = temp;
            }
            h = (h - 1) / 3;
        }
    }
    
    public static void displayList(int[] arr){
        for(int i = 0; i < arr.length;i++){
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
    
}

/*快速排序：将一个数组划分为两个子数组，递归调用自身为每个子数组进行快速排序。
 * 注意：确定好递归终止条件right - left <= 0
 * 每次划分组：是根据划分的思想确定出下次组的边界
 *2.划分思想：按照序列中的某个值将序列划分为两部分，右边值全部小于该值左边的部分全部大于该值，
 *该值的选择尽量接近该组序列的平均值.通过在设置两个指针，分别从相反的方向找到比中间值大的
 *和比中间值小的，交换，最后将中间值放在其位置上。
 *3.快速排序：通常来说是效率比较好的排序算法O(NlogN)
 *4.中枢值选择关键，最好两边长度差不多比较好，假如两边差的多，将导致多的一边过多的划分
 * 效率降低，序列无序度高效果会好点--对于随机选择的中枢值
 * */
public class QuickSort {

    public static void main(String[] args) {
        int[] list = {3,2,5,7,5,38,20,18,27,39,12};
        displayList(list);
        quickSort(list);
        displayList(list);
    }
    
    public static void quickSort(int[] arr){
        recQuickSort(0,arr.length-1,arr);
    }
    
    private static void recQuickSort(int left, int right,int[] arr) {
        if(right - left <= 0){//size<=1.递归基准条件
            return;
        }
        else{
            int pivot = arr[right];
            //整理一次小的在一边大的在一边,并获得下次分组的边界
            int partition = partitionIt(left,right,pivot,arr);  
            recQuickSort(left, partition - 1, arr);
            recQuickSort(partition + 1, right, arr);
        }
        
    }

    public static int partitionIt(int left,int right,int pivot,int[] arr){
        int lefter = left - 1;   //第一个元素的左边
        int righter = right;  //最后一个元素
        
        while(true){
            while(arr[++lefter] < pivot);//左边直到找到比中间值大的一个元素
            
            while(righter > 0 && arr[--righter] > pivot);//右边直到找到比中间值小的一个元素
            
            if(lefter >= righter){
                break;
            }
            else{
                swap(lefter,righter,arr);   //交换两个元素
            }
        }
        swap(lefter,right,arr);   //将选定的中间值放其位置上
        return lefter;
        
    }

    private static void swap(int lefter, int righter,int[] list) {
        int temp = list[lefter];
        list[lefter] = list[righter];
        list[righter] = temp;
    }
    
    public static void displayList(int[] arr){
        for(int i = 0; i < arr.length;i++){
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

}