fuhouyin/hello-algo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update the comments of bubble sort

Browse Source 
and insertion sort
This commit is contained in:
krahets 2023-05-22 23:05:37 +08:00
parent 5b406666d8
commit f6d290d903
36 changed files with 119 additions and 119 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
codes/c/chapter_computational_complexity/time_complexity.c
View File

@ -51,9 +51,9 @@ int quadratic(int n) {
/* 平方阶（冒泡排序） */
int bubbleSort(int *nums, int n) {
int count = 0; // 计数器
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
for (int i = n - 1; i > 0; i--) {
// 内循环：冒泡操作
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for (int j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]

8
codes/c/chapter_sorting/bubble_sort.c
View File

@ -8,9 +8,9 @@
/* 冒泡排序 */
void bubbleSort(int nums[], int size) {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
for (int i = 0; i < size - 1; i++) {
// 内循环：冒泡操作
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for (int j = 0; j < size - 1 - i; j++) {
if (nums[j] > nums[j + 1]) {
int temp = nums[j];
@ -23,10 +23,10 @@ void bubbleSort(int nums[], int size) {
/* 冒泡排序（标志优化）*/
void bubbleSortWithFlag(int nums[], int size) {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
for (int i = 0; i < size - 1; i++) {
bool flag = false;
// 内循环：冒泡操作
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for (int j = 0; j < size - 1 - i; j++) {
if (nums[j] > nums[j + 1]) {
int temp = nums[j];

8
codes/c/chapter_sorting/insertion_sort.c
View File

@ -8,16 +8,16 @@
/* 插入排序 */
void insertionSort(int nums[], int size) {
// 外循环：base = nums[1], nums[2], ..., nums[n-1]
// 外循环：已排序元素数量为 1, 2, ..., n
for (int i = 1; i < size; i++) {
int base = nums[i], j = i - 1;
// 内循环：将 base 插入到左边的正确位置
// 内循环：将 base 插入到已排序部分的正确位置
while (j >= 0 && nums[j] > base) {
// 1. 将 nums[j] 向右移动一位
// 将 nums[j] 向右移动一位
nums[j + 1] = nums[j];
j--;
}
// 2. 将 base 赋值到正确位置
// 将 base 赋值到正确位置
nums[j + 1] = base;
}
}

4
codes/cpp/chapter_computational_complexity/time_complexity.cpp
View File

@ -48,9 +48,9 @@ int quadratic(int n) {
/* 平方阶（冒泡排序） */
int bubbleSort(vector<int> &nums) {
int count = 0; // 计数器
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
for (int i = nums.size() - 1; i > 0; i--) {
// 内循环：冒泡操作
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for (int j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]

8
codes/cpp/chapter_sorting/bubble_sort.cpp
View File

@ -8,9 +8,9 @@
/* 冒泡排序 */
void bubbleSort(vector<int> &nums) {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
for (int i = nums.size() - 1; i > 0; i--) {
// 内循环：冒泡操作
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for (int j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]
@ -23,10 +23,10 @@ void bubbleSort(vector<int> &nums) {
/* 冒泡排序（标志优化）*/
void bubbleSortWithFlag(vector<int> &nums) {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
for (int i = nums.size() - 1; i > 0; i--) {
bool flag = false; // 初始化标志位
// 内循环：冒泡操作
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for (int j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]

8
codes/cpp/chapter_sorting/insertion_sort.cpp
View File

@ -8,15 +8,15 @@
/* 插入排序 */
void insertionSort(vector<int> &nums) {
// 外循环：base = nums[1], nums[2], ..., nums[n-1]
// 外循环：已排序元素数量为 1, 2, ..., n
for (int i = 1; i < nums.size(); i++) {
int base = nums[i], j = i - 1;
// 内循环：将 base 插入到左边的正确位置
// 内循环：将 base 插入到已排序部分的正确位置
while (j >= 0 && nums[j] > base) {
nums[j + 1] = nums[j]; // 1. 将 nums[j] 向右移动一位
nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位
j--;
}
nums[j + 1] = base; // 2. 将 base 赋值到正确位置
nums[j + 1] = base; // 将 base 赋值到正确位置
}
}

4
codes/csharp/chapter_computational_complexity/time_complexity.cs
View File

@ -81,9 +81,9 @@ public class time_complexity {
/* 平方阶（冒泡排序） */
static int bubbleSort(int[] nums) {
int count = 0; // 计数器
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
for (int i = nums.Length - 1; i > 0; i--) {
// 内循环：冒泡操作
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for (int j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]

8
codes/csharp/chapter_sorting/bubble_sort.cs
View File

@ -9,9 +9,9 @@ namespace hello_algo.chapter_sorting;
public class bubble_sort {
/* 冒泡排序 */
static void bubbleSort(int[] nums) {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
for (int i = nums.Length - 1; i > 0; i--) {
// 内循环：冒泡操作
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for (int j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]
@ -25,10 +25,10 @@ public class bubble_sort {
/* 冒泡排序（标志优化）*/
static void bubbleSortWithFlag(int[] nums) {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
for (int i = nums.Length - 1; i > 0; i--) {
bool flag = false; // 初始化标志位
// 内循环：冒泡操作
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for (int j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]

8
codes/csharp/chapter_sorting/insertion_sort.cs
View File

@ -9,15 +9,15 @@ namespace hello_algo.chapter_sorting;
public class insertion_sort {
/* 插入排序 */
static void insertionSort(int[] nums) {
// 外循环：base = nums[1], nums[2], ..., nums[n-1]
// 外循环：已排序元素数量为 1, 2, ..., n
for (int i = 1; i < nums.Length; i++) {
int bas = nums[i], j = i - 1;
// 内循环：将 base 插入到左边的正确位置
// 内循环：将 base 插入到已排序部分的正确位置
while (j >= 0 && nums[j] > bas) {
nums[j + 1] = nums[j]; // 1. 将 nums[j] 向右移动一位
nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位
j--;
}
nums[j + 1] = bas; // 2. 将 base 赋值到正确位置
nums[j + 1] = bas; // 将 base 赋值到正确位置
}
}

4
codes/dart/chapter_computational_complexity/time_complexity.dart
View File

@ -48,9 +48,9 @@ int quadratic(int n) {
/* 平方阶（冒泡排序） */
int bubbleSort(List<int> nums) {
int count = 0; // 计数器
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
for (var i = nums.length - 1; i > 0; i--) {
// 内循环：冒泡操作
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for (var j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]

8
codes/dart/chapter_sorting/bubble_sort.dart
View File

@ -6,9 +6,9 @@
/* 冒泡排序 */
void bubbleSort(List<int> nums) {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
for (int i = nums.length - 1; i > 0; i--) {
// 内循环：冒泡操作
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for (int j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]
@ -22,10 +22,10 @@ void bubbleSort(List<int> nums) {
/* 冒泡排序（标志优化）*/
void bubbleSortWithFlag(List<int> nums) {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
for (int i = nums.length - 1; i > 0; i--) {
bool flag = false; // 初始化标志位
// 内循环：冒泡操作
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for (int j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]

8
codes/dart/chapter_sorting/insertion_sort.dart
View File

@ -6,15 +6,15 @@
/* 插入排序 */
void insertionSort(List<int> nums) {
// 外循环：base = nums[1], nums[2], ..., nums[n-1]
// 外循环：已排序元素数量为 1, 2, ..., n
for (int i = 1; i < nums.length; i++) {
int base = nums[i], j = i - 1;
// 内循环：将 base 插入到左边的正确位置
// 内循环：将 base 插入到已排序部分的正确位置
while (j >= 0 && nums[j] > base) {
nums[j + 1] = nums[j]; // 1. 将 nums[j] 向右移动一位
nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位
j--;
}
nums[j + 1] = base; // 2. 将 base 赋值到正确位置
nums[j + 1] = base; // 将 base 赋值到正确位置
}
}

4
codes/go/chapter_computational_complexity/time_complexity.go
View File

@ -48,9 +48,9 @@ func quadratic(n int) int {
/* 平方阶（冒泡排序） */
func bubbleSort(nums []int) int {
count := 0 // 计数器
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
for i := len(nums) - 1; i > 0; i-- {
// 内循环：冒泡操作
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for j := 0; j < i; j++ {
if nums[j] > nums[j+1] {
// 交换 nums[j] 与 nums[j + 1]

8
codes/go/chapter_sorting/bubble_sort.go
View File

@ -6,9 +6,9 @@ package chapter_sorting
/* 冒泡排序 */
func bubbleSort(nums []int) {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
for i := len(nums) - 1; i > 0; i-- {
// 内循环：冒泡操作
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for j := 0; j < i; j++ {
if nums[j] > nums[j+1] {
// 交换 nums[j] 与 nums[j + 1]
@ -20,10 +20,10 @@ func bubbleSort(nums []int) {
/* 冒泡排序（标志优化）*/
func bubbleSortWithFlag(nums []int) {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
for i := len(nums) - 1; i > 0; i-- {
flag := false // 初始化标志位
// 内循环：冒泡操作
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for j := 0; j < i; j++ {
if nums[j] > nums[j+1] {
// 交换 nums[j] 与 nums[j + 1]

8
codes/go/chapter_sorting/insertion_sort.go
View File

@ -6,15 +6,15 @@ package chapter_sorting
/* 插入排序 */
func insertionSort(nums []int) {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
for i := 1; i < len(nums); i++ {
base := nums[i]
j := i - 1
// 内循环：将 base 插入到左边的正确位置
// 内循环：将 base 插入到已排序部分的正确位置
for j >= 0 && nums[j] > base {
nums[j+1] = nums[j] // 1. 将 nums[j] 向右移动一位
nums[j+1] = nums[j] // 将 nums[j] 向右移动一位
j--
}
nums[j+1] = base // 2. 将 base 赋值到正确位置
nums[j+1] = base // 将 base 赋值到正确位置
}
}

4
codes/java/chapter_computational_complexity/time_complexity.java
View File

@ -49,9 +49,9 @@ public class time_complexity {
/* 平方阶（冒泡排序） */
static int bubbleSort(int[] nums) {
int count = 0; // 计数器
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
for (int i = nums.length - 1; i > 0; i--) {
// 内循环：冒泡操作
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for (int j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]

8
codes/java/chapter_sorting/bubble_sort.java
View File

@ -11,9 +11,9 @@ import java.util.*;
public class bubble_sort {
/* 冒泡排序 */
static void bubbleSort(int[] nums) {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
for (int i = nums.length - 1; i > 0; i--) {
// 内循环：冒泡操作
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for (int j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]
@ -27,10 +27,10 @@ public class bubble_sort {
/* 冒泡排序（标志优化） */
static void bubbleSortWithFlag(int[] nums) {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
for (int i = nums.length - 1; i > 0; i--) {
boolean flag = false; // 初始化标志位
// 内循环：冒泡操作
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for (int j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]

8
codes/java/chapter_sorting/insertion_sort.java
View File

@ -11,15 +11,15 @@ import java.util.*;
public class insertion_sort {
/* 插入排序 */
static void insertionSort(int[] nums) {
// 外循环：base = nums[1], nums[2], ..., nums[n-1]
// 外循环：已排序元素数量为 1, 2, ..., n
for (int i = 1; i < nums.length; i++) {
int base = nums[i], j = i - 1;
// 内循环：将 base 插入到左边的正确位置
// 内循环：将 base 插入到已排序部分的正确位置
while (j >= 0 && nums[j] > base) {
nums[j + 1] = nums[j]; // 1. 将 nums[j] 向右移动一位
nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位
j--;
}
nums[j + 1] = base; // 2. 将 base 赋值到正确位置
nums[j + 1] = base; // 将 base 赋值到正确位置
}
}

4
codes/javascript/chapter_computational_complexity/time_complexity.js
View File

@ -44,9 +44,9 @@ function quadratic(n) {
/* 平方阶（冒泡排序） */
function bubbleSort(nums) {
let count = 0; // 计数器
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
for (let i = nums.length - 1; i > 0; i--) {
// 内循环：冒泡操作
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for (let j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]

8
codes/javascript/chapter_sorting/bubble_sort.js
View File

@ -6,9 +6,9 @@
/* 冒泡排序 */
function bubbleSort(nums) {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
for (let i = nums.length - 1; i > 0; i--) {
// 内循环：冒泡操作
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for (let j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]
@ -22,10 +22,10 @@ function bubbleSort(nums) {
/* 冒泡排序（标志优化）*/
function bubbleSortWithFlag(nums) {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
for (let i = nums.length - 1; i > 0; i--) {
let flag = false; // 初始化标志位
// 内循环：冒泡操作
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for (let j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]

8
codes/javascript/chapter_sorting/insertion_sort.js
View File

@ -6,16 +6,16 @@
/* 插入排序 */
function insertionSort(nums) {
// 外循环：base = nums[1], nums[2], ..., nums[n-1]
// 外循环：已排序元素数量为 1, 2, ..., n
for (let i = 1; i < nums.length; i++) {
let base = nums[i],
j = i - 1;
// 内循环：将 base 插入到左边的正确位置
// 内循环：将 base 插入到已排序部分的正确位置
while (j >= 0 && nums[j] > base) {
nums[j + 1] = nums[j]; // 1. 将 nums[j] 向右移动一位
nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位
j--;
}
nums[j + 1] = base; // 2. 将 base 赋值到正确位置
nums[j + 1] = base; // 将 base 赋值到正确位置
}
}

4
codes/python/chapter_computational_complexity/time_complexity.py
View File

@ -44,9 +44,9 @@ def quadratic(n: int) -> int:
def bubble_sort(nums: list[int]) -> int:
"""平方阶（冒泡排序）"""
count = 0 # 计数器
# 外循环：待排序元素数量为 n-1, n-2, ..., 1
# 外循环：未排序区间为 [0, i]
for i in range(len(nums) - 1, 0, -1):
# 内循环：冒泡操作
# 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for j in range(i):
if nums[j] > nums[j + 1]:
# 交换 nums[j] 与 nums[j + 1]

8
codes/python/chapter_sorting/bubble_sort.py
View File

@ -8,9 +8,9 @@ Author: timi (xisunyy@163.com)
def bubble_sort(nums: list[int]) -> None:
"""冒泡排序"""
n = len(nums)
# 外循环：待排序元素数量为 n-1, n-2, ..., 1
# 外循环：未排序区间为 [0, i]
for i in range(n - 1, 0, -1):
# 内循环：冒泡操作
# 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for j in range(i):
if nums[j] > nums[j + 1]:
# 交换 nums[j] 与 nums[j + 1]
@ -20,10 +20,10 @@ def bubble_sort(nums: list[int]) -> None:
def bubble_sort_with_flag(nums: list[int]) -> None:
"""冒泡排序（标志优化）"""
n = len(nums)
# 外循环：待排序元素数量为 n-1, n-2, ..., 1
# 外循环：未排序区间为 [0, i]
for i in range(n - 1, 0, -1):
flag = False # 初始化标志位
# 内循环：冒泡操作
# 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for j in range(i):
if nums[j] > nums[j + 1]:
# 交换 nums[j] 与 nums[j + 1]

8
codes/python/chapter_sorting/insertion_sort.py
View File

@ -7,15 +7,15 @@ Author: timi (xisunyy@163.com)
def insertion_sort(nums: list[int]) -> None:
"""插入排序"""
# 外循环：base = nums[1], nums[2], ..., nums[n-1]
# 外循环：已排序区间为 [0, i-1]
for i in range(1, len(nums)):
base = nums[i]
j = i - 1
# 内循环：将 base 插入到左边的正确位置
# 内循环：将 base 插入到已排序区间 [0, i-1] 中的正确位置
while j >= 0 and nums[j] > base:
nums[j + 1] = nums[j] # 1. 将 nums[j] 向右移动一位
nums[j + 1] = nums[j] # 将 nums[j] 向右移动一位
j -= 1
nums[j + 1] = base # 2. 将 base 赋值到正确位置
nums[j + 1] = base # 将 base 赋值到正确位置
"""Driver Code"""

4
codes/rust/chapter_computational_complexity/time_complexity.rs
View File

@ -49,9 +49,9 @@ fn quadratic(n: i32) -> i32 {
/* 平方阶（冒泡排序） */
fn bubble_sort(nums: &mut [i32]) -> i32 {
let mut count = 0; // 计数器
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
for i in (1..nums.len()).rev() {
// 内循环：冒泡操作
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for j in 0..i {
if nums[j] > nums[j + 1] {
// 交换 nums[j] 与 nums[j + 1]

8
codes/rust/chapter_sorting/bubble_sort.rs
View File

@ -8,9 +8,9 @@ include!("../include/include.rs");
/* 冒泡排序 */
fn bubble_sort(nums: &mut [i32]) {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
for i in (1..nums.len()).rev() {
// 内循环：冒泡操作
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for j in 0..i {
if nums[j] > nums[j + 1] {
// 交换 nums[j] 与 nums[j + 1]
@ -24,10 +24,10 @@ fn bubble_sort(nums: &mut [i32]) {
/* 冒泡排序（标志优化） */
fn bubble_sort_with_flag(nums: &mut [i32]) {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
for i in (1..nums.len()).rev() {
let mut flag = false; // 初始化标志位
// 内循环：冒泡操作
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for j in 0..i {
if nums[j] > nums[j + 1] {
// 交换 nums[j] 与 nums[j + 1]

8
codes/rust/chapter_sorting/insertion_sort.rs
View File

@ -8,15 +8,15 @@ include!("../include/include.rs");
/*插入排序 */
fn insertion_sort(nums: &mut [i32]) {
// 外循环：base = nums[1], nums[2], ..., nums[n-1]
// 外循环：已排序元素数量为 1, 2, ..., n
for i in 1..nums.len() {
let (base, mut j) = (nums[i], (i - 1) as i32);
// 内循环：将 base 插入到左边的正确位置
// 内循环：将 base 插入到已排序部分的正确位置
while j >= 0 && nums[j as usize] > base {
nums[(j + 1) as usize] = nums[j as usize]; // 1. 将 nums[j] 向右移动一位
nums[(j + 1) as usize] = nums[j as usize]; // 将 nums[j] 向右移动一位
j -= 1;
}
nums[(j + 1) as usize] = base; // 2. 将 base 赋值到正确位置
nums[(j + 1) as usize] = base; // 将 base 赋值到正确位置
}
}

4
codes/swift/chapter_computational_complexity/time_complexity.swift
View File

@ -48,9 +48,9 @@ func quadratic(n: Int) -> Int {
/* 平方阶（冒泡排序） */
func bubbleSort(nums: inout [Int]) -> Int {
var count = 0 // 计数器
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
for i in stride(from: nums.count - 1, to: 0, by: -1) {
// 内循环：冒泡操作
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for j in 0 ..< i {
if nums[j] > nums[j + 1] {
// 交换 nums[j] 与 nums[j + 1]

6
codes/swift/chapter_sorting/bubble_sort.swift
View File

@ -6,9 +6,9 @@
/* 冒泡排序 */
func bubbleSort(nums: inout [Int]) {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
for i in stride(from: nums.count - 1, to: 0, by: -1) {
// 内循环：冒泡操作
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for j in stride(from: 0, to: i, by: 1) {
if nums[j] > nums[j + 1] {
// 交换 nums[j] 与 nums[j + 1]
@ -22,7 +22,7 @@ func bubbleSort(nums: inout [Int]) {
/* 冒泡排序（标志优化）*/
func bubbleSortWithFlag(nums: inout [Int]) {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
for i in stride(from: nums.count - 1, to: 0, by: -1) {
var flag = false // 初始化标志位
for j in stride(from: 0, to: i, by: 1) {

8
codes/swift/chapter_sorting/insertion_sort.swift
View File

@ -6,16 +6,16 @@
/* 插入排序 */
func insertionSort(nums: inout [Int]) {
// 外循环：base = nums[1], nums[2], ..., nums[n-1]
// 外循环：已排序元素数量为 1, 2, ..., n
for i in stride(from: 1, to: nums.count, by: 1) {
let base = nums[i]
var j = i - 1
// 内循环：将 base 插入到左边的正确位置
// 内循环：将 base 插入到已排序部分的正确位置
while j >= 0, nums[j] > base {
nums[j + 1] = nums[j] // 1. 将 nums[j] 向右移动一位
nums[j + 1] = nums[j] // 将 nums[j] 向右移动一位
j -= 1
}
nums[j + 1] = base // 2. 将 base 赋值到正确位置
nums[j + 1] = base // 将 base 赋值到正确位置
}
}

4
codes/typescript/chapter_computational_complexity/time_complexity.ts
View File

@ -44,9 +44,9 @@ function quadratic(n: number): number {
/* 平方阶（冒泡排序） */
function bubbleSort(nums: number[]): number {
let count = 0; // 计数器
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
for (let i = nums.length - 1; i > 0; i--) {
// 内循环：冒泡操作
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for (let j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]

8
codes/typescript/chapter_sorting/bubble_sort.ts
View File

@ -6,9 +6,9 @@
/* 冒泡排序 */
function bubbleSort(nums: number[]): void {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
for (let i = nums.length - 1; i > 0; i--) {
// 内循环：冒泡操作
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for (let j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]
@ -22,10 +22,10 @@ function bubbleSort(nums: number[]): void {
/* 冒泡排序（标志优化）*/
function bubbleSortWithFlag(nums: number[]): void {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
for (let i = nums.length - 1; i > 0; i--) {
let flag = false; // 初始化标志位
// 内循环：冒泡操作
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for (let j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]

8
codes/typescript/chapter_sorting/insertion_sort.ts
View File

@ -6,16 +6,16 @@
/* 插入排序 */
function insertionSort(nums: number[]): void {
// 外循环：base = nums[1], nums[2], ..., nums[n-1]
// 外循环：已排序元素数量为 1, 2, ..., n
for (let i = 1; i < nums.length; i++) {
const base = nums[i];
let j = i - 1;
// 内循环：将 base 插入到左边的正确位置
// 内循环：将 base 插入到已排序部分的正确位置
while (j >= 0 && nums[j] > base) {
nums[j + 1] = nums[j]; // 1. 将 nums[j] 向右移动一位
nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位
j--;
}
nums[j + 1] = base; // 2. 将 base 赋值到正确位置
nums[j + 1] = base; // 将 base 赋值到正确位置
}
}

4
codes/zig/chapter_computational_complexity/time_complexity.zig
View File

@ -53,11 +53,11 @@ fn quadratic(n: i32) i32 {
// 平方阶（冒泡排序）
fn bubbleSort(nums: []i32) i32 {
var count: i32 = 0; // 计数器
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
var i: i32 = @intCast(i32, nums.len ) - 1;
while (i > 0) : (i -= 1) {
var j: usize = 0;
// 内循环：冒泡操作
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
while (j < i) : (j += 1) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]

8
codes/zig/chapter_sorting/bubble_sort.zig
View File

@ -7,11 +7,11 @@ const inc = @import("include");
// 冒泡排序
fn bubbleSort(nums: []i32) void {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
var i: usize = nums.len - 1;
while (i > 0) : (i -= 1) {
var j: usize = 0;
// 内循环：冒泡操作
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
while (j < i) : (j += 1) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]
@ -25,12 +25,12 @@ fn bubbleSort(nums: []i32) void {
// 冒泡排序（标志优化）
fn bubbleSortWithFlag(nums: []i32) void {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
// 外循环：未排序区间为 [0, i]
var i: usize = nums.len - 1;
while (i > 0) : (i -= 1) {
var flag = false; // 初始化标志位
var j: usize = 0;
// 内循环：冒泡操作
// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
while (j < i) : (j += 1) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]

8
codes/zig/chapter_sorting/insertion_sort.zig
View File

@ -7,16 +7,16 @@ const inc = @import("include");
// 插入排序
fn insertionSort(nums: []i32) void {
// 外循环：base = nums[1], nums[2], ..., nums[n-1]
// 外循环：已排序元素数量为 1, 2, ..., n
var i: usize = 1;
while (i < nums.len) : (i += 1) {
var base = nums[i];
var j: usize = i;
// 内循环：将 base 插入到左边的正确位置
// 内循环：将 base 插入到已排序部分的正确位置
while (j >= 1 and nums[j - 1] > base) : (j -= 1) {
nums[j] = nums[j - 1]; // 1. 将 nums[j] 向右移动一位
nums[j] = nums[j - 1]; // 将 nums[j] 向右移动一位
}
nums[j] = base; // 2. 将 base 赋值到正确位置
nums[j] = base; // 将 base 赋值到正确位置
}
}