Skip to content

Commit 18fafb9

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0912
No.0912.Sort an Array
1 parent 68b6993 commit 18fafb9

File tree

5 files changed

+220
-130
lines changed

5 files changed

+220
-130
lines changed

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

+86-43
Original file line numberDiff line numberDiff line change
@@ -63,26 +63,24 @@
6363
```python
6464
class Solution:
6565
def sortArray(self, nums: List[int]) -> List[int]:
66-
def quick_sort(nums, left, right):
67-
if left >= right:
66+
def quick_sort(l, r):
67+
if l >= r:
6868
return
69-
i, j = left - 1, right + 1
70-
x = nums[(left + right) >> 1]
71-
while i < j:
72-
while 1:
73-
i += 1
74-
if nums[i] >= x:
75-
break
76-
while 1:
69+
x = nums[randint(l, r)]
70+
i, j, k = l - 1, r + 1, l
71+
while k < j:
72+
if nums[k] < x:
73+
nums[i + 1], nums[k] = nums[k], nums[i + 1]
74+
i, k = i + 1, k + 1
75+
elif nums[k] > x:
7776
j -= 1
78-
if nums[j] <= x:
79-
break
80-
if i < j:
81-
nums[i], nums[j] = nums[j], nums[i]
82-
quick_sort(nums, left, j)
83-
quick_sort(nums, j + 1, right)
84-
85-
quick_sort(nums, 0, len(nums) - 1)
77+
nums[j], nums[k] = nums[k], nums[j]
78+
else:
79+
k = k + 1
80+
quick_sort(l, i)
81+
quick_sort(j, r)
82+
83+
quick_sort(0, len(nums) - 1)
8684
return nums
8785
```
8886

@@ -127,28 +125,70 @@ class Solution:
127125

128126
```java
129127
class Solution {
128+
private int[] nums;
129+
130130
public int[] sortArray(int[] nums) {
131-
quickSort(nums, 0, nums.length - 1);
131+
this.nums = nums;
132+
quikcSort(0, nums.length - 1);
132133
return nums;
133134
}
134135

135-
private void quickSort(int[] nums, int left, int right) {
136-
if (left >= right) {
136+
private void quikcSort(int l, int r) {
137+
if (l >= r) {
137138
return;
138139
}
139-
int i = left - 1, j = right + 1;
140-
int x = nums[(left + right) >> 1];
140+
int x = nums[(l + r) >> 1];
141+
int i = l - 1, j = r + 1;
141142
while (i < j) {
142-
while (nums[++i] < x);
143-
while (nums[--j] > x);
143+
while (nums[++i] < x) {
144+
}
145+
while (nums[--j] > x) {
146+
}
144147
if (i < j) {
145148
int t = nums[i];
146149
nums[i] = nums[j];
147150
nums[j] = t;
148151
}
149152
}
150-
quickSort(nums, left, j);
151-
quickSort(nums, j + 1, right);
153+
quikcSort(l, j);
154+
quikcSort(j + 1, r);
155+
}
156+
}
157+
```
158+
159+
```java
160+
class Solution {
161+
private int[] nums;
162+
163+
public int[] sortArray(int[] nums) {
164+
this.nums = nums;
165+
quickSort(0, nums.length - 1);
166+
return nums;
167+
}
168+
169+
private void quickSort(int l, int r) {
170+
if (l >= r) {
171+
return;
172+
}
173+
int i = l - 1, j = r + 1, k = l;
174+
int x = nums[(l + r) >> 1];
175+
while (k < j) {
176+
if (nums[k] < x) {
177+
swap(++i, k++);
178+
} else if (nums[k] > x) {
179+
swap(--j, k);
180+
} else {
181+
++k;
182+
}
183+
}
184+
quickSort(l, i);
185+
quickSort(j, r);
186+
}
187+
188+
private void swap(int i, int j) {
189+
int t = nums[i];
190+
nums[i] = nums[j];
191+
nums[j] = t;
152192
}
153193
}
154194
```
@@ -199,24 +239,27 @@ class Solution {
199239
class Solution {
200240
public:
201241
vector<int> sortArray(vector<int>& nums) {
202-
quick_sort(nums, 0, nums.size() - 1);
242+
function<void(int, int)> quick_sort = [&](int l, int r) {
243+
if (l >= r) {
244+
return;
245+
}
246+
int i = l - 1, j = r + 1;
247+
int x = nums[(l + r) >> 1];
248+
while (i < j) {
249+
while (nums[++i] < x) {
250+
}
251+
while (nums[--j] > x) {
252+
}
253+
if (i < j) {
254+
swap(nums[i], nums[j]);
255+
}
256+
}
257+
quick_sort(l, j);
258+
quick_sort(j + 1, r);
259+
};
260+
quick_sort(0, nums.size() - 1);
203261
return nums;
204262
}
205-
206-
void quick_sort(vector<int>& nums, int left, int right) {
207-
if (left >= right) return;
208-
int i = left - 1, j = right + 1;
209-
int x = nums[left + right >> 1];
210-
while (i < j) {
211-
while (nums[++i] < x)
212-
;
213-
while (nums[--j] > x)
214-
;
215-
if (i < j) swap(nums[i], nums[j]);
216-
}
217-
quick_sort(nums, left, j);
218-
quick_sort(nums, j + 1, right);
219-
}
220263
};
221264
```
222265

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

+86-43
Original file line numberDiff line numberDiff line change
@@ -44,26 +44,24 @@ Quick Sort:
4444
```python
4545
class Solution:
4646
def sortArray(self, nums: List[int]) -> List[int]:
47-
def quick_sort(nums, left, right):
48-
if left >= right:
47+
def quick_sort(l, r):
48+
if l >= r:
4949
return
50-
i, j = left - 1, right + 1
51-
x = nums[(left + right) >> 1]
52-
while i < j:
53-
while 1:
54-
i += 1
55-
if nums[i] >= x:
56-
break
57-
while 1:
50+
x = nums[randint(l, r)]
51+
i, j, k = l - 1, r + 1, l
52+
while k < j:
53+
if nums[k] < x:
54+
nums[i + 1], nums[k] = nums[k], nums[i + 1]
55+
i, k = i + 1, k + 1
56+
elif nums[k] > x:
5857
j -= 1
59-
if nums[j] <= x:
60-
break
61-
if i < j:
62-
nums[i], nums[j] = nums[j], nums[i]
63-
quick_sort(nums, left, j)
64-
quick_sort(nums, j + 1, right)
65-
66-
quick_sort(nums, 0, len(nums) - 1)
58+
nums[j], nums[k] = nums[k], nums[j]
59+
else:
60+
k = k + 1
61+
quick_sort(l, i)
62+
quick_sort(j, r)
63+
64+
quick_sort(0, len(nums) - 1)
6765
return nums
6866
```
6967

@@ -106,28 +104,70 @@ Quick Sort:
106104

107105
```java
108106
class Solution {
107+
private int[] nums;
108+
109109
public int[] sortArray(int[] nums) {
110-
quickSort(nums, 0, nums.length - 1);
110+
this.nums = nums;
111+
quikcSort(0, nums.length - 1);
111112
return nums;
112113
}
113114

114-
private void quickSort(int[] nums, int left, int right) {
115-
if (left >= right) {
115+
private void quikcSort(int l, int r) {
116+
if (l >= r) {
116117
return;
117118
}
118-
int i = left - 1, j = right + 1;
119-
int x = nums[(left + right) >> 1];
119+
int x = nums[(l + r) >> 1];
120+
int i = l - 1, j = r + 1;
120121
while (i < j) {
121-
while (nums[++i] < x);
122-
while (nums[--j] > x);
122+
while (nums[++i] < x) {
123+
}
124+
while (nums[--j] > x) {
125+
}
123126
if (i < j) {
124127
int t = nums[i];
125128
nums[i] = nums[j];
126129
nums[j] = t;
127130
}
128131
}
129-
quickSort(nums, left, j);
130-
quickSort(nums, j + 1, right);
132+
quikcSort(l, j);
133+
quikcSort(j + 1, r);
134+
}
135+
}
136+
```
137+
138+
```java
139+
class Solution {
140+
private int[] nums;
141+
142+
public int[] sortArray(int[] nums) {
143+
this.nums = nums;
144+
quickSort(0, nums.length - 1);
145+
return nums;
146+
}
147+
148+
private void quickSort(int l, int r) {
149+
if (l >= r) {
150+
return;
151+
}
152+
int i = l - 1, j = r + 1, k = l;
153+
int x = nums[(l + r) >> 1];
154+
while (k < j) {
155+
if (nums[k] < x) {
156+
swap(++i, k++);
157+
} else if (nums[k] > x) {
158+
swap(--j, k);
159+
} else {
160+
++k;
161+
}
162+
}
163+
quickSort(l, i);
164+
quickSort(j, r);
165+
}
166+
167+
private void swap(int i, int j) {
168+
int t = nums[i];
169+
nums[i] = nums[j];
170+
nums[j] = t;
131171
}
132172
}
133173
```
@@ -178,24 +218,27 @@ Quick Sort:
178218
class Solution {
179219
public:
180220
vector<int> sortArray(vector<int>& nums) {
181-
quick_sort(nums, 0, nums.size() - 1);
221+
function<void(int, int)> quick_sort = [&](int l, int r) {
222+
if (l >= r) {
223+
return;
224+
}
225+
int i = l - 1, j = r + 1;
226+
int x = nums[(l + r) >> 1];
227+
while (i < j) {
228+
while (nums[++i] < x) {
229+
}
230+
while (nums[--j] > x) {
231+
}
232+
if (i < j) {
233+
swap(nums[i], nums[j]);
234+
}
235+
}
236+
quick_sort(l, j);
237+
quick_sort(j + 1, r);
238+
};
239+
quick_sort(0, nums.size() - 1);
182240
return nums;
183241
}
184-
185-
void quick_sort(vector<int>& nums, int left, int right) {
186-
if (left >= right) return;
187-
int i = left - 1, j = right + 1;
188-
int x = nums[left + right >> 1];
189-
while (i < j) {
190-
while (nums[++i] < x)
191-
;
192-
while (nums[--j] > x)
193-
;
194-
if (i < j) swap(nums[i], nums[j]);
195-
}
196-
quick_sort(nums, left, j);
197-
quick_sort(nums, j + 1, right);
198-
}
199242
};
200243
```
201244

‎solution/0900-0999/0912.Sort an Array/Solution.cpp

+19-16
Original file line numberDiff line numberDiff line change
@@ -1,22 +1,25 @@
11
class Solution {
22
public:
33
vector<int> sortArray(vector<int>& nums) {
4-
quick_sort(nums, 0, nums.size() - 1);
4+
function<void(int, int)> quick_sort = [&](int l, int r) {
5+
if (l >= r) {
6+
return;
7+
}
8+
int i = l - 1, j = r + 1;
9+
int x = nums[(l + r) >> 1];
10+
while (i < j) {
11+
while (nums[++i] < x) {
12+
}
13+
while (nums[--j] > x) {
14+
}
15+
if (i < j) {
16+
swap(nums[i], nums[j]);
17+
}
18+
}
19+
quick_sort(l, j);
20+
quick_sort(j + 1, r);
21+
};
22+
quick_sort(0, nums.size() - 1);
523
return nums;
624
}
7-
8-
void quick_sort(vector<int>& nums, int left, int right) {
9-
if (left >= right) return;
10-
int i = left - 1, j = right + 1;
11-
int x = nums[left + right >> 1];
12-
while (i < j) {
13-
while (nums[++i] < x)
14-
;
15-
while (nums[--j] > x)
16-
;
17-
if (i < j) swap(nums[i], nums[j]);
18-
}
19-
quick_sort(nums, left, j);
20-
quick_sort(nums, j + 1, right);
21-
}
2225
};

0 commit comments

Comments
 (0)