第七章学习小结

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

typedef struct
{
    ElemType *R;        //存储空间基地址
    int length;            //当前长度
}SSTable;

int Search_Seq(SSTable ST, KeyType key)
{//在顺序表ST中顺序查找其关键字等于key的数据元素。若找到，则函数值为该元素在表中的位置，否则为0
    for(i = ST.length;i >= 1;--i)    //从后往前找
        if(ST.R[i].key == key) return i;
    return i;
}

int Search_Seq(SSTable ST,KeyType key)
{//在顺序表ST中顺序查找其关键字等于key的数据元素。若找到，则函数值为该元素在表中的位置，否则为0
    ST.R[i].key = key;                                        //设置“哨兵”
    for(i = ST.lengthl;ST.R[i].key != key;--i);        //从后往前找
}

int Search_Bin(SSTable ST,KeyType key)
{//在有序表ST中这般查找七关键字等于key的数据元素。若找到，则函数值为该元素在表中的位置，否则为0
    low = 1;                        
    high = ST.length;        //初始化
    while(low <= high)
    {
        mid = (high + low) / 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;                                                                //表中不存在待查元素
}                

typedef struct
{
　　KeyType key;　　　　//关键字项
　　InfoType otherinfo;　  //其他数据项
}ElemType;　　　　　　　//每个结点的数据域的类型
typedef struct BSTNode
{
　　ElemType data;　　　　　　　　//每个结点的数据域包括关键字项和其他数据项
　　struct BSTNode *lchild,*rchild;　　//左右孩子指针
}BSTNode,*BSTree;

BSTree SearchBST(BSTree T,KeyType key)
{//在根指针T所指二叉排序树种递归查找某该关键字等于key的数据元素
 //查找成功，则返回指向该数据元素结点的指针，否则返回空指针
    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);    //在右子树继续查找
}

void InsertBST(BSTree &T, ElemType e)
{//当二叉排序树T种不存在关键字等于e.key的数据元素时，则插入该元素
    if(!T)
    {                                                //找到插入位置，递归结束
        S = new BSTNode;                  //生成新结点*S
        S->data = e;                          //新结点*S的数据域置为e
        S->lchild = S->rchild = NULL; //新结点*S作为叶子结点
        T = S;
    }
    else if(e.key < T->data.key)    InsertBST(T->lchild,e); //将*S插入左子树
    else if(e.key > T->data.key)    InsertBST(T->rchild,e); //将*S插入右子树
}

void CreatBST(BSTree &T)
{//依次输入一个关键字为key的结点，将此结点插入二叉排序树中
    T = NULL;            //将二叉排序树T初始化为空树
    cin >> e;
    while(e.key != ENDFLAG)    //ENDFLAG为自定义常量，作为输入结束标志
    {
        InsertBST(T,e);        //将此结点插入二叉排序树T中
        cin >> e;
    }
}

#define m 3;    //B-树的阶，暂设为3
typedef struct BTNode
{
    int keynum;            //结点中关键字的个数，即结点的大小
    struct BTNode *parent;        //指向双亲结点
    KeyType key[m + 1];        //关键字向量，0单元未用
    struct BTNode *ptr[m + 1];        //子树指针向量
    Record *recptr[m + 1];        记录指针向量，0号单元未用
}BTNode,*BTree;
typedef struct
{
    BTNode *pt;        //指向找到的结点
    int i;        //l...m，在结点中的关键字序号
    int tag;        //1:查找成功，0：查找失败
}Result;        //B-树的查找结果类型

Result SearchBTree(BTree T,KeyType key)
{//在m阶B-树上查找关键字key，返回结果（pt，i，tag）
//若查找成功，则特征值tag = 1，指针pt所指结点中第i和关键字等于key
//否则特征值tag = 0，等于key的关键字应插入在指针pt所指结点第i和第i+1个关键字之间
    p = T;q = NULL;found = FALSE;i = 0;    //初始化，p指向待查结点，q指向p的双亲
    while(p && !found)
    {
        i = Search(p,key);
        //在p->key[1...keynum]中查找i，使得：p->key[i] <= key < p->key[i+1]
        if(i > 0 && p->key[i] == key)    found = TRUE;    //找到待查关键字
        else
        { 
            q = p;
            p = p->ptr[i];
        }
    }
    if(found)    return(p,i,1);    //查找成功
    else return(q,i,0);    //查找失败
}