feat: add golang solution to lcof problem: No.51. Reverse Pairs

yanglbme · yanglbme · commit bf007d307c90 · 2021-08-08T20:52:19.000+08:00
diff --git a/basic/sorting/QuickSort/Main.java b/basic/sorting/QuickSort/Main.java
@@ -14,11 +14,11 @@ public static void main(String[] args) {
         }
     }
     
-    public static void quickSort(int[] nums, int left, int high) {
-        if (left >= high) {
+    public static void quickSort(int[] nums, int left, int right) {
+        if (left >= right) {
             return;
         }
-        int i = left - 1, j = high + 1;
+        int i = left - 1, j = right + 1;
         int x = nums[left];
         while (i < j) {
             while (nums[++i] < x);
@@ -30,6 +30,6 @@ public static void quickSort(int[] nums, int left, int high) {
             }
         }
         quickSort(nums, left, j);
-        quickSort(nums, j + 1, high);
+        quickSort(nums, j + 1, right);
     }
 }
diff --git a/basic/sorting/QuickSort/Main.js b/basic/sorting/QuickSort/Main.js
@@ -9,14 +9,14 @@ let getInputArgs = line => {
     return line.split(' ').filter(s => s !== '').map(x => parseInt(x));
 }
 
-function quickSort(nums, left, high) {
-    if (left >= high) {
+function quickSort(nums, left, right) {
+    if (left >= right) {
         return;
     }
     
     let i = left - 1;
-    let j = high + 1;
-    let x = nums[(left + high) >> 1];
+    let j = right + 1;
+    let x = nums[(left + right) >> 1];
     while (i < j) {
         while (nums[++i] < x);
         while (nums[--j] > x);
@@ -27,7 +27,7 @@ function quickSort(nums, left, high) {
         }
     }
     quickSort(nums, left, j);
-    quickSort(nums, j + 1, high);
+    quickSort(nums, j + 1, right);
 }
 
 
diff --git a/basic/sorting/QuickSort/Main.py b/basic/sorting/QuickSort/Main.py
@@ -2,11 +2,11 @@
 nums = list(map(int, input().split()))
 
 
-def quick_sort(nums, left, high):
-    if left >= high:
+def quick_sort(nums, left, right):
+    if left >= right:
         return
-    i, j = left - 1, high + 1
-    x = nums[(left + high) >> 1]
+    i, j = left - 1, right + 1
+    x = nums[(left + right) >> 1]
     while i < j:
         while 1:
             i += 1
@@ -19,7 +19,7 @@ def quick_sort(nums, left, high):
         if i < j:
             nums[i], nums[j] = nums[j], nums[i]
     quick_sort(nums, left, j)
-    quick_sort(nums, j + 1, high)
+    quick_sort(nums, j + 1, right)
 
 
 quick_sort(nums, 0, N - 1)
diff --git a/basic/sorting/QuickSort/README.md b/basic/sorting/QuickSort/README.md
@@ -5,11 +5,11 @@
 **快速排序算法模板：**
 
 ```java
-void quickSort(int[] nums, int left, int high) {
-    if (left >= high) {
+void quickSort(int[] nums, int left, int right) {
+    if (left >= right) {
         return;
     }
-    int i = left - 1, j = high + 1;
+    int i = left - 1, j = right + 1;
     int x = nums[left];
     while (i < j) {
         while (nums[++i] < x);
@@ -21,7 +21,7 @@ void quickSort(int[] nums, int left, int high) {
         }
     }
     quickSort(nums, left, j);
-    quickSort(nums, j + 1, high);
+    quickSort(nums, j + 1, right);
 }
 ```
 
@@ -72,11 +72,11 @@ N = int(input())
 nums = list(map(int, input().split()))
 
 
-def quick_sort(nums, left, high):
-    if left >= high:
+def quick_sort(nums, left, right):
+    if left >= right:
         return
-    i, j = left - 1, high + 1
-    x = nums[(left + high) >> 1]
+    i, j = left - 1, right + 1
+    x = nums[(left + right) >> 1]
     while i < j:
         while 1:
             i += 1
@@ -89,7 +89,7 @@ def quick_sort(nums, left, high):
         if i < j:
             nums[i], nums[j] = nums[j], nums[i]
     quick_sort(nums, left, j)
-    quick_sort(nums, j + 1, high)
+    quick_sort(nums, j + 1, right)
 
 
 quick_sort(nums, 0, N - 1)
@@ -115,11 +115,11 @@ public class Main {
         }
     }
     
-    public static void quickSort(int[] nums, int left, int high) {
-        if (left >= high) {
+    public static void quickSort(int[] nums, int left, int right) {
+        if (left >= right) {
             return;
         }
-        int i = left - 1, j = high + 1;
+        int i = left - 1, j = right + 1;
         int x = nums[left];
         while (i < j) {
             while (nums[++i] < x);
@@ -131,7 +131,7 @@ public class Main {
             }
         }
         quickSort(nums, left, j);
-        quickSort(nums, j + 1, high);
+        quickSort(nums, j + 1, right);
     }
 }
 ```
@@ -150,14 +150,14 @@ let getInputArgs = line => {
     return line.split(' ').filter(s => s !== '').map(x => parseInt(x));
 }
 
-function quickSort(nums, left, high) {
-    if (left >= high) {
+function quickSort(nums, left, right) {
+    if (left >= right) {
         return;
     }
     
     let i = left - 1;
-    let j = high + 1;
-    let x = nums[(left + high) >> 1];
+    let j = right + 1;
+    let x = nums[(left + right) >> 1];
     while (i < j) {
         while (nums[++i] < x);
         while (nums[--j] > x);
@@ -168,7 +168,7 @@ function quickSort(nums, left, high) {
         }
     }
     quickSort(nums, left, j);
-    quickSort(nums, j + 1, high);
+    quickSort(nums, j + 1, right);
 }
 
 
@@ -192,12 +192,12 @@ package main
 
 import "fmt"
 
-func quickSort(nums []int, left, high int) {
-	if left >= high {
+func quickSort(nums []int, left, right int) {
+	if left >= right {
 		return
 	}
-	i, j := left-1, high+1
-	x := nums[(left+high)>>1]
+	i, j := left-1, right+1
+	x := nums[(left+right)>>1]
 	for i < j {
 		for {
 			i++
@@ -216,7 +216,7 @@ func quickSort(nums []int, left, high int) {
 		}
 	}
 	quickSort(nums, left, j)
-	quickSort(nums, j+1, high)
+	quickSort(nums, j+1, right)
 }
 
 func main() {
diff --git a/lcof/面试题51. 数组中的逆序对/README.md b/lcof/面试题51. 数组中的逆序对/README.md
@@ -37,25 +37,24 @@ class Solution:
                 return 0
             mid = (left + right) >> 1
             res = merge_sort(nums, left, mid) + merge_sort(nums, mid + 1, right)
-            i, j, k = left, mid + 1, 0
+            i, j = left, mid + 1
             tmp = []
             while i <= mid and j <= right:
                 if nums[i] <= nums[j]:
                     tmp.append(nums[i])
                     i += 1
                 else:
+                    res += (mid - i + 1)
                     tmp.append(nums[j])
                     j += 1
-                    res += (mid - i + 1)
             while i <= mid:
                 tmp.append(nums[i])
                 i += 1
             while j <= right:
                 tmp.append(nums[j])
                 j += 1
             for i in range(left, right + 1):
-                nums[i] = tmp[k]
-                k += 1
+                nums[i] = tmp[i - left]
             return res
         
         return merge_sort(nums, 0, len(nums) - 1)
@@ -67,8 +66,8 @@ class Solution:
 
 ```java
 class Solution {
-    private static int[] tmp = new int[50000];
-    
+    private static int[] tmp = new int[50010];
+
     public int reversePairs(int[] nums) {
         return mergeSort(nums, 0, nums.length - 1);
     }
@@ -77,15 +76,15 @@ class Solution {
         if (left >= right) {
             return 0;
         }
-        int mid = (left + right) >>> 1;
+        int mid = (left + right) >> 1;
         int res = mergeSort(nums, left, mid) + mergeSort(nums, mid + 1, right);
         int i = left, j = mid + 1, k = 0;
         while (i <= mid && j <= right) {
             if (nums[i] <= nums[j]) {
                 tmp[k++] = nums[i++];
             } else {
-                tmp[k++] = nums[j++];
                 res += (mid - i + 1);
+                tmp[k++] = nums[j++];
             }
         }
         while (i <= mid) {
@@ -94,8 +93,8 @@ class Solution {
         while (j <= right) {
             tmp[k++] = nums[j++];
         }
-        for (i = left, j = 0; i <= right; ++i) {
-            nums[i] = tmp[j++];
+        for (i = left; i <= right; ++i) {
+            nums[i] = tmp[i - left];
         }
         return res;
     }
@@ -222,6 +221,46 @@ function reversePairs(nums: number[]): number {
 };
 ```
 
+### **Go**
+
+```go
+func reversePairs(nums []int) int {
+	return mergeSort(nums, 0, len(nums)-1)
+}
+
+func mergeSort(nums []int, left, right int) int {
+	if left >= right {
+		return 0
+	}
+	mid := (left + right) >> 1
+	res := mergeSort(nums, left, mid) + mergeSort(nums, mid+1, right)
+	i, j := left, mid+1
+	var tmp []int
+	for i <= mid && j <= right {
+		if nums[i] <= nums[j] {
+			tmp = append(tmp, nums[i])
+			i++
+		} else {
+			res += (mid - i + 1)
+			tmp = append(tmp, nums[j])
+			j++
+		}
+	}
+	for i <= mid {
+		tmp = append(tmp, nums[i])
+		i++
+	}
+	for j <= right {
+		tmp = append(tmp, nums[j])
+		j++
+	}
+	for i = left; i <= right; i++ {
+		nums[i] = tmp[i-left]
+	}
+	return res
+}
+```
+
 ### **...**
 
 ```
diff --git a/lcof/面试题51. 数组中的逆序对/Solution.go b/lcof/面试题51. 数组中的逆序对/Solution.go
@@ -0,0 +1,35 @@
+func reversePairs(nums []int) int {
+	return mergeSort(nums, 0, len(nums)-1)
+}
+
+func mergeSort(nums []int, left, right int) int {
+	if left >= right {
+		return 0
+	}
+	mid := (left + right) >> 1
+	res := mergeSort(nums, left, mid) + mergeSort(nums, mid+1, right)
+	i, j := left, mid+1
+	var tmp []int
+	for i <= mid && j <= right {
+		if nums[i] <= nums[j] {
+			tmp = append(tmp, nums[i])
+			i++
+		} else {
+			res += (mid - i + 1)
+			tmp = append(tmp, nums[j])
+			j++
+		}
+	}
+	for i <= mid {
+		tmp = append(tmp, nums[i])
+		i++
+	}
+	for j <= right {
+		tmp = append(tmp, nums[j])
+		j++
+	}
+	for i = left; i <= right; i++ {
+		nums[i] = tmp[i-left]
+	}
+	return res
+}
diff --git a/lcof/面试题51. 数组中的逆序对/Solution.java b/lcof/面试题51. 数组中的逆序对/Solution.java
@@ -1,6 +1,6 @@
 class Solution {
-    private static int[] tmp = new int[50000];
-    
+    private static int[] tmp = new int[50010];
+
     public int reversePairs(int[] nums) {
         return mergeSort(nums, 0, nums.length - 1);
     }
@@ -9,15 +9,15 @@ private int mergeSort(int[] nums, int left, int right) {
         if (left >= right) {
             return 0;
         }
-        int mid = (left + right) >>> 1;
+        int mid = (left + right) >> 1;
         int res = mergeSort(nums, left, mid) + mergeSort(nums, mid + 1, right);
         int i = left, j = mid + 1, k = 0;
         while (i <= mid && j <= right) {
             if (nums[i] <= nums[j]) {
                 tmp[k++] = nums[i++];
             } else {
-                tmp[k++] = nums[j++];
                 res += (mid - i + 1);
+                tmp[k++] = nums[j++];
             }
         }
         while (i <= mid) {
@@ -26,8 +26,8 @@ private int mergeSort(int[] nums, int left, int right) {
         while (j <= right) {
             tmp[k++] = nums[j++];
         }
-        for (i = left, j = 0; i <= right; ++i) {
-            nums[i] = tmp[j++];
+        for (i = left; i <= right; ++i) {
+            nums[i] = tmp[i - left];
         }
         return res;
     }
diff --git a/lcof/面试题51. 数组中的逆序对/Solution.py b/lcof/面试题51. 数组中的逆序对/Solution.py

Original file line number	Diff line number	Diff line change
`@@ -14,11 +14,11 @@ public static void main(String[] args) {`
`14`	`14`	`}`
`15`	`15`	`}`
`16`	`16`
`17`		`- public static void quickSort(int[] nums, int left, int high) {`
`18`		`- if (left >= high) {`
	`17`	`+ public static void quickSort(int[] nums, int left, int right) {`
	`18`	`+ if (left >= right) {`
`19`	`19`	`return;`
`20`	`20`	`}`
`21`		`- int i = left - 1, j = high + 1;`
	`21`	`+ int i = left - 1, j = right + 1;`
`22`	`22`	`int x = nums[left];`
`23`	`23`	`while (i < j) {`
`24`	`24`	`while (nums[++i] < x);`
`@@ -30,6 +30,6 @@ public static void quickSort(int[] nums, int left, int high) {`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`	`quickSort(nums, left, j);`
`33`		`- quickSort(nums, j + 1, high);`
	`33`	`+ quickSort(nums, j + 1, right);`
`34`	`34`	`}`
`35`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,14 +9,14 @@ let getInputArgs = line => {`
`9`	`9`	`return line.split(' ').filter(s => s !== '').map(x => parseInt(x));`
`10`	`10`	`}`
`11`	`11`
`12`		`-function quickSort(nums, left, high) {`
`13`		`- if (left >= high) {`
	`12`	`+function quickSort(nums, left, right) {`
	`13`	`+ if (left >= right) {`
`14`	`14`	`return;`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`let i = left - 1;`
`18`		`- let j = high + 1;`
`19`		`- let x = nums[(left + high) >> 1];`
	`18`	`+ let j = right + 1;`
	`19`	`+ let x = nums[(left + right) >> 1];`
`20`	`20`	`while (i < j) {`
`21`	`21`	`while (nums[++i] < x);`
`22`	`22`	`while (nums[--j] > x);`
`@@ -27,7 +27,7 @@ function quickSort(nums, left, high) {`
`27`	`27`	`}`
`28`	`28`	`}`
`29`	`29`	`quickSort(nums, left, j);`
`30`		`- quickSort(nums, j + 1, high);`
	`30`	`+ quickSort(nums, j + 1, right);`
`31`	`31`	`}`
`32`	`32`
`33`	`33`
Original file line number	Diff line number	Diff line change
`@@ -5,11 +5,11 @@`
`5`	`5`	`快速排序算法模板：`
`6`	`6`
`7`	`7`	```java
`8`		`-void quickSort(int[] nums, int left, int high) {`
`9`		`- if (left >= high) {`
	`8`	`+void quickSort(int[] nums, int left, int right) {`
	`9`	`+ if (left >= right) {`
`10`	`10`	`return;`
`11`	`11`	`}`
`12`		`- int i = left - 1, j = high + 1;`
	`12`	`+ int i = left - 1, j = right + 1;`
`13`	`13`	`int x = nums[left];`
`14`	`14`	`while (i < j) {`
`15`	`15`	`while (nums[++i] < x);`
`@@ -21,7 +21,7 @@ void quickSort(int[] nums, int left, int high) {`
`21`	`21`	`}`
`22`	`22`	`}`
`23`	`23`	`quickSort(nums, left, j);`
`24`		`- quickSort(nums, j + 1, high);`
	`24`	`+ quickSort(nums, j + 1, right);`
`25`	`25`	`}`
`26`	`26`	```
`27`	`27`
`@@ -72,11 +72,11 @@ N = int(input())`
`72`	`72`	`nums = list(map(int, input().split()))`
`73`	`73`
`74`	`74`
`75`		`-def quick_sort(nums, left, high):`
`76`		`- if left >= high:`
	`75`	`+def quick_sort(nums, left, right):`
	`76`	`+ if left >= right:`
`77`	`77`	`return`
`78`		`- i, j = left - 1, high + 1`
`79`		`- x = nums[(left + high) >> 1]`
	`78`	`+ i, j = left - 1, right + 1`
	`79`	`+ x = nums[(left + right) >> 1]`
`80`	`80`	`while i < j:`
`81`	`81`	`while 1:`
`82`	`82`	`i += 1`
`@@ -89,7 +89,7 @@ def quick_sort(nums, left, high):`
`89`	`89`	`if i < j:`
`90`	`90`	`nums[i], nums[j] = nums[j], nums[i]`
`91`	`91`	`quick_sort(nums, left, j)`
`92`		`- quick_sort(nums, j + 1, high)`
	`92`	`+ quick_sort(nums, j + 1, right)`
`93`	`93`
`94`	`94`
`95`	`95`	`quick_sort(nums, 0, N - 1)`
`@@ -115,11 +115,11 @@ public class Main {`
`115`	`115`	`}`
`116`	`116`	`}`
`117`	`117`
`118`		`- public static void quickSort(int[] nums, int left, int high) {`
`119`		`- if (left >= high) {`
	`118`	`+ public static void quickSort(int[] nums, int left, int right) {`
	`119`	`+ if (left >= right) {`
`120`	`120`	`return;`
`121`	`121`	`}`
`122`		`- int i = left - 1, j = high + 1;`
	`122`	`+ int i = left - 1, j = right + 1;`
`123`	`123`	`int x = nums[left];`
`124`	`124`	`while (i < j) {`
`125`	`125`	`while (nums[++i] < x);`
`@@ -131,7 +131,7 @@ public class Main {`
`131`	`131`	`}`
`132`	`132`	`}`
`133`	`133`	`quickSort(nums, left, j);`
`134`		`- quickSort(nums, j + 1, high);`
	`134`	`+ quickSort(nums, j + 1, right);`
`135`	`135`	`}`
`136`	`136`	`}`
`137`	`137`	```
`@@ -150,14 +150,14 @@ let getInputArgs = line => {`
`150`	`150`	`return line.split(' ').filter(s => s !== '').map(x => parseInt(x));`
`151`	`151`	`}`
`152`	`152`
`153`		`-function quickSort(nums, left, high) {`
`154`		`- if (left >= high) {`
	`153`	`+function quickSort(nums, left, right) {`
	`154`	`+ if (left >= right) {`
`155`	`155`	`return;`
`156`	`156`	`}`
`157`	`157`
`158`	`158`	`let i = left - 1;`
`159`		`- let j = high + 1;`
`160`		`- let x = nums[(left + high) >> 1];`
	`159`	`+ let j = right + 1;`
	`160`	`+ let x = nums[(left + right) >> 1];`
`161`	`161`	`while (i < j) {`
`162`	`162`	`while (nums[++i] < x);`
`163`	`163`	`while (nums[--j] > x);`
`@@ -168,7 +168,7 @@ function quickSort(nums, left, high) {`
`168`	`168`	`}`
`169`	`169`	`}`
`170`	`170`	`quickSort(nums, left, j);`
`171`		`- quickSort(nums, j + 1, high);`
	`171`	`+ quickSort(nums, j + 1, right);`
`172`	`172`	`}`
`173`	`173`
`174`	`174`
`@@ -192,12 +192,12 @@ package main`
`192`	`192`
`193`	`193`	`import "fmt"`
`194`	`194`
`195`		`-func quickSort(nums []int, left, high int) {`
`196`		`- if left >= high {`
	`195`	`+func quickSort(nums []int, left, right int) {`
	`196`	`+ if left >= right {`
`197`	`197`	`return`
`198`	`198`	`}`
`199`		`- i, j := left-1, high+1`
`200`		`- x := nums[(left+high)>>1]`
	`199`	`+ i, j := left-1, right+1`
	`200`	`+ x := nums[(left+right)>>1]`
`201`	`201`	`for i < j {`
`202`	`202`	`for {`
`203`	`203`	`i++`
`@@ -216,7 +216,7 @@ func quickSort(nums []int, left, high int) {`
`216`	`216`	`}`
`217`	`217`	`}`
`218`	`218`	`quickSort(nums, left, j)`
`219`		`- quickSort(nums, j+1, high)`
	`219`	`+ quickSort(nums, j+1, right)`
`220`	`220`	`}`
`221`	`221`
`222`	`222`	`func main() {`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`class Solution {`
`2`		`- private static int[] tmp = new int[50000];`
`3`		`-`
	`2`	`+ private static int[] tmp = new int[50010];`
	`3`	`+`
`4`	`4`	`public int reversePairs(int[] nums) {`
`5`	`5`	`return mergeSort(nums, 0, nums.length - 1);`
`6`	`6`	`}`
`@@ -9,15 +9,15 @@ private int mergeSort(int[] nums, int left, int right) {`
`9`	`9`	`if (left >= right) {`
`10`	`10`	`return 0;`
`11`	`11`	`}`
`12`		`- int mid = (left + right) >>> 1;`
	`12`	`+ int mid = (left + right) >> 1;`
`13`	`13`	`int res = mergeSort(nums, left, mid) + mergeSort(nums, mid + 1, right);`
`14`	`14`	`int i = left, j = mid + 1, k = 0;`
`15`	`15`	`while (i <= mid && j <= right) {`
`16`	`16`	`if (nums[i] <= nums[j]) {`
`17`	`17`	`tmp[k++] = nums[i++];`
`18`	`18`	`} else {`
`19`		`- tmp[k++] = nums[j++];`
`20`	`19`	`res += (mid - i + 1);`
	`20`	`+ tmp[k++] = nums[j++];`
`21`	`21`	`}`
`22`	`22`	`}`
`23`	`23`	`while (i <= mid) {`
`@@ -26,8 +26,8 @@ private int mergeSort(int[] nums, int left, int right) {`
`26`	`26`	`while (j <= right) {`
`27`	`27`	`tmp[k++] = nums[j++];`
`28`	`28`	`}`
`29`		`- for (i = left, j = 0; i <= right; ++i) {`
`30`		`- nums[i] = tmp[j++];`
	`29`	`+ for (i = left; i <= right; ++i) {`
	`30`	`+ nums[i] = tmp[i - left];`
`31`	`31`	`}`
`32`	`32`	`return res;`
`33`	`33`	`}`