【数据结构】查找

查找

基本概念

在数据集合中寻找满足某种条件的数据元素的过程称为查找

• 查找表：静态查找表，动态查找表
• 平均查找长度

$$\begin{gathered} ASL=\sum _{i=1}^n{P}_i{C}_i \\ n:查找表的长度 \\ {P}_i:查找第i个数据元素的概率 \\ {C}_i:找到第i个数据元素所需进行的比较次数 \end{gathered}$$

顺序查找（线性查找）

简介

适用于顺序表或链表。

对于顺序表，可以通过数组下标递增来顺序扫描每个元素；

对于链表，可以通过next指针来依次扫描每个元素。

代码实现

c++实现顺序表查找

template <typename T>
int sequential_serch(T arr[], int len, T key)
{
    for (int i = 0; i < len; i++)
    {
        if (arr[i] == key)
        {
            return i;
        }
    }
    return -1;
}

python实现顺序表查找

def sequential_serch(arr: list, key) -> int:
    for i in range(len(arr)):
        if arr[i] == key:
            return i
    return -1

c/c++实现链表查找

typedef int ElemType;

typedef struct LNode
{
    ElemType data;
    LNode *next;
} LNode, *LinkList;

void init(LinkList ll, ElemType a[], int len)
{
    LNode *t = ll;
    for (int i = 0; i < len; i++)
    {
        LNode *p = new LNode;
        p->data = a[i];
        p->next = NULL;
        t->next = p;
        t = p;
    }
}

LNode *sequential_serch(LinkList ll, ElemType key)
{
    LNode *p = ll->next;
    while (p != NULL)
    {
        if (p->data == key)
        {
            return p;
        }
        p = p->next;
    }
    return NULL;
}

python实现链表查找

class LNode:
    def __init__(self, data) -> None:
        self.data = data
        self.next: LNode = None


class LinkList:
    def __init__(self, arr: list) -> None:
        self.head = LNode(arr[0])
        p = self.head
        for i in range(1, len(arr)):
            p.next = LNode(arr[i])
            p = p.next


def sequential_serch(ll: LinkList, key) -> LNode:
    p = ll.head
    while p is not None:
        if p.data == key:
            return p
        p = p.next
    return None

分析

对于有$n$个元素的查找表，给定值$key$与表中第$i$个元素相等，需要进行$i+1$次关键字的比较，即$C_i=i+1$，当每个元素查找概率相同时，$P_i=\frac{1}{n}$，有
$$AS{L}_{成功}=\sum _{i=0}^{n-1}\frac{1}{n}(i+1)=\frac{n+1}{2}$$
查找不成功时，需要与表中各个关键字比较，次数为$n$，即
$$AS{L}_{不成功}=n$$
时间复杂度：$O(n)$

折半查找（二分查找）

简介

仅适用于有序的顺序表。

基本思想：

1. 首先将给定值key与表中间位置元素比较，若相等，则返回该元素的存储位置；
2. 如果不相等，则只需要在中间元素以外的前半部分或后半部分，重复以上步骤，直到查找到或者确定表中没有key元素，返回查找不成功。

代码实现

python非递归

def binary_search(arr: list,  key) -> int:
    low = 0
    high = len(arr)-1
    while low <= high:
        mid = (low+high)//2
        if arr[mid] == key:
            return mid
        elif arr[mid] > key:
            high = mid-1
        else:
            low = mid+1
    return -1

python递归

def _binary_serch(arr: list, low: int, high: int, key) -> int:
    if low > high:
        return -1
    mid = (low+high)//2
    if arr[mid] == key:
        return mid
    if arr[mid] > key:
        return _binary_serch(arr, mid+1, high, key)
    else:
        return _binary_serch(arr, low, mid-1, key)


def binary_search_recursion(arr: list,  key) -> int:
    low = 0
    high = len(arr)-1
    return _binary_serch(arr, low, high, key)

c/c++非递归

template <typename T>
int binary_search(T a[], int len, T key)
{
    int low = 0, high = len - 1, mid;
    while (low <= high)
    {
        mid = (low + high) / 2;
        if (a[mid] == key)
            return mid;
        else if (a[mid] < key)
            low = mid + 1;
        else
            high = mid - 1;
    }
    return -1;
}

c/c++递归

template <typename T>
int _binary_search(T a[], int low, int high, T key)
{
    if (low > high)
        return -1;
    int mid = (low + high) / 2;
    if (a[mid] == key)
        return mid;
    else if (a[mid] > key)
        return _binary_search(a, 0, mid - 1, key);
    else
        return _binary_search(a, mid + 1, high, key);
}

template <typename T>
int binary_search_recursion(T a[], int len, T key)
{
    int low = 0, high = len - 1;
    return _binary_search(a, low, high, key);
}

分析

折半查找查找给定值的比较次数为其所在树的高度。
$$\begin{gathered} AS{L}_{成功}=\frac{1}{n}\sum _{i=0}^{n-1}{l}_i=\frac{1}{n}(1\times 2^0+2\times 2^1+\cdots +h\times 2^{h-1}) \\ =\frac{n+1}{n}{\log }_2(n+1)-1\approx {\log }_2(n+1)-1 \end{gathered}$$
时间复杂度：$O(lo{g}_{2}n)$

（待更新）