搜索算法

Θ(logn)Θ(logn)Θ(1)
template<
int HashTable<E,K>::hSearch(const
K& k)const
{//查找一个开地址表
//如果存在，则返回k的位置。

否则返回
插入点(如果有足
够空间)
int i = k%D;//起始桶int j = i;//在起始桶处开始
do{
if(empty[j] || ht[j]==k) return j;
j=(j+1)%D;//下一个桶
}while(j != i);//又返回起始桶?
return j ;//表已经满
template<class T>int BinarySearch(T a[],
const T& x, int n){ // 在a[0] <= a[1] <=
... <= a[n-1 ]中搜索x
// 如果找到，则返回所在位置，否则返回- 1
int left = 0; int right = n-1 ;
while (left <= right) {
int middle = (left +
right)/2;
if (x == a[middle])return middle;
Θ（n）搜索时，首先将欲搜索元素与中间元素进行比较。

如果欲搜索的元素较
小，
则仅需搜索链表的左半部分，否则，只要在链表右半部分进行比较即可。

template<class E, class K>
bool SkipList<E,K>::Search(const K&
k, E& e) const
{//搜索与k相匹配的元素，并将所找到的
元素放入e
//如果不存在这样的元素，则返回false if (k >= TailKey) return false;//调
整指针p，使其恰好
指向可能与k匹配的节点的前一个节点
SkipNode<E,K> *p = head;
for (int i = Levels; i >= 0; i--)
// 逐级向下
while (p->link[i]->data < k) // 在
第i级链中搜索
template<class T>int SequentialSearch(T a[], const T& x,int n){int i;for (i = 0; i < n &&a[i] != x; i++);if (i == n) return -1 ;return i;}代码
复杂性
在未排序的数组a[0:n-1]中搜索x，如果找到，则返回所在位置，否则返回- 1分类
思想
搜索过程从x 与数组[left:right]中间元素的比较开始。

如果x等于中间元素，则查找过程结束。

如果x小于中间元素，则仅需要查找数组的左半部分，所以right 被修改为middle - 1。

首先搜索起始桶继
桶进行搜索，直到发生以下情况：
1)存有关键字为K的桶已找到，即找
到
了要搜索的元素；2)到达一个空桶；
3)又回到f(k)桶。

n 若发生后两种情况，则说明表中没有关
顺序搜索
折半搜索
线性搜索
跳表搜索散列
时间复杂性：Θ（n） 空间复杂性：O（n）
时间复杂性Θ（n） 空间复杂性：O（n）
前序遍历中序遍历后序遍历逐层遍
首先访问根结点然后遍历左子树，最后遍历右子树。

在遍历左、右子树时，仍然先访问根结点，然后遍历左子树，最后遍历右子树。

首先遍历左子树，然后访问根结点，最后遍历右子树。

在遍历左、右子树时，仍然先遍历左子树，再访问根结点，最后遍历右子树。

Θ(1)
template <class T>
void
PreOrder(BinaryTreeNode
<T> *t)
{// 对*t进行前序遍历
if (t) {
Visit(t) ; // 访问根节点
Preorder(t-
>LeftChild);//遍历左子树
Preorder(t-
>RightChild);//遍历右子
树
}
}
时间复杂性：Θ
（n） 空间
复杂性：O（n）
时间复杂性：Θ
（n） 空间
复杂性：O（n）
template <class T>
void
InOrder(BinaryTreeNode<
T> *t)
{// 对* t进行中序遍历
if (t) {
Inorder(t->LeftChild )
; //遍历左子树
Visit(t) ; // 访问根节
点
Inorder(t->RightChild
); //遍历右子树
}
}
late<class E,class K>
int HashTable<E,K>::hSearch(const
K& k)const
{//查找一个开地址表
//如果存在，则返回k的位置。

否则返回
插入点(如果有足
够空间)
int i = k%D;//起始桶
int j = i;//在起始桶处开始
do{
if(empty[j] || ht[j]==k) return j;
j=(j+1)%D;//下一个桶
}while(j != i);//又返回起始桶?
return j ;//表已经满
template <class T>
void
PostOrder(BinaryTreeNod
e<T> *t)
{// 对* t进行后序遍历
if (t) {
Postorder(t-
>LeftChild);//遍历左子
树
Postorder(t-
>RightChild);//遍历右子
树
Visit(t) ; // 访问根节
点
template <cl
void
LevelOrder(BinaryTreeNo
de<T> *t)
{// 对*t逐层遍历
LinkedQueue<BinaryTreeN
ode<T>*> Q;
while (t) {
Visit(t); // 访问t
// 将t的右孩子放入队列
if (t->LeftChild)
Q.Add(t->LeftChild);
if (t->RightChild)
Q.Add(t->RightChild);首先遍历左子树，然后
遍历右子树，最后遍历
访问根结点，在遍历左
、右子树时，仍然先遍
历左子树，然后遍历右
子树，最后遍历根结点。

.从上到下,从左
历二叉树的各个结点
起始桶f(k)，接着对表中后
继
桶进行搜索，直到发生以下情况：1)存有关键字为K的桶已找到，即找
到
了要搜索的元素；
2)到达一个空桶；
3)又回到f(k)桶。

n 若发生后两种情况，则说明表中没
有关树搜索
散列搜索
复杂性：Θ（n） 空间复杂性：O（n）
层遍历
void Network::BFS(int v,int
reach[],int label){//宽度优先搜索
//初始时对于所有顶点有reach[i]=0并且
label≠0LinkedQueue<int> Q;
InitializePos();//初始化图遍历器数组
reach[v]=label;
Q.Add(v);
while(!Q.IsEmpty()){
int w;Q.Delete(w);//获取一个已标记的顶点
int u=Begin(w);
while(u){//访问w的邻接顶点
O(h)Θ（sn）Θ（sn）
　若b是空树，则搜索失败，否则： 若x等于b的根结点的数据域之
值，则查找成功；否则： 若x小于b的根
结点的数据域之值，则搜索左子树；否则：查找右子树。

template<class E,class K>bool BSTree<E,K>::Search(con stK& k,E& e)const {//搜索与k匹配的元素//指针p从树根开始进行查找BinaryTreeNode<E>*p=root;while(p)//检查p->data if(k<p->data) p=p->LeftChild;else if(k>p->data) p=p-n从顶点，然后选择一个与v 邻接的尚未到达的顶点u，如果这样的u 不
存在，搜索中止。

n 假设这样的u 存在，那么从u 又开
始一个新的DFS。

n 当从u 开始的搜索结束时，再选择另外一个与v 邻接的尚未到达的顶
点，如果这样的顶点不存在，那么搜索终止。

而如果存在这样的顶点，又从这个顶点开始DFS，如此循环下去
void Network::DFS(int v,int reach[],int label){//深度优先搜索InitializePos();//初始化图遍历器数组dfs(v,reach,label);//执行dfs DeactivatePos();//释放图遍历器数组}Void Network::dfs(int v,int reach[],int label){//实际执行深度优先搜索的代码reach[v]=label;int u=Begin(v);e <class T>void
LevelOrder(BinaryTreeNo
de<T> *t){// 对*t逐层遍历LinkedQueue<BinaryTreeN
ode<T>*> Q;while (t) {Visit(t); // 访问t // 将t的右孩子放入队列if (t->LeftChild)Q.Add(t->LeftChild);if (t->RightChild)Q.Add(t->RightChild);
下,从左到右遍历二叉树的各个结点宽度优先
n 从一个顶点开始，识别所有可到达
顶
点的方法叫作宽度优先搜索(Breadth
-FirstSearch, BFS)。

n 这种搜索可使用队列来实现。

图搜索
二叉搜索树搜索
深度优先。