第十四周 项目4 二叉排序树

<img src="https://img-blog.youkuaiyun.com/20151130170932846" alt="" />

<img src="https://img-blog.youkuaiyun.com/20151130170947104" alt="" /><img src="https://img-blog.youkuaiyun.com/20151130170954126" alt="" />
<img src="https://img-blog.youkuaiyun.com/20151130171003910" alt="" />

//头文件

#ifndef GRAPH_H_INCLUDED
#define GRAPH_H_INCLUDED

#define MAXV 100                //最大顶点个数
#define INF 32767       //INF表示∞
typedef int InfoType;

//以下定义邻接矩阵类型
typedef struct
{
    int no;                     //顶点编号
    InfoType info;              //顶点其他信息，在此存放带权图权值
} VertexType;                   //顶点类型

typedef struct                  //图的定义
{
    int edges[MAXV][MAXV];      //邻接矩阵
    int n,e;                    //顶点数，弧数
    VertexType vexs[MAXV];      //存放顶点信息
} MGraph;                       //图的邻接矩阵类型

//以下定义邻接表类型
typedef struct ANode            //弧的结点结构类型
{
    int adjvex;                 //该弧的终点位置
    struct ANode *nextarc;      //指向下一条弧的指针
    InfoType info;              //该弧的相关信息,这里用于存放权值
} ArcNode;

typedef int Vertex;

typedef struct Vnode            //邻接表头结点的类型
{
    Vertex data;                //顶点信息
    int count;                  //存放顶点入度,只在拓扑排序中用
    ArcNode *firstarc;          //指向第一条弧
} VNode;

typedef VNode AdjList[MAXV];    //AdjList是邻接表类型

typedef struct
{
    AdjList adjlist;            //邻接表
    int n,e;                    //图中顶点数n和边数e
} ALGraph;                      //图的邻接表类型

//功能：由一个反映图中顶点邻接关系的二维数组，构造出用邻接矩阵存储的图
//参数：Arr - 数组名，由于形式参数为二维数组时必须给出每行的元素个数，在此将参数Arr声明为一维数组名（指向int的指针）
//      n - 矩阵的阶数
//      g - 要构造出来的邻接矩阵数据结构
void ArrayToMat(int *Arr, int n, MGraph &g); //用普通数组构造图的邻接矩阵
void ArrayToList(int *Arr, int n, ALGraph *&); //用普通数组构造图的邻接表
void MatToList(MGraph g,ALGraph *&G);//将邻接矩阵g转换成邻接表G
void ListToMat(ALGraph *G,MGraph &g);//将邻接表G转换成邻接矩阵g
void DispMat(MGraph g);//输出邻接矩阵g
void DispAdj(ALGraph *G);//输出邻接表G

#endif // GRAPH_H_INCLUDED

源文件

#include <stdio.h>
#include <malloc.h>
#include "graph.h"

//功能：由一个反映图中顶点邻接关系的二维数组，构造出用邻接矩阵存储的图
//参数：Arr - 数组名，由于形式参数为二维数组时必须给出每行的元素个数，在此将参数Arr声明为一维数组名（指向int的指针）
//      n - 矩阵的阶数
//      g - 要构造出来的邻接矩阵数据结构
void ArrayToMat(int *Arr, int n, MGraph &g)
{
    int i,j,count=0;  //count用于统计边数，即矩阵中非0元素个数
    g.n=n;
    for (i=0; i<g.n; i++)
        for (j=0; j<g.n; j++)
        {
            g.edges[i][j]=Arr[i*n+j]; //将Arr看作n×n的二维数组，Arr[i*n+j]即是Arr[i][j]，计算存储位置的功夫在此应用
            if(g.edges[i][j]!=0 && g.edges[i][j]!=INF)
                count++;
        }
    g.e=count;
}

void ArrayToList(int *Arr, int n, ALGraph *&G)
{
    int i,j,count=0;  //count用于统计边数，即矩阵中非0元素个数
    ArcNode *p;
    G=(ALGraph *)malloc(sizeof(ALGraph));
    G->n=n;
    for (i=0; i<n; i++)                 //给邻接表中所有头节点的指针域置初值
        G->adjlist[i].firstarc=NULL;
    for (i=0; i<n; i++)                 //检查邻接矩阵中每个元素
        for (j=n-1; j>=0; j--)
            if (Arr[i*n+j]!=0)      //存在一条边，将Arr看作n×n的二维数组，Arr[i*n+j]即是Arr[i][j]
            {
                p=(ArcNode *)malloc(sizeof(ArcNode));   //创建一个节点*p
                p->adjvex=j;
                p->info=Arr[i*n+j];
                p->nextarc=G->adjlist[i].firstarc;      //采用头插法插入*p
                G->adjlist[i].firstarc=p;
            }

    G->e=count;
}

void MatToList(MGraph g, ALGraph *&G)
//将邻接矩阵g转换成邻接表G
{
    int i,j;
    ArcNode *p;
    G=(ALGraph *)malloc(sizeof(ALGraph));
    for (i=0; i<g.n; i++)                   //给邻接表中所有头节点的指针域置初值
        G->adjlist[i].firstarc=NULL;
    for (i=0; i<g.n; i++)                   //检查邻接矩阵中每个元素
        for (j=g.n-1; j>=0; j--)
            if (g.edges[i][j]!=0)       //存在一条边
            {
                p=(ArcNode *)malloc(sizeof(ArcNode));   //创建一个节点*p
                p->adjvex=j;
                p->info=g.edges[i][j];
                p->nextarc=G->adjlist[i].firstarc;      //采用头插法插入*p
                G->adjlist[i].firstarc=p;
            }
    G->n=g.n;
    G->e=g.e;
}

void ListToMat(ALGraph *G,MGraph &g)
//将邻接表G转换成邻接矩阵g
{
    int i,j;
    ArcNode *p;
    g.n=G->n;   //根据一楼同学“举报”改的。g.n未赋值，下面的初始化不起作用
    g.e=G->e;
    for (i=0; i<g.n; i++)   //先初始化邻接矩阵
        for (j=0; j<g.n; j++)
            g.edges[i][j]=0;
    for (i=0; i<G->n; i++)  //根据邻接表，为邻接矩阵赋值
    {
        p=G->adjlist[i].firstarc;
        while (p!=NULL)
        {
            g.edges[i][p->adjvex]=p->info;
            p=p->nextarc;
        }
    }
}

void DispMat(MGraph g)
//输出邻接矩阵g
{
    int i,j;
    for (i=0; i<g.n; i++)
    {
        for (j=0; j<g.n; j++)
            if (g.edges[i][j]==INF)
                printf("%3s","∞");
            else
                printf("%3d",g.edges[i][j]);
        printf("\n");
    }
}

void DispAdj(ALGraph *G)
//输出邻接表G
{
    int i;
    ArcNode *p;
    for (i=0; i<G->n; i++)
    {
        p=G->adjlist[i].firstarc;
        printf("%3d: ",i);
        while (p!=NULL)
        {
            printf("-->%d/%d ",p->adjvex,p->info);
            p=p->nextarc;
        }
        printf("\n");
    }
}

//主函数

#include <stdio.h>
#include <malloc.h>
typedef int KeyType;

typedef struct node                 //记录类型
{
    KeyType key;                    //关键字项
    InfoType data;                  //其他数据域
    struct node *lchild,*rchild;    //左右孩子指针
} BSTNode;

//在p所指向的二叉排序树中，插入值为k的节点
int InsertBST(BSTNode *&p,KeyType k)
{
    if (p==NULL)                        //原树为空, 新插入的记录为根结点
    {
        p=(BSTNode *)malloc(sizeof(BSTNode));
        p->key=k;
        p->lchild=p->rchild=NULL;
        return 1;
    }
    else if (k==p->key)                 //树中存在相同关键字的结点,返回0
        return 0;
    else if (k<p->key)
        return InsertBST(p->lchild,k);  //插入到*p的左子树中
    else
        return InsertBST(p->rchild,k);  //插入到*p的右子树中
}

//由有n个元素的数组A，创建一个二叉排序树
BSTNode *CreateBST(KeyType A[],int n)   //返回BST树根结点指针
{
    BSTNode *bt=NULL;                   //初始时bt为空树
    int i=0;
    while (i<n)
    {
        InsertBST(bt,A[i]);             //将关键字A[i]插入二叉排序树T中
        i++;
    }
    return bt;                          //返回建立的二叉排序树的根指针
}

//输出一棵排序二叉树
void DispBST(BSTNode *bt)
{
    if (bt!=NULL)
    {
        printf("%d",bt->key);
        if (bt->lchild!=NULL || bt->rchild!=NULL)
        {
            printf("(");                        //有孩子结点时才输出(
            DispBST(bt->lchild);                //递归处理左子树
            if (bt->rchild!=NULL) printf(",");  //有右孩子结点时才输出,
            DispBST(bt->rchild);                //递归处理右子树
            printf(")");                        //有孩子结点时才输出)
        }
    }
}

//在bt指向的节点为根的排序二叉树中，查找值为k的节点。找不到返回NULL
BSTNode *SearchBST(BSTNode *bt,KeyType k)
{
    if (bt==NULL || bt->key==k)         //递归终结条件
        return bt;
    if (k<bt->key)
        return SearchBST(bt->lchild,k);  //在左子树中递归查找
    else
        return SearchBST(bt->rchild,k);  //在右子树中递归查找
}

//二叉排序树中查找的非递归算法
BSTNode *SearchBST1(BSTNode *bt,KeyType k)
{
    while (bt!=NULL)
    {
        if (k==bt->key)
            return bt;
        else if (k<bt->key)
            bt=bt->lchild;
        else
            bt=bt->rchild;
    }
    return NULL;
}

void Delete1(BSTNode *p,BSTNode *&r)  //当被删*p结点有左右子树时的删除过程
{
    BSTNode *q;
    if (r->rchild!=NULL)
        Delete1(p,r->rchild);   //递归找最右下结点
    else                        //找到了最右下结点*r
    {
        p->key=r->key;          //将*r的关键字值赋给*p
        q=r;
        r=r->lchild;            //直接将其左子树的根结点放在被删结点的位置上
        free(q);                //释放原*r的空间
    }
}

void Delete(BSTNode *&p)   //从二叉排序树中删除*p结点
{
    BSTNode *q;
    if (p->rchild==NULL)        //*p结点没有右子树的情况
    {
        q=p;
        p=p->lchild;            //直接将其右子树的根结点放在被删结点的位置上
        free(q);
    }
    else if (p->lchild==NULL)   //*p结点没有左子树的情况
    {
        q=p;
        p=p->rchild;            //将*p结点的右子树作为双亲结点的相应子树
        free(q);
    }
    else Delete1(p,p->lchild);  //*p结点既没有左子树又没有右子树的情况
}

int DeleteBST(BSTNode *&bt, KeyType k)  //在bt中删除关键字为k的结点
{
    if (bt==NULL)
        return 0;               //空树删除失败
    else
    {
        if (k<bt->key)
            return DeleteBST(bt->lchild,k); //递归在左子树中删除为k的结点
        else if (k>bt->key)
            return DeleteBST(bt->rchild,k); //递归在右子树中删除为k的结点
        else
        {
            Delete(bt);     //调用Delete(bt)函数删除*bt结点
            return 1;
        }
    }
}
int main()
{
    BSTNode *bt;
    int n=12,x=46;
    KeyType a[]= {25,18,46,2,53,39,32,4,74,67,60,11};
    bt=CreateBST(a,n);
    printf("BST:");
    DispBST(bt);
    printf("\n");
    printf("删除%d结点\n",x);
    if (SearchBST(bt,x)!=NULL)
    {
        DeleteBST(bt,x);
        printf("BST:");
        DispBST(bt);
        printf("\n");
    }
    return 0;

}

运行结果：