文章目录
查找
基本概念
在数据集合中寻找满足某种条件的数据元素的过程称为查找
- 查找表:静态查找表,动态查找表
- 平均查找长度
A S L = ∑ i = 1 n P i C i n : 查找表的长度 P i : 查找第 i 个数据元素的概率 C i : 找到第 i 个数据元素所需进行的比较次数 ASL=\sum_{i=1}^{n}P_iC_i\\ n:查找表的长度\\ P_i:查找第i个数据元素的概率\\ C_i:找到第i个数据元素所需进行的比较次数 ASL=i=1∑nPiCin:查找表的长度Pi:查找第i个数据元素的概率Ci:找到第i个数据元素所需进行的比较次数
顺序查找(线性查找)
简介
适用于顺序表或链表。
对于顺序表,可以通过数组下标递增来顺序扫描每个元素;
对于链表,可以通过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
n
n个元素的查找表,给定值
k
e
y
key
key与表中第
i
i
i个元素相等,需要进行
i
+
1
i+1
i+1次关键字的比较,即
C
i
=
i
+
1
C_i=i+1
Ci=i+1,当每个元素查找概率相同时,
P
i
=
1
n
P_i=\frac{1}{n}
Pi=n1,有
A
S
L
成功
=
∑
i
=
0
n
−
1
1
n
(
i
+
1
)
=
n
+
1
2
ASL_{成功}=\sum_{i=0}^{n-1}\frac{1}{n}(i+1)=\frac{n+1}{2}
ASL成功=i=0∑n−1n1(i+1)=2n+1
查找不成功时,需要与表中各个关键字比较,次数为
n
n
n,即
A
S
L
不成功
=
n
ASL_{不成功}=n
ASL不成功=n
时间复杂度:
O
(
n
)
O(n)
O(n)
折半查找(二分查找)
简介
仅适用于有序的顺序表。
基本思想:
- 首先将给定值key与表中间位置元素比较,若相等,则返回该元素的存储位置;
- 如果不相等,则只需要在中间元素以外的前半部分或后半部分,重复以上步骤,直到查找到或者确定表中没有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);
}
分析
折半查找查找给定值的比较次数为其所在树的高度。
A
S
L
成功
=
1
n
∑
i
=
0
n
−
1
l
i
=
1
n
(
1
×
2
0
+
2
×
2
1
+
⋯
+
h
×
2
h
−
1
)
=
n
+
1
n
log
2
(
n
+
1
)
−
1
≈
log
2
(
n
+
1
)
−
1
ASL_{成功}=\frac{1}{n}\sum_{i=0}^{n-1}l_i=\frac{1}{n}(1\times2^0+2\times2^1+\dots+h\times2^{h-1})\\=\frac{n+1}{n}\log_2 (n+1)-1\approx\log_2(n+1)-1
ASL成功=n1i=0∑n−1li=n1(1×20+2×21+⋯+h×2h−1)=nn+1log2(n+1)−1≈log2(n+1)−1
时间复杂度:
O
(
l
o
g
2
n
)
O(log_2n)
O(log2n)
(待更新)