数据结构 查找

最新推荐文章于 2024-06-05 10:49:28 发布
最新推荐文章于 2024-06-05 10:49:28 发布
阅读量1.5k 收藏 14
点赞数 2
分类专栏： 数据结构 文章标签： 数据结构 散列表 b树 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52847866/article/details/131577447
版权

一.查找的基本概念

在计算机科学中，查找是一种在数据结构中寻找特定值的过程。在编程中，查找可以用于在数组、列表、树等数据结构中搜索特定值。不同的查找算法有不同的时间和空间复杂度，因此在选择查找算法时需要根据数据结构和查询需求来权衡时间和空间复杂度。

常见的查找算法包括线性查找、二分查找、哈希表查找、二叉搜索树查找等。其中，线性查找是最简单的查找算法，但时间复杂度较高为O(n)。二分查找适用于有序数组，时间复杂度为O(log n)。哈希表查找和二叉搜索树查找能够在O(1)或O(log n)的时间内完成查找，但需要额外的空间来存储哈希表或二叉搜索树。

在实际应用中，可以根据数据的大小、查询频率、插入和删除的操作频率等因素来选择不同的查找算法。

二. 查找方法

以下是对每种查找方法的补全和C语言示例代码，并对代码进行逐行分析。

顺序查找

顺序查找是一种简单的查找方法，它按顺序逐个比较待查找元素与数据结构中的元素，直到找到匹配的元素或遍历完整个数据结构。

C语言示例代码：
#include <stdio.h>

int sequentialSearch(int arr[], int n, int key) {
    int i;
    for (i = 0; i < n; i++) {
        if (arr[i] == key) {
            return i;  // 返回元素在数组中的索引
        }
    }
    return -1;  // 没有找到元素，返回-1
}

int main() {
    int arr[] = {4, 2, 7, 1, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    int key = 7;
    int result = sequentialSearch(arr, n, key);
    if (result == -1) {
        printf("元素 %d 未找到\n", key);
    } else {
        printf("元素 %d 的索引为 %d\n", key, result);
    }
    return 0;
}
代码分析：
  • sequentialSearch 函数接受一个数组 arr、数组长度 n 和待查找的关键字 key 作为参数。
  • 通过 for 循环逐个比较数组元素和关键字，如果找到匹配的元素，返回该元素在数组中的索引。
  • 如果遍历完整个数组都没有找到匹配的元素，函数返回 -1。
  • 在 main 函数中，定义一个整型数组 arr 并初始化。
  • 通过 sizeof 运算符计算数组的长度，并将其除以 sizeof(arr[0]) 得到元素个数。
  • 定义关键字 key，调用 sequentialSearch 函数进行查找，并将结果存储在 result 变量中。
  • 最后根据 result 的值输出查找结果。

分块查找

分块查找又称为索引顺序查找，它将数据结构分为若干块，每块中的元素可以是无序的，但块与块之间必须按照关键字的大小有序排列。

C语言示例代码：
#include <stdio.h>

// 分块查找
int blockSearch(int blocks[], int indices[], int n, int m, int key) {
    int i, j;
    for (i = 0; i < n; i++) {
        if (key <= indices[i]) {
            break;  // 找到对应的块
        }
    }
    if (i == n) {
        return -1;  // 关键字超出范围，未找到
    }
    int start = (i == 0) ? 0 : blocks[i-1];  // 块的起始位置
    int end = blocks[i];  //

块的结束位置
    for (j = start; j < end; j++) {
        if (key == blocks[j]) {
            return j;  // 在块中找到关键字，返回索引
        }
    }
    return -1;  // 在块中未找到关键字，返回-1
}

int main() {
    int blocks[] = {2, 6, 8, 12, 15};
    int indices[] = {4, 9, 14, 17, 20};
    int n = sizeof(blocks) / sizeof(blocks[0]);
    int m = sizeof(indices) / sizeof(indices[0]);
    int key = 12;
    int result = blockSearch(blocks, indices, n, m, key);
    if (result == -1) {
        printf("元素 %d 未找到\n", key);
    } else {
        printf("元素 %d 的索引为 %d\n", key, result);
    }
    return 0;
}
代码分析：
  • blockSearch 函数接受两个数组 blocks 和 indices，分别表示块中的元素和块的索引，以及两个整数 n 和 m 分别表示块的数量和索引的数量，还有待查找的关键字 key。
  • 通过 for 循环找到关键字所在的块，如果关键字超出范围，则返回 -1。
  • 根据块的索引计算出块的起始位置 start 和结束位置 end。
  • 在块中使用 for 循环逐个比较元素和关键字，如果找到匹配的元素，返回该元素在块中的索引。
  • 如果在块中未找到匹配的元素，则返回 -1。
  • 在 main 函数中，定义两个数组 blocks 和 indices 并初始化。
  • 通过 sizeof 运算符计算数组的长度，并将其除以 sizeof(blocks[0]) 得到元素个数。
  • 定义关键字 key，调用 blockSearch 函数进行查找，并将结果存储在 result 变量中。
  • 最后根据 result 的值输出查找结果。

折半查找

折半查找也称为二分查找，它要求数据结构中的元素必须按照关键字的大小有序排列，通过将待查找范围逐渐缩小一半来快速定位目标元素。

C语言示例代码：
#include <stdio.h>

// 折半查找
int binarySearch(int arr[], int low, int high, int key) {
    while (low <= high) {
        int mid = (low + high) / 2;
        if (arr[mid] == key) {
            return mid;  // 找到关键字，返回索引
        } else if (arr[mid] < key) {
            low = mid + 1;  // 关键字在右半部分
        } else {
            high = mid - 1;  // 关键字在左

半部分
        }
    }
    return -1;  // 未找到关键字，返回-1
}

int main() {
    int arr[] = {1, 2, 4, 5, 7};
    int n = sizeof(arr) / sizeof(arr[0]);
    int key = 4;
    int result = binarySearch(arr, 0, n-1, key);
    if (result == -1) {
        printf("元素 %d 未找到\n", key);
    } else {
        printf("元素 %d 的索引为 %d\n", key, result);
    }
    return 0;
}
代码分析：
  • binarySearch 函数接受一个有序数组 arr、查找范围的起始位置 low 和结束位置 high，以及待查找的关键字 key。
  • 使用 while 循环进行折半查找，循环条件是起始位置小于等于结束位置。
  • 在循环中，通过计算中间位置 mid，并将其与关键字进行比较。
  • 如果中间位置的元素等于关键字，返回该元素的索引。
  • 如果中间位置的元素小于关键字，则将起始位置 low 更新为 mid + 1，以缩小查找范围至右半部分。
  • 如果中间位置的元素大于关键字，则将结束位置 high 更新为 mid - 1，以缩小查找范围至左半部分。
  • 如果循环结束仍未找到关键字，则返回 -1。
  • 在 main 函数中，定义一个有序数组 arr 并初始化。
  • 通过 sizeof 运算符计算数组的长度，并将其除以 sizeof(arr[0]) 得到元素个数。
  • 定义关键字 key，调用 binarySearch 函数进行查找，并将结果存储在 result 变量中。
  • 最后根据 result 的值输出查找结果。

树型查找

树型查找方法基于树的结构，通过利用树的特性来提高查找效率。其中常用的树型查找方法包括二叉搜索树、平衡二叉树和红黑树。

二叉搜索树

二叉搜索树（Binary Search Tree，BST）是一种二叉树，它满足以下性质：

  • 左子树上的所有节点的关键字都小于根节点的关键字。
  • 右子树上的所有节点的关键字都大于根节点的关键字。
  • 左子树和右子树也都是二叉搜索树。
C语言示例代码：
#include <stdio.h>
#include <stdlib.h>

struct Node {
    int key;
    struct Node* left;
    struct Node* right;
};

// 创建新节点
struct Node* createNode(int key) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->key = key

;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

// 插入节点
struct Node* insertNode(struct Node* root, int key) {
    if (root == NULL) {
        return createNode(key);
    }
    if (key < root->key) {
        root->left = insertNode(root->left, key);
    } else if (key > root->key) {
        root->right = insertNode(root->right, key);
    }
    return root;
}

// 在二叉搜索树中查找关键字
struct Node* searchNode(struct Node* root, int key) {
    if (root == NULL || root->key == key) {
        return root;
    }
    if (key < root->key) {
        return searchNode(root->left, key);
    } else {
        return searchNode(root->right, key);
    }
}

int main() {
    struct Node* root = NULL;
    root = insertNode(root, 4);
    insertNode(root, 2);
    insertNode(root, 7);
    insertNode(root, 1);
    insertNode(root, 5);
    
    int key = 7;
    struct Node* result = searchNode(root, key);
    if (result == NULL) {
        printf("元素 %d 未找到\n", key);
    } else {
        printf("元素 %d 已找到\n", key);
    }
    
    return 0;
}
代码分析：
  • 定义一个结构体 Node 表示二叉搜索树的节点，其中包含关键字 key，左子节点 left 和右子节点 right。
  • 创建一个新节点的函数 createNode 接受一个关键字 key，分配内存并初始化节点的值和子节点指针，然后返回该节点的指针。
  • 插入节点的函数 insertNode 接受根节点 root 和关键字 key，如果根节点为空，则创建一个新节点并将其作为根节点返回。
  • 如果关键字小于根节点的值，则将关键字插入左子树中。
  • 如果关键字大于根节点的值，则将关键字插入右子树中。
  • 查找关键字的函数 searchNode 接受根节点 root 和关键字 key，如果根节点为空或关键字等于根节点的值，则返回根节点。
  • 如果关键字小于根节点的值，则在左子树中继续查找。
  • 如果关键字大于根节点的值，则在右子树中继续查找。
  • 在 main 函数中，定义根节点 root 并初始化为空。
  • 使用 insertNode 函数插入一些关键字构建二叉搜索树。
  • 定义待查找的关键字 key，调用 searchNode 函数进行查找，并将结果存储在 result 变量中。
  • 最后根据 result 的值输出查找结果。
平衡二叉树

平衡二叉树（Balanced Binary Tree），也称为AVL树，是

一种特殊的二叉搜索树，它的左子树和右子树的高度差不超过1，以保持树的平衡。

C语言示例代码：
#include <stdio.h>
#include <stdlib.h>

struct Node {
    int key;              // 键值
    struct Node* left;    // 左子节点指针
    struct Node* right;   // 右子节点指针
    int height;           // 节点的高度
};

// 计算节点的高度
int getHeight(struct Node* node) {
    if (node == NULL) {
        return 0;
    }
    return node->height;
}

// 计算节点的平衡因子
int getBalanceFactor(struct Node* node) {
    if (node == NULL) {
        return 0;
    }
    return getHeight(node->left) - getHeight(node->right);
}

// 创建新节点
struct Node* createNode(int key) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->key = key;
    newNode->left = NULL;
    newNode->right = NULL;
    newNode->height = 1;
    return newNode;
}

// 执行右旋操作
struct Node* rightRotate(struct Node* y) {
    struct Node* x = y->left;
    struct Node* T2 = x->right;

    // 右旋操作
    x->right = y;
    y->left = T2;

    // 更新节点的高度
    y->height = 1 + ((getHeight(y->left) > getHeight(y->right)) ? getHeight(y->left) : getHeight(y->right));
    x->height = 1 + ((getHeight(x->left) > getHeight(x->right)) ? getHeight(x->left) : getHeight(x->right));

    return x;
}

// 执行左旋操作
struct Node* leftRotate(struct Node* x) {
    struct Node* y = x->right;
    struct Node* T2 = y->left;

    // 左旋操作
    y->left = x;
    x->right = T2;

    // 更新节点的高度
    x->height = 1 + ((getHeight(x->left) > getHeight(x->right)) ? getHeight(x->left) : getHeight(x->right));
    y->height = 1 + ((getHeight(y->left) > getHeight(y->right)) ? getHeight(y->left) : getHeight(y->right));

    return y;
}

// 在平衡二叉树中插入节点
struct Node* insertNode(struct Node* root, int key) {
    if (root == NULL) {
        return createNode(key);
    }
    if (key < root->key) {
        root->left = insertNode(root->left, key);
    } else if (key > root->key) {
        root->right = insertNode(root->right, key);
    } else {
        return root;  // 重复的关键字，不插入
    }

    // 更新节点的高度
    root->height = 1 + ((getHeight(root->left) > getHeight(root->right)) ? getHeight(root->left) : getHeight(root->right));

    int balanceFactor = getBalanceFactor(root);

    // 左子树的高度大于右子树的高度，不平衡的情况下，需要进行旋转操作
    if (balanceFactor > 1 && key < root->left->key) {
        return rightRotate(root);
    }

    // 右子树的高度大于左子树的高度，不平衡的情况下，需要进行旋转操作
    if (balanceFactor < -1 && key > root->right->key) {
        return leftRotate(root);
    }

    // 左子树的高度大于右子树的高度，但插入节点的键值大于左子节点的键值，不平衡的情况下，需要进行先左旋再右旋的操作
    if (balanceFactor > 1 && key > root->left->key) {
        root->left = leftRotate(root->left);
        return rightRotate(root);
    }

    // 右子树的高度大于左子树的高度，但插入节点的键值小于右子节点的键值，不平衡的情况下，需要进行先右旋再左旋的操作
    if (balanceFactor < -1 && key < root->right->key) {
        root->right = rightRotate(root->right);
        return leftRotate(root);
    }

    return root;
}

// 中序遍历打印二叉树
void inOrder(struct Node* root) {
    if (root == NULL) {
        return;
    }
    inOrder(root->left);
    printf("%d ", root->key);
    inOrder(root->right);
}

int main() {
    struct Node* root = NULL;
    
    // 插入节点
    root = insertNode(root, 10);
    root = insertNode(root, 20);
    root = insertNode(root, 30);
    root = insertNode(root, 40);
    root = insertNode(root, 50);
    root = insertNode(root, 25);
    
    printf("Inorder traversal of the AVL tree: ");
    inOrder(root);
    
    return 0;
}
红黑树 (Red-Black Tree):

红黑树是一种自平衡的二叉搜索树，具有以下特性：

  1. 每个节点要么是红色，要么是黑色。
  2. 根节点是黑色。
  3. 所有叶子节点（NULL节点）都是黑色。
  4. 如果一个节点是红色，那么它的两个子节点都是黑色。
  5. 从任意节点到其每个叶子节点的所有路径都包含相同数目的黑色节点。

红黑树通过这些特性保持平衡，确保在最坏情况下，插入、删除和搜索操作的时间复杂度都为O(log n)。

B树和B+树:

B树和B+树是一种多路搜索树，用于在大量数据中进行高效的查找。

B树和B+树具有以下特性：

  1. 每个节点可以包含多个键值对，且按照键值的顺序排列。
  2. 内部节点包含的键值对数量比子节点数量少一个。
  3. 所有叶子节点都在同一层级，且通过指针连接。
  4. B树允许在非叶子节点中存储键值对，而B+树只在叶子节点中存储键值对。
  5. B树和B+树通过调整节点的分裂和合并来保持平衡。

B树和B+树适用于需要高效处理大量数据的场景，如数据库系统和文件系统索引。

散列表 (Hash Table):

散列表是一种数据结构，将键值对存储在数组中，并通过散列函数将键映射到数组索引上。

散列表具有以下特性：

  1. 通过散列函数将键转换为数组索引。
  2. 使用数组存储键值对，称为哈希表。
  3. 解决冲突的方法包括开放寻址法和链表法。
  4. 散列函数应该具有良好的散列性能，尽量避免冲突。

散列表提供了快速的插入、删除和查找操作，平均情况下时间复杂度为O(1)，但最坏情况下可能为O(n)。

查找算法的分析以及应用:

查找算法用于在数据集合中查找特定元素的位置或判断元素是否存在。

常见的查找算法包括线性查找、二分查找、哈希查找和树查找。

线性查找是最简单的查找算法，逐个比较元素直到找到目标元素或遍历完整个集合。时间复杂度为O(n)。

二分查找是一种在有序数组中查找目标

元素的高效算法。通过将数组分成两部分，并使用中间元素与目标元素进行比较，可以排除一半的元素，从而快速定位目标元素。时间复杂度为O(log n)。

哈希查找利用散列表来存储和查找元素，通过散列函数将键映射到数组索引上，从而实现快速的查找操作。平均情况下时间复杂度为O(1)，但最坏情况下可能为O(n)。

树查找包括二叉搜索树、平衡二叉搜索树（如红黑树和AVL树）、B树和B+树等。这些树结构通过按照特定规则组织元素，可以快速进行查找操作。时间复杂度通常为O(log n)。

这些查找算法在不同的应用场景中发挥着重要的作用。例如，在数据库系统中，使用索引结构（如B+树）来加速数据的查找操作。在字典或词典应用中，可以使用哈希表来实现快速的单词查找。在排序和搜索问题中，二分查找算法可以大大减少比较的次数，提高效率。

下面是一个使用二分查找算法在有序数组中查找目标元素的C语言代码示例：

#include <stdio.h>

int binarySearch(int arr[], int low, int high, int target) {
    while (low <= high) {
        int mid = low + (high - low) / 2;
        
        if (arr[mid] == target) {
            return mid;
        }
        
        if (arr[mid] < target) {
            low = mid + 1;
        } else {
            high = mid - 1;
        }
    }
    
    return -1; // Target element not found
}

int main() {
    int arr[] = {2, 5, 8, 12, 16, 23, 38, 56, 72, 91};
    int n = sizeof(arr) / sizeof(arr[0]);
    int target = 23;
    
    int index = binarySearch(arr, 0, n - 1, target);
    
    if (index != -1) {
        printf("Element found at index %d\n", index);
    } else {
        printf("Element not found\n");
    }
    
    return 0;
}

以上代码演示了如何使用二分查找算法在有序数组中查找目标元素。

雪落之下
关注
  • 2
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——查找最全总结（期末复习必备）
weixin_65049289的博客
12-16 3364
数据结构——查找最全总结（期末复习必备）
数据结构——查找
m0_70403090的博客
06-20 1659
若左子树非空，则左子树上所有结点的值均小于根结点的值；若右子树非空，则右子树上所有结点的值均大于根结点的值；左右子树也是一棵二叉排序树==（左小右大）==对二叉排序树进行中序遍历就得到一个递增的有序序列。
【数据结构】查找（顺序查找、二分查找、索引顺序查找、二叉排序树、平衡排序树、B树、B+树、哈希表）
最新发布
ChenZHIHAO_y的博客
06-05 995
查找（顺序查找、二分查找、索引顺序查找、二叉排序树、平衡排序树、B树、B+树、哈希表）
数据结构-查找
weixin_43735634的博客
04-01 2550
数据结构-查找 查找基本概念 1.查找：在数据集合中寻找满足要求的的数据元素成为查找，查找有两种结果1.查找成功，找到目标元素；2.查找失败，遍历完集合仍未找到目标元素。 2.查找表：用于查找的数据集合叫做查找表，由同一类型的数据元素组成。对查找表的操作一般有四种1.查找某个元素是否在查找表中 2.访问目标元素 3.向查找表中插入元素 4.从查找表中删除元素。 查找的类别 顺序查找 顺序查找又叫线性查找，从线性表的一端顺序查找到另一端。顺序查找既可用于顺序表，也适用于链表。当被查找的线性表有序时，则不必一一
数据结构之查找(一)——基本概念
daocaoren_的博客
08-09 692
在哪里查找？——查找表 查找表是由同一类型的数据元素(或记录)构成的集合。由于“集合”中的数据元素之间存在着松散的关系，没有严格的前驱和后继的关系，因此查找表是一种应用灵活的结构。 什么是查找？ 根据给定的某个值，在查找表中确定一个其关键字等于给定值的数据元素(或记录)。 关键字： 用来标识一个数据元素(或记录)的某个数据项的值。 主关键字：可唯一地标识一个记录的关键字 次关键字：用以识...
数据结构学习笔记——查找算法中的线性、散列查找（顺序、折半、分块、散列）
小宇y的博客
11-25 4177
查找可大致分为线性查找、树形查找和散列查找三种，这里只介绍线性查找中的顺序查找、折半和分块查找，散列查找中的散列表（哈希表）。
合工大数据结构查找实验
12-28
合肥工业大学数据结构 查找实验 编写算法实现下列问题的求解。 (1) 对下列数据表，分别采用二分查找算法实现查找，给出查找过程依次所比较的元素，并以二分查找的判定树来解释。 (2) 设计出在二叉排序树中插入结点的...
数据结构查找实验报告.doc
12-15
数据结构查找实验报告详细解析： 本实验主要涵盖了四种基本的查找算法：顺序查找、折半查找、二叉排序树查找以及哈希表查找。这些算法是数据结构中的基础且重要的部分，它们对于理解和优化数据访问效率至关重要。 ...
数据结构查找方法 哈希查找
08-27
数据结构查找方法 哈希查找
数据结构查找
12-12
在计算机科学中，数据结构是组织和存储数据的方式，它直接影响到算法的效率。查找算法是数据结构中的重要组成部分，用于在数据...通过对这两个源代码文件的深入分析和学习，你可以更深入地理解数据结构查找的实践应用。
数据结构查找题目及代码
12-20
实验题目包括1.实现并运行顺序查找。2.实现并运行二分查找。3.根据输入的数字，构造一棵二叉判定树。
边学边记——数据结构☞和搜索有关的数据结构（搜索树，Set，Map，哈希表）
lil_ghost_的博客
05-05 833
虽然哈希表一直在和冲突做斗争，但在实际使用过程中，我们认为哈希表的冲突率是不高的，冲突个数是可控的，也就是每个桶中的链表的长度是一个常数，所以，通常意义下，我们认为哈希表的插入/删除/查找时间复杂度是O(1)。比如在之前的场景，现在需要插入元素44，先通过哈希函数计算哈希地址，下标为4，因此44理论上应该插在该位置，但是该位置已经放了值为4的元素，即发生哈希冲突。对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。
【数据结构】查找算法
qq_45813532的博客
09-03 5312
查找：在数据集合中寻找满足某种条件的数据元素的过程称为查找。 查找表：用于查找的数据集合称为查找表，它由同一类型的数据元素组成，可以是一个数组或链表等数据类型。从名义上来看，查找表是一种新的数据结构，但实际上它指的就是用线性表，树或者图结构来存储数据，只不过数据间的逻辑关系是人为赋予的。数据结构中，将存储无逻辑关系数据的线性表，树或者图结构统称为查找表。查找表常见操作：如果只对查找表做前俩种操作，不改变查找表的存储结构，这样的查找表称为静态查找表；反之，如果对查找表做插入或者删除操作，查找表的结构发生了变化
数据结构例题代码及其讲解-查找和排序
knighthood2001
10-30 949
数据结构例题代码及其讲解-查找与排序
6-4 结构体-查找最低分
Tomatos_baby的博客
05-04 3478
struct student { int num ; char name[20]; int score;}; typedef struct student stu; 有上面面学生记录类型定义， 定义函数在一组学生记录中找成绩最低的学生信息， 最低分唯一 函数接口定义： void fun( stu a[],stu *b ) 数组a里存储N个学生记录，返回值是最低分记录 裁判测试程序样例： 在这里给出函数被调用进行测试的例子。例如： #include <stdio.h&.
数据结构_顺序查找(C语言)
热门推荐
小黯
07-18 1万+
从表的一端开始，依次将表中的关键字和给定的值进行比较，若表中的关键字和给定的值相等，则查找成功，反之查找失败。
数据结构与算法——查找算法
skyshine94的博客
12-05 1033
目录 一、查找算法 1.1 分类 二、线性查找（SequenceSearch） 2.1 基本思想 2.2 线性查找算法实现 三、二分查找（BinarySearch） 3.1 基本思想 3.2 二分查找算法实现 四、插值查找（InterpolationSearch） 4.1 基本思想 4.2 期望索引值公式 4.3 插值查找算法实现 五、斐波那契查找（FibonacciSearch） 5.1 基本介绍 5.2 基本思想 5.3期望索引值公式 5.4 斐波那契查找算法实现 .
数据结构查找详解：从顺序到Hash表
"《数据结构查找学习笔记.pdf》是一份针对已经掌握C语言基础并熟悉数据结构概念的人员编写的参考资料。这份文档深入讲解了查找这一关键主题，包括查找的基本概念、查找方法及其在不同数据结构中的应用。 首先，查找...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值