algorithm/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2025-11-02 12:58:42 +08:00
Code Issues Packages Projects Releases Wiki Activity

Update bubble sort and insertion sort.

Browse Source
This commit is contained in:
krahets
2023-05-23 21:20:14 +08:00
parent abecea9ab6
commit eb8df49993
17 changed files with 60 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
codes/c/chapter_sorting/quick_sort.c
View File

@ -103,10 +103,10 @@ void quickSortTailCall(int nums[], int left, int right) {
// 对两个子数组中较短的那个执行快排
if (pivot - left < right - pivot) {
quickSortTailCall(nums, left, pivot - 1); // 递归排序左子数组
left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right]
left = pivot + 1; // 剩余未排序区间为 [pivot + 1, right]
} else {
quickSortTailCall(nums, pivot + 1, right); // 递归排序右子数组
right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1]
right = pivot - 1; // 剩余未排序区间为 [left, pivot - 1]
}
}
}

4
codes/cpp/chapter_sorting/quick_sort.cpp
View File

@ -135,10 +135,10 @@ class QuickSortTailCall {
// 对两个子数组中较短的那个执行快排
if (pivot - left < right - pivot) {
quickSort(nums, left, pivot - 1); // 递归排序左子数组
left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right]
left = pivot + 1; // 剩余未排序区间为 [pivot + 1, right]
} else {
quickSort(nums, pivot + 1, right); // 递归排序右子数组
right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1]
right = pivot - 1; // 剩余未排序区间为 [left, pivot - 1]
}
}
}

4
codes/csharp/chapter_sorting/quick_sort.cs
View File

@ -128,10 +128,10 @@ class QuickSortTailCall {
// 对两个子数组中较短的那个执行快排
if (pivot - left < right - pivot) {
quickSort(nums, left, pivot - 1); // 递归排序左子数组
left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right]
left = pivot + 1; // 剩余未排序区间为 [pivot + 1, right]
} else {
quickSort(nums, pivot + 1, right); // 递归排序右子数组
right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1]
right = pivot - 1; // 剩余未排序区间为 [left, pivot - 1]
}
}
}

4
codes/dart/chapter_sorting/quick_sort.dart
View File

@ -119,10 +119,10 @@ class QuickSortTailCall {
// 对两个子数组中较短的那个执行快排
if (pivot - left < right - pivot) {
quickSort(nums, left, pivot - 1); // 递归排序左子数组
left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right]
left = pivot + 1; // 剩余未排序区间为 [pivot + 1, right]
} else {
quickSort(nums, pivot + 1, right); // 递归排序右子数组
right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1]
right = pivot - 1; // 剩余未排序区间为 [left, pivot - 1]
}
}
}

4
codes/go/chapter_sorting/quick_sort.go
View File

@ -121,10 +121,10 @@ func (q *quickSortTailCall) quickSort(nums []int, left, right int) {
// 对两个子数组中较短的那个执行快排
if pivot-left < right-pivot {
q.quickSort(nums, left, pivot-1) // 递归排序左子数组
left = pivot + 1 // 剩余待排序区间为 [pivot + 1, right]
left = pivot + 1 // 剩余未排序区间为 [pivot + 1, right]
} else {
q.quickSort(nums, pivot+1, right) // 递归排序右子数组
right = pivot - 1 // 剩余待排序区间为 [left, pivot - 1]
right = pivot - 1 // 剩余未排序区间为 [left, pivot - 1]
}
}
}

4
codes/java/chapter_sorting/quick_sort.java
View File

@ -131,10 +131,10 @@ class QuickSortTailCall {
// 对两个子数组中较短的那个执行快排
if (pivot - left < right - pivot) {
quickSort(nums, left, pivot - 1); // 递归排序左子数组
left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right]
left = pivot + 1; // 剩余未排序区间为 [pivot + 1, right]
} else {
quickSort(nums, pivot + 1, right); // 递归排序右子数组
right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1]
right = pivot - 1; // 剩余未排序区间为 [left, pivot - 1]
}
}
}

4
codes/javascript/chapter_sorting/quick_sort.js
View File

@ -130,10 +130,10 @@ class QuickSortTailCall {
// 对两个子数组中较短的那个执行快排
if (pivot - left < right - pivot) {
this.quickSort(nums, left, pivot - 1); // 递归排序左子数组
left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right]
left = pivot + 1; // 剩余未排序区间为 [pivot + 1, right]
} else {
this.quickSort(nums, pivot + 1, right); // 递归排序右子数组
right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1]
right = pivot - 1; // 剩余未排序区间为 [left, pivot - 1]
}
}
}

4
codes/python/chapter_sorting/quick_sort.py
View File

@ -106,10 +106,10 @@ class QuickSortTailCall:
# 对两个子数组中较短的那个执行快排
if pivot - left < right - pivot:
self.quick_sort(nums, left, pivot - 1) # 递归排序左子数组
left = pivot + 1 # 剩余待排序区间为 [pivot + 1, right]
left = pivot + 1 # 剩余未排序区间为 [pivot + 1, right]
else:
self.quick_sort(nums, pivot + 1, right) # 递归排序右子数组
right = pivot - 1 # 剩余待排序区间为 [left, pivot - 1]
right = pivot - 1 # 剩余未排序区间为 [left, pivot - 1]
"""Driver Code"""

4
codes/rust/chapter_sorting/quick_sort.rs
View File

@ -119,10 +119,10 @@ impl QuickSortTailCall {
// 对两个子数组中较短的那个执行快排
if pivot - left < right - pivot {
Self::quick_sort(left, pivot - 1, nums); // 递归排序左子数组
left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right]
left = pivot + 1; // 剩余未排序区间为 [pivot + 1, right]
} else {
Self::quick_sort(pivot + 1, right, nums); // 递归排序右子数组
right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1]
right = pivot - 1; // 剩余未排序区间为 [left, pivot - 1]
}
}
}

4
codes/swift/chapter_sorting/quick_sort.swift
View File

@ -90,10 +90,10 @@ func quickSortTailCall(nums: inout [Int], left: Int, right: Int) {
// 对两个子数组中较短的那个执行快排
if (pivot - left) < (right - pivot) {
quickSortTailCall(nums: &nums, left: left, right: pivot - 1) // 递归排序左子数组
left = pivot + 1 // 剩余待排序区间为 [pivot + 1, right]
left = pivot + 1 // 剩余未排序区间为 [pivot + 1, right]
} else {
quickSortTailCall(nums: &nums, left: pivot + 1, right: right) // 递归排序右子数组
right = pivot - 1 // 剩余待排序区间为 [left, pivot - 1]
right = pivot - 1 // 剩余未排序区间为 [left, pivot - 1]
}
}
}

4
codes/typescript/chapter_sorting/quick_sort.ts
View File

@ -152,10 +152,10 @@ class QuickSortTailCall {
// 对两个子数组中较短的那个执行快排
if (pivot - left < right - pivot) {
this.quickSort(nums, left, pivot - 1); // 递归排序左子数组
left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right]
left = pivot + 1; // 剩余未排序区间为 [pivot + 1, right]
} else {
this.quickSort(nums, pivot + 1, right); // 递归排序右子数组
right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1]
right = pivot - 1; // 剩余未排序区间为 [left, pivot - 1]
}
}
}

4
codes/zig/chapter_sorting/quick_sort.zig
View File

@ -130,10 +130,10 @@ const QuickSortTailCall = struct {
// 对两个子数组中较短的那个执行快排
if (pivot - left < right - pivot) {
quickSort(nums, left, pivot - 1); // 递归排序左子数组
left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right]
left = pivot + 1; // 剩余未排序区间为 [pivot + 1, right]
} else {
quickSort(nums, pivot + 1, right); // 递归排序右子数组
right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1]
right = pivot - 1; // 剩余未排序区间为 [left, pivot - 1]
}
}
}