【算法】查找-优快云博客

在这里插入图片描述

上期回顾: 【算法】高阶数据结构
个人主页：GUIQU.
归属专栏：算法

在这里插入图片描述

1. 顺序查找

1.1 基本原理

顺序查找是一种最简单、最直观的查找算法。它的基本思想是从数据结构（如数组、链表等）的一端开始，逐个元素地进行比较，直到找到目标元素或者遍历完整个数据结构为止。

例如，对于一个存储在数组 arr 中的整数序列，要查找值为 target 的元素，就从数组的第一个元素 arr[0] 开始，依次比较 arr[0]、arr[1]、arr[2]……直到找到 arr[i] 等于 target 或者遍历完整个数组。

1.2 代码实现（以数组为例）

#include <iostream>
using namespace std;

int sequentialSearch(int arr[], int n, int target) {
    for (int i = 0; i < n; i++) {
        if (arr[i] == target) {
            return i;  // 返回找到元素的下标
        }
    }
    return -1;  // 表示未找到
}

int main() {
    int arr[] = {5, 3, 8, 2, 9};
    int n = sizeof(arr) / sizeof(arr[0]);
    int target = 8;
    int result = sequentialSearch(arr, n, target);
    if (result!= -1) {
        cout << "在数组中找到目标元素，下标为: " << result << endl;
    } else {
        cout << "未在数组中找到目标元素" << endl;
    }
    return 0;
}

1.3 时间复杂度与空间复杂度

时间复杂度：在最坏情况下，需要遍历整个数据结构，若数据结构中有 n 个元素，时间复杂度为 $O (n)$ 。平均情况下，假设目标元素在数据结构中出现的概率相等且各位置出现概率也相等，平均时间复杂度也是 $O (n)$ 。
空间复杂度：只需要常数级别的额外空间来存储一些临时变量，如循环变量等，所以空间复杂度为 $O (1)$ 。

1.4 应用场景

适用于数据结构无序，或者对查找效率要求不是特别高的简单查找场景，比如在一个小型的、不常查找的数据集合中查找某个元素，像小型的学生成绩记录单中查找某个学生的成绩情况等。

2. 二分查找

2.1 基本原理

二分查找要求数据结构中的元素是有序的（升序或降序均可，以下以升序为例）。它每次把查找区间分成两部分，通过比较目标元素与中间元素的大小关系，确定目标元素可能存在的区间，然后继续在该区间内进行同样的划分和查找操作，直到找到目标元素或者确定目标元素不存在为止。

比如，在有序数组 arr 中查找 target，先取数组中间位置 mid = (left + right) / 2（left 和 right 分别是当前查找区间的左右边界），如果 arr[mid] == target，就找到了；如果 arr[mid] > target，则目标元素在左半区间 [left, mid - 1]；如果 arr[mid] < target，则目标元素在右半区间 [mid + 1, right]。

2.2 代码实现（以升序数组为例）

#include <iostream>
using namespace std;

int binarySearch(int arr[], int n, int target) {
    int left = 0, right = n - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] == target) {
            return mid;
        } else if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return -1;  // 表示未找到
}

int main() {
    int arr[] = {1, 3, 5, 7, 9};
    int n = sizeof(arr) / sizeof(arr[0]);
    int target = 5;
    int result = binarySearch(arr, n, target);
    if (result!= -1) {
        cout << "在数组中找到目标元素，下标为: " << result << endl;
    } else {
        cout << "未在数组中找到目标元素" << endl;
    }
    return 0;
}

2.3 时间复杂度与空间复杂度

时间复杂度：每次查找都能将区间缩小一半，最多需要查找的次数为以2为底 n 的对数次，所以时间复杂度为 $O(\log n)$ ，效率比顺序查找高很多，尤其是在数据量较大时优势明显。
空间复杂度：同样只需要常数级别的额外空间来存储如 left、right、mid 等临时变量，空间复杂度为 $O (1)$ 。

2.4 应用场景

常用于有序数据的快速查找，比如在一个已经排好序的字典（按字母顺序排序的单词列表）中查找某个单词，或者在有序的数据库索引表中查找特定记录等场景。

3. 插值查找

3.1 基本原理

插值查找是二分查找的一种改进算法，它也是基于有序数据结构进行查找。不过，在确定下一次查找区间时，不是简单地取中间位置，而是根据目标元素与当前查找区间两端元素的相对位置关系，通过插值公式来估算目标元素更可能所在的位置，从而更精准地缩小查找区间。

插值公式大致为：pos = left + (target - arr[left]) * (right - left) / (arr[right] - arr[left])（这里 pos 是估算出的目标元素可能所在位置，left、right 是当前查找区间边界，arr 是有序数组）。其核心思想是，如果目标元素更靠近区间的某一端，就偏向那一端去查找，充分利用数据的分布特性。

3.2 代码实现（以升序数组为例）

#include <iostream>
using namespace std;

int interpolationSearch(int arr[], int n, int target) {
    int left = 0, right = n - 1;
    while (left <= right && target >= arr[left] && target <= arr[right]) {
        int pos = left + (target - arr[left]) * (right - left) / (arr[right] - arr[left]);
        if (arr[pos] == target) {
            return pos;
        } else if (arr[pos] < target) {
            left = pos + 1;
        } else {
            right = pos - 1;
        }
    }
    return -1;  // 表示未找到
}

int main() {
    int arr[] = {1, 3, 5, 7, 9};
    int n = sizeof(arr) / sizeof(arr[0]);
    int target = 5;
    int result = interpolationSearch(arr, n, target);
    if (result!= -1) {
        cout << "在数组中找到目标元素，下标为: " << result << endl;
    } else {
        cout << "未在数组中找到目标元素" << endl;
    }
    return 0;
}

3.3 时间复杂度与空间复杂度

时间复杂度：在数据分布比较均匀的情况下，插值查找的平均时间复杂度接近 $O(\log \log n)$ ，比二分查找更优；但在数据分布不均匀时，性能可能会退化到接近顺序查找的 $O (n)$ 。
空间复杂度：和二分查找一样，只需要常数级别的额外空间，空间复杂度为 $O (1)$ 。

3.4 应用场景

适合处理数据分布比较均匀的有序数据查找场景，比如在一些统计数据（如年龄分布相对均匀的人群年龄数据）中查找特定值，能够更快地定位到目标元素所在区间，提高查找效率。

4. 斐波那契查找

4.1 基本原理

斐波那契查找利用了斐波那契数列的特性来进行查找，同样基于有序数据结构。它通过构造斐波那契数列，并根据数列的值来划分查找区间，使得每次查找能更有效地缩小范围。

首先，要将待查找的有序数组的长度扩充（一般通过添加最后一个元素的值来扩充）为最接近的斐波那契数对应的长度，然后根据斐波那契数列中相邻两项的关系来确定中间位置（不同于二分查找的简单取中间），比较目标元素与该中间位置元素的大小关系，进而确定下一次查找区间，重复操作直至找到目标元素或者确定不存在。

例如，斐波那契数列 F(n) 满足 F(n) = F(n - 1) + F(n - 2)（n >= 2，F(0) = 0，F(1) = 1），在查找时会利用类似的数值关系来定位中间位置。

4.2 代码实现（以升序数组为例）

#include <iostream>
#include <vector>
using namespace std;

// 计算斐波那契数列的第n项
int fibonacci(int n) {
    if (n == 0) return 0;
    if (n == 1) return 1;
    return fibonacci(n - 1) + fibonacci(n - 2);
}

int fibonacciSearch(int arr[], int n, int target) {
    int left = 0, right = n - 1;
    int k = 0;
    // 找到满足F(k) >= n的最小k值，即扩充数组长度到最接近的斐波那契数长度对应的k
    while (fibonacci(k) < n) {
        k++;
    }
    // 创建临时数组，扩充长度到F(k)，并复制原数组元素
    vector<int> temp(fibonacci(k), arr[n - 1]);
    for (int i = 0; i < n; i++) {
        temp[i] = arr[i];
    }
    while (left <= right) {
        int mid = left + fibonacci(k - 1);  // 根据斐波那契数确定中间位置
        if (temp[mid] == target) {
            if (mid < n) {
                return mid;
            } else {
                return n - 1;  // 如果是扩充部分，实际对应原数组最后一个元素位置
            }
        } else if (temp[mid] < target) {
            left = mid + 1;
            k -= 2;
        } else {
            right = mid - 1;
            k -= 1;
        }
    }
    return -1;  // 表示未找到
}

int main() {
    int arr[] = {1, 3, 5, 7, 9};
    int n = sizeof(arr) / sizeof(arr[0]);
    int target = 5;
    int result = fibonacciSearch(arr, n, target);
    if (result!= -1) {
        cout << "在数组中找到目标元素，下标为: " << result << endl;
    } else {
        cout << "未在数组中找到目标元素" << endl;
    }
    return 0;
}

4.3 时间复杂度与空间复杂度

时间复杂度：平均时间复杂度为 $O(\log n)$ ，与二分查找相近，但在一些特定的数据分布和操作场景下，斐波那契查找可能会有更好的性能表现，尤其是在频繁进行查找操作的有序数据处理中。
空间复杂度：由于需要创建临时数组来扩充长度，空间复杂度为 $O (n)$ （这里 n 是原数组扩充后的长度，即最接近的斐波那契数对应的长度），相较于前面几种查找算法，空间复杂度相对较高，但在一些可以接受额外空间开销的场景中依然有应用价值。

4.4 应用场景

适用于有序数据的查找，特别是在对查找性能有进一步优化需求，且对一定的空间开销不太敏感的场景，比如在一些内部数据结构相对固定、查找操作频繁的算法模块中，利用斐波那契查找来提高查找效率。

5. 哈希查找

5.1 基本原理

哈希查找基于哈希表（散列表）这种数据结构来实现快速查找。通过一个哈希函数，将查找的键（比如一个字符串、整数等）映射到哈希表中的一个位置（桶），理想情况下可以在常数时间内定位到目标元素所在位置。

但实际中可能会出现哈希冲突，即不同的键通过哈希函数计算后得到相同的桶位置，这时需要采用相应的解决冲突的方法，如开放定址法（线性探测、二次探测等）、链地址法（将冲突的元素放在同一个链表中）等来处理，然后在对应的位置或链表中查找目标元素。

5.2 代码实现（以C++中 `unordered_map` 为例，它底层基于哈希表实现）

#include <iostream>
#include <unordered_map>
using namespace std;

int main() {
    // 创建一个unordered_map，键为string类型，值为int类型
    unordered_map<string, int> myMap;

    // 插入元素
    myMap["apple"] = 5;
    myMap["banana"] = 3;

    // 查找元素
    string target = "apple";
    if (myMap.find(target)!= myMap.end()) {
        cout << "找到了键为 " << target << " 的值，值为: " << myMap[target] << endl;
    } else {
        cout << "未找到键为 " << target << " 的元素" << endl;
    }

    return 0;
}

5.3 时间复杂度与空间复杂度

时间复杂度：在理想情况下，即没有哈希冲突或者冲突很少，且哈希函数计算时间复杂度较低时，查找操作的平均时间复杂度可以接近 $O (1)$ ，这是非常高效的；但在最坏情况下（比如哈希冲突严重，所有元素都映射到同一个桶等极端情况），时间复杂度可能会退化为 $O (n)$ ，不过这种情况在合理设计哈希函数和处理冲突机制时很少出现。
空间复杂度：哈希表需要占用一定的空间来存储元素以及可能用于处理冲突的额外结构（如链表等），空间复杂度一般取决于元素的数量以及哈希表的负载因子等因素，大致为 $O (n)$ （这里 n 是元素个数）。

5.4 应用场景

广泛应用于需要快速查找元素的场景，特别是在处理大量数据且对查找速度要求极高的情况下，比如在编译器的符号表管理中（快速查找变量名对应的各种属性）、搜索引擎的索引构建与查询（快速查找关键词对应的网页信息）等场景中都发挥着重要作用。

6. 树状数组查找（基于树状数组实现区间查找）

6.1 基本原理

树状数组（Binary Indexed Tree，BIT）本身主要用于高效处理区间查询和单点更新。对于查找操作，它可以基于树状数组的结构特性，通过巧妙地利用二进制运算来快速获取区间信息。

例如，要查找区间 [1, right] 的元素和，通过不断减去 right 的二进制表示中的最低位 lowbit(right)，并累加对应树状数组节点的值，就可以逐步获取到该区间的元素和。这是因为树状数组的每个节点覆盖了一定的区间范围，且这些区间范围与二进制运算相关，通过这样的操作可以高效地汇总区间内的元素信息。

6.2 代码实现（以获取区间和为例）

#include <iostream>
#include <vector>
using namespace std;

// 获取lowbit值
int lowbit(int x) {
    return x & (-x);
}

// 树状数组查询区间和操作
int query(int right, const vector<int>& bit) {
    int sum = 0;
    for (; right > 0; right -= lowbit(right)) {
        sum += bit[right];
    }
    return sum;
}

int main() {
    vector<int> arr = {1, 3, 5, 7, 9};
    int n = arr.size();
    vector<int> bit(n + 1, 0);
    // 构建树状数组（这里省略完整构建过程，假设已经构建好）
    int right = 3;
    int result = query(right, bit);
    cout << "区间 [1, " << right << "] 的元素和为: " << result << endl;
    return 0;
}

6.3 时间复杂度与空间复杂度

时间复杂度：每次查询操作最多需要进行 $O(\log n)$ 次累加操作（n 是树状数组对应的原数组长度），因为每次减去 lowbit 值的操作相当于在逐步缩小查找区间，而最多需要操作的次数与数组长度的二进制表示的位数相关，也就是 $O(\log n)$ ，所以查询区间和的时间复杂度为 $O(\log n)$ 。
空间复杂度：树状数组需要额外开辟一个与原数组长度相关的数组来存储节点信息，空间复杂度为 $O (n)$ 。

6.4 应用场景

适用于需要频繁进行区间查询以及单点更新的场景，比如在统计一些动态变化的数据区间和（如实时统计某段时间内的销售额总和，随着销售数据不断更新，能快速获取不同区间的销售额情况），或者在计算数组中某个区间内满足特定条件元素的数量等场景下，利用树状数组查找能高效地完成任务，相较于直接遍历计算区间情况，能极大地提升效率。同时在一些基于动态规划且涉及区间统计优化的算法中也经常会用到树状数组来辅助进行快速查找操作。

7. 线段树查找（用于区间最值、区间和等查找）

7.1 基本原理

线段树是一种基于区间的数据结构，每个节点对应一个区间，并且存储了该区间的相关统计信息（比如区间和、区间最值等）。

在进行查找操作时，比如要查找区间 [left, right] 的最值或者和，从根节点开始，根据当前节点所代表区间与目标查找区间的关系来决定如何向下遍历子节点。如果当前节点区间完全包含目标区间，那么该节点存储的就是目标区间的统计值，直接返回即可；如果目标区间与当前节点的左右子区间有交集，那就分别递归地在左右子区间对应的子树中继续查找，最后汇总得到目标区间的结果。

例如，对于一棵存储区间和的线段树，根节点对应整个区间 [1, 10]，要查找区间 [3, 7] 的和，就从根节点开始判断，若根节点不能直接提供该区间和，就看其左右子节点对应的区间与 [3, 7] 的关系，然后继续深入子树查找，直到找到能满足要求的节点并汇总其区间和信息。

7.2 代码实现（以查找区间和为例）

#include <iostream>
using namespace std;

// 线段树节点结构体定义
struct SegmentTreeNode {
    int start, end;  // 节点对应的区间范围
    int sum;  // 该区间的元素和
    SegmentTreeNode* left;
    SegmentTreeNode* right;
    SegmentTreeNode(int s, int e) : start(s), end(e), sum(0), left(NULL), right(NULL) {}
};

// 构建线段树（这里省略完整构建过程，假设已经构建好）
SegmentTreeNode* buildSegmentTree(int arr[], int start, int end) {
    if (start > end) return NULL;
    SegmentTreeNode* root = new SegmentTreeNode(start, end);
    if (start == end) {
        root->sum = arr[start];
    } else {
        int mid = start + (end - start) / 2;
        root->left = buildSegmentTree(arr, start, mid);
        root->right = buildSegmentTree(arr, mid + 1, end);
        root->sum = root->left->sum + root->right->sum;
    }
    return root;
}

// 线段树查找区间和操作
int query(SegmentTreeNode* root, int left, int right) {
    if (root->start == left && root->end == right) {
        return root->sum;
    }
    int mid = root->start + (root->end - root->start) / 2;
    if (right <= mid) {
        return query(root->left, left, right);
    } else if (left > mid) {
        return query(root->right, left, right);
    } else {
        return query(root->left, left, mid) + query(root->right, mid + 1, right);
    }
}

int main() {
    int arr[] = {1, 3, 5, 7, 9};
    int n = sizeof(arr) / sizeof(arr[0]);
    SegmentTreeNode* root = buildSegmentTree(arr, 0, n - 1);
    int left = 1, right = 3;
    int result = query(root, left, right);
    cout << "区间 [" << left << ", " << right << "] 的元素和为: " << result << endl;
    return 0;
}

7.3 时间复杂度与空间复杂度

时间复杂度：每次查找操作最多会遍历树的高度次节点，而线段树的高度为 $O(\log n)$ （n 为原数组长度，因为每次区间划分都是对半分的，树的高度与划分次数相关），所以查找区间信息的时间复杂度为 $O(\log n)$ 。
空间复杂度：线段树需要额外开辟节点空间来存储区间信息，其节点数量与 n 相关，最坏情况下节点数量接近 $4 n$ ，所以空间复杂度为 $O (n)$ 。

7.4 应用场景

在处理大量区间查询（如区间最值、区间和、区间个数统计等）且需要支持区间更新操作（如对区间内元素统一修改值等）的场景中非常有用。例如在图形处理中计算矩形区域内像素值的统计信息、在地理信息系统中统计某个区域内的地理数据指标总和等，或者在各种算法竞赛题目中涉及区间操作和查询的情况，线段树都是很常用的工具。

8. 字典树（Trie树）查找

8.1 基本原理

字典树（Trie树）主要用于高效地存储和检索字符串集合中的字符串。查找操作时，从根节点开始，沿着要查找字符串的字符顺序依次在树中查找对应的子节点路径。

如果沿着字符串的字符能顺利找到最后一个字符对应的节点，并且该节点被标记为一个完整单词（通常会有一个标记位来表示），那就说明该字符串存在于字典树中；如果在查找过程中某个字符对应的子节点不存在，那就说明该字符串不在字典树中。

例如，在一棵存储了单词 “apple”、“app”、“banana”等的字典树中，查找单词 “apple”，就从根节点出发，先找字符 a 对应的子节点，再找 p 对应的子节点，依次类推，直到找到 e 对应的节点且该节点标记为完整单词的情况，就表示找到了。

8.2 代码实现

#include <iostream>
#include <string>
using namespace std;

// 字典树节点结构体定义
struct TrieNode {
    TrieNode* children[26];  // 假设只处理小写字母，用长度为26的数组存储子节点指针
    bool isEnd;  // 标记位，用于表示从根节点到该节点的路径是否构成一个完整的单词
    TrieNode() {
        isEnd = false;
        for (int i = 0; i < 26; i++) {
            children[i] = NULL;
        }
    }
};

// 插入单词到字典树
void insert(TrieNode* root, string word) {
    TrieNode* cur = root;
    for (char c : word) {
        int index = c - 'a';
        if (cur->children[index] == NULL) {
            cur->children[index] = new TrieNode();
        }
        cur = cur->children[index];
    }
    cur->isEnd = true;
}

// 在字典树中查找单词
bool search(TrieNode* root, string word) {
    TrieNode* cur = root;
    for (char c : word) {
        int index = c - 'a';
        if (cur->children[index] == NULL) {
            return false;
        }
        cur = cur->children[index];
    }
    return cur->isEnd;
}

int main() {
    TrieNode* root = new TrieNode();
    insert(root, "apple");
    insert(root, "app");
    insert(root, "banana");

    string target = "apple";
    if (search(root, target)) {
        cout << "在字典树中找到了单词 " << target << endl;
    } else {
        cout << "在字典树中未找到单词 " << target << endl;
    }

    return 0;
}

8.3 时间复杂度与空间复杂度

时间复杂度：查找一个长度为 m 的字符串在字典树中的情况，时间复杂度为 $O (m)$ ，因为只需要沿着字符串的字符依次查找对应的节点，最多查找 m 次。
空间复杂度：字典树的空间复杂度取决于存储的单词数量以及单词的长度，最坏情况下，如果所有单词都没有公共前缀，且单词长度较长，空间复杂度会比较高，大致为 $O(\sum_{i = 1}^{n} l_{i})$ （n 是单词数量，l_i 是第 i 个单词的长度），不过在实际应用中，由于单词通常有公共前缀等情况，能在一定程度上节省空间。

8.4 应用场景

自动补全功能：在搜索引擎的输入框、代码编辑器的代码补全功能等场景中，根据用户已输入的前缀快速查找可能的完整单词，字典树可以快速定位到以该前缀开头的所有单词，进而提供补全建议。
单词拼写检查：将大量正确的单词构建成字典树，对于待检查的单词，可以在字典树中查找是否存在，若不存在则可能拼写有误，并且可以基于字典树给出一些相似的正确单词建议，方便用户纠错。
文本分类与过滤：比如在垃圾邮件过滤中，将一些关键词构建成字典树，快速查找邮件内容中是否包含特定的关键词，辅助判断邮件性质，进行分类处理。

9. 平衡二叉搜索树查找（以AVL树为例）

9.1 基本原理

AVL树是一种自平衡的二叉搜索树，它在满足二叉搜索树性质（左子树上所有节点的值都小于根节点的值，右子树上所有节点的值都大于根节点的值，且左右子树也分别是二叉搜索树）的基础上，还保证任意节点的左右子树的高度差的绝对值不超过1。

查找操作时，从根节点开始，比较目标值与当前节点值的大小关系。如果目标值等于当前节点值，那就找到了；如果目标值小于当前节点值，就向左子树继续查找；如果目标值大于当前节点值，就向右子树继续查找，如此递归，直到找到目标值或者到达叶子节点确定目标值不存在为止。

例如，在一棵AVL树中查找值为 10 的节点，先与根节点的值比较，若根节点值大于 10，则往根节点的左子树去查找，不断重复这个比较和选择子树的过程。

9.2 代码实现（简化示例，节点结构体包含值、左右子节点指针和高度信息等常规内容）

#include <iostream>
using namespace std;

// AVL树节点结构体定义
struct AVLTreeNode {
    int val;
    AVLTreeNode* left;
    AVLTreeNode* right;
    int height;  // 节点所在子树的高度
    AVLTreeNode(int v) : val(v), left(NULL), right(NULL), height(1) {}
};

// 获取节点高度（辅助函数）
int getHeight(AVLTreeNode* node) {
    if (node == NULL) return 0;
    return node->height;
}

// 计算平衡因子（左右子树高度差，辅助函数）
int getBalanceFactor(AVLTreeNode* node) {
    if (node == NULL) return 0;
    return getHeight(node->left) - getHeight(node->right);
}

// 右旋操作（辅助函数，用于平衡调整）
AVLTreeNode* rightRotate(AVLTreeNode* y) {
    AVLTreeNode* x = y->left;
    y->left = x->right;
    x->right = y;
    // 更新节点高度
    y->height = max(getHeight(y->left), getHeight(y->right)) + 1;
    x->height = max(getHeight(x->left), getHeight(x->right)) + 1;
    return x;
}

// 左旋操作（辅助函数，用于平衡调整）
AVLTreeNode* leftRotate(AVLTreeNode* x) {
    AVLTreeNode* y = x->right;
    x->right = y->left;
    y->left = x;
    // 更新节点高度
    y->height = max(getHeight(y->left), getHeight(y->right)) + 1;
    x->height = max(getHeight(x->left), getHeight(x->right)) + 1;
    return y;
}

// AVL树查找操作
AVLTreeNode* search(AVLTreeNode* root, int target) {
    if (root == NULL) return root;
    if (root->val == target) return root;
    if (target < root->val) {
        return search(root->left, target);
    } else {
        return search(root->left, target);
    }
}

int main() {
    // 构建一棵简单的AVL树示例（这里手动构建简单情况演示）
    AVLTreeNode* root = new AVLTreeNode(10);
    root->left = new AVLTreeNode(5);
    root->right = new AVLTreeNode(15);
    root->right->left = new AVLTreeNode(12);

    int target = 12;
    AVLTreeNode* result = search(root, target);
    if (result!= NULL) {
        cout << "在AVL树中找到了目标值对应的节点" << endl;
    } else {
        cout << "在AVL树中未找到目标值对应的节点" << endl;
    }

    return 0;
}

9.3 时间复杂度与空间复杂度

时间复杂度：由于AVL树的高度始终保持在 $O(\log n)$ （n 为树中节点数量），所以查找操作最多需要遍历树的高度次节点，时间复杂度为 $O(\log n)$ ，这在保证了二叉搜索树有序查找特性的同时，避免了普通二叉搜索树在最坏情况下退化成链表导致查找效率低下的问题。
空间复杂度：AVL树每个节点除了存储数据值外，还需要存储左右子节点指针以及高度信息等，空间复杂度为 $O (n)$ ，不过相较于其查找效率的优势，在很多需要高效查找且对空间不太敏感的场景中是可以接受的。

9.4 应用场景

数据库索引：在数据库管理系统中，需要对大量的数据记录进行高效的查找、插入和删除操作，AVL树可以作为索引结构的一种实现方式，通过维护数据的有序性以及保证树的平衡性，快速定位到目标数据记录，提高数据库操作的整体效率。
有序数据的动态管理：对于一些需要动态地插入、删除和查找元素，并且要求始终保持数据有序的场景，比如实时更新的排行榜（按照分数等属性排序），AVL树可以很好地胜任，能快速查找特定元素在排序中的位置以及方便进行元素的增减操作。

结语
感谢您的阅读！期待您的一键三连！欢迎指正！

在这里插入图片描述