数据结构-查找（1）

一、查找的核心目标

1. 存在性检查：判断目标元素是否存在于数据集合中。

2. 位置定位：若存在，确定其存储位置（如数组索引、内存地址）。

3. 信息获取：返回与目标元素关联的数据（如键值对中的值）

二、查找算法的关键指标

1. 时间复杂度：衡量算法执行时间与数据规模的关系。

2. 空间复杂度：算法执行所需的额外内存空间。

3. 稳定性：是否总能找到目标（如哈希表可能因冲突漏查）。

4. 适用性：是否依赖数据结构的特性（如有序性）。

三、静态查找方法

1. 适用场景

• 数据集合初始化后不再修改。

• 需要高效的单次或批量查找操作。

• 示例：历史数据查询、离线数据分析。

2. 常用方法

a. 顺序查找（线性查找）

• 原理：逐个遍历元素，直到找到目标。

• 时间复杂度：𝑂(𝑛)O(n)。

• 代码示例：

• #include <stdio.h>
  #include <stdlib.h> // 用于动态内存分配// 顺序查找函数
  int sequential_search(int arr[], int size, int target) {for (int i = 0; i < size; i++) {if (arr[i] == target) {return i; // 找到目标，返回索引位置}}return -1; // 未找到目标
  }int main() {int n, target, result;// 输入数组大小printf("请输入数组的大小：");scanf("%d", &n);// 动态分配数组内存int *arr = (int *)malloc(n * sizeof(int));if (arr == NULL) {printf("内存分配失败！\n");return 1;}// 输入数组元素printf("请输入%d个整数：\n", n);for (int i = 0; i < n; i++) {scanf("%d", &arr[i]);}// 输入要查找的目标值printf("请输入要查找的目标值：");scanf("%d", &target);// 执行顺序查找result = sequential_search(arr, n, target);// 输出结果if (result != -1) {printf("目标值 %d 在数组中的位置是第 %d 个元素（下标：%d）\n", target, result + 1, result);} else {printf("目标值 %d 未在数组中找到。\n", target);}// 释放动态分配的内存free(arr);return 0;
  }

  

b. 二分查找（折半查找）

• 原理：要求数据有序，每次比较中间元素缩小范围。

• 时间复杂度：𝑂(log⁡𝑛)O(logn)。

• 代码示例：

• #include <stdio.h>
  #include <stdlib.h> // 用于动态内存分配和qsort// 二分查找函数（迭代实现）
  int binary_search(int arr[], int size, int target) {int low = 0;int high = size - 1;while (low <= high) {int mid = low + (high - low) / 2; // 避免整数溢出if (arr[mid] == target) {return mid;           // 找到目标值} else if (arr[mid] < target) {low = mid + 1;        // 目标在右半区} else {high = mid - 1;       // 目标在左半区}}return -1; // 未找到目标值
  }// 检查数组是否升序排列
  int is_sorted(int arr[], int size) {for (int i = 0; i < size-1; i++) {if (arr[i] > arr[i+1]) {return 0; // 发现逆序对}}return 1; // 数组已排序
  }int main() {int n, target, result;// 输入数组大小printf("请输入升序数组的大小：");scanf("%d", &n);// 动态分配数组内存int *arr = (int *)malloc(n * sizeof(int));if (arr == NULL) {printf("内存分配失败！\n");return 1;}// 输入数组元素printf("请依次输入%d个升序整数：\n", n);for (int i = 0; i < n; i++) {scanf("%d", &arr[i]);}// 验证数组有序性if (!is_sorted(arr, n)) {printf("错误：数组不是升序排列！\n");free(arr);return 1;}// 输入要查找的目标值printf("请输入要查找的目标值：");scanf("%d", &target);// 执行二分查找result = binary_search(arr, n, target);// 输出结果if (result != -1) {printf("目标值 %d 在数组中的位置是第 %d 个元素（下标：%d）\n", target, result + 1, result);} else {printf("目标值 %d 未在数组中找到。\n", target);}// 释放动态分配的内存free(arr);return 0;
  }

• 

c. 插值查找

• 原理：根据目标值分布预测位置，适用于均匀分布的有序数据。

• 公式：𝑚𝑖𝑑=𝑙𝑜𝑤+(𝑡𝑎𝑟𝑔𝑒𝑡−𝑎𝑟𝑟[𝑙𝑜𝑤])𝑎𝑟𝑟[ℎ𝑖𝑔ℎ]−𝑎𝑟𝑟[𝑙𝑜𝑤]×(ℎ𝑖𝑔ℎ−𝑙𝑜𝑤)mid=low+arr[high]−arr[low](target−arr[low])​×(high−low)

• 时间复杂度：平均 𝑂(log⁡log⁡𝑛)O(loglogn)，最坏 𝑂(𝑛)O(n)。

d. 斐波那契查找

• 原理：利用斐波那契数列分割有序数组。

• 时间复杂度：𝑂(log⁡𝑛)O(logn)。

• 优势：避免二分查找的乘除运算，适合计算资源受限环境。

• 示例代码：

• #include <stdio.h>
  #include <stdlib.h>// 生成斐波那契数列，直到找到第一个 >= n 的斐波那契数
  int generateFibonacci(int n, int** fib) {if (n <= 0) return 0;int k = 0;int a = 0, b = 1, c = 1;// 计算所需的斐波那契数列长度while (c < n) {a = b;b = c;c = a + b;k++;}// 动态分配内存存储斐波那契数列*fib = (int*)malloc((k + 3) * sizeof(int)); // 多分配一些空间防止溢出(*fib)[0] = 0;(*fib)[1] = 1;for (int i = 2; ; i++) {(*fib)[i] = (*fib)[i - 1] + (*fib)[i - 2];if ((*fib)[i] >= n) {return i; // 返回斐波那契数列的索引k}}
  }// 斐波那契查找算法
  int fibonacciSearch(int arr[], int n, int target) {int* fib = NULL;int k = generateFibonacci(n, &fib); // 生成斐波那契数列int low = 0, high = n - 1;int mid;// 扩展数组到 F(k)-1 的长度int extendedSize = fib[k] - 1;int* extendedArr = (int*)malloc(extendedSize * sizeof(int));for (int i = 0; i < n; i++) extendedArr[i] = arr[i];for (int i = n; i < extendedSize; i++) extendedArr[i] = arr[n - 1]; // 填充末尾元素// 开始查找while (low <= high) {mid = low + fib[k - 1] - 1;if (target < extendedArr[mid]) {high = mid - 1;k -= 1; // 左半部分长度为 F(k-1)}else if (target > extendedArr[mid]) {low = mid + 1;k -= 2; // 右半部分长度为 F(k-2)}else {// 返回原始数组的索引（避免返回填充的位置）free(fib);free(extendedArr);return (mid < n) ? mid : n - 1;}}// 未找到free(fib);free(extendedArr);return -1;
  }/********************** 示例测试 **********************/
  int main() {int arr[] = { 1, 3, 5, 7, 9, 11 };int n = sizeof(arr) / sizeof(arr[0]);int target = 5;int index = fibonacciSearch(arr, n, target);if (index != -1) {printf("元素 %d 在数组中的索引为: %d\n", target, index);}else {printf("元素 %d 未找到\n", target);}return 0;
  }

  

三、动态查找方法

1. 适用场景

• 数据集合频繁插入、删除。

• 需要实时维护数据结构的平衡性。

• 示例：数据库索引、实时缓存系统。

2. 常用方法

a. 二叉搜索树（BST）

• 原理：左子树值 < 根 < 右子树值。

• 时间复杂度：平均 𝑂(log⁡𝑛)O(logn)，最坏 𝑂(𝑛)O(n)（退化为链表）。

• 代码示例：

• #include <stdio.h>
  #include <stdlib.h>// 定义二叉排序树节点结构
  typedef struct TreeNode 
  {int data;struct TreeNode* left;struct TreeNode* right;
  } TreeNode;
  //作用：定义二叉树的节点结构，每个节点包含：
  //data：存储整数值。
  //left 和 right：分别指向左子树和右子树的指针
  /*--------------------- 核心操作函数 ---------------------*///// 创建新节点
  TreeNode* createNode(int value) {TreeNode* newNode = (TreeNode*)malloc(sizeof(TreeNode));if (newNode == NULL) {fprintf(stderr, "内存分配失败！\n");exit(EXIT_FAILURE);}newNode->data = value;newNode->left = NULL;newNode->right = NULL;return newNode;
  }// 插入节点（递归实现）
  TreeNode* insertNode(TreeNode* root, int value) {if (root == NULL) {return createNode(value);}if (value < root->data) {root->left = insertNode(root->left, value);}else if (value > root->data) {root->right = insertNode(root->right, value);}// 如果值已存在，不做插入return root;
  }// 查找节点（递归实现）
  TreeNode* searchNode(TreeNode* root, int target) {if (root == NULL || root->data == target) {return root;}if (target < root->data) {return searchNode(root->left, target);}else {return searchNode(root->right, target);}
  }// 找到子树的最小节点（用于删除操作）
  TreeNode* findMinNode(TreeNode* node) {while (node->left != NULL) {node = node->left;}return node;
  }// 删除节点（递归实现）
  TreeNode* deleteNode(TreeNode* root, int key) {if (root == NULL) return root;// 定位要删除的节点if (key < root->data) {root->left = deleteNode(root->left, key);}else if (key > root->data) {root->right = deleteNode(root->right, key);}else {// 找到目标节点，处理三种情况：// 1. 无子节点或只有一个子节点if (root->left == NULL) {TreeNode* temp = root->right;free(root);return temp;}else if (root->right == NULL) {TreeNode* temp = root->left;free(root);return temp;}// 2. 有两个子节点：用右子树的最小节点替换当前节点TreeNode* temp = findMinNode(root->right);root->data = temp->data;root->right = deleteNode(root->right, temp->data);}return root;
  }// 中序遍历（升序输出）
  void inOrderTraversal(TreeNode* root) {if (root != NULL) {inOrderTraversal(root->left);printf("%d ", root->data);inOrderTraversal(root->right);}
  }// 释放二叉树内存
  void freeTree(TreeNode* root) {if (root == NULL) return;freeTree(root->left);freeTree(root->right);free(root);
  }/*--------------------- 测试用例 ---------------------*/
  int main() {TreeNode* root = NULL;int values[] = { 8, 3, 10, 1, 6, 14, 4, 7, 13 };int n = sizeof(values) / sizeof(values[0]);// 插入节点构建BSTfor (int i = 0; i < n; i++) {root = insertNode(root, values[i]);}// 中序遍历验证结构printf("中序遍历结果: ");inOrderTraversal(root);printf("\n");// 查找节点测试int searchKey = 6;TreeNode* result = searchNode(root, searchKey);if (result != NULL) {printf("找到节点 %d\n", searchKey);}else {printf("未找到节点 %d\n", searchKey);}// 删除节点测试printf("删除节点 6 后:\n");root = deleteNode(root, 6);inOrderTraversal(root);printf("\n");// 再次查找已删除节点result = searchNode(root, searchKey);if (result != NULL) {printf("错误: 节点 %d 未被正确删除\n", searchKey);}else {printf("节点 %d 已成功删除\n", searchKey);}// 释放内存freeTree(root);return 0;
  }

  

b. 平衡二叉树（AVL树、红黑树）

• 原理：通过旋转保持树平衡，确保高度差受限。

• 时间复杂度：严格 𝑂(log⁡𝑛)O(logn)。

• 应用场景：C++ STL的std::map（红黑树实现）。

• 示例代码：

• #include <stdio.h>
  #include <stdlib.h>// AVL树节点结构
  typedef struct AVLNode {int key;//节点存储的键值struct AVLNode* left;//左子节点指针struct AVLNode* right;//右子节点指针int height; // 节点高度（用于计算平衡因子）
  } AVLNode;// 辅助函数：获取节点高度
  int height(AVLNode* node) {return node ? node->height : 0;
  }// 辅助函数：计算平衡因子（左子树高度 - 右子树高度）
  //bf>1 左子树过高，需右旋
  //bf<1 右子树过高，需左旋
  int balanceFactor(AVLNode* node) 
  {return node ? height(node->left) - height(node->right) : 0;
  }// 辅助函数：更新节点高度
  //节点高度 = 左右子树中较高的高度 + 1
  //调用时机：插入、删除或旋转后需更新高度
  void updateHeight(AVLNode* node) 
  {if (node) {int leftHeight = height(node->left);int rightHeight = height(node->right);node->height = (leftHeight > rightHeight ? leftHeight : rightHeight) + 1;}
  }// 右旋操作（处理左左失衡）
  AVLNode* rightRotate(AVLNode* y) 
  {AVLNode* x = y->left;AVLNode* T2 = x->right;// 执行旋转x->right = y;y->left = T2;// 更新高度updateHeight(y);updateHeight(x);return x;
  }// 左旋操作（处理右右失衡）
  AVLNode* leftRotate(AVLNode* x) {AVLNode* y = x->right;AVLNode* T2 = y->left;// 执行旋转y->left = x;x->right = T2;// 更新高度updateHeight(x);updateHeight(y);return y;
  }// 平衡节点（四种失衡情况处理）
  AVLNode* balanceNode(AVLNode* node) {if (!node) return NULL;// 更新高度updateHeight(node);// 检查平衡因子int bf = balanceFactor(node);// 左左失衡if (bf > 1 && balanceFactor(node->left) >= 0)return rightRotate(node);// 右右失衡if (bf < -1 && balanceFactor(node->right) <= 0)return leftRotate(node);// 左右失衡if (bf > 1 && balanceFactor(node->left) < 0) {node->left = leftRotate(node->left);return rightRotate(node);}// 右左失衡if (bf < -1 && balanceFactor(node->right) > 0) {node->right = rightRotate(node->right);return leftRotate(node);}return node;
  }// 插入节点
  AVLNode* insert(AVLNode* node, int key) {// 执行标准BST插入if (!node) {AVLNode* newNode = (AVLNode*)malloc(sizeof(AVLNode));newNode->key = key;newNode->left = newNode->right = NULL;newNode->height = 1;return newNode;}if (key < node->key)node->left = insert(node->left, key);else if (key > node->key)node->right = insert(node->right, key);elsereturn node; // 不允许重复键// 平衡当前节点return balanceNode(node);
  }// 找到最小值节点（用于删除操作）
  AVLNode* minValueNode(AVLNode* node) {while (node->left)node = node->left;return node;
  }// 删除节点
  AVLNode* deleteNode(AVLNode* root, int key) {if (!root) return root;// 执行标准BST删除if (key < root->key)//无左子节点，用右子节点替换root->left = deleteNode(root->left, key);else if (key > root->key)//无右子节点，用左子节点替换root->right = deleteNode(root->right, key);else //两个子节点，用右子树的最小节点替换当前值，再递归删除该最小节点{if (!root->left || !root->right) {AVLNode* temp = root->left ? root->left : root->right;if (!temp) {temp = root;root = NULL;}else*root = *temp; // 复制内容free(temp);}else {AVLNode* temp = minValueNode(root->right);root->key = temp->key;root->right = deleteNode(root->right, temp->key);}}if (!root) return root;// 平衡当前节点return balanceNode(root);
  }// 中序遍历
  void inOrder(AVLNode* root) 
  {if (root) {inOrder(root->left);printf("%d ", root->key);inOrder(root->right);}
  }// 释放内存
  void freeTree(AVLNode* root) {if (root) {freeTree(root->left);freeTree(root->right);free(root);}
  }// 测试用例
  int main() {AVLNode* root = NULL;// 测试插入root = insert(root, 10);root = insert(root, 20);root = insert(root, 30);  // 触发左旋root = insert(root, 40);root = insert(root, 50);root = insert(root, 25);  // 触发右左旋printf("中序遍历结果: ");inOrder(root);  // 输出: 10 20 25 30 40 50printf("\n");// 测试删除root = deleteNode(root, 30);printf("删除30后遍历: ");inOrder(root);  // 输出: 10 20 25 40 50printf("\n");freeTree(root);return 0;
  }

  

• 示例代码：C++ STL的std::map（红黑树实现）

• #include <iostream>
  #include <map>
  #include <string>using namespace std;int main() {// 创建一个空的map，键类型为int，值类型为stringmap<int, string> studentMap;// 插入元素的三种方式// 1. 使用insert和pairstudentMap.insert(pair<int, string>(101, "Alice"));// 2. 使用insert和make_pairstudentMap.insert(make_pair(102, "Bob"));// 3. 使用emplace（C++11+更高效的方式）studentMap.emplace(103, "Charlie");studentMap.emplace(105, "Eva");studentMap.emplace(104, "David");// 遍历map（自动按键升序排列）cout << "学生列表（学号顺序）：" << endl;for (const auto& pair : studentMap) {cout << "学号：" << pair.first << "\t姓名：" << pair.second << endl;}/* 输出：学号：101    姓名：Alice学号：102    姓名：Bob学号：103    姓名：Charlie学号：104    姓名：David学号：105    姓名：Eva*/// 查找元素int searchId = 103;auto it = studentMap.find(searchId);if (it != studentMap.end()) {cout << "\n找到学生：" << endl<< "学号：" << it->first << "\t姓名：" << it->second << endl;} else {cout << "\n未找到学号：" << searchId << endl;}// 删除元素int deleteId = 102;if (studentMap.erase(deleteId)) {cout << "\n已删除学号：" << deleteId << endl;} else {cout << "\n删除失败，学号不存在：" << deleteId << endl;}// 修改元素studentMap[104] = "Daniel";  // 通过键直接访问studentMap.at(101) = "Alex"; // 安全访问方式（会检查键是否存在）// 检查元素存在性cout << "\n104号学生存在性：" << (studentMap.count(104) ? "存在" : "不存在") << endl;// 显示修改后的mapcout << "\n更新后的学生列表：" << endl;for (auto iter = studentMap.begin(); iter != studentMap.end(); ++iter) {cout << "学号：" << iter->first << "\t姓名：" << iter->second << endl;}/* 输出：学号：101    姓名：Alex学号：103    姓名：Charlie学号：104    姓名：Daniel学号：105    姓名：Eva*/// 获取map信息cout << "\nMap大小：" << studentMap.size() << endl;cout << "最大容量：" << studentMap.max_size() << endl;cout << "是否为空：" << (studentMap.empty() ? "是" : "否") << endl;return 0;
  }

  

c. B树/B+树

• 原理：多路平衡树，减少磁盘I/O。

• B树特点：内部节点存储数据，适合文件系统。

• B+树特点：数据仅存于叶子节点，叶子形成链表，适合数据库索引。

• 示例代码：

• #include <stdio.h>
  #include <stdlib.h>
  #include <stdbool.h>#define MAX_ORDER 3  
  #define MIN_KEYS (MAX_ORDER/2)typedef struct BPlusTreeNode Node;struct BPlusTreeNode {int is_leaf;        int num_keys;       int keys[MAX_ORDER];union {Node **children; // 内部节点子节点指针（数组）void *values[MAX_ORDER]; // 叶子节点值指针（数组，修正此处）};Node *next; 
  };typedef struct {Node *root;
  } BPlusTree;Node* create_node(int is_leaf) {Node *node = (Node*)malloc(sizeof(Node));node->is_leaf = is_leaf;node->num_keys = 0;node->next = NULL;if (!is_leaf) { // 内部节点初始化子节点数组node->children = (Node**)malloc((MAX_ORDER + 1) * sizeof(Node*));for (int i = 0; i < MAX_ORDER + 1; i++) {node->children[i] = NULL;}}// 叶子节点的values数组无需手动初始化，malloc已分配内存return node;
  }Node* find_leaf(Node *root, int key) {// 无需修改if (!root) return NULL;Node *current = root;while (!current->is_leaf) {int i = 0;while (i < current->num_keys && key >= current->keys[i]) i++;current = current->children[i];}return current;
  }void insert_into_leaf(Node *leaf, int key, void *value) {int pos = 0;while (pos < leaf->num_keys && leaf->keys[pos] < key) pos++;// 移动键和值（修正为操作数组）for (int i = leaf->num_keys; i > pos; i--) {leaf->keys[i] = leaf->keys[i-1];leaf->values[i] = leaf->values[i-1]; // 操作数组元素}leaf->keys[pos] = key;leaf->values[pos] = value; // 存入数组对应位置leaf->num_keys++;
  }Node* split_leaf(Node *leaf) {Node *new_leaf = create_node(true);int split_pos = leaf->num_keys / 2;// 复制后半部分键和值到新节点（修正为数组操作）for (int i = split_pos; i < leaf->num_keys; i++) {new_leaf->keys[i - split_pos] = leaf->keys[i];new_leaf->values[i - split_pos] = leaf->values[i]; // 复制数组元素}new_leaf->num_keys = leaf->num_keys - split_pos;leaf->num_keys = split_pos;new_leaf->next = leaf->next;leaf->next = new_leaf;return new_leaf;
  }void insert(BPlusTree *tree, int key, void *value) {// 逻辑无需修改，但需确保values是数组if (!tree->root) {tree->root = create_node(true);insert_into_leaf(tree->root, key, value);return;}Node *leaf = find_leaf(tree->root, key);insert_into_leaf(leaf, key, value);if (leaf->num_keys == MAX_ORDER) {Node *new_leaf = split_leaf(leaf);int new_key = new_leaf->keys[0];Node *new_root = create_node(false);new_root->keys[0] = new_key;new_root->children[0] = leaf;new_root->children[1] = new_leaf;new_root->num_keys = 1;tree->root = new_root;}
  }void* search(BPlusTree *tree, int key) {if (!tree->root) return NULL;Node *leaf = find_leaf(tree->root, key);for (int i = 0; i < leaf->num_keys; i++) {if (leaf->keys[i] == key) {return leaf->values[i]; // 返回数组元素}}return NULL;
  }void print_tree(Node *node, int level) {// 无需修改if (!node) return;printf("Level %d: ", level);for (int i = 0; i < node->num_keys; i++) {printf("%d ", node->keys[i]);}printf("\n");if (!node->is_leaf) {for (int i = 0; i <= node->num_keys; i++) {print_tree(node->children[i], level + 1);}}
  }int main() {BPlusTree tree = {0};// 插入时仍需强制转换（C语言字符串字面量为const char*）insert(&tree, 5, (void*)"Apple");insert(&tree, 8, (void*)"Banana");insert(&tree, 3, (void*)"Cherry");insert(&tree, 7, (void*)"Date");insert(&tree, 12, (void*)"Fig");insert(&tree, 6, (void*)"Grape");printf("B+树结构：\n");print_tree(tree.root, 0);int keys[] = {5, 7, 10};for (int i = 0; i < 3; i++) {void *result = search(&tree, keys[i]);if (result) {printf("键 %d 找到值：%s\n", keys[i], (char*)result);} else {printf("键 %d 未找到\n", keys[i]);}}return 0;
  }

  

d. 哈希表

• 原理：通过哈希函数直接定位存储位置。

• 时间复杂度：平均 𝑂(1)O(1)，最坏 𝑂(𝑛)O(n)（冲突严重时）。

• 代码示例（开放寻址法）：

  #define HASH_SIZE 10007int hash(int key) { return key % HASH_SIZE; }int hash_search(int* table, int key) {int index = hash(key);while (table[index] != -1) { // -1表示空槽if (table[index] == key) return index;index = (index + 1) % HASH_SIZE; // 线性探测}return -1;
  }

四、方法选择策略

需求	推荐方法
数据静态，需快速查找	二分查找、插值查找
数据动态，频繁增删	平衡树（AVL/红黑树）、B+树
精确匹配，高速访问	哈希表
范围查询	B+树（叶子链表支持顺序访问）
内存受限环境	跳表（比平衡树更简单）

五、性能对比

方法	插入/删除时间复杂度	查找时间复杂度	空间复杂度	适用场景
二分查找	-	𝑂(log⁡𝑛)O(logn)	𝑂(1)O(1)	静态有序数组
二叉搜索树	𝑂(𝑛)O(n)（最坏）	𝑂(𝑛)O(n)	𝑂(𝑛)O(n)	小规模动态数据
AVL树	𝑂(log⁡𝑛)O(logn)	𝑂(log⁡𝑛)O(logn)	𝑂(𝑛)O(n)	严格平衡场景
红黑树	𝑂(log⁡𝑛)O(logn)	𝑂(log⁡𝑛)O(logn)	𝑂(𝑛)O(n)	通用动态数据
哈希表	𝑂(1)O(1)（平均）	𝑂(1)O(1)	𝑂(𝑛)O(n)	精确匹配、无范围查询

六、实际应用案例

1. 数据库索引

   • B+树：MySQL的InnoDB引擎使用B+树索引，支持范围查询和高效磁盘访问。

   • 哈希索引：Memcached通过哈希表实现键值快速存取。

2. 文件系统

   • B树：NTFS文件系统用B树管理文件元数据，加速目录查找。

3. 编程语言标准库

   • 红黑树：C++的std::map、Java的TreeMap基于红黑树实现有序键值对。

   • 哈希表：Python的字典（dict）采用哈希表，支持平均 𝑂(1)O(1) 的查找。

七、总结

• 静态查找：适用于数据固定的场景，以预处理（如排序）换取高效查询，典型方法为二分查找。

• 动态查找：适用于数据频繁变动的场景，通过动态平衡结构（如AVL树、B+树）维护操作效率。

选择原则：根据数据变动频率、查询模式（精确/范围）、内存/磁盘访问特点综合选择。例如，数据库系统常组合使用B+树（范围查询）和哈希索引（精确匹配）以满足不同需求。