xmengnet/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2024-12-26 12:36:30 +08:00
Code Issues Projects Releases Packages Wiki Activity Actions

build

Browse source
This commit is contained in:
krahets 2024-03-15 02:28:46 +08:00
parent f9a1d0ab9e
commit bc0054a577
4 changed files with 108 additions and 118 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

44
docs/chapter_sorting/insertion_sort.md
View file

@ -50,10 +50,10 @@ comments: true
```cpp title="insertion_sort.cpp" ```cpp title="insertion_sort.cpp"
/* 插入排序 */ /* 插入排序 */
void insertionSort(vector<int> &nums) { void insertionSort(vector<int> &nums) {
// 外循环：已排序元素数量为 1, 2, ..., n // 外循环：已排序区间为 [0, i-1]
for (int i = 1; i < nums.size(); i++) { for (int i = 1; i < nums.size(); i++) {
int base = nums[i], j = i - 1; int base = nums[i], j = i - 1;
// 内循环：将 base 插入到已排序部分的正确位置 // 内循环：将 base 插入到已排序区间 [0, i-1] 中的正确位置
while (j >= 0 && nums[j] > base) { while (j >= 0 && nums[j] > base) {
nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位 nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位
j--; j--;
@ -68,10 +68,10 @@ comments: true
```java title="insertion_sort.java" ```java title="insertion_sort.java"
/* 插入排序 */ /* 插入排序 */
void insertionSort(int[] nums) { void insertionSort(int[] nums) {
// 外循环：已排序元素数量为 1, 2, ..., n // 外循环：已排序区间为 [0, i-1]
for (int i = 1; i < nums.length; i++) { for (int i = 1; i < nums.length; i++) {
int base = nums[i], j = i - 1; int base = nums[i], j = i - 1;
// 内循环：将 base 插入到已排序部分的正确位置 // 内循环：将 base 插入到已排序区间 [0, i-1] 中的正确位置
while (j >= 0 && nums[j] > base) { while (j >= 0 && nums[j] > base) {
nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位 nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位
j--; j--;
@ -86,10 +86,10 @@ comments: true
```csharp title="insertion_sort.cs" ```csharp title="insertion_sort.cs"
/* 插入排序 */ /* 插入排序 */
void InsertionSort(int[] nums) { void InsertionSort(int[] nums) {
// 外循环：已排序元素数量为 1, 2, ..., n // 外循环：已排序区间为 [0, i-1]
for (int i = 1; i < nums.Length; i++) { for (int i = 1; i < nums.Length; i++) {
int bas = nums[i], j = i - 1; int bas = nums[i], j = i - 1;
// 内循环：将 base 插入到已排序部分的正确位置 // 内循环：将 base 插入到已排序区间 [0, i-1] 中的正确位置
while (j >= 0 && nums[j] > bas) { while (j >= 0 && nums[j] > bas) {
nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位 nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位
j--; j--;
@ -104,11 +104,11 @@ comments: true
```go title="insertion_sort.go" ```go title="insertion_sort.go"
/* 插入排序 */ /* 插入排序 */
func insertionSort(nums []int) { func insertionSort(nums []int) {
// 外循环：未排序区间为 [0, i] // 外循环：已排序区间为 [0, i-1]
for i := 1; i < len(nums); i++ { for i := 1; i < len(nums); i++ {
base := nums[i] base := nums[i]
j := i - 1 j := i - 1
// 内循环：将 base 插入到已排序部分的正确位置 // 内循环：将 base 插入到已排序区间 [0, i-1] 中的正确位置
for j >= 0 && nums[j] > base { for j >= 0 && nums[j] > base {
nums[j+1] = nums[j] // 将 nums[j] 向右移动一位 nums[j+1] = nums[j] // 将 nums[j] 向右移动一位
j-- j--
@ -123,11 +123,11 @@ comments: true
```swift title="insertion_sort.swift" ```swift title="insertion_sort.swift"
/* 插入排序 */ /* 插入排序 */
func insertionSort(nums: inout [Int]) { func insertionSort(nums: inout [Int]) {
// 外循环：已排序元素数量为 1, 2, ..., n // 外循环：已排序区间为 [0, i-1]
for i in stride(from: 1, to: nums.count, by: 1) { for i in stride(from: 1, to: nums.count, by: 1) {
let base = nums[i] let base = nums[i]
var j = i - 1 var j = i - 1
// 内循环：将 base 插入到已排序部分的正确位置 // 内循环：将 base 插入到已排序区间 [0, i-1] 中的正确位置
while j >= 0, nums[j] > base { while j >= 0, nums[j] > base {
nums[j + 1] = nums[j] // 将 nums[j] 向右移动一位 nums[j + 1] = nums[j] // 将 nums[j] 向右移动一位
j -= 1 j -= 1
@ -142,11 +142,11 @@ comments: true
```javascript title="insertion_sort.js" ```javascript title="insertion_sort.js"
/* 插入排序 */ /* 插入排序 */
function insertionSort(nums) { function insertionSort(nums) {
// 外循环：已排序元素数量为 1, 2, ..., n // 外循环：已排序区间为 [0, i-1]
for (let i = 1; i < nums.length; i++) { for (let i = 1; i < nums.length; i++) {
let base = nums[i], let base = nums[i],
j = i - 1; j = i - 1;
// 内循环：将 base 插入到已排序部分的正确位置 // 内循环：将 base 插入到已排序区间 [0, i-1] 中的正确位置
while (j >= 0 && nums[j] > base) { while (j >= 0 && nums[j] > base) {
nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位 nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位
j--; j--;
@ -161,11 +161,11 @@ comments: true
```typescript title="insertion_sort.ts" ```typescript title="insertion_sort.ts"
/* 插入排序 */ /* 插入排序 */
function insertionSort(nums: number[]): void { function insertionSort(nums: number[]): void {
// 外循环：已排序元素数量为 1, 2, ..., n // 外循环：已排序区间为 [0, i-1]
for (let i = 1; i < nums.length; i++) { for (let i = 1; i < nums.length; i++) {
const base = nums[i]; const base = nums[i];
let j = i - 1; let j = i - 1;
// 内循环：将 base 插入到已排序部分的正确位置 // 内循环：将 base 插入到已排序区间 [0, i-1] 中的正确位置
while (j >= 0 && nums[j] > base) { while (j >= 0 && nums[j] > base) {
nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位 nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位
j--; j--;
@ -180,10 +180,10 @@ comments: true
```dart title="insertion_sort.dart" ```dart title="insertion_sort.dart"
/* 插入排序 */ /* 插入排序 */
void insertionSort(List<int> nums) { void insertionSort(List<int> nums) {
// 外循环：已排序元素数量为 1, 2, ..., n // 外循环：已排序区间为 [0, i-1]
for (int i = 1; i < nums.length; i++) { for (int i = 1; i < nums.length; i++) {
int base = nums[i], j = i - 1; int base = nums[i], j = i - 1;
// 内循环：将 base 插入到已排序部分的正确位置 // 内循环：将 base 插入到已排序区间 [0, i-1] 中的正确位置
while (j >= 0 && nums[j] > base) { while (j >= 0 && nums[j] > base) {
nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位 nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位
j--; j--;
@ -198,10 +198,10 @@ comments: true
```rust title="insertion_sort.rs" ```rust title="insertion_sort.rs"
/* 插入排序 */ /* 插入排序 */
fn insertion_sort(nums: &mut [i32]) { fn insertion_sort(nums: &mut [i32]) {
// 外循环：已排序元素数量为 1, 2, ..., n // 外循环：已排序区间为 [0, i-1]
for i in 1..nums.len() { for i in 1..nums.len() {
let (base, mut j) = (nums[i], (i - 1) as i32); let (base, mut j) = (nums[i], (i - 1) as i32);
// 内循环：将 base 插入到已排序部分的正确位置 // 内循环：将 base 插入到已排序区间 [0, i-1] 中的正确位置
while j >= 0 && nums[j as usize] > base { while j >= 0 && nums[j as usize] > base {
nums[(j + 1) as usize] = nums[j as usize]; // 将 nums[j] 向右移动一位 nums[(j + 1) as usize] = nums[j as usize]; // 将 nums[j] 向右移动一位
j -= 1; j -= 1;
@ -216,10 +216,10 @@ comments: true
```c title="insertion_sort.c" ```c title="insertion_sort.c"
/* 插入排序 */ /* 插入排序 */
void insertionSort(int nums[], int size) { void insertionSort(int nums[], int size) {
// 外循环：已排序元素数量为 1, 2, ..., n // 外循环：已排序区间为 [0, i-1]
for (int i = 1; i < size; i++) { for (int i = 1; i < size; i++) {
int base = nums[i], j = i - 1; int base = nums[i], j = i - 1;
// 内循环：将 base 插入到已排序部分的正确位置 // 内循环：将 base 插入到已排序区间 [0, i-1] 中的正确位置
while (j >= 0 && nums[j] > base) { while (j >= 0 && nums[j] > base) {
// 将 nums[j] 向右移动一位 // 将 nums[j] 向右移动一位
nums[j + 1] = nums[j]; nums[j + 1] = nums[j];
@ -236,12 +236,12 @@ comments: true
```zig title="insertion_sort.zig" ```zig title="insertion_sort.zig"
// 插入排序 // 插入排序
fn insertionSort(nums: []i32) void { fn insertionSort(nums: []i32) void {
// 外循环：已排序元素数量为 1, 2, ..., n // 外循环：已排序区间为 [0, i-1]
var i: usize = 1; var i: usize = 1;
while (i < nums.len) : (i += 1) { while (i < nums.len) : (i += 1) {
var base = nums[i]; var base = nums[i];
var j: usize = i; var j: usize = i;
// 内循环：将 base 插入到已排序部分的正确位置 // 内循环：将 base 插入到已排序区间 [0, i-1] 中的正确位置
while (j >= 1 and nums[j - 1] > base) : (j -= 1) { while (j >= 1 and nums[j - 1] > base) : (j -= 1) {
nums[j] = nums[j - 1]; // 将 nums[j] 向右移动一位 nums[j] = nums[j - 1]; // 将 nums[j] 向右移动一位
} }

174
docs/chapter_sorting/quick_sort.md
View file

@ -627,12 +627,11 @@ comments: true
```python title="quick_sort.py" ```python title="quick_sort.py"
def median_three(self, nums: list[int], left: int, mid: int, right: int) -> int: def median_three(self, nums: list[int], left: int, mid: int, right: int) -> int:
"""选取三个候选元素的中位数""" """选取三个候选元素的中位数"""
# 此处使用异或运算来简化代码 l, m, r = nums[left], nums[mid], nums[right]
# 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1 if (l <= m <= r) or (r <= m <= l):
if (nums[left] < nums[mid]) ^ (nums[left] < nums[right]): return mid # m 在 l 和 r 之间
return left if (m <= l <= r) or (r <= l <= m):
elif (nums[mid] < nums[left]) ^ (nums[mid] < nums[right]): return left # l 在 m 和 r 之间
return mid
return right return right
def partition(self, nums: list[int], left: int, right: int) -> int: def partition(self, nums: list[int], left: int, right: int) -> int:
@ -660,14 +659,12 @@ comments: true
```cpp title="quick_sort.cpp" ```cpp title="quick_sort.cpp"
/* 选取三个候选元素的中位数 */ /* 选取三个候选元素的中位数 */
int medianThree(vector<int> &nums, int left, int mid, int right) { int medianThree(vector<int> &nums, int left, int mid, int right) {
// 此处使用异或运算来简化代码 int l = nums[left], m = nums[mid], r = nums[right];
// 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1 if ((l <= m && m <= r) || (r <= m && m <= l))
if ((nums[left] < nums[mid]) ^ (nums[left] < nums[right])) return mid; // m 在 l 和 r 之间
return left; if ((m <= l && l <= r) || (r <= l && l <= m))
else if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right])) return left; // l 在 m 和 r 之间
return mid; return right;
else
return right;
} }
/* 哨兵划分（三数取中值） */ /* 哨兵划分（三数取中值） */
@ -695,14 +692,12 @@ comments: true
```java title="quick_sort.java" ```java title="quick_sort.java"
/* 选取三个候选元素的中位数 */ /* 选取三个候选元素的中位数 */
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];
// 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1 if ((l <= m && m <= r) || (r <= m && m <= l))
if ((nums[left] < nums[mid]) ^ (nums[left] < nums[right])) return mid; // m 在 l 和 r 之间
return left; if ((m <= l && l <= r) || (r <= l && l <= m))
else if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right])) return left; // l 在 m 和 r 之间
return mid; return right;
else
return right;
} }
/* 哨兵划分（三数取中值） */ /* 哨兵划分（三数取中值） */
@ -730,14 +725,12 @@ comments: true
```csharp title="quick_sort.cs" ```csharp title="quick_sort.cs"
/* 选取三个候选元素的中位数 */ /* 选取三个候选元素的中位数 */
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];
// 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1 if ((l <= m && m <= r) || (r <= m && m <= l))
if ((nums[left] < nums[mid]) ^ (nums[left] < nums[right])) return mid; // m 在 l 和 r 之间
return left; if ((m <= l && l <= r) || (r <= l && l <= m))
else if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right])) return left; // l 在 m 和 r 之间
return mid; return right;
else
return right;
} }
/* 哨兵划分（三数取中值） */ /* 哨兵划分（三数取中值） */
@ -765,12 +758,12 @@ comments: true
```go title="quick_sort.go" ```go title="quick_sort.go"
/* 选取三个候选元素的中位数 */ /* 选取三个候选元素的中位数 */
func (q *quickSortMedian) medianThree(nums []int, left, mid, right int) int { func (q *quickSortMedian) medianThree(nums []int, left, mid, right int) int {
// 此处使用异或运算来简化代码（!= 在这里起到异或的作用） l, m, r := nums[left], nums[mid], nums[right]
// 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1 if (l <= m && m <= r) || (r <= m && m <= l) {
if (nums[left] < nums[mid]) != (nums[left] < nums[right]) { return mid // m 在 l 和 r 之间
return left }
} else if (nums[mid] < nums[left]) != (nums[mid] < nums[right]) { if (m <= l && l <= r) || (r <= l && l <= m) {
return mid return left // l 在 m 和 r 之间
} }
return right return right
} }
@ -804,13 +797,16 @@ comments: true
```swift title="quick_sort.swift" ```swift title="quick_sort.swift"
/* 选取三个候选元素的中位数 */ /* 选取三个候选元素的中位数 */
func medianThree(nums: [Int], left: Int, mid: Int, right: Int) -> Int { func medianThree(nums: [Int], left: Int, mid: Int, right: Int) -> Int {
if (nums[left] < nums[mid]) != (nums[left] < nums[right]) { let l = nums[left]
return left let m = nums[mid]
} else if (nums[mid] < nums[left]) != (nums[mid] < nums[right]) { let r = nums[right]
return mid if (l <= m && m <= r) || (r <= m && m <= l) {
} else { return mid; // m 在 l 和 r 之间
return right
} }
if (m <= l && l <= r) || (r <= l && l <= m) {
return left; // l 在 m 和 r 之间
}
return right;
} }
/* 哨兵划分（三数取中值） */ /* 哨兵划分（三数取中值） */
@ -828,12 +824,14 @@ comments: true
```javascript title="quick_sort.js" ```javascript title="quick_sort.js"
/* 选取三个候选元素的中位数 */ /* 选取三个候选元素的中位数 */
medianThree(nums, left, mid, right) { medianThree(nums, left, mid, right) {
// 此处使用异或运算来简化代码 let l = nums[left],
// 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1 m = nums[mid],
if ((nums[left] < nums[mid]) ^ (nums[left] < nums[right])) return left; r = nums[right];
else if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right])) // m 在 l 和 r 之间
return mid; if ((l <= m && m <= r) || (r <= m && m <= l)) return mid;
else return right; // l 在 m 和 r 之间
if ((m <= l && l <= r) || (r <= l && l <= m)) return left;
return right;
} }
/* 哨兵划分（三数取中值） */ /* 哨兵划分（三数取中值） */
@ -870,17 +868,14 @@ comments: true
mid: number, mid: number,
right: number right: number
): number { ): number {
// 此处使用异或运算来简化代码 let l = nums[left],
// 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1 m = nums[mid],
if (Number(nums[left] < nums[mid]) ^ Number(nums[left] < nums[right])) { r = nums[right];
return left; // m 在 l 和 r 之间
} else if ( if ((l <= m && m <= r) || (r <= m && m <= l)) return mid;
Number(nums[mid] < nums[left]) ^ Number(nums[mid] < nums[right]) // l 在 m 和 r 之间
) { if ((m <= l && l <= r) || (r <= l && l <= m)) return left;
return mid; return right;
} else {
return right;
}
} }
/* 哨兵划分（三数取中值） */ /* 哨兵划分（三数取中值） */
@ -916,14 +911,12 @@ comments: true
```dart title="quick_sort.dart" ```dart title="quick_sort.dart"
/* 选取三个候选元素的中位数 */ /* 选取三个候选元素的中位数 */
int _medianThree(List<int> nums, int left, int mid, int right) { int _medianThree(List<int> nums, int left, int mid, int right) {
// 此处使用异或运算来简化代码 int l = nums[left], m = nums[mid], r = nums[right];
// 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1 if ((l <= m && m <= r) || (r <= m && m <= l))
if ((nums[left] < nums[mid]) ^ (nums[left] < nums[right])) return mid; // m 在 l 和 r 之间
return left; if ((m <= l && l <= r) || (r <= l && l <= m))
else if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right])) return left; // l 在 m 和 r 之间
return mid; return right;
else
return right;
} }
/* 哨兵划分（三数取中值） */ /* 哨兵划分（三数取中值） */
@ -949,12 +942,12 @@ comments: true
```rust title="quick_sort.rs" ```rust title="quick_sort.rs"
/* 选取三个候选元素的中位数 */ /* 选取三个候选元素的中位数 */
fn median_three(nums: &mut [i32], left: usize, mid: usize, right: usize) -> usize { fn median_three(nums: &mut [i32], left: usize, mid: usize, right: usize) -> usize {
// 此处使用异或运算来简化代码 let (mut l, mut m, mut r) = (nums[left], nums[mid], nums[right]);
// 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1 if ((l <= m && m <= r) || (r <= m && m <= l)) {
if (nums[left] < nums[mid]) ^ (nums[left] < nums[right]) { return mid; // m 在 l 和 r 之间
return left; }
} else if (nums[mid] < nums[left]) ^ (nums[mid] < nums[right]) { if ((m <= l && l <= r) || (r <= l && l <= m)) {
return mid; return left; // l 在 m 和 r 之间
} }
right right
} }
@ -976,8 +969,8 @@ comments: true
} }
nums.swap(i, j); // 交换这两个元素 nums.swap(i, j); // 交换这两个元素
} }
nums.swap(i, left); // 将基准数交换至两子数组的分界线 nums.swap(i, left); // 将基准数交换至两子数组的分界线
i // 返回基准数的索引 i // 返回基准数的索引
} }
``` ```
@ -987,14 +980,12 @@ comments: true
/* 快速排序类（中位基准数优化） */ /* 快速排序类（中位基准数优化） */
// 选取三个候选元素的中位数 // 选取三个候选元素的中位数
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];
// 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1 if ((l <= m && m <= r) || (r <= m && m <= l))
if ((nums[left] < nums[mid]) ^ (nums[left] < nums[right])) return mid; // m 在 l 和 r 之间
return left; if ((m <= l && l <= r) || (r <= l && l <= m))
else if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right])) return left; // l 在 m 和 r 之间
return mid; return right;
else
return right;
} }
/* 哨兵划分（三数取中值） */ /* 哨兵划分（三数取中值） */
@ -1022,15 +1013,14 @@ comments: true
```zig title="quick_sort.zig" ```zig title="quick_sort.zig"
// 选取三个候选元素的中位数 // 选取三个候选元素的中位数
fn medianThree(nums: []i32, left: usize, mid: usize, right: usize) usize { fn medianThree(nums: []i32, left: usize, mid: usize, right: usize) usize {
// 此处使用异或运算来简化代码 var l = nums[left];
// 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1 var m = nums[mid];
if ((nums[left] < nums[mid]) != (nums[left] < nums[right])) { var r = nums[right];
return left; if ((l <= m && m <= r) || (r <= m && m <= l))
} else if ((nums[mid] < nums[left]) != (nums[mid] < nums[right])) { return mid; // m 在 l 和 r 之间
return mid; if ((m <= l && l <= r) || (r <= l && l <= m))
} else { return left; // l 在 m 和 r 之间
return right; return right;
}
} }
// 哨兵划分（三数取中值） // 哨兵划分（三数取中值）

2
docs/chapter_stack_and_queue/queue.md
View file

@ -48,7 +48,7 @@ comments: true
que.append(4) que.append(4)
# 访问队首元素 # 访问队首元素
front: int = que[0]; front: int = que[0]
# 元素出队 # 元素出队
pop: int = que.popleft() pop: int = que.popleft()

4
docs/chapter_tree/avl_tree.md
View file

@ -22,7 +22,7 @@ comments: true
## 7.5.1 &nbsp; AVL 树常见术语 ## 7.5.1 &nbsp; AVL 树常见术语
AVL 树既是二叉搜索树，也是平衡二叉树，同时满足这两类二叉树的所有性质，因此也被称为「平衡二叉搜索树 balanced binary search tree」。 AVL 树既是二叉搜索树，也是平衡二叉树，同时满足这两类二叉树的所有性质，因此是一种「平衡二叉搜索树 balanced binary search tree」。
### 1. &nbsp; 节点高度 ### 1. &nbsp; 节点高度
@ -2459,4 +2459,4 @@ AVL 树的节点查找操作与二叉搜索树一致，在此不再赘述。
- 组织和存储大型数据，适用于高频查找、低频增删的场景。 - 组织和存储大型数据，适用于高频查找、低频增删的场景。
- 用于构建数据库中的索引系统。 - 用于构建数据库中的索引系统。
- 红黑树在许多应用中比 AVL 树更受欢迎。这是因为红黑树的平衡条件相对宽松，在红黑树中插入与删除节点所需的旋转操作相对较少，其节点增删操作的平均效率更高。 - 红黑树也是一种常见的平衡二叉搜索树。相较于 AVL 树，红黑树的平衡条件更宽松，插入与删除节点所需的旋转操作更少，节点增删操作的平均效率更高。