数据结构：查找的概念和基本算法

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

•在长度为n的有序顺序表List中顺序查找一个目标值=>O(n)

•为什么慢！

•因每次比较判断只排除了一个元素，完全没有利用表的有序性

•二分查找：在比较失效时，利用表的有序性排除待查找元素中的一半

•每次排除一半=>O(lg(n))

•算法流程

        1.用I和r表示待查找范围的左右边界（含），初始时I=0，r=n-1

        2.循环以下操作直至I>r:

                •找到当前搜索范围的正中间：mid=（I+r）/2

                •判断target和List[mid]的关系：

                        •==：找到了结果，返回mid

                        •<:target只可能在mid位置左边，排除mid及其右侧所有元素=>既更新r=mid-1

                        •>:target只可能在mid位置右边，排除mid及其左侧所有元素=>既更新I=mid+1

        3.循环能结束说明数组中不存在target，返回-1

 •牢记：

        •二分查找只能发生在有序数组上

        •时间复杂度为O(lgn)

        •代码较为简单，尽量掌握

*key1:二分查找只能用于有序数组：需要通过下标直接访问元素

1.顺序查找可以用于（C）

A.单链表        B.顺序表        C.顺序表或单链表        D.二叉树

2.对线性表进行二分查找时要求该线性表（B）

A.是单链表，且必须有序

B.是顺序表，且必须有序

C.是顺序表，可以无序

D.是单链表，可以无序

*key2:二分（折半）查找过程：1.找中        2.折半

*key3：二分查找每次排除一半，至多

 

 二.AVL树

二叉搜索树/二叉查找树/二叉排序树

•二叉查找树中的任何一个结点都满足：

        •左子树如果不空，则左子树所有结点都<本结点

        •右子树如果不空，则右子树所有结点都>本结点

•左小右大

•查找目标值：

        •如果target<当前结点，进入左子树

        •如果target>当前结点，进入右子树

        •如果进入空结点表明树中无target

给定序列构造二叉查找树

•给定一个序列{31,25,57,11,44,78,2,49,19}，将其依次插入一颗二叉查找树

•方法：

        •第一个元素为根

        •第二个元素开始，逐个按照小往左往右的原则插至叶子节点

        •每次新插入的元素一定位于叶子

 AVL树（平衡二叉查找树）

•思考：从序列｛1，2，3，4，5...n｝依次插入构造出的二叉查找树长什么样？

•退化成一个单链表，查找目标值的时间复杂度为O（n）

•AVL树：尽量保持一颗二叉查找树的平衡性

        •每一个结点的左右子树的高度差<=1

•方法：

        •如果插入一个结点导致树不平衡，通过旋转调整回平衡

 *key1：二叉查找树中任意结点：>左子树所有结点，<右子树所有结点

*key2：二叉查找树查找：从左往右

*key3：二叉查找树插入：小往左，大往右

  *key4：AVL树：任意结点左右子树高度差<=1

*key5:当插入或删除导致AVL树不平衡则需要进行旋转使其重新平衡

*key6：二叉查找树的中序遍历就是其所有元素的有序序列

 三.哈希表

哈希表（散列表）

•前面介绍的两种查找都需要维持元素的有序性

•但我们只是单纯的想知道，有or没有

•所有可以建立元素值->数组元素的映射，直接判断目标值是否存在结构中

 哈希表冲突

•假设哈希函数为h(x)=x%7

•元素为｛22，6，19，18，2｝，构造了哈希表

•现插入元素为29：

        •计算哈希值h(29)=29%7=1

        •试图将29放入nums【1】，发现nums【1】已经放了22=>产生了冲突

哈希表冲突解决方法1：开放地址法

•假设哈希函数为H（x）=x%7

•元素为｛22，6，19，18，2｝，构造了哈希表：

 •现在插入元素29，哈希值为1，产生了冲突                              线性探测法                  二次探测法 

•开放地址法：产生冲突时使用增量di继续哈希，直至有空位或发现表满了

•hi=（H+di）%m

        1.线性探测：

                        di=1，2，3，4，5.......k（k<m-1）

        2.二次探测：

                        

哈希表冲突解决办法2：链地址法

•链地址法：将哈希值相同的元素存放在同一个单链表中

•h（X）=x%7,依次插入22，6，19，18，2，29，30，42，10，54，50

 哈希表查找时间复杂度

•最理想情况下：哈希函数特别厉害，没有冲突，所有目标值只需一次哈希=>O(1)

•一般情况下：取决于数据元素的分布，哈希函数的设计和冲突解决方法

*key1:哈希函数是一个映射：元素值->哈希值

*key2:不同的元素拥有相同的哈希值：冲突

*key3:哈希函数应尽量能较为均匀地映射元素=>降低冲突概率

 *key4：冲突解决方法：1.开放地址法        2.链地址法

 *key5：线性探测法就是向后逐个位置试

 练习：

 

 

 

 

 

8. 

 

 代码：

/*
查找
*/

#include <cstdio>

/* 二分查找(折半查找) */
// 在长度为N的有序表nums中查找目标值target, 成功返回其下标, 失败返回-1
int BinarySearch(int *nums, int N, int target) {
    // 在查找过程中, r和l一直是当前查找范围的左右界, 即nums[r]也是待搜索的
    int l = 0, r = N - 1;
    while (l <= r) {  // 出口条件是l>r, 因l==r时, l位置还没被搜索, 还需再搜一次
        int mid = (l + r) / 2;
        if (target == nums[mid]) {
            return mid;
        }
        if (target < nums[mid]) {
            r = mid - 1;  // mid该被排除出查找范围了,所以r = mid - 1
        } else {
            l = mid + 1;  // +1同理
        }
    }

    // 循环结束了都没return说明数组内没有target
    return -1;
}

// 该函数和上一函数的区别在于nums[r]定义为搜索范围外的上界
// 即nums[r]已经被排除了而nums[r-1]还在待搜索范围内, 这两种写法都可以,
// 但注意其区别
int BinarySearch2(int *nums, int N, int target) {
    // 在查找过程中, nums[l]仍是待搜索元素，nums[r]不是待搜索元素
    int l = 0, r = N;
    while (l < r) {  // 出口条件是l==r, 因这意味着没有可以搜索的元素了
        int mid = (l + r) / 2;
        if (target == nums[mid]) {
            return mid;
        }
        if (target < nums[mid]) {
            r = mid;  // mid被排除出查找范围了,所以r = mid
        } else {
            l = mid + 1;
        }
    }

    // 循环结束了都没return说明没有target
    return -1;
}

/* 二叉查找树查找目标值 */
// 二叉树结构
typedef struct TreeNode {
    int data;
    struct TreeNode *left;
    struct TreeNode *right;
} TreeNode;

// 存在目标元素返回其指针，不存在则返回NULL
TreeNode *SearchTree(TreeNode *root, int target) {
    if (!root) {
        return NULL;  // 树为空
    }

    TreeNode *cur = root;  // cur始终表示当前搜索结点
    while (cur) {
        if (target == cur->data) {
            return cur;
        }
        if (target < cur->data) {
            cur = cur->left;  // 小进左
        } else {
            cur = cur->right;  // 大进右
        }
    }

    return NULL;  // 循环能结束说明树中没有目标值
}

int main() {
    int nums[10] = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
    printf("search for 5: %d\n", BinarySearch(nums, 10, 5));
    printf("search for 13: %d\n", BinarySearch2(nums, 10, 13));
    printf("search for 8: %d\n", BinarySearch(nums, 10, 8));
    printf("search for 8: %d\n", BinarySearch2(nums, 10, 8));
}