数据结构之查找2

2020年3月21日 85次阅读

数据结构的最终目的是提高数据的处理速度，索引是为了加快查找速度而设计的一种数据结构。

索引就是把关键字和它对应的记录相关联的过程。

所谓线性索引就是把索引项集合组织为线性结构，也称为索引表。

稠密索引就是指在线性索引中，将数据集中的每个记录对应一个索引项。

对于稠密索引来说，索引项一定按照关键码有序排列。

分块索引：分块有序，是把数据集分成若干块，并且满足两个条件：

  1. 块内无序
  2. 块间有序

分块索引分为三个数据项：

  1. 最大关键码，存储每一块中的最大关键字。
  2. 存储块中记录个数，以便循环
  3. 用于指向块首数据元素的指针，便于开始对这一块中记录进行遍历

分为两步：

  1. 在分块索引表中查找要查关键字所在的块
  2. 根据块首指针查找相应的块，并在块中顺序查找关键码

倒排索引

索引项的结构：

  1. 次关键码
  2. 记录号表

其中记录号表存储具有相同的次关键字的所有记录的记录号，这样的索引方法就是倒排索引。

二叉排序树，又称二叉查找树，它或者是一棵空树，或者具有以下性质的二叉树：

  1. 若左子树不空，则左子树所有结点的值小于它根结点的值
  2. 若右子树不空，则右子树所有结点的值大于它根结点的值
  3. 它的左右子树分别为二叉排序树
//二叉树的二叉链表结点结构定义
typedef struct BiTNode
{
    int data;
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

//递归查找二叉排序树T中是否存在key
//指针f指向T的双亲，其初始调用值为NULL
//若查找成功，则指针p指向该数据元素结点，并返回TRUE
//否则指针p指向查找路径上访问的最后一个结点并返回FALSE
Status SearchBST(BiTree T,int key,BiTree f,BiTree *p)
{
    if(!T)          //查找不成功
    {
        *p = f;
        return FALSE;
    }
    else if(key == T->data) //查找成功
    {
        *p = T;
        return TRUE;
    }
    else if(key < T->data)
        return SearchBST(T->lchild,key,T,p);//在左子树继续查找
    else
    {
        return SearchBST(T->rchild,key,T,p);//在右子树继续查找
    }
    
}


//当二叉排序树T中不存在关键字等于key的数据元素时
//插入key并返回TRUE，否则返回FALSE
Status InsertBST(BiTree *T,int key)
{
    BiTree p,s;
    if(!SearchBST(*T,key,NULL,&p))  //查找不成功
    {
        s = (BiTree)malloc(sizeof(BiTNode));
        s->data = key;
        s->lchild = s->rchild = NULL;
        if(!p)
            *T = s; //插入s为新的根结点
        else if(key < p->data)
            p->lchild = s;  //插入s为左孩子
        else
        {
            p->rchild = s;
        }
        return TRUE;
    }
    else 
        return FALSE;
}


//若二叉排序树T中存在关键字等于key的数据元素时，则删除该数据元素结点
//并返回TRUE，否则返回FALSE
Status DeleteBST(BiTree *T,int key)
{
    if(!*T) //不存在关键字等于key的数据元素
        return FALSE;
    else
    {
        if(key == (*T)->data)   //找到关键字key的数据元素
            return Delete(T);
        else if(key < (*T)->data)
            return DeleteBST(&(*T)->lchild,key);
        else
        {
            return DeleteBSAT(&(*T)->rchild,key);
        }   
    } 
}

//从二叉排序树中删除结点p并重接它的左或右子树
Status Delete(BiTree *p)
{
    BiTree q,s;
    if((*p)->rchild == NULL)    //右子树空则只需重接它的左子树
    {
        q = *p;
        *p = (*p)->lchild;
        free(q);
    }
    else if((*p)->lchild == NULL)//只需重接它的右子树
    {
        q = *p;
        *p = (*p)->rchild;
        free(q);
    }
    else        //左右子树均不空
    {
        q = *p;
        s = (*p)->lchild;
        while(s->rchild)//转左，然后向右到尽头
        {
            q = s;
            s = s->rchild;
        }
        (*p)->data = d->data;   //s指向被删除结点的直接前驱
        if(q != *p)
            q->rchild = s->lchild;  //重接q的右子树
        else
        {
            q->lchild = s->lchild;  //重接q的左子树
        }
        free(s);
    }
    return TRUE;
}

时间复杂度Olog（n）

 

点赞