Organizing all the code blocks.

This commit is contained in:
Yudong Jin
2022-12-03 01:31:29 +08:00
parent fec56afd5f
commit 9bd5980a81
21 changed files with 2520 additions and 310 deletions

View File

@@ -74,26 +74,6 @@ comments: true
}
```
=== "JavaScript"
```js title="bubble_sort.js"
/* 冒泡排序 */
function bubbleSort(nums) {
// 外循环:待排序元素数量为 n-1, n-2, ..., 1
for (let i = nums.length - 1; i > 0; i--) {
// 内循环:冒泡操作
for (let j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]
let tmp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = tmp;
}
}
}
}
```
=== "C++"
```cpp title="bubble_sort.cpp"
@@ -129,6 +109,50 @@ comments: true
nums[j], nums[j + 1] = nums[j + 1], nums[j]
```
=== "Go"
```go title="bubble_sort.go"
```
=== "JavaScript"
```js title="bubble_sort.js"
/* 冒泡排序 */
function bubbleSort(nums) {
// 外循环:待排序元素数量为 n-1, n-2, ..., 1
for (let i = nums.length - 1; i > 0; i--) {
// 内循环:冒泡操作
for (let j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]
let tmp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = tmp;
}
}
}
}
```
=== "TypeScript"
```typescript title="bubble_sort.ts"
```
=== "C"
```c title="bubble_sort.c"
```
=== "C#"
```csharp title="bubble_sort.cs"
```
## 算法特性
**时间复杂度 $O(n^2)$ ** 各轮「冒泡」遍历的数组长度为 $n - 1$ , $n - 2$ , $\cdots$ , $2$ , $1$ 次,求和为 $\frac{(n - 1) n}{2}$ ,因此使用 $O(n^2)$ 时间。
@@ -170,29 +194,6 @@ comments: true
}
```
=== "JavaScript"
```js title="bubble_sort.js"
/* 冒泡排序(标志优化)*/
function bubbleSortWithFlag(nums) {
// 外循环:待排序元素数量为 n-1, n-2, ..., 1
for (let i = nums.length - 1; i > 0; i--) {
let flag = false; // 初始化标志位
// 内循环:冒泡操作
for (let j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]
let tmp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = tmp;
flag = true; // 记录交换元素
}
}
if (!flag) break; // 此轮冒泡未交换任何元素,直接跳出
}
}
```
=== "C++"
```cpp title="bubble_sort.cpp"
@@ -234,3 +235,50 @@ comments: true
if not flag:
break # 此轮冒泡未交换任何元素,直接跳出
```
=== "Go"
```go title="bubble_sort.go"
```
=== "JavaScript"
```js title="bubble_sort.js"
/* 冒泡排序(标志优化)*/
function bubbleSortWithFlag(nums) {
// 外循环:待排序元素数量为 n-1, n-2, ..., 1
for (let i = nums.length - 1; i > 0; i--) {
let flag = false; // 初始化标志位
// 内循环:冒泡操作
for (let j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]
let tmp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = tmp;
flag = true; // 记录交换元素
}
}
if (!flag) break; // 此轮冒泡未交换任何元素,直接跳出
}
}
```
=== "TypeScript"
```typescript title="bubble_sort.ts"
```
=== "C"
```c title="bubble_sort.c"
```
=== "C#"
```csharp title="bubble_sort.cs"
```

View File

@@ -42,24 +42,6 @@ comments: true
}
```
=== "JavaScript"
```js title="insertion_sort.js"
/* 插入排序 */
function insertionSort(nums) {
// 外循环base = nums[1], nums[2], ..., nums[n-1]
for (let i = 1; i < nums.length; i++) {
let base = nums[i], j = i - 1;
// 内循环:将 base 插入到左边的正确位置
while (j >= 0 && nums[j] > base) {
nums[j + 1] = nums[j]; // 1. 将 nums[j] 向右移动一位
j--;
}
nums[j + 1] = base; // 2. 将 base 赋值到正确位置
}
}
```
=== "C++"
```cpp title="insertion_sort.cpp"
@@ -94,6 +76,48 @@ comments: true
nums[j + 1] = base # 2. 将 base 赋值到正确位置
```
=== "Go"
```go title="insertion_sort.go"
```
=== "JavaScript"
```js title="insertion_sort.js"
/* 插入排序 */
function insertionSort(nums) {
// 外循环base = nums[1], nums[2], ..., nums[n-1]
for (let i = 1; i < nums.length; i++) {
let base = nums[i], j = i - 1;
// 内循环:将 base 插入到左边的正确位置
while (j >= 0 && nums[j] > base) {
nums[j + 1] = nums[j]; // 1. 将 nums[j] 向右移动一位
j--;
}
nums[j + 1] = base; // 2. 将 base 赋值到正确位置
}
}
```
=== "TypeScript"
```typescript title="insertion_sort.ts"
```
=== "C"
```c title="insertion_sort.c"
```
=== "C#"
```csharp title="insertion_sort.cs"
```
## 算法特性
**时间复杂度 $O(n^2)$ ** 最差情况下,各轮插入操作循环 $n - 1$ , $n-2$ , $\cdots$ , $2$ , $1$ 次,求和为 $\frac{(n - 1) n}{2}$ ,使用 $O(n^2)$ 时间。

View File

@@ -103,51 +103,6 @@ comments: true
}
```
=== "JavaScript"
```js title="merge_sort.js"
/**
* 合并左子数组和右子数组
* 左子数组区间 [left, mid]
* 右子数组区间 [mid + 1, right]
*/
function merge(nums, left, mid, right) {
// 初始化辅助数组
let tmp = nums.slice(left, right + 1);
// 左子数组的起始索引和结束索引
let leftStart = left - left, leftEnd = mid - left;
// 右子数组的起始索引和结束索引
let rightStart = mid + 1 - left, rightEnd = right - left;
// i, j 分别指向左子数组、右子数组的首元素
let i = leftStart, j = rightStart;
// 通过覆盖原数组 nums 来合并左子数组和右子数组
for (let k = left; k <= right; k++) {
// 若 “左子数组已全部合并完”,则选取右子数组元素,并且 j++
if (i > leftEnd) {
nums[k] = tmp[j++];
// 否则,若 “右子数组已全部合并完” 或 “左子数组元素 < 右子数组元素”,则选取左子数组元素,并且 i++
} else if (j > rightEnd || tmp[i] <= tmp[j]) {
nums[k] = tmp[i++];
// 否则,若 “左子数组元素 > 右子数组元素”,则选取右子数组元素,并且 j++
} else {
nums[k] = tmp[j++];
}
}
}
/* 归并排序 */
function mergeSort(nums, left, right) {
// 终止条件
if (left >= right) return; // 当子数组长度为 1 时终止递归
// 划分阶段
let mid = Math.floor((left + right) / 2); // 计算中点
mergeSort(nums, left, mid); // 递归左子数组
mergeSort(nums, mid + 1, right); // 递归右子数组
// 合并阶段
merge(nums, left, mid, right);
}
```
=== "C++"
```cpp title="merge_sort.cpp"
@@ -237,6 +192,75 @@ comments: true
merge(nums, left, mid, right)
```
=== "Go"
```go title="merge_sort.go"
```
=== "JavaScript"
```js title="merge_sort.js"
/**
* 合并左子数组和右子数组
* 左子数组区间 [left, mid]
* 右子数组区间 [mid + 1, right]
*/
function merge(nums, left, mid, right) {
// 初始化辅助数组
let tmp = nums.slice(left, right + 1);
// 左子数组的起始索引和结束索引
let leftStart = left - left, leftEnd = mid - left;
// 右子数组的起始索引和结束索引
let rightStart = mid + 1 - left, rightEnd = right - left;
// i, j 分别指向左子数组、右子数组的首元素
let i = leftStart, j = rightStart;
// 通过覆盖原数组 nums 来合并左子数组和右子数组
for (let k = left; k <= right; k++) {
// 若 “左子数组已全部合并完”,则选取右子数组元素,并且 j++
if (i > leftEnd) {
nums[k] = tmp[j++];
// 否则,若 “右子数组已全部合并完” 或 “左子数组元素 < 右子数组元素”,则选取左子数组元素,并且 i++
} else if (j > rightEnd || tmp[i] <= tmp[j]) {
nums[k] = tmp[i++];
// 否则,若 “左子数组元素 > 右子数组元素”,则选取右子数组元素,并且 j++
} else {
nums[k] = tmp[j++];
}
}
}
/* 归并排序 */
function mergeSort(nums, left, right) {
// 终止条件
if (left >= right) return; // 当子数组长度为 1 时终止递归
// 划分阶段
let mid = Math.floor((left + right) / 2); // 计算中点
mergeSort(nums, left, mid); // 递归左子数组
mergeSort(nums, mid + 1, right); // 递归右子数组
// 合并阶段
merge(nums, left, mid, right);
}
```
=== "TypeScript"
```typescript title="merge_sort.ts"
```
=== "C"
```c title="merge_sort.c"
```
=== "C#"
```csharp title="merge_sort.cs"
```
下面重点解释一下合并方法 `merge()` 的流程:
1. 初始化一个辅助数组 `tmp` 暂存待合并区间 `[left, right]` 内的元素,后续通过覆盖原数组 `nums` 的元素来实现合并;

View File

@@ -61,35 +61,6 @@ comments: true
}
```
=== "JavaScript"
``` js title="quick_sort.js"
/* 元素交换 */
function swap(nums, i, j) {
let tmp = nums[i]
nums[i] = nums[j]
nums[j] = tmp
}
/* 哨兵划分 */
function partition(nums, left, right){
// 以 nums[left] 作为基准数
let i = left, j = right
while(i < j){
while(i < j && nums[j] >= nums[left]){
j -= 1 // 从右向左找首个小于基准数的元素
}
while(i < j && nums[i] <= nums[left]){
i += 1 // 从左向右找首个大于基准数的元素
}
// 元素交换
swap(nums, i, j) // 交换这两个元素
}
swap(nums, i, left) // 将基准数交换至两子数组的分界线
return i // 返回基准数的索引
}
```
=== "C++"
```cpp title="quick_sort.cpp"
@@ -135,6 +106,59 @@ comments: true
return i # 返回基准数的索引
```
=== "Go"
```go title="quick_sort.go"
```
=== "JavaScript"
``` js title="quick_sort.js"
/* 元素交换 */
function swap(nums, i, j) {
let tmp = nums[i]
nums[i] = nums[j]
nums[j] = tmp
}
/* 哨兵划分 */
function partition(nums, left, right){
// 以 nums[left] 作为基准数
let i = left, j = right
while(i < j){
while(i < j && nums[j] >= nums[left]){
j -= 1 // 从右向左找首个小于基准数的元素
}
while(i < j && nums[i] <= nums[left]){
i += 1 // 从左向右找首个大于基准数的元素
}
// 元素交换
swap(nums, i, j) // 交换这两个元素
}
swap(nums, i, left) // 将基准数交换至两子数组的分界线
return i // 返回基准数的索引
}
```
=== "TypeScript"
```typescript title="quick_sort.ts"
```
=== "C"
```c title="quick_sort.c"
```
=== "C#"
```csharp title="quick_sort.cs"
```
!!! note "快速排序的分治思想"
哨兵划分的实质是将 **一个长数组的排序问题** 简化为 **两个短数组的排序问题**。
@@ -167,21 +191,6 @@ comments: true
}
```
=== "JavaScript"
```js title="quick_sort.js"
/* 快速排序 */
function quickSort(nums, left, right){
// 子数组长度为 1 时终止递归
if(left >= right) return
// 哨兵划分
const pivot = partition(nums, left, right)
// 递归左子数组、右子数组
quick_sort(nums, left, pivot - 1)
quick_sort(nums, pivot + 1, right)
}
```
=== "C++"
```cpp title="quick_sort.cpp"
@@ -213,6 +222,45 @@ comments: true
self.quick_sort(nums, pivot + 1, right)
```
=== "Go"
```go title="quick_sort.go"
```
=== "JavaScript"
```js title="quick_sort.js"
/* 快速排序 */
function quickSort(nums, left, right){
// 子数组长度为 1 时终止递归
if(left >= right) return
// 哨兵划分
const pivot = partition(nums, left, right)
// 递归左子数组、右子数组
quick_sort(nums, left, pivot - 1)
quick_sort(nums, pivot + 1, right)
}
```
=== "TypeScript"
```typescript title="quick_sort.ts"
```
=== "C"
```c title="quick_sort.c"
```
=== "C#"
```csharp title="quick_sort.cs"
```
## 算法特性
**平均时间复杂度 $O(n \log n)$ ** 平均情况下,哨兵划分的递归层数为 $\log n$ ,每层中的总循环数为 $n$ ,总体使用 $O(n \log n)$ 时间。
@@ -269,32 +317,6 @@ comments: true
}
```
=== "JavaScript"
```js title="quick_sort.js"
/* 选取三个元素的中位数 */
function medianThree(nums, left, mid, right) {
// 使用了异或操作来简化代码
// 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1
if ((nums[left] > nums[mid]) ^ (nums[left] > nums[right]))
return left;
else if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right]))
return mid;
else
return right;
}
/* 哨兵划分(三数取中值) */
function partition(nums, left, right) {
// 选取三个候选元素的中位数
let med = medianThree(nums, left, Math.floor((left + right) / 2), right);
// 将中位数交换至数组最左端
swap(nums, left, med);
// 以 nums[left] 作为基准数
// 下同省略...
}
```
=== "C++"
```cpp title="quick_sort.cpp"
@@ -344,6 +366,56 @@ comments: true
# 下同省略...
```
=== "Go"
```go title="quick_sort.go"
```
=== "JavaScript"
```js title="quick_sort.js"
/* 选取三个元素的中位数 */
function medianThree(nums, left, mid, right) {
// 使用了异或操作来简化代码
// 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1
if ((nums[left] > nums[mid]) ^ (nums[left] > nums[right]))
return left;
else if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right]))
return mid;
else
return right;
}
/* 哨兵划分(三数取中值) */
function partition(nums, left, right) {
// 选取三个候选元素的中位数
let med = medianThree(nums, left, Math.floor((left + right) / 2), right);
// 将中位数交换至数组最左端
swap(nums, left, med);
// 以 nums[left] 作为基准数
// 下同省略...
}
```
=== "TypeScript"
```typescript title="quick_sort.ts"
```
=== "C"
```c title="quick_sort.c"
```
=== "C#"
```csharp title="quick_sort.cs"
```
## 尾递归优化
**普通快速排序在某些输入下的空间效率变差。** 仍然以完全倒序的输入数组为例,由于每轮哨兵划分后右子数组长度为 0 ,那么将形成一个高度为 $n - 1$ 的递归树,此时使用的栈帧空间大小劣化至 $O(n)$ 。
@@ -371,27 +443,6 @@ comments: true
}
```
=== "JavaScript"
```js title="quick_sort.js"
/* 快速排序(尾递归优化) */
quickSort(nums, left, right) {
// 子数组长度为 1 时终止
while (left < right) {
// 哨兵划分操作
let pivot = partition(nums, left, right);
// 对两个子数组中较短的那个执行快排
if (pivot - left < right - pivot) {
quickSort(nums, left, pivot - 1); // 递归排序左子数组
left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right]
} else {
quickSort(nums, pivot + 1, right); // 递归排序右子数组
right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1]
}
}
}
```
=== "C++"
```cpp title="quick_sort.cpp"
@@ -430,3 +481,48 @@ comments: true
self.quick_sort(nums, pivot + 1, right) # 递归排序右子数组
right = pivot - 1 # 剩余待排序区间为 [left, pivot - 1]
```
=== "Go"
```go title="quick_sort.go"
```
=== "JavaScript"
```js title="quick_sort.js"
/* 快速排序(尾递归优化) */
quickSort(nums, left, right) {
// 子数组长度为 1 时终止
while (left < right) {
// 哨兵划分操作
let pivot = partition(nums, left, right);
// 对两个子数组中较短的那个执行快排
if (pivot - left < right - pivot) {
quickSort(nums, left, pivot - 1); // 递归排序左子数组
left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right]
} else {
quickSort(nums, pivot + 1, right); // 递归排序右子数组
right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1]
}
}
}
```
=== "TypeScript"
```typescript title="quick_sort.ts"
```
=== "C"
```c title="quick_sort.c"
```
=== "C#"
```csharp title="quick_sort.cs"
```