美文网首页算法与数据结构
排序算法学习笔记(nlogn部分)

排序算法学习笔记(nlogn部分)

作者: 邵俊颖 | 来源:发表于2018-08-29 15:52 被阅读0次

    归并排序

    自顶向下进行归并排序(方法1)

    注意:
    1.对于已经有序的数组,插入排序的效率要高于归并排序

        // 将arr[l...mid]和arr[mid+1...r]两部分进行归并
        private static void merge(Comparable[] arr, int l, int mid, int r) {
    
            Comparable[] aux = Arrays.copyOfRange(arr, l, r+1);
    
            // 初始化,i指向左半部分的起始索引位置l;j指向右半部分起始索引位置mid+1
            int i = l, j = mid+1;
            for( int k = l ; k <= r; k ++ ){
    
                if( i > mid ){  // 如果左半部分元素已经全部处理完毕
                    arr[k] = aux[j-l]; j ++;
                }
                else if( j > r ){   // 如果右半部分元素已经全部处理完毕
                    arr[k] = aux[i-l]; i ++;
                }
                else if( aux[i-l].compareTo(aux[j-l]) < 0 ){  // 左半部分所指元素 < 右半部分所指元素
                    arr[k] = aux[i-l]; i ++;
                }
                else{  // 左半部分所指元素 >= 右半部分所指元素
                    arr[k] = aux[j-l]; j ++;
                }
            }
        }
    
        // 递归使用归并排序,对arr[l...r]的范围进行排序
        private static void sort(Comparable[] arr, int l, int r) {
    
            //优化2:对于元素个数较少的时候,可以进行        
            //插入排序的操作,将会节省更多的时间
            //nlogn算法前面都会有一定的系数,在元素个  
            //数较少的时候,插入排序相比于归并排序要 
            //更快
            //优化后的代码
            //if(r-l <= 15)
            //     insertSort(arr,l,r);
            if (l >= r)
                return;
    
            int mid = (l+r)/2;
            sort(arr, l, mid);
            sort(arr, mid + 1, r);
            //优化1:
            //在merge之前,需要判断arr[mid]>arr[mid+1]`    
            //是否成立,如果不成立,那么已经有序,就不需 
            //要进行归并操作
            //优化下面的代码改成
            //if(arr[mid] > arr[mid+1])
            //      merge(arr,l,mid,r);
    
            merge(arr, l, mid, r);
        }
    
        public static void sort(Comparable[] arr){
    
            int n = arr.length;
            sort(arr, 0, n-1);
        }
    
    自底向上的归并排序(方法2)

    由于没有使用数组下标直接获取数组中的元素,所以可以对链表实现归并排序

        //本函数跟上面的一样的
        // 将arr[l...mid]和arr[mid+1...r]两部分进行归并
        private static void merge(Comparable[] arr, int l, int mid, int r) {
    
            Comparable[] aux = Arrays.copyOfRange(arr, l, r+1);
    
            // 初始化,i指向左半部分的起始索引位置l;j指向右半部分起始索引位置mid+1
            int i = l, j = mid+1;
            for( int k = l ; k <= r; k ++ ){
    
                if( i > mid ){  // 如果左半部分元素已经全部处理完毕
                    arr[k] = aux[j-l]; j ++;
                }
                else if( j > r ){   // 如果右半部分元素已经全部处理完毕
                    arr[k] = aux[i-l]; i ++;
                }
                else if( aux[i-l].compareTo(aux[j-l]) < 0 ){  // 左半部分所指元素 < 右半部分所指元素
                    arr[k] = aux[i-l]; i ++;
                }
                else{  // 左半部分所指元素 >= 右半部分所指元素
                    arr[k] = aux[j-l]; j ++;
                }
            }
        }
    
        public static void sort(Comparable[] arr){
    
            int n = arr.length;
    
            // Merge Sort Bottom Up 无优化版本
            for (int sz = 1; sz < n; sz *= 2)
                for (int i = 0; i < n - sz; i += sz+sz)
    
                    //改进1:如下代码改成
                    //if(arr[i+sz-1].compareTo(arr[i+sz]) >0)
                    //merge(arr, i, i+sz-1,Math.min(i+sz+sz-1,n-1));
    
                    // 对 arr[i...i+sz-1] 和 arr[i+sz...i+2*sz-1]进行归并
                    merge(arr, i, i+sz-1, Math.min(i+sz+sz-1,n-1));
    
        }
    

    快速排序

    原始版本

    1.该版本比优化后的归并排序更快
    注:可以使用随机数作为目标元素的下标,从而避免有序的时候递归树深度接近于n

        // 对arr[l...r]部分进行partition操作
        // 返回p, 使得arr[l...p-1] < arr[p] ; arr[p+1...r] > arr[p]
        private static int partition(Comparable[] arr, int l, int r){
    
            // 随机在arr[l...r]的范围中, 选择一个数值作为标定点pivot
            swap( arr, l , (int)(Math.random()*(r-l+1))+l );
    
            Comparable v = arr[l];
    
            int j = l; // arr[l+1...j] < v ; arr[j+1...i) > v
            for( int i = l + 1 ; i <= r ; i ++ )
                if( arr[i].compareTo(v) < 0 ){
                    j ++;
                    swap(arr, j, i);
                }
    
            swap(arr, l, j);
    
            return j;
        }
    
        // 递归使用快速排序,对arr[l...r]的范围进行排序
        private static void sort(Comparable[] arr, int l, int r){
    
            //优化1:
            // 对于小规模数组, 使用插入排序
            //if( r - l <= 15 ){
            //    InsertionSort.sort(arr, l, r);
            //    return;
            //}
            //原始版本:
            if(r <= l)
                return;
            
    
            int p = partition(arr, l, r);
            sort(arr, l, p-1 );
            sort(arr, p+1, r);
        }
    
        public static void sort(Comparable[] arr){
            int n = arr.length;
            sort(arr, 0, n-1);
        }
    
    思路2:两路排序

    解决的是:
    解决拥有非常多重复元素的时候本排序将拥有较好的效果.不然,当拥有非常多的重复元素的时候,重复元素将会倒向一边.
    用两个指针分别指向数组的两端,然后循环,遇到两边不符合的元素,调换位置,直到左边的指针与右边的指针重合或者超过右边的指针即可

        // 双路快速排序的partition
        // 返回p, 使得arr[l...p-1] < arr[p] ; arr[p+1...r] > arr[p]
        private static int partition(Comparable[] arr, int l, int r){
    
            // 随机在arr[l...r]的范围中, 选择一个数值作为标定点pivot
            swap( arr, l , (int)(Math.random()*(r-l+1))+l );
    
            Comparable v = arr[l];
    
            // arr[l+1...i) <= v; arr(j...r] >= v
            int i = l+1, j = r;
            while( true ){
                // 注意这里的边界, arr[i].compareTo(v) < 0, 不能是arr[i].compareTo(v) <= 0
                // 思考一下为什么?
                while( i <= r && arr[i].compareTo(v) < 0 )
                    i ++;
    
                // 注意这里的边界, arr[j].compareTo(v) > 0, 不能是arr[j].compareTo(v) >= 0
                // 思考一下为什么?
                while( j >= l+1 && arr[j].compareTo(v) > 0 )
                    j --;
    
                // 对于上面的两个边界的设定, 有的同学在课程的问答区有很好的回答:)
                // 大家可以参考: http://coding.imooc.com/learn/questiondetail/4920.html
    
                if( i > j )
                    break;
    
                swap( arr, i, j );
                i ++;
                j --;
            }
    
            swap(arr, l, j);
    
            return j;
        }
    
        // 递归使用快速排序,对arr[l...r]的范围进行排序
        private static void sort(Comparable[] arr, int l, int r){
    
            // 对于小规模数组, 使用插入排序
            if( r - l <= 15 ){
                InsertionSort.sort(arr, l, r);
                return;
            }
    
            int p = partition(arr, l, r);
            sort(arr, l, p-1 );
            sort(arr, p+1, r);
        }
    
        public static void sort(Comparable[] arr){
    
            int n = arr.length;
            sort(arr, 0, n-1);
        }
    

    另一种优化:三路快排

        // 递归使用快速排序,对arr[l...r]的范围进行排序
        private static void sort(Comparable[] arr, int l, int r){
    
            // 对于小规模数组, 使用插入排序
            if( r - l <= 15 ){
                InsertionSort.sort(arr, l, r);
                return;
            }
    
            // 随机在arr[l...r]的范围中, 选择一个数值作为标定点pivot
            swap( arr, l, (int)(Math.random()*(r-l+1)) + l );
    
            Comparable v = arr[l];
    
            int lt = l;     // arr[l+1...lt] < v
            int gt = r + 1; // arr[gt...r] > v
            int i = l+1;    // arr[lt+1...i) == v
            while( i < gt ){
                if( arr[i].compareTo(v) < 0 ){
                    swap( arr, i, lt+1);
                    i ++;
                    lt ++;
                }
                else if( arr[i].compareTo(v) > 0 ){
                    swap( arr, i, gt-1);
                    gt --;
                }
                else{ // arr[i] == v
                    i ++;
                }
            }
    
            swap( arr, l, lt );
    
            sort(arr, l, lt-1);
            sort(arr, gt, r);
        }
    
        public static void sort(Comparable[] arr){
    
            int n = arr.length;
            sort(arr, 0, n-1);
        }
    

    相关文章

      网友评论

        本文标题:排序算法学习笔记(nlogn部分)

        本文链接:https://www.haomeiwen.com/subject/cuqkwftx.html