yetao
/
hello-algo
mirror of https://github.com/krahets/hello-algo.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

build

Browse Source
docs
krahets 7 months ago
parent 3dcdda193f
commit 9332a91e26
3 changed files with 38 additions and 54 deletions
Show Stats Download Patch File Download Diff File

72
docs/chapter_sorting/quick_sort.md
Unescape View File

@ -302,19 +302,16 @@ comments: true
nums[j] = tmp; nums[j] = tmp;
} }
/* 快速排序类 */ /* 哨兵划分 */
// 快速排序类-哨兵划分
int partition(int nums[], int left, int right) { int partition(int nums[], int left, int right) {
// 以 nums[left] 为基准数 // 以 nums[left] 为基准数
int i = left, j = right; int i = left, j = right;
while (i < j) { while (i < j) {
while (i < j && nums[j] >= nums[left]) { while (i < j && nums[j] >= nums[left]) {
// 从右向左找首个小于基准数的元素 j--; // 从右向左找首个小于基准数的元素
j--;
} }
while (i < j && nums[i] <= nums[left]) { while (i < j && nums[i] <= nums[left]) {
// 从左向右找首个大于基准数的元素 i++; // 从左向右找首个大于基准数的元素
i++;
} }
// 交换这两个元素 // 交换这两个元素
swap(nums, i, j); swap(nums, i, j);
@ -563,30 +560,7 @@ comments: true
=== "C" === "C"
```c title="quick_sort.c" ```c title="quick_sort.c"
/* 快速排序类 */ /* 快速排序 */
// 快速排序类-哨兵划分
int partition(int nums[], int left, int right) {
// 以 nums[left] 为基准数
int i = left, j = right;
while (i < j) {
while (i < j && nums[j] >= nums[left]) {
// 从右向左找首个小于基准数的元素
j--;
}
while (i < j && nums[i] <= nums[left]) {
// 从左向右找首个大于基准数的元素
i++;
}
// 交换这两个元素
swap(nums, i, j);
}
// 将基准数交换至两子数组的分界线
swap(nums, i, left);
// 返回基准数的索引
return i;
}
// 快速排序类-快速排序
void quickSort(int nums[], int left, int right) { void quickSort(int nums[], int left, int right) {
// 子数组长度为 1 时终止递归 // 子数组长度为 1 时终止递归
if (left >= right) { if (left >= right) {
@ -1022,8 +996,7 @@ comments: true
=== "C" === "C"
```c title="quick_sort.c" ```c title="quick_sort.c"
/* 快速排序类（中位基准数优化） */ /* 选取三个候选元素的中位数 */
// 选取三个候选元素的中位数
int medianThree(int nums[], int left, int mid, int right) { int medianThree(int nums[], int left, int mid, int right) {
int l = nums[left], m = nums[mid], r = nums[right]; int l = nums[left], m = nums[mid], r = nums[right];
if ((l <= m && m <= r) || (r <= m && m <= l)) if ((l <= m && m <= r) || (r <= m && m <= l))
@ -1033,7 +1006,7 @@ comments: true
return right; return right;
} }
/* 哨兵划分（三数取中值） */ /* 哨兵划分（三数取中值） */
int partitionMedian(int nums[], int left, int right) { int partitionMedian(int nums[], int left, int right) {
// 选取三个候选元素的中位数 // 选取三个候选元素的中位数
int med = medianThree(nums, left, (left + right) / 2, right); int med = medianThree(nums, left, (left + right) / 2, right);
@ -1068,20 +1041,24 @@ comments: true
return right return right
} }
/* 哨兵划分 */ /* 哨兵划分（三数取中值） */
fun partition(nums: IntArray, left: Int, right: Int): Int { fun partitionMedian(nums: IntArray, left: Int, right: Int): Int {
// 选取三个候选元素的中位数
val med = medianThree(nums, left, (left + right) / 2, right)
// 将中位数交换至数组最左端
swap(nums, left, med)
// 以 nums[left] 为基准数 // 以 nums[left] 为基准数
var i = left var i = left
var j = right var j = right
while (i < j) { while (i < j) {
while (i < j && nums[j] >= nums[left]) while (i < j && nums[j] >= nums[left])
j-- // 从右向左找首个小于基准数的元素 j-- // 从右向左找首个小于基准数的元素
while (i < j && nums[i] <= nums[left]) while (i < j && nums[i] <= nums[left])
i++ // 从左向右找首个大于基准数的元素 i++ // 从左向右找首个大于基准数的元素
swap(nums, i, j) // 交换这两个元素 swap(nums, i, j) // 交换这两个元素
} }
swap(nums, i, left) // 将基准数交换至两子数组的分界线 swap(nums, i, left) // 将基准数交换至两子数组的分界线
return i // 返回基准数的索引 return i // 返回基准数的索引
} }
``` ```
@ -1350,8 +1327,7 @@ comments: true
=== "C" === "C"
```c title="quick_sort.c" ```c title="quick_sort.c"
/* 快速排序类（尾递归优化） */ /* 快速排序（尾递归优化） */
// 快速排序（尾递归优化）
void quickSortTailCall(int nums[], int left, int right) { void quickSortTailCall(int nums[], int left, int right) {
// 子数组长度为 1 时终止 // 子数组长度为 1 时终止
while (left < right) { while (left < right) {
@ -1359,11 +1335,15 @@ comments: true
int pivot = partition(nums, left, right); int pivot = partition(nums, left, right);
// 对两个子数组中较短的那个执行快速排序 // 对两个子数组中较短的那个执行快速排序
if (pivot - left < right - pivot) { if (pivot - left < right - pivot) {
quickSortTailCall(nums, left, pivot - 1); // 递归排序左子数组 // 递归排序左子数组
left = pivot + 1; // 剩余未排序区间为 [pivot + 1, right] quickSortTailCall(nums, left, pivot - 1);
// 剩余未排序区间为 [pivot + 1, right]
left = pivot + 1;
} else { } else {
quickSortTailCall(nums, pivot + 1, right); // 递归排序右子数组 // 递归排序右子数组
right = pivot - 1; // 剩余未排序区间为 [left, pivot - 1] quickSortTailCall(nums, pivot + 1, right);
// 剩余未排序区间为 [left, pivot - 1]
right = pivot - 1;
} }
} }
} }

2
overrides/main.html
Unescape View File

@ -6,7 +6,7 @@
{% elif config.theme.language == 'zh-Hant' %} {% elif config.theme.language == 'zh-Hant' %}
{% set announcements = '紙質書（簡體中文版）已發行，詳情請見<a href="/chapter_paperbook/">這裡</a>' %} {% set announcements = '紙質書（簡體中文版）已發行，詳情請見<a href="/chapter_paperbook/">這裡</a>' %}
{% elif config.theme.language == 'en' %} {% elif config.theme.language == 'en' %}
{% set announcements = 'Feel free to engage in Chinese-to-English translation and pull request review! Please visit <a href="https://github.com/krahets/hello-algo/issues/914">#914</a> for details.' %} {% set announcements = 'Welcome to contribute to Chinese-to-English translation! Please visit <a href="https://github.com/krahets/hello-algo/issues/914">#914</a> for more details.' %}
{% endif %} {% endif %}
<div class="banner-svg"> <div class="banner-svg">
<svg xmlns="http://www.w3.org/2000/svg" <svg xmlns="http://www.w3.org/2000/svg"

18
zh-Hant/docs/chapter_sorting/quick_sort.md
Unescape View File

@ -1068,20 +1068,24 @@ comments: true
return right return right
} }
/* 哨兵劃分 */ /* 哨兵劃分（三數取中值） */
fun partition(nums: IntArray, left: Int, right: Int): Int { fun partitionMedian(nums: IntArray, left: Int, right: Int): Int {
// 選取三個候選元素的中位數
val med = medianThree(nums, left, (left + right) / 2, right)
// 將中位數交換至陣列最左端
swap(nums, left, med)
// 以 nums[left] 為基準數 // 以 nums[left] 為基準數
var i = left var i = left
var j = right var j = right
while (i < j) { while (i < j) {
while (i < j && nums[j] >= nums[left]) while (i < j && nums[j] >= nums[left])
j-- // 從右向左找首個小於基準數的元素 j-- // 從右向左找首個小於基準數的元素
while (i < j && nums[i] <= nums[left]) while (i < j && nums[i] <= nums[left])
i++ // 從左向右找首個大於基準數的元素 i++ // 從左向右找首個大於基準數的元素
swap(nums, i, j) // 交換這兩個元素 swap(nums, i, j) // 交換這兩個元素
} }
swap(nums, i, left) // 將基準數交換至兩子陣列的分界線 swap(nums, i, left) // 將基準數交換至兩子陣列的分界線
return i // 返回基準數的索引 return i // 返回基準數的索引
} }
``` ```

Write Preview
Loading…
Cancel
Save