Skip to content

Commit 920ab60

Browse files
wilonhustcc
wilon
authored and
hustcc
committedApr 16, 2018
添加PHP代码实现及测试文件 (#18)
1 parent 6954cf8 commit 920ab60

11 files changed

+609
-0
lines changed
 

‎1.bubbleSort.md

+19
Original file line numberDiff line numberDiff line change
@@ -110,3 +110,22 @@ public class BubbleSort implements IArraySort {
110110
}
111111
}
112112
```
113+
114+
## 9. PHP 代码实现
115+
116+
```php
117+
function bubbleSort($arr)
118+
{
119+
$len = count($arr);
120+
for ($i = 0; $i < $len - 1; $i++) {
121+
for ($j = 0; $j < $len - 1 - $i; $j++) {
122+
if ($arr[$j] > $arr[$j+1]) {
123+
$tmp = $arr[$j];
124+
$arr[$j] = $arr[$j+1];
125+
$arr[$j+1] = $tmp;
126+
}
127+
}
128+
}
129+
return $arr;
130+
}
131+
```

‎10.radixSort.md

+37
Original file line numberDiff line numberDiff line change
@@ -133,3 +133,40 @@ public class RadixSort implements IArraySort {
133133
}
134134
}
135135
```
136+
137+
## 5. PHP 代码实现
138+
139+
```php
140+
function radixSort($arr, $maxDigit = null)
141+
{
142+
if ($maxDigit === null) {
143+
$maxDigit = max($arr);
144+
}
145+
$counter = [];
146+
for ($i = 0; $i < $maxDigit; $i++) {
147+
for ($j = 0; $j < count($arr); $j++) {
148+
preg_match_all('/\d/', (string) $arr[$j], $matches);
149+
$numArr = $matches[0];
150+
$lenTmp = count($numArr);
151+
$bucket = array_key_exists($lenTmp - $i - 1, $numArr)
152+
? intval($numArr[$lenTmp - $i - 1])
153+
: 0;
154+
if (!array_key_exists($bucket, $counter)) {
155+
$counter[$bucket] = [];
156+
}
157+
$counter[$bucket][] = $arr[$j];
158+
}
159+
$pos = 0;
160+
for ($j = 0; $j < count($counter); $j++) {
161+
$value = null;
162+
if ($counter[$j] !== null) {
163+
while (($value = array_shift($counter[$j])) !== null) {
164+
$arr[$pos++] = $value;
165+
}
166+
}
167+
}
168+
}
169+
170+
return $arr;
171+
}
172+
```

‎2.selectionSort.md

+21
Original file line numberDiff line numberDiff line change
@@ -105,3 +105,24 @@ public class SelectionSort implements IArraySort {
105105
}
106106
}
107107
```
108+
109+
## 7. PHP 代码实现
110+
111+
```php
112+
function selectionSort($arr)
113+
{
114+
$len = count($arr);
115+
for ($i = 0; $i < $len - 1; $i++) {
116+
$minIndex = $i;
117+
for ($j = $i + 1; $j < $len; $j++) {
118+
if ($arr[$j] < $arr[$minIndex]) {
119+
$minIndex = $j;
120+
}
121+
}
122+
$temp = $arr[$i];
123+
$arr[$i] = $arr[$minIndex];
124+
$arr[$minIndex] = $temp;
125+
}
126+
return $arr;
127+
}
128+
```

‎3.insertionSort.md

+19
Original file line numberDiff line numberDiff line change
@@ -99,3 +99,22 @@ public class InsertSort implements IArraySort {
9999
}
100100
}
101101
```
102+
103+
## 7. PHP 代码实现
104+
105+
```php
106+
function insertionSort($arr)
107+
{
108+
$len = count($arr);
109+
for ($i = 1; $i < $len; $i++) {
110+
$preIndex = $i - 1;
111+
$current = $arr[$i];
112+
while($preIndex >= 0 && $arr[$preIndex] > $current) {
113+
$arr[$preIndex+1] = $arr[$preIndex];
114+
$preIndex--;
115+
}
116+
$arr[$preIndex+1] = $current;
117+
}
118+
return $arr;
119+
}
120+
```

‎4.shellSort.md

+24
Original file line numberDiff line numberDiff line change
@@ -120,3 +120,27 @@ public class ShellSort implements IArraySort {
120120
}
121121
}
122122
```
123+
124+
## 6. PHP 代码实现
125+
126+
```php
127+
function shellSort($arr)
128+
{
129+
$len = count($arr);
130+
$temp = 0;
131+
$gap = 1;
132+
while($gap < $len / 3) {
133+
$gap = $gap * 3 + 1;
134+
}
135+
for ($gap; $gap > 0; $gap = floor($gap / 3)) {
136+
for ($i = $gap; $i < $len; $i++) {
137+
$temp = $arr[$i];
138+
for ($j = $i - $gap; $j >= 0 && $arr[$j] > $temp; $j -= $gap) {
139+
$arr[$j+$gap] = $arr[$j];
140+
}
141+
$arr[$j+$gap] = $temp;
142+
}
143+
}
144+
return $arr;
145+
}
146+
```

‎5.mergeSort.md

+37
Original file line numberDiff line numberDiff line change
@@ -186,3 +186,40 @@ public class MergeSort implements IArraySort {
186186

187187
}
188188
```
189+
190+
## 8. PHP 代码实现
191+
192+
```php
193+
function mergeSort($arr)
194+
{
195+
$len = count($arr);
196+
if ($len < 2) {
197+
return $arr;
198+
}
199+
$middle = floor($len / 2);
200+
$left = array_slice($arr, 0, $middle);
201+
$right = array_slice($arr, $middle);
202+
return merge(mergeSort($left), mergeSort($right));
203+
}
204+
205+
function merge($left, $right)
206+
{
207+
$result = [];
208+
209+
while (count($left) > 0 && count($right) > 0) {
210+
if ($left[0] <= $right[0]) {
211+
$result[] = array_shift($left);
212+
} else {
213+
$result[] = array_shift($right);
214+
}
215+
}
216+
217+
while (count($left))
218+
$result[] = array_shift($left);
219+
220+
while (count($right))
221+
$result[] = array_shift($right);
222+
223+
return $result;
224+
}
225+
```

‎6.quickSort.md

+25
Original file line numberDiff line numberDiff line change
@@ -228,3 +228,28 @@ public class QuickSort implements IArraySort {
228228
229229
}
230230
```
231+
232+
## 8. PHP 代码实现
233+
234+
```php
235+
function quickSort($arr)
236+
{
237+
if (count($arr) <= 1)
238+
return $arr;
239+
$middle = $arr[0];
240+
$leftArray = array();
241+
$rightArray = array();
242+
243+
for ($i = 1; $i < count($arr); $i++) {
244+
if ($arr[$i] > $middle)
245+
$rightArray[] = $arr[$i];
246+
else
247+
$leftArray[] = $arr[$i];
248+
}
249+
$leftArray = quickSort($leftArray);
250+
$leftArray[] = $middle;
251+
252+
$rightArray = quickSort($rightArray);
253+
return array_merge($leftArray, $rightArray);
254+
}
255+
```

‎7.heapSort.md

+52
Original file line numberDiff line numberDiff line change
@@ -203,3 +203,55 @@ public class HeapSort implements IArraySort {
203203

204204
}
205205
```
206+
207+
## 7. PHP 代码实现
208+
209+
```php
210+
function buildMaxHeap(&$arr)
211+
{
212+
global $len;
213+
for ($i = floor($len/2); $i >= 0; $i--) {
214+
heapify($arr, $i);
215+
}
216+
}
217+
218+
function heapify(&$arr, $i)
219+
{
220+
global $len;
221+
$left = 2 * $i + 1;
222+
$right = 2 * $i + 2;
223+
$largest = $i;
224+
225+
if ($left < $len && $arr[$left] > $arr[$largest]) {
226+
$largest = $left;
227+
}
228+
229+
if ($right < $len && $arr[$right] > $arr[$largest]) {
230+
$largest = $right;
231+
}
232+
233+
if ($largest != $i) {
234+
swap($arr, $i, $largest);
235+
heapify($arr, $largest);
236+
}
237+
}
238+
239+
function swap(&$arr, $i, $j)
240+
{
241+
$temp = $arr[$i];
242+
$arr[$i] = $arr[$j];
243+
$arr[$j] = $temp;
244+
}
245+
246+
function heapSort($arr) {
247+
global $len;
248+
$len = count($arr);
249+
buildMaxHeap($arr);
250+
for ($i = count($arr) - 1; $i > 0; $i--) {
251+
swap($arr, 0, $i);
252+
$len--;
253+
heapify($arr, 0);
254+
}
255+
return $arr;
256+
}
257+
```

‎8.countingSort.md

+29
Original file line numberDiff line numberDiff line change
@@ -126,3 +126,32 @@ public class CountingSort implements IArraySort {
126126

127127
}
128128
```
129+
130+
## 6. PHP 代码实现
131+
132+
```php
133+
function countingSort($arr, $maxValue = null)
134+
{
135+
if ($maxValue === null) {
136+
$maxValue = max($arr);
137+
}
138+
for ($m = 0; $m < $maxValue + 1; $m++) {
139+
$bucket[] = null;
140+
}
141+
142+
$arrLen = count($arr);
143+
for ($i = 0; $i < $arrLen; $i++) {
144+
if (!array_key_exists($arr[$i], $bucket)) {
145+
$bucket[$arr[$i]] = 0;
146+
}
147+
$bucket[$arr[$i]]++;
148+
}
149+
150+
$sortedIndex = 0;
151+
foreach ($bucket as $key => $len) {
152+
if ($len !== null) $arr[$sortedIndex++] = $key;
153+
}
154+
155+
return $arr;
156+
}
157+
```

‎9.bucketSort.md

+42
Original file line numberDiff line numberDiff line change
@@ -131,3 +131,45 @@ public class BucketSort implements IArraySort {
131131

132132
}
133133
```
134+
135+
## 5. PHP 代码实现
136+
137+
```php
138+
function bucketSort($arr, $bucketSize = 5)
139+
{
140+
if (count($arr) === 0) {
141+
return $arr;
142+
}
143+
144+
$minValue = $arr[0];
145+
$maxValue = $arr[0];
146+
for ($i = 1; $i < count($arr); $i++) {
147+
if ($arr[$i] < $minValue) {
148+
$minValue = $arr[$i];
149+
} else if ($arr[$i] > $maxValue) {
150+
$maxValue = $arr[$i];
151+
}
152+
}
153+
154+
$bucketCount = floor(($maxValue - $minValue) / $bucketSize) + 1;
155+
$buckets = array();
156+
for ($i = 0; $i < count($buckets); $i++) {
157+
$buckets[$i] = [];
158+
}
159+
160+
for ($i = 0; $i < count($arr); $i++) {
161+
$buckets[floor(($arr[$i] - $minValue) / $bucketSize)][] = $arr[$i];
162+
}
163+
164+
$arr = array();
165+
for ($i = 0; $i < count($buckets); $i++) {
166+
$bucketTmp = $buckets[$i];
167+
sort($bucketTmp);
168+
for ($j = 0; $j < count($bucketTmp); $j++) {
169+
$arr[] = $bucketTmp[$j];
170+
}
171+
}
172+
173+
return $arr;
174+
}
175+
```

‎src/phpSortTest.php

+304
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,304 @@
1+
<?php
2+
3+
/**
4+
* Create by wilon <github.com/wilon>
5+
*
6+
* 主要参考了 JS 的写法及网上的一些写法。
7+
*
8+
* Require: php -v >= 5.4
9+
* Test: php phpSortTest.php
10+
*/
11+
12+
function sortTest($func, $total = 5000)
13+
{
14+
global $arr;
15+
if (empty($arr)) {
16+
$arr = range(1, $total);
17+
echo "Verify sort md5: ", substr(md5(json_encode($arr)), 0, 8), "\r\n";
18+
shuffle($arr);
19+
}
20+
list($m1, $n1) = explode(' ', microtime());
21+
$res = $func($arr);
22+
list($m2, $n2) = explode(' ', microtime());
23+
$time = round(($m2 - $m1) + ($n2 - $n1), 6);
24+
echo " $func {$time}s " . substr(md5(json_encode($res)), 0, 8) . "\r\n";
25+
}
26+
27+
function bubbleSort($arr)
28+
{
29+
$len = count($arr);
30+
for ($i = 0; $i < $len; $i++) {
31+
for ($j = 0; $j < $len - 1 - $i; $j++) {
32+
if ($arr[$j] > $arr[$j+1]) {
33+
$tmp = $arr[$j];
34+
$arr[$j] = $arr[$j+1];
35+
$arr[$j+1] = $tmp;
36+
}
37+
}
38+
}
39+
return $arr;
40+
}
41+
42+
function selectionSort($arr)
43+
{
44+
$len = count($arr);
45+
for ($i = 0; $i < $len - 1; $i++) {
46+
$minIndex = $i;
47+
for ($j = $i + 1; $j < $len; $j++) {
48+
if ($arr[$j] < $arr[$minIndex]) {
49+
$minIndex = $j;
50+
}
51+
}
52+
$temp = $arr[$i];
53+
$arr[$i] = $arr[$minIndex];
54+
$arr[$minIndex] = $temp;
55+
}
56+
return $arr;
57+
}
58+
59+
function insertionSort($arr)
60+
{
61+
$len = count($arr);
62+
for ($i = 1; $i < $len; $i++) {
63+
$preIndex = $i - 1;
64+
$current = $arr[$i];
65+
while($preIndex >= 0 && $arr[$preIndex] > $current) {
66+
$arr[$preIndex+1] = $arr[$preIndex];
67+
$preIndex--;
68+
}
69+
$arr[$preIndex+1] = $current;
70+
}
71+
return $arr;
72+
}
73+
74+
function shellSort($arr)
75+
{
76+
$len = count($arr);
77+
$temp = 0;
78+
$gap = 1;
79+
while($gap < $len / 3) {
80+
$gap = $gap * 3 + 1;
81+
}
82+
for ($gap; $gap > 0; $gap = floor($gap / 3)) {
83+
for ($i = $gap; $i < $len; $i++) {
84+
$temp = $arr[$i];
85+
for ($j = $i - $gap; $j >= 0 && $arr[$j] > $temp; $j -= $gap) {
86+
$arr[$j+$gap] = $arr[$j];
87+
}
88+
$arr[$j+$gap] = $temp;
89+
}
90+
}
91+
return $arr;
92+
}
93+
94+
function mergeSort($arr)
95+
{
96+
$len = count($arr);
97+
if ($len < 2) {
98+
return $arr;
99+
}
100+
$middle = floor($len / 2);
101+
$left = array_slice($arr, 0, $middle);
102+
$right = array_slice($arr, $middle);
103+
return merge(mergeSort($left), mergeSort($right));
104+
}
105+
106+
function merge($left, $right)
107+
{
108+
$result = [];
109+
110+
while (count($left) > 0 && count($right) > 0) {
111+
if ($left[0] <= $right[0]) {
112+
$result[] = array_shift($left);
113+
} else {
114+
$result[] = array_shift($right);
115+
}
116+
}
117+
118+
while (count($left))
119+
$result[] = array_shift($left);
120+
121+
while (count($right))
122+
$result[] = array_shift($right);
123+
124+
return $result;
125+
}
126+
127+
function quickSort($arr)
128+
{
129+
if (count($arr) <= 1)
130+
return $arr;
131+
$middle = $arr[0];
132+
$leftArray = array();
133+
$rightArray = array();
134+
135+
for ($i = 1; $i < count($arr); $i++) {
136+
if ($arr[$i] > $middle)
137+
$rightArray[] = $arr[$i];
138+
else
139+
$leftArray[] = $arr[$i];
140+
}
141+
$leftArray = quickSort($leftArray);
142+
$leftArray[] = $middle;
143+
144+
$rightArray = quickSort($rightArray);
145+
return array_merge($leftArray, $rightArray);
146+
}
147+
148+
149+
function buildMaxHeap(&$arr)
150+
{
151+
global $len;
152+
for ($i = floor($len/2); $i >= 0; $i--) {
153+
heapify($arr, $i);
154+
}
155+
}
156+
157+
function heapify(&$arr, $i)
158+
{
159+
global $len;
160+
$left = 2 * $i + 1;
161+
$right = 2 * $i + 2;
162+
$largest = $i;
163+
164+
if ($left < $len && $arr[$left] > $arr[$largest]) {
165+
$largest = $left;
166+
}
167+
168+
if ($right < $len && $arr[$right] > $arr[$largest]) {
169+
$largest = $right;
170+
}
171+
172+
if ($largest != $i) {
173+
swap($arr, $i, $largest);
174+
heapify($arr, $largest);
175+
}
176+
}
177+
178+
function swap(&$arr, $i, $j)
179+
{
180+
$temp = $arr[$i];
181+
$arr[$i] = $arr[$j];
182+
$arr[$j] = $temp;
183+
}
184+
185+
function heapSort($arr) {
186+
global $len;
187+
$len = count($arr);
188+
buildMaxHeap($arr);
189+
for ($i = count($arr) - 1; $i > 0; $i--) {
190+
swap($arr, 0, $i);
191+
$len--;
192+
heapify($arr, 0);
193+
}
194+
return $arr;
195+
}
196+
197+
function countingSort($arr, $maxValue = null)
198+
{
199+
if ($maxValue === null) {
200+
$maxValue = max($arr);
201+
}
202+
for ($m = 0; $m < $maxValue + 1; $m++) {
203+
$bucket[] = null;
204+
}
205+
206+
$arrLen = count($arr);
207+
for ($i = 0; $i < $arrLen; $i++) {
208+
if (!array_key_exists($arr[$i], $bucket)) {
209+
$bucket[$arr[$i]] = 0;
210+
}
211+
$bucket[$arr[$i]]++;
212+
}
213+
214+
$sortedIndex = 0;
215+
foreach ($bucket as $key => $len) {
216+
if ($len !== null) $arr[$sortedIndex++] = $key;
217+
}
218+
219+
return $arr;
220+
}
221+
222+
function bucketSort($arr, $bucketSize = 5)
223+
{
224+
if (count($arr) === 0) {
225+
return $arr;
226+
}
227+
228+
$minValue = $arr[0];
229+
$maxValue = $arr[0];
230+
for ($i = 1; $i < count($arr); $i++) {
231+
if ($arr[$i] < $minValue) {
232+
$minValue = $arr[$i];
233+
} else if ($arr[$i] > $maxValue) {
234+
$maxValue = $arr[$i];
235+
}
236+
}
237+
238+
$bucketCount = floor(($maxValue - $minValue) / $bucketSize) + 1;
239+
$buckets = array();
240+
for ($i = 0; $i < count($buckets); $i++) {
241+
$buckets[$i] = [];
242+
}
243+
244+
for ($i = 0; $i < count($arr); $i++) {
245+
$buckets[floor(($arr[$i] - $minValue) / $bucketSize)][] = $arr[$i];
246+
}
247+
248+
$arr = array();
249+
for ($i = 0; $i < count($buckets); $i++) {
250+
$bucketTmp = $buckets[$i];
251+
sort($bucketTmp);
252+
for ($j = 0; $j < count($bucketTmp); $j++) {
253+
$arr[] = $bucketTmp[$j];
254+
}
255+
}
256+
257+
return $arr;
258+
}
259+
260+
function radixSort($arr, $maxDigit = null)
261+
{
262+
if ($maxDigit === null) {
263+
$maxDigit = max($arr);
264+
}
265+
$counter = [];
266+
for ($i = 0; $i < $maxDigit; $i++) {
267+
for ($j = 0; $j < count($arr); $j++) {
268+
preg_match_all('/\d/', (string) $arr[$j], $matches);
269+
$numArr = $matches[0];
270+
$lenTmp = count($numArr);
271+
$bucket = array_key_exists($lenTmp - $i - 1, $numArr)
272+
? intval($numArr[$lenTmp - $i - 1])
273+
: 0;
274+
if (!array_key_exists($bucket, $counter)) {
275+
$counter[$bucket] = [];
276+
}
277+
$counter[$bucket][] = $arr[$j];
278+
}
279+
$pos = 0;
280+
for ($j = 0; $j < count($counter); $j++) {
281+
$value = null;
282+
if ($counter[$j] !== null) {
283+
while (($value = array_shift($counter[$j])) !== null) {
284+
$arr[$pos++] = $value;
285+
}
286+
}
287+
}
288+
}
289+
290+
return $arr;
291+
}
292+
293+
$total = 2000;
294+
295+
sortTest('bubbleSort', $total);
296+
sortTest('selectionSort', $total);
297+
sortTest('insertionSort', $total);
298+
sortTest('shellSort', $total);
299+
sortTest('mergeSort', $total);
300+
sortTest('quickSort', $total);
301+
sortTest('heapSort', $total);
302+
sortTest('countingSort', $total);
303+
sortTest('bucketSort', $total);
304+
sortTest('radixSort', $total);

0 commit comments

Comments
 (0)
Please sign in to comment.