2.1.0 归并排序

归并排序,时间复杂度O(N * log N) 额外空间复杂度O(N)


public class MergeSort {
    
    public static void sort(int[] array) {
        if(array == null || array.length <2) return;
        mergesort(array, 0, array.length-1);
        return;
        
    }
    
    public static void mergesort(int[] array, int leftIndex, int rightIndex) {
        if(leftIndex >= rightIndex) return;
        int mid = leftIndex + ((rightIndex - leftIndex) >>1);
        mergesort(array, leftIndex, mid);
        mergesort(array, mid+1,rightIndex);
        merge(array,leftIndex,rightIndex,mid);
        return;
    }
    
    public static void merge(int[] array, int leftIndex, int rightIndex, int mid) {
        int[] tempArray = new int[rightIndex - leftIndex + 1];
        int left = leftIndex;
        int right = mid + 1;
        int pos = 0;
        
        while(left <= mid && right <= rightIndex) {
            if(array[left] <= array[right]) {
                tempArray[pos++] = array[left++];
            }else {
                tempArray[pos++] = array[right++];
            }
        }
        
        while(left <= mid) {
            tempArray[pos++] = array[left++];
        }
        
        while(right <= mid) {
            tempArray[pos++] = array[right++];
        }
        System.arraycopy(tempArray, 0, array, leftIndex, tempArray.length);
        return;
    }
    
    public static void main(String[] args)throws Exception {
        int [] arr = {4,3,2,1};
        MergeSort sol = new MergeSort();
        sol.sort(arr);
        for(int i=0; i < arr.length;i++) {
            System.out.println(arr[i]);
        }
    }

}

小和问题
在一个数组中,每一个数左边比当前数小的数累加起来,叫做这个数组的小和。求一个数组的小和
如[1, 3, 4, 2, 5]的
小和为(0)+(1)+(1+3)+(1)+(1+3+4+2)
直接解法,暴力遍历O(N^2)

public class SmallSum {

    public static int sum = 0;

    public static int smallSum(int[] arr) {
        if (arr == null || arr.length < 2)
            return 0;
        return subSmallSum(arr, 0, arr.length - 1);
    }

    public static int subSmallSum(int[] arr, int leftIndex, int rightIndex) {
        if (leftIndex >= rightIndex)
            return 0;
        int mid = leftIndex + ((rightIndex - leftIndex) >> 1);
        return subSmallSum(arr, leftIndex, mid) + subSmallSum(arr, mid + 1, rightIndex)
                + mergeCount(arr, leftIndex, rightIndex, mid);
    }

    public static int mergeCount(int[] arr, int leftIndex, int rightIndex, int mid) {
        int[] temparr = new int[rightIndex - leftIndex + 1];
        int left = leftIndex;
        int right = mid + 1;
        int pos = 0;
        int sum = 0;
        while (left <= mid && right <= rightIndex) {
            if (arr[left] < arr[right]) {
                sum += arr[left] * (rightIndex - right + 1);
                temparr[pos++] = arr[left++];
            } else {
                temparr[pos++] = arr[right++];
            }

        }

        while (left <= mid) {
            temparr[pos++] = arr[left++];
        }

        while (right <= rightIndex) {
            temparr[pos++] = arr[right++];
        }
                System.arraycopy(temparr, 0, arr, leftIndex, temparr.length);
        return sum;
    }

    public static void main(String[] args) {
        int[] arr = { 1, 3, 4, 2, 5 };

        System.out.println(smallSum(arr));
    }

}

逆序对问题
在一个数组中,左边的数如果比右边的数大,则这两个数构成一个逆序对,求所有逆序对

public class ReverseCouple {
    public static List<int[]> countReverseCouple(int [] arr){
        if(arr == null || arr.length < 2) return new ArrayList<int[]>();
        return countReverseCoupleSub(arr, 0, arr.length -1);
    }
    
    public static List<int[]> countReverseCoupleSub(int[] arr, int left, int right) {
        if(left >=right) {
            return new ArrayList<int[]>();
        }
        List<int[]> res = new ArrayList<>();
        int mid = left + ((right - left)>>1);
        res.addAll(countReverseCoupleSub(arr, left, mid));
        res.addAll(countReverseCoupleSub(arr, mid + 1, right));
        res.addAll(merge(arr, left, mid, right));
        return res; 
    }
    
    public static List<int[]> merge(int[] arr, int leftIndex, int mid, int rightIndex){
        List<int[]> res = new ArrayList<>();
        if(rightIndex <= leftIndex) return res;
        int[] tempArr = new int[rightIndex - leftIndex + 1];
        int left = mid;
        int right = rightIndex;
        int pos = tempArr.length -1;

        while(left >= leftIndex  && right >= mid + 1) {
            
            if(arr[left] > arr[right]) {
                for(int i = mid+1; i<=right; i++) {
                    int[] temp = new int[2];
                    temp[0] = arr[left];
                    temp[1] = arr[i];
                    res.add(temp);
                }
                tempArr[pos--] = arr[left--];
            }else {
                tempArr[pos--] = arr[right--];
            }
        }
        
        while(left >= leftIndex) {
            tempArr[pos--] = arr[left--];
        }
        while(right >= mid + 1) {
            tempArr[pos--] = arr[right--];
        }
        System.arraycopy(tempArr, 0, arr, leftIndex, tempArr.length);
        return res;
    }
    
    public static void main(String[] args) {
        int[] arr = { 1, 3, 4, 2, 5 };
        System.out.println(countReverseCouple(arr).size());
    }

}

推荐阅读更多精彩内容

  • 知 识 点 / 超 人 数据结构算法排序是比较枯燥的知识,学习一定要耐着性子看,不然很容易理解错误。本文比较适合自...
    树下敲代码的超人阅读 4,641评论 9 57
  • 一些概念 数据结构就是研究数据的逻辑结构和物理结构以及它们之间相互关系,并对这种结构定义相应的运算,而且确保经过这...
    Winterfell_Z阅读 4,428评论 0 13
  • 1 初级排序算法 排序算法关注的主要是重新排列数组元素,其中每个元素都有一个主键。排序算法是将所有元素主键按某种方...
    深度沉迷学习阅读 940评论 0 1
  • 1. 解题思路 归并排序的核心思想是先让序列的左半部分有序、再让序列的右半部分有序,最后从两个子序列(左右两半)从...
    霍运浩阅读 266评论 0 0
  • 目录 冒泡排序 选择排序 插入排序 归并排序 小和问题 逆序对问题 冒泡排序 冒泡排序的思路:每一个数与自己后面的...
    管弦_阅读 1,001评论 0 1
  • 在卑微割下前 他许下了关于大海的愿望 小小的纸船游出港湾 发誓不再返回故乡 他也许喝醉了 固执的要把破碎的梦复原 ...
    伍丁零阅读 85评论 0 5
  • 公元二零一六年九月十六日,乔任梁的名字像病毒爆发在网络疯传。名气并不大的他一时间上了热搜榜,出于好奇就咨询度娘,被...
    黑白镜阅读 424评论 7 1
  • 青春是星光 青春是火苗 青春是回忆时含泪的思念 那一瞬 如流星般消逝 使人流连忘返 当年许下的愿望 如今实现了吗?
    紫央读书阅读 172评论 0 8