Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit f626e96

Browse files
committed
feat: add solutions to lc problem: No.0912
No.0912.Sort an Array
1 parent b9fe632 commit f626e96

File tree

5 files changed

+347
-179
lines changed

5 files changed

+347
-179
lines changed

‎solution/0900-0999/0912.Sort an Array/README.md‎

Lines changed: 156 additions & 83 deletions
Original file line numberDiff line numberDiff line change
@@ -89,31 +89,29 @@ class Solution:
8989
```python
9090
class Solution:
9191
def sortArray(self, nums: List[int]) -> List[int]:
92-
def merge_sort(nums, left, right):
93-
if left >= right:
92+
def merge_sort(l, r):
93+
if l >= r:
9494
return
95-
mid = (left + right) >> 1
96-
merge_sort(nums, left, mid)
97-
merge_sort(nums, mid + 1, right)
98-
i, j = left, mid + 1
95+
mid = (l + r) >> 1
96+
merge_sort(l, mid)
97+
merge_sort(mid + 1, r)
98+
i, j = l, mid + 1
9999
tmp = []
100-
while i <= mid and j <= right:
100+
while i <= mid and j <= r:
101101
if nums[i] <= nums[j]:
102102
tmp.append(nums[i])
103103
i += 1
104104
else:
105105
tmp.append(nums[j])
106106
j += 1
107-
while i <= mid:
108-
tmp.append(nums[i])
109-
i += 1
110-
while j <= right:
111-
tmp.append(nums[j])
112-
j += 1
113-
for i in range(left, right + 1):
114-
nums[i] = tmp[i - left]
115-
116-
merge_sort(nums, 0, len(nums) - 1)
107+
if i <= mid:
108+
tmp.extend(nums[i:mid + 1])
109+
if j <= r:
110+
tmp.extend(nums[j: r + 1])
111+
for i in range(l, r + 1):
112+
nums[i] = tmp[i - l]
113+
114+
merge_sort(0, len(nums) - 1)
117115
return nums
118116
```
119117

@@ -197,21 +195,24 @@ class Solution {
197195

198196
```java
199197
class Solution {
198+
private int[] nums;
199+
200200
public int[] sortArray(int[] nums) {
201-
mergeSort(nums, 0, nums.length - 1);
201+
this.nums = nums;
202+
mergeSort(0, nums.length - 1);
202203
return nums;
203204
}
204205

205-
private void mergeSort(int[] nums, int left, intright) {
206-
if (left >= right) {
206+
private void mergeSort(intl, int r) {
207+
if (l >= r) {
207208
return;
208209
}
209-
int mid = (left + right) >> 1;
210-
mergeSort(nums, left, mid);
211-
mergeSort(nums, mid + 1, right);
212-
int i = left, j = mid + 1, k = 0;
213-
int[] tmp = new int[right - left + 1];
214-
while (i <= mid && j <= right) {
210+
int mid = (l + r) >> 1;
211+
mergeSort(l, mid);
212+
mergeSort(mid + 1, r);
213+
int i = l, j = mid + 1, k = 0;
214+
int[] tmp = new int[r - l + 1];
215+
while (i <= mid && j <= r) {
215216
if (nums[i] <= nums[j]) {
216217
tmp[k++] = nums[i++];
217218
} else {
@@ -221,11 +222,11 @@ class Solution {
221222
while (i <= mid) {
222223
tmp[k++] = nums[i++];
223224
}
224-
while (j <= right) {
225+
while (j <= r) {
225226
tmp[k++] = nums[j++];
226227
}
227-
for (i = left; i <= right; ++i) {
228-
nums[i] = tmp[i - left];
228+
for (i = l; i <= r; ++i) {
229+
nums[i] = tmp[i - l];
229230
}
230231
}
231232
}
@@ -269,26 +270,35 @@ public:
269270
class Solution {
270271
public:
271272
vector<int> sortArray(vector<int>& nums) {
272-
merge_sort(nums, 0, nums.size() - 1);
273+
function<void(int, int)> merge_sort = [&](int l, int r) {
274+
if (l >= r) {
275+
return;
276+
}
277+
int mid = (l + r) >> 1;
278+
merge_sort(l, mid);
279+
merge_sort(mid + 1, r);
280+
int i = l, j = mid + 1, k = 0;
281+
int tmp[r - l + 1];
282+
while (i <= mid && j <= r) {
283+
if (nums[i] <= nums[j]) {
284+
tmp[k++] = nums[i++];
285+
} else {
286+
tmp[k++] = nums[j++];
287+
}
288+
}
289+
while (i <= mid) {
290+
tmp[k++] = nums[i++];
291+
}
292+
while (j <= r) {
293+
tmp[k++] = nums[j++];
294+
}
295+
for (i = l; i <= r; ++i) {
296+
nums[i] = tmp[i - l];
297+
}
298+
};
299+
merge_sort(0, nums.size() - 1);
273300
return nums;
274301
}
275-
276-
void merge_sort(vector<int>& nums, int left, int right) {
277-
if (left >= right) return;
278-
int mid = left + right >> 1;
279-
merge_sort(nums, left, mid);
280-
merge_sort(nums, mid + 1, right);
281-
int i = left, j = mid + 1, k = 0;
282-
vector<int> tmp(right - left + 1);
283-
while (i <= mid && j <= right)
284-
{
285-
if (nums[i] <= nums[j]) tmp[k++] = nums[i++];
286-
else tmp[k++] = nums[j++];
287-
}
288-
while (i <= mid) tmp[k++] = nums[i++];
289-
while (j <= right) tmp[k++] = nums[j++];
290-
for (i = left; i <= right; ++i) nums[i] = tmp[i - left];
291-
}
292302
};
293303
```
294304

@@ -302,12 +312,12 @@ func sortArray(nums []int) []int {
302312
return nums
303313
}
304314

305-
func quickSort(nums []int, left, right int) {
306-
if left >= right {
315+
func quickSort(nums []int, l, r int) {
316+
if l >= r {
307317
return
308318
}
309-
i, j := left-1, right+1
310-
x := nums[(left+right)>>1]
319+
i, j := l-1, r+1
320+
x := nums[(l+r)>>1]
311321
for i < j {
312322
for {
313323
i++
@@ -325,8 +335,8 @@ func quickSort(nums []int, left, right int) {
325335
nums[i], nums[j] = nums[j], nums[i]
326336
}
327337
}
328-
quickSort(nums, left, j)
329-
quickSort(nums, j+1, right)
338+
quickSort(nums, l, j)
339+
quickSort(nums, j+1, r)
330340
}
331341
```
332342

@@ -338,16 +348,16 @@ func sortArray(nums []int) []int {
338348
return nums
339349
}
340350

341-
func mergeSort(nums []int, left, right int) {
342-
if left >= right {
351+
func mergeSort(nums []int, l, r int) {
352+
if l >= r {
343353
return
344354
}
345-
mid := (left + right) >> 1
346-
mergeSort(nums, left, mid)
347-
mergeSort(nums, mid+1, right)
348-
i, j, k := left, mid+1, 0
349-
tmp := make([]int, right-left+1)
350-
for i <= mid && j <= right {
355+
mid := (l + r) >> 1
356+
mergeSort(nums, l, mid)
357+
mergeSort(nums, mid+1, r)
358+
i, j, k := l, mid+1, 0
359+
tmp := make([]int, r-l+1)
360+
for i <= mid && j <= r {
351361
if nums[i] <= nums[j] {
352362
tmp[k] = nums[i]
353363
i++
@@ -357,22 +367,85 @@ func mergeSort(nums []int, left, right int) {
357367
}
358368
k++
359369
}
360-
for i <= mid {
370+
for ; i <= mid; i++ {
361371
tmp[k] = nums[i]
362-
i++
363372
k++
364373
}
365-
for j <= right {
374+
for ; j <= r; j++ {
366375
tmp[k] = nums[j]
367-
j++
368376
k++
369377
}
370-
for i = left; i <= right; i++ {
371-
nums[i] = tmp[i-left]
378+
for i = l; i <= r; i++ {
379+
nums[i] = tmp[i-l]
372380
}
373381
}
374382
```
375383

384+
### **TypeScript**
385+
386+
快速排序:
387+
388+
```ts
389+
function sortArray(nums: number[]): number[] {
390+
function quickSort(l: number, r: number) {
391+
if (l >= r) {
392+
return;
393+
}
394+
let i = l - 1;
395+
let j = r + 1;
396+
const x = nums[(l + r) >> 1];
397+
while (i < j) {
398+
while (nums[++i] < x);
399+
while (nums[--j] > x);
400+
if (i < j) {
401+
[nums[i], nums[j]] = [nums[j], nums[i]];
402+
}
403+
}
404+
quickSort(l, j);
405+
quickSort(j + 1, r);
406+
}
407+
const n = nums.length;
408+
quickSort(0, n - 1);
409+
return nums;
410+
}
411+
```
412+
413+
归并排序:
414+
415+
```ts
416+
function sortArray(nums: number[]): number[] {
417+
function mergetSort(l: number, r: number) {
418+
if (l >= r) {
419+
return;
420+
}
421+
const mid = (l + r) >> 1;
422+
mergetSort(l, mid);
423+
mergetSort(mid + 1, r);
424+
let [i, j, k] = [l, mid + 1, 0];
425+
while (i <= mid && j <= r) {
426+
if (nums[i] <= nums[j]) {
427+
tmp[k++] = nums[i++];
428+
} else {
429+
tmp[k++] = nums[j++];
430+
}
431+
}
432+
while (i <= mid) {
433+
tmp[k++] = nums[i++];
434+
}
435+
while (j <= r) {
436+
tmp[k++] = nums[j++];
437+
}
438+
for (i = l, j = 0; i <= r; ++i, ++j) {
439+
nums[i] = tmp[j];
440+
}
441+
}
442+
const n = nums.length;
443+
let tmp = new Array(n).fill(0);
444+
mergetSort(0, n - 1);
445+
return nums;
446+
}
447+
```
448+
376449
### **JavaScript**
377450

378451
快速排序:
@@ -383,22 +456,22 @@ func mergeSort(nums []int, left, right int) {
383456
* @return {number[]}
384457
*/
385458
var sortArray = function (nums) {
386-
function quickSort(left, right) {
387-
if (left >= right) {
459+
function quickSort(l, r) {
460+
if (l >= r) {
388461
return;
389462
}
390-
let i = left - 1;
391-
let j = right + 1;
392-
const x = nums[(left + right) >> 1];
463+
let i = l - 1;
464+
let j = r + 1;
465+
const x = nums[(l + r) >> 1];
393466
while (i < j) {
394467
while (nums[++i] < x);
395468
while (nums[--j] > x);
396469
if (i < j) {
397470
[nums[i], nums[j]] = [nums[j], nums[i]];
398471
}
399472
}
400-
quickSort(left, j);
401-
quickSort(j + 1, right);
473+
quickSort(l, j);
474+
quickSort(j + 1, r);
402475
}
403476
const n = nums.length;
404477
quickSort(0, n - 1);
@@ -414,15 +487,15 @@ var sortArray = function (nums) {
414487
* @return {number[]}
415488
*/
416489
var sortArray = function (nums) {
417-
function mergetSort(left, right) {
418-
if (left >= right) {
490+
function mergetSort(l, r) {
491+
if (l >= r) {
419492
return;
420493
}
421-
const mid = (left + right) >> 1;
422-
mergetSort(left, mid);
423-
mergetSort(mid + 1, right);
424-
let [i, j, k] = [left, mid + 1, 0];
425-
while (i <= mid && j <= right) {
494+
const mid = (l + r) >> 1;
495+
mergetSort(l, mid);
496+
mergetSort(mid + 1, r);
497+
let [i, j, k] = [l, mid + 1, 0];
498+
while (i <= mid && j <= r) {
426499
if (nums[i] <= nums[j]) {
427500
tmp[k++] = nums[i++];
428501
} else {
@@ -432,10 +505,10 @@ var sortArray = function (nums) {
432505
while (i <= mid) {
433506
tmp[k++] = nums[i++];
434507
}
435-
while (j <= right) {
508+
while (j <= r) {
436509
tmp[k++] = nums[j++];
437510
}
438-
for (i = left, j = 0; i <= right; ++i, ++j) {
511+
for (i = l, j = 0; i <= r; ++i, ++j) {
439512
nums[i] = tmp[j];
440513
}
441514
}

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /