数据结构(七)

最新推荐文章于 2022-04-23 17:24:35 发布

CS@zeny

最新推荐文章于 2022-04-23 17:24:35 发布

阅读量190

点赞数

分类专栏：数据结构笔记文章标签：数据结构 c语言

本文链接：https://blog.csdn.net/honorzoey/article/details/113448344

版权

笔记同时被 2 个专栏收录

101 篇文章 10 订阅

订阅专栏

数据结构

9 篇文章 1 订阅

订阅专栏

数据结构(七)–查找

查找

查找的基本概念

基本概念

查找表: 同一类型的数据元素构成的集合; 包括线性表、树表、散列表

由于"集合"中的数据元素之间存在着松散的关系, 因此查找表示一种应用灵便的结构
关键字: 是数据元素中某个数据项的值, 用以标识数据元素(或记录), 分主关键字和次关键字

主关键字: 可唯一地标识一个记录的关键字是主关键字;

次关键字: 反之, 用以识别若干记录的关键字是次关键字.
查找 (是否成功)
1. 查询某个"特定的"数据元素是否在查找表中
2. 检索某个"特定的"数据元素的各种属性
3. 在查找表中插入一个数据元素
4. 从查找表中删去某个数据元素
查找表分类
1. 静态查找表
  仅作"查询"(检索)操作的查找表
2. 动态查找表
  - 作"插入"和"删除"操作的查找表
  - 查找表示在查找过程中动态生成的.
  - 伴随着插入不存在元素或删除已存在的元素
3. 平均查找长度 (评价查找算法的优劣,这里就不用算法的通用指标:时间复杂度,而是用平均查找长度)
  - 关键字的平均比较次数,也称平均查找长度 (ASL : Average Search Length)
  - ASL = $\sum_{i=1}^n ({p_i c_i})$ (关键字比较次数的期望值)
    n : 记录的个数
    p_i :查找第i个记录的概率(通常认为p_i = 1 / n)
    c_i : 找到第i个记录所需的比较次数

在这里插入图片描述

线性表的查找

应用范围:

顺序表或线性表表示的静态查找表
表内元素之间无序

顺序表的表示:

数据元素类型的定义:

typedef struct{
    KeyType key; //关键字域
    ......       //其他域
}ElemType;

typedef struct{//顺序表及结构类型定义
    ElemType *R;    //表基址
    int length;    //表长
}SSTable;//Sequential Search Table
SSTable ST; //定义顺序表ST

一、顺序查找法:

算法:

下面有三种算法:

int Search_Seq(SSTable ST, KeyType key){
    //若查找成功返回其位置信息,否则返回0
    for(i = ST.Length;i >= 1; --i)   //下标从1开始, 0位置不放元素
        if(ST.R[i].key == key) return i;
    return 0;
}//Search_Seq

int Search_Seq(SSTable ST, KeyType key){
    for(i = ST.Length;ST.R[i].key != key; --i)   
        if(i<=0) break;
    if(i>0)return i;
    else return 0;
}

int Search_Seq(SSTable ST, KeyType key){
    for(i = ST.Length;ST.R[i].key != key && i>0 ; --i); 
    if(i>0)return i;
    else return 0;
}

改进算法

int Search_Seq(SSTable ST, KeyType key)
{ ST.R[0].key = key;
 for(i = ST.length; ST.R[i].key != key; --i);
 return i;
}//Search_Seq
//设置哨兵,避免每次比较i>=1, 当n比较大时, 时间可减少一半

可用于顺序或链式存储结构
从后往前,依次比较. 查找成功, 返回位序, 否则返回0(不存在的位序)
设置"哨兵",避免位序控制

性能分析

在等概率查找的情况下,顺序表查找的平均查找长度为:

ASL = $\frac{1}{n}$ $\sum_{i=1}^n ({n-i+1})$ = $\frac{n+1}{2}$
时间复杂度: T(n) = O(n)

在这里插入图片描述

二、折半查找

基本要求: 1. 只能用顺序存储结构 2. 表中记录按关键字有序排列

指针low和high分别表示当前查找区间的下界和上界, mid为区间的中间位置

mid = $\lfloor$ (low + high)/2 $\rfloor$ (向下取整)

如果关键字key 比中间位置记录的关键字小,则high = mid - 1,否则low = mid + 1

在这里插入图片描述

算法描述:

int Search_Bin(SSTable ST, KeyType key)
{ low = 1; high = ST.length;
 while(low<=high)
 {mid = (low<=high)/2;
  if(key == ST.R[mid].key) return mid;
  else if(key<ST.R[mid].key)high=mid-1;
  		else low = mid + 1;
  return 0;
 }//Search_Bin

举个栗子:

判定树 : 把当前查找区间的中间位置作为根,左子表和右子表分别作为根的左子树和右子树,得到的二叉树称为折半查找的判定树

折半查找在查找成功时进行比较的关键字个数最多不超过树的深度.
判定树的形态只与表记录个数n相关,而关键字的取值无关
具有n个结点的判定树的深度为 $\lfloor$ $log_2n$ $\rfloor$ +1
ASL = $\sum_{i=1}^n ({P_i C_i})$ = $\frac{n+1}{n}$ $log_2 (n+1)$ -1
- 当n较大时,近似结果 ASL = $log_2 (n+1)$ -1
- 折半查找时间复杂度为O( $log_2n$ )
优点是折半查找效率比顺序查找高,比较次数少
缺点是只能用于顺序表,而且是有序表,不是适合用于数据元素经常变动的线性表

折半查找的判定树中，若mid = $\lfloor$ (low+high)/2 $\rfloor$ ,则对于任何一个结点,必有:右子树结点数-左子树结点数 = 0或1 ；即折半查找的判定树一定是平衡二叉树，判定树中只有最下面一层是不满的，因此元素个数为n时，树高h = $\lceil$ $log_2(n+1)$ $\rceil$ 【计算方法和“完全二叉树”相同】

判定树结点关键字:左<中<右,满足二叉排序树的定义,失败结点:n+1个(等于成功结点的空链域数量)

三、分块查找

也叫索引查找,是顺序查找的一种改进

为查找表建立索引表:关键字+指针
索引表按关键字有序,查找表按关键字有序或分块有序
查找过程:
1. 由索引表确定待查找记录所在分块: 折半查找,或者顺序查找
2. 在对应的分块中查找记录: 折半查找或顺序查找

在这里插入图片描述

树表的查找

一、二叉排序树

1.定义：二叉排序树或者是一棵空树，或者是具有下列性质的二叉树

左子树上所有结点的值都小于根结点的值
右子树上所有结点的值都大于根结点的值
左子树和右子树也是二叉排序树

二叉排序树的二叉链表存储：

typedef stuct
{KeyType key;
 InfoType otherinfo;
}ElemType;

typedef stuct BSTNode
{ElemType data;
stuct BSTNode *lchild,*rchild;
}BSTNode,*BSTree;

2.查找: 二叉排序树又称二叉查找树，其查找过程是一个从根结点开始，沿某一个分支逐层向下进行比较判等的过程
- 算法思想：
- 1. 从根结点开始，如果根指针为NULL，则查找不成功
  2. 否则用给定值key与根结点的关键字值T->data.key进行比较
    1. 如果key == T->data.key,则查找成功返回根结点地址
    2. 如果key < T->data.key, 则递归查找根结点的左子树
    3. 如果key > T->data.key, 则递归查找根结点的右子树

BSTree SearchBST(BSTree T,KeyType key) 
{BSTree p=T;
 if ((!T)|| key==T->data.key) return T;
 else if (key < T->data.key) return SearchBST(T->lchild,key);
 	else return SearchBST(T->rchild,key);
}//SearchBST

其中时间复杂度:T(n)=O( $log_2n$ )
3.插入
- (1)若BST为空, 则待插入结点*S作为根结点插入空树
- (2)若BST非空,则将key与T->data.key比较:
  - ①若key==T->data.key:停止插入
  - ②若key < T->data.key:将*S插入左子树
  - ③若key > T->data.key:将*S插入右子树
(3)新插入的结点一定是不成功结点的左孩子或右孩子
```
  void InsertBST(BSTree &T.ElemType e) 
{ if (!T) 
	{s=new BSTNode; s->data=e;
       s->lchild = s->rchild = NULL: T=S;}
   else if (e.key < T->data.key) InsertBST(T->lchild,e);
   	else InsertBST(T->rchild,e);
  }//InsertBST
```
- 时间复杂度: T(n) = O( $log_2n$ )
4.创建:
- 1.将BST初始化为空树
- 2.读入一个关键字为key的结点,插入BST中
- 3.重复执行,直到结束标志

void CreatBST(BSTree &T)
{T = NULL; cin>>e;
 while(e.key!=ENDFLAG)
 {InsertBST(T,e); cin>>e;}}

时间复杂度: T(n) = O( $nlog_2n$ )

在这里插入图片描述

小结: 1) 构造BST的过程为对无序序列进行排序的过程

2) 利用BST插入结点不必移动已排好序的结点,只需添加一个叶结点即可

3) 初始序列不同,BST的形态也不同,查找性能ASL也不同,最短为 $log_2n$ ,最长可能为n

4) BST 既有类似于折半查找的特性, 又可采用链表作为存储结构, 因此是动态查找表的适宜表示
5.删除:

在BST中删除一个结点时, 必须将断开的二叉链表重新链接起来,并确保BST的性质不会丢失

2)为了保证在执行删除后,其搜索性能不至于降低吗还需要防止重新链接后树的高度增加

假设BST中被删的结点是*p(PL和PR分别表示其左子树和右子树),其双亲结点是*f, 并设*p是*f的左孩子. 分三种情况:

第一种:
第二种:
第三种:

二、平衡二叉树——AVL树

1.定义： 一颗AVL树或者是空树，或者是具有下列性质的二叉树；它的左右子树都是AVL树，且左子树和右子树的高度之差的绝对值不超过1。

结点的平衡因子（BF）定义为该结点的左子树的深度减去右子树的深度：

所有结点的BF只能是-1、0、1

若有结点BF的绝对值大于1，则是非AVL树

2.结论

1）使二叉树经过处理成为平衡二叉树（AVL）的过程称作平衡化

2）对二叉排序树（BST）进行平衡化得到平衡二叉排序树（BBST）

3）平衡二叉排序树（BBST）具有最佳ASL

3.创建

1）建立平衡二叉排序树的算法从一颗空树开始，通过输入一系列的关键字，逐步建立AVL树

2）在插入新结点时进行平衡旋转，分四种情形：

LL型->单向右旋
LR型->先左后右
RR型->单向左旋
RL型->先右后左

3)基准点:距离叶结点最近的不平衡结点；旋转点：从基准点出发，按照平衡化处理方法寻找旋转点

在这里插入图片描述

三、B-树

1.定义：m阶的B树或为空，或满足：

①每个结点至多有m棵树

②若根结点不是叶子结点，则至少有两棵树

③除根结点之外的所有非终端结点至少有 $\lceil$ m/2 $\rceil$ 棵子树

④非终端结点包含以下信息：(n, $A_0$ , $K_1$ , $A_1$ , $K_2$ , $A_2$ , $K_3$ , $A_3$ ,…, $K_n$ , $A_n$ ) $K_1$ ( $\lceil$ m/2 $\rceil$ -1≤i≤n)为关键字,且 $K_1$ < $K_2$ <…< $K_n$ ; $A_i$ 为所指向子树上的指针(0≤i≤n),且 $A_{i-1}$ 所指子树上的所有关键字均小于 $K_i$ , $A_i$ 所指子树均大于 $K_i$