merge sort ref

README.md

@@ -37,17 +37,25 @@
 [重建二叉树问题](https://www.cnblogs.com/greyzeng/p/16715432.html)
 
 [二叉树的按层遍历相关问题](https://www.cnblogs.com/greyzeng/p/16356829.html)
+
 - 类似问题一： 二叉树自底向上层序遍历
 - 类似问题二：以数组的形式返回每一层节点的平均值
 - 类似问题三：填充每个节点的下一个右侧节点指针
 
 [使用二叉树的递归套路来解决的问题](https://www.cnblogs.com/greyzeng/p/16703346.html)
+
 - 判断一棵树是否为平衡二叉树
 - 判断一棵树是否为搜索二叉树
 - 判断一棵树是否为完全二叉树
 
 [二叉树路径总和系列问题](https://www.cnblogs.com/greyzeng/p/15700243.html)
 
+[与归并排序相关的一些问题](https://www.cnblogs.com/greyzeng/p/16653063.html)
+
+- 归并排序递归和非递归解法
+- 合并两个有序数组
+- 计算右侧小于当前元素的个数问题
+
 ## 更多
 
 [算法和数据结构学习笔记：CSDN](https://blog.csdn.net/hotonyhui/category_1250716.html)

src/main/java/git/snippet/mergesort/LeetCode_0315_CountOfSmallerNumbersAfterSelf.java

 package git.snippet.mergesort;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.List;
 
 
 /**
@@ -18,20 +19,18 @@ public class LeetCode_0315_CountOfSmallerNumbersAfterSelf {
     // 思路转换为：一个数的右边有多少个数比它小！
     // 改归并排序（从大到小）
     public List<Integer> countSmaller(int[] nums) {
-        List<Integer> ans = new LinkedList<>();
-        int[] result = new int[nums.length];
+        List<Integer> ans = new ArrayList<>(nums.length);
         Node[] nodes = new Node[nums.length];
         for (int i = 0; i < nums.length; i++) {
             nodes[i] = new Node(i, nums[i]);
+            ans.add(0);
         }
-        count(nodes, 0, nums.length - 1, result);
-        for (int n : result) {
-            ans.add(n);
-        }
+        count(nodes, 0, nums.length - 1, ans);
+
         return ans;
     }
 
-    public void count(Node[] nums, int l, int r, int[] result) {
+    public void count(Node[] nums, int l, int r, List<Integer> result) {
         if (l != r) {
             int m = ((r - l) >> 1) + l;
             count(nums, l, m, result);
@@ -41,14 +40,14 @@ public class LeetCode_0315_CountOfSmallerNumbersAfterSelf {
     }
 
     // 54 21 20 19 18 17
-    public void merge(Node[] nums, int l, int m, int r, int[] result) {
+    public void merge(Node[] nums, int l, int m, int r, List<Integer> result) {
         Node[] help = new Node[r - l + 1];
         int i = 0;
         int ls = l;
         int rs = m + 1;
         while (ls <= m && rs <= r) {
             if (nums[ls].value > nums[rs].value) {
-                result[nums[ls].index] = r - rs + 1 + result[nums[ls].index];
+                result.set(nums[ls].index, r - rs + 1 + result.get(nums[ls].index));
                 help[i++] = nums[ls++];
             } else {
                 help[i++] = nums[rs++];