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

最新推荐文章于 2024-10-22 21:45:02 发布
最新推荐文章于 2024-10-22 21:45:02 发布
阅读量469 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/LYS621/article/details/50115597
版权 
<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;

}

运行结果：



吕云双
关注
【数据结构】考点三十三 ：二叉排序树
超越的博客
04-29 929
二叉排序树（Binary Sort Tree），又称为二叉搜索树（Binary Search Tree），是一种特殊的二叉树。在二叉排序树中，对于每个节点，其左子树中的所有节点的值都小于该节点的值，而右子树中的所有节点的值都大于该节点的值。这样的性质使得二叉排序树在查找、插入和删除操作中具有高效的性能。
第2关：二叉排序树的定义及查找
xiyunSacire的博客
06-14 844
头歌上的答案
二叉排序树
John的博客
10-20 6838
二叉排序树什么是二叉排序树：即一个二叉树，它的每一个结点的左孩子的key值比当前结点的key值小，而右孩子结点的key值比当前结点的key值大，这样的一个树就是二叉排序树，也叫二叉搜索树（BST_tree）；一颗排序二叉树的结点框架大概就是这样：template<class K> struct SearchBinaryTreeNode { SearchBinaryTreeNode<K>* _
二叉排序树--
BePosit的博客
09-08 248
#include&lt;bits/stdc++.h&gt; using namespace std; int n; string str[25]; struct node { node *l,*r; char data; }*root; string a,b,c; struct node *creat(node *root,char data) { if(root==NU...
【C++、数据结构】二叉排序树（二叉查找树、二叉搜索树）（图解+完整代码）
金哥的博客
10-22 2057
二叉搜索树/二叉排序树/二叉查找树：创建、插入、查找、删除（非递归以及递归版本代码），以及超详细步骤图解
数据结构复习指导之树形查找（二叉排序树和平衡二叉树）
心碎烤肠的博客
05-24 1450
本章是考研命题的重点。 对于折半查找，应掌握折半查找的过程、构造判定树、分析平均查找长度等。 对于二叉排序树、二叉平衡树和红黑树，要了解它们的概念、性质和相关操作等。 B 树和 B+树是本章的难点。对于B树，考研大纲要求掌握插入、删除和査找的操作过程； 对于 B+树，仅要求了解其基本概念和性质。 对于散列查找，应掌握散列表的构造、冲突处理方法(各种方法的处理过程)、查找成功和查找失败的平均查找长度、散列查找的特征和性能分析。
二叉排序树（Binary Sort Tree）/二叉查找树（Binary Search Tree）/亦称二叉搜索树
zxf347085420的博客
02-22 776
原文链接：数据结构-二叉排序树（图文详细版）-优快云博客
树：二叉排序树
前端_叶发发のBlog~~~
09-13 114
#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;string.h&gt; typedef struct tree { int data; struct tree *l,*r; } tree; tree *BST(tree *t,int k) { if(t==NULL) { ...
数据结构-----二叉排序树
m0_73633088的博客
10-01 2万+
今天我们继续学习新的知识点----排序二叉树，在此之前我们学习了相关的排序算法，给你一个数组，然后对这个数组进行排序。那么同样的我们也可以去构建一个二叉排序树，在创建树的过程中进行排序，也能实现排序的效果，下面就一起来看看吧！二叉排序树（Binary Sort Tree），又称二叉查找树（Binary Search Tree），亦称二叉搜索树。是数据结构中的一类。在一般情况下，查询效率比链表结构要高。给定一个二叉树，如果满足以下条件，那就是二叉排序树。
数据结构--图的创建之邻接表
0k-ok
11-21 1185
思绪不断阻挡着回忆播放，盲目的追寻仍然空空荡荡，灰蒙蒙的夜晚睡意又不知躲到哪去，一转身孤单已躺在身旁。 算法中也写过一篇关于建图的方法的博客，点这里。 邻接矩阵比较好理解，这里就不记录了，主要是邻接表，比较难理解， 邻接表存储类型定义： typedef struct ANode { int adjvex; //该边的终点编号 struct ANod...
二叉排序树详解
热门推荐
William
03-26 3万+
前言博客编写人：Willam 博客编写时间：2017/3/25 博主邮箱：2930526477@qq.com（有志同道合之人，可以加qq交流交流编程心得）1、二叉排序树的介绍二叉排序树又称二叉查找树。二叉排序树有如下性质： 如果它的左子树不为空，那么左子树上的所有结点的值均小于它的根结点的值 如果它的右子树不为空，那么右子树上的左右结点的值均大于它的根结点的值 根结点的左子树和右子树又是二叉排序树。
数据结构——图的邻接表、图的存储结构
马句
12-16 4021
要理解基础的话可以下看下b站这位老师的视频 数据结构与算法基础--第10周05--6.4图的存储结构5-6.4.2邻接表表示法1-无向图的邻接表 下面是一个无向的网图： 邻接表中数据的存储图示如下 顶点表也就是个结构体数组，是存放顶点的结构，顶点表中有data元素，存放顶点信息firstarc是一个边结构体表指针，存放邻接点的信息。 边表也是一个结构体，内有adivex元素...
第十二周项目1-验证算法（1）
sunshine1119213的博客
11-16 191
/* *Copyright (c) 2017,烟台大学计算机与控制工程学院 *All rights reserved. *文件名称：项目1-prim算法的验证 *作 者：董丽娟 *完成日期：2017年11月16日 *版 本 号：v1.0 */
二叉排序树（新建，插入，查找，删除）（C语言编写）
半岛落枫的博客
11-23 7425
#include #include typedef struct BSTNode{         int data;         struct BSTNode *lchild,*rchild; }BSTNode,*BSTree; BSTree InsertBST(BSTree T,int data); BSTree CreatBST(BSTree T)
稳压罐sw16_三维3D设计图纸_包括零件图_机械3D图可修改打包下载_三维3D设计图纸_包括零件图_机械3D图可修改打包下载.zip
最新发布
04-09
稳压罐sw16_三维3D设计图纸_包括零件图_机械3D图可修改打包下载_三维3D设计图纸_包括零件图_机械3D图可修改打包下载.zip
基于递推最小二乘法的永磁同步电机参数辨识及其MATLAB仿真
04-09
内容概要：本文详细介绍了利用递推最小二乘法（RLS）进行永磁同步电机参数辨识的方法及其MATLAB仿真过程。首先解释了RLS算法的优势，如不需要概率模型、计算量适中以及适用于嵌入式系统的实时参数更新。接着展示了将电机电压方程转换为标准形式Y=φθ的具体步骤，并提供了核心的RLS迭代代码。文中还讨论了仿真过程中的一些关键技术细节，如遗忘因子的选择、协方差矩阵的初始化和更新方式、电流信号的处理方法等。最终给出了仿真结果，显示电阻和电感的辨识误差分别达到了0.08%和0.12%，并指出了实际应用中需要注意的数据同步和数值稳定性问题。 适合人群：从事电机控制研究的技术人员、研究生及以上学历的学生。 使用场景及目标：①帮助研究人员理解和掌握RLS算法在电机参数辨识中的应用；②提供详细的仿真代码和配置建议，便于快速搭建实验环境；③指导如何优化算法性能，提高参数辨识精度。 其他说明：本文不仅涵盖了理论推导，还包括了大量的实践经验分享和技术细节探讨，有助于读者全面理解RLS算法的实际应用。同时，文中提到的仿真方案可以方便地移植到DSP平台，进一步扩展了其实用价值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值