数据结构——树

最新推荐文章于 2024-03-22 15:46:02 发布
最新推荐文章于 2024-03-22 15:46:02 发布
阅读量231 收藏
点赞数
分类专栏： C++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangying_496/article/details/81477057
版权

1、树的基本定义

1、树的定义：n个结点的有限集合（n>=0）。
2、树的结点：包含1个数据元素及若干指向其子树的分支。
3、结点的度：结点所拥有的子树数量。
4、树的度：树中所有结点的度的最大值。
5、结点的层次：从根节点开始为第一层
6、树的深度：最大的层次数。

/2、二叉树（Binary Tree）

1、二叉树：n个结点的有限集合（n>=0）。特殊在于：n>1时，1个根节点和两棵互不相交的二叉树。
2、满二叉树：①所有的分支结点都有左子树和右子树；②所有的叶子结点都在同一层。
3、完全二叉树：对有n个结点的二叉树按照层序编号，若编号i(1<=i<=n)与同样深度的满二叉树的位置完全相同，则该二叉树为完全二叉树。
4、二叉树的一些性质：

/2.1 二叉树的顺序结构

注意：逻辑结构和物理结构的差异。
逻辑结构：分为线性和非线性。（树是非线性结构）
物理结构（存储结构）：分为顺序、链式、索引、哈希等，表征数据是如何存储的。（因此树结构也可以有顺序或链式存储结构）

二叉树的顺序存储结构如下：

//二叉树的顺序结构中：一个数组和一个表示位置的结构体。数组存放数据，下标从0开始；位置表征结点的层数和本层序号数。
typedef TElemType SqBiTree[MAX_TREE_SIZE];  //0号单元存储根节点，使用一个数组存放数据
typedef struct 
{
    int level, order;   //结点的层，本层序号（按照满二叉树计算）

}Position;

二叉树的顺序存储，元素是放在数组中，注意点要在根节点与孩子结点的2倍关系、以及结点所在层数和序号之间的计算上。

/************************************************************************/
/*      1.二叉树的顺序结构                                                                     */
/************************************************************************/

#define OK 1
#define  ERROR 0
#define  TRUE 1
#define  FALSE 0
#define  MAXSIZE 100    //存储空间初始分配量
#define  MAX_TREE_SIZE 100  //二叉树的最大结点数

typedef int Status;
typedef int TElemType;
typedef TElemType SqBiTree[MAX_TREE_SIZE];  //0号单元存储根节点，使用一个数组存放数据

typedef struct 
{
    int level, order;   //结点的层，本层序号（按照满二叉树计算）

}Position;

TElemType Nil=0;    //设整型以0为空

Status visit_SqBiTree(TElemType c)
{
    printf("%d ",c);
    return OK;
}

//构造空二叉树T。因为T是固定数组，不会改变，因此不需要&
Status InitBiTree(SqBiTree T)
{
    int i;
    for (i=0;i<MAX_TREE_SIZE;i++)
        T[i]=Nil;   //初值为空
    return OK;
}

//按层序的次序输入二叉树中结点的值，构造顺序存储的二叉树T
Status CreateBiTree(SqBiTree T)
{
    int i=0;
    printf("请按照层序输入结点的值，0表示空节点，输入999表示结束，结点数<=%d\n",MAX_TREE_SIZE);

    while(i<10)
    {
        T[i]=i+1;
        if (i !=0 && T[(i+1)/2-1]==Nil && T[i]!=Nil)    //此结点不空，无双亲且不是根
        {
            printf("出现无双亲的非根结点%d\n",T[i]);
            exit(ERROR);
        }
        i++;
    }
    while(i<MAX_TREE_SIZE)
    {
        T[i]=Nil;       //将空值赋给T后面的结点
        i++;
    }
    return OK;
}


#define ClearBiTree InitBiTree //在二叉树的顺序存储结构中，清除和初始化函数一样

/*  初始条件：二叉树T存在*/
/*操作结果：若T为空二叉树，则返回TRUE；否则返回FALSE*/
Status isBiTreeEmpty(SqBiTree T)
{
    if (T[0]==Nil)  //若根节点为空，则树空
        return TRUE;
    else 
        return FALSE;
}


/*初始条件:二叉树T存在。操作结果：返回T的深度*/
int BiTreeDepth(SqBiTree T)
{
    int i,j=-1;
    for (i=MAX_TREE_SIZE-1; i>=0;i--)   //找到最后一个结点
    {
        if (T[i]!=Nil)
            break;
    }
    i++;
    do 
    {
        j++;
    } while (i>=powl(2,j)); //计算2的j次幂.pow(x,y):计算x的y次方

    return j;
}


/*  初始条件：二叉树T存在*/
/*  操作结果：当T不为空，用e返回T的根，返回OK；否则返回ERROR*/
Status Root(SqBiTree T, TElemType *e)
{
    if (isBiTreeEmpty(T))   //先判断是否为空
        return ERROR;
    else
    {
        *e =T[0];
        return OK;
    }
}


/*  初始条件：二叉树T存在，e是T中某个结点*/
/*操作结果：返回处于位置e（层，本层序号）的结点的值*/

TElemType Value(SqBiTree T, Position e)
{
    //2的k-1次方是当前层的第一个元素下标，再加上元素在当前层的序列，-1是得到在该层的准确位置，再进行-1是因为数组下标从0开始存数据（T[0]存放根节点数据）
    return T[(int)powl(2,e.level-1)+e.order-2];//将层序号转换为在数组中存放的下标
}


/*  初始条件：二叉树T存在，e是T中某个结点的位置*/
/*  操作结果：给处于位置e（层）的结点赋予新值value*/
Status Assign(SqBiTree T, Position e, TElemType value)
{
    int i=(int)powl(2,e.level-1)+e.order-2; //将层号转换为矩阵（一位数组）序号
    if (value!=Nil && T[(i+1)/2-1]==Nil)    //value非空；若双亲为空
        return ERROR;
    else if (value==Nil && (T[i*2+1]!=Nil || T[i*2+2]!=Nil))    //给存在孩子的双亲赋空
        return ERROR;

    T[i]=value; //以上两种情况都不是，即给T[i]赋值
    return OK;
}


/*初始条件：二叉树T存在，e是T中的某个结点*/
/*操作结果：若e是T的非根节点，则返回它的双亲，否则返回空*/
TElemType Parent(SqBiTree T, TElemType e)
{
    //判断是否为空树
    if (T[0]==Nil)  
        return Nil;
    for (int i=1; i<=MAX_TREE_SIZE-1; i++)
    {
        if (T[i]==e)    //先找到结点e
        {
            return T[(i+1)/2-1];
        }
    }
    return Nil;     //没找到e
}


/*初始条件：二叉树T存在，e是T中的某个结点*/
/*操作结果：返回e的左孩子。若e无左孩子，返回空*/
TElemType LeftChild(SqBiTree T, TElemType e)
{
    //判断是否为空树
    if (T[0]==Nil)
        return Nil;
    for(int i=0;i<=MAX_TREE_SIZE-1;i++)
    {
        if (T[i]==e)
        {
            return T[i*2+1];
        }
    }

    return Nil;//没找到e
}

/*操作结果，返回右孩子；若无右孩子，返回空*/
TElemType RightChild(SqBiTree T, TElemType e)
{
    if (T[0]==Nil)
        return Nil;
    for (int i=0; i<=MAX_TREE_SIZE-1; i++)
    {
        if (T[i]==e)
        {
            return T[(i+1)*2];
        }
    }
    return Nil;//没找到e,返回空
}


/*初始条件：二叉树T存在，e是T中的某个结点*/
/*操作结果：返回e的做兄弟。若e是左孩子或无左兄弟，返回空*/
TElemType LeftBrother(SqBiTree T, TElemType e)
{
    if (T[0]==Nil)
        return Nil;
    for (int i=1; i<=MAX_TREE_SIZE-1;i++)
    {
        if (T[i]==e && i%2==0)
        {
            return T[i-1];
        }
    }

    return Nil;//没找到e,或者e就是左孩子
}

//返回e的右兄弟
TElemType RightBrother(SqBiTree T, TElemType e)
{
    if (T[0]==Nil)
        return Nil;
    for(int i=1; i<MAX_TREE_SIZE;i++)
    {
        if (T[i]==e && i%2==1 /*&&T[i+1]!=Nil*/)
        {
            return T[i+1];
        }
    }
    return Nil;//没找到e
}


/*PreOrderTraverse()调用*/
void PreTraverse(SqBiTree T, int e)
{
    visit_SqBiTree(T[e]);
    if (T[2*e+1]!=Nil)      //左子树不为空
    {
        PreTraverse(T,2*e+1);
    }

    if (T[2*e+2]!=Nil)  //右子树不为空
    {
        PreTraverse(T,2*e+2);
    }
}


/*初始条件：二叉树存在*/
/*操作结果：先序遍历T（先序是指根节点先）*/
Status PreOrderTraverse(SqBiTree T)
{
    if (isBiTreeEmpty(T))
        return ERROR;
    PreTraverse(T,0);
    printf("\n");
    return OK;
}

//中序遍历InOrderTraverse()调用
void InTraverse(SqBiTree T,TElemType e)
{
    if (T[2*e+1]!=Nil)                  //左子树不为空，先左子树
    {
        InTraverse(T,2*e+1);
    }

    visit_SqBiTree(T[e]);               //第二才是对应根节点

    if (T[2*e+2]!=Nil)                  //第三是右子树
    {
        InTraverse(T,2*e+2);
    }

}

/*初始条件：二叉树T存在*/
/*操作结果：中序遍历*/
Status InOrderTraverse(SqBiTree T)
{
    if (!isBiTreeEmpty(T))
    {
        InTraverse(T,0);
    }
    printf("\n");
    return OK;
}


//后续遍历PostOrderTraverse()的调用函数
void PostTraverse(SqBiTree T, TElemType e)
{

    if (T[2*e+1]!=Nil)
    {
        PostTraverse(T,2*e+1);
    }

    if (T[2*e+2]!=Nil)
    {
        PostTraverse(T,2*e+2);
    }

    visit_SqBiTree(T[e]);

}

//后序遍历
Status PostOrderTraverse(SqBiTree T)
{
    if (!isBiTreeEmpty(T))
    {
        PostTraverse(T,0);
    }
    printf("\n");
    return OK;
}


/*层序遍历二叉树*/
void LevelOrderTraverse(SqBiTree T)
{
    //注意：要先找到最后一个非空节点的序号，然后再依次遍历
    int i=MAX_TREE_SIZE-1;
    while(T[i]==Nil)
        i--;
    for (int j=0;j<=i;j++)
    {
        if (T[j]!=Nil)          //只遍历非空结点
                visit_SqBiTree(T[j]);
    }
    printf("\n");
}

/*逐层、按照本层序号输出二叉树*/
void Print(SqBiTree T)
{
    Position p;
    TElemType e;
    for(int j=1;j<=BiTreeDepth(T);j++)
    {
        printf("第%d层：",j);
        for(int i=1;i<=powl(2,j-1);i++)
        {
            p.level=j;
            p.order=i;
            e=Value(T,p);
            if (e!=Nil)
            {
                printf("第%d个:%d",i,e);
            }
        }
        printf("\n");
    }
}

int main()
{
    Status i;
    Position p;
    TElemType e;
    SqBiTree T;
    InitBiTree(T);
    CreateBiTree(T);
    printf("建立二叉树之后，树是否为空？%d(1：是；0：否)\n",isBiTreeEmpty(T));
    printf("树的深度为%d\n",BiTreeDepth(T));

    i=Root(T,&e);
    if (i)
    {
        printf("二叉树的根节点为%d\n",i);
    }
    else
        printf("二叉树为空");

    printf("先序遍历二叉树：\n");
    PreOrderTraverse(T);

    printf("中序遍历二叉树：\n");
    InOrderTraverse(T);

    printf("后序遍历二叉树：\n");
    PostOrderTraverse(T);
    printf("层序遍历二叉树：\n");
    LevelOrderTraverse(T);

    printf("修改结点的层号3本层序号2.(第三层的第二个结点)");
    p.level=3;
    p.order=2;
    e=Value(T,p);
    printf(" %d",e);
    e=50;
    Assign(T,p,e);
    printf("修改后，前序遍历二叉树：\n");
    PreOrderTraverse(T);

    printf("结点%d的双亲为%d,左右孩子分别为%d和%d",e,Parent(T,e),LeftChild(T,e),RightChild(T,e));

    getchar();

}

2.2 二叉树的链式结构：二叉链表

首先要构造链式表的结构体，如下：

//和单链表类似。区别在于多了一个指针
typedef struct BiTNode
{
    TelemType data;//存放数据
    struct BiTNode *lchild,*rchild;//构造两个指针分别指向左子树和右子树
}BitNode，*BiTree;

其次，二叉链表在使用的时候，注意力在于根节点与左孩子和右孩子之间的关系。

/************************************************************************/
/* 树的链式存储结构  ：二叉链表                                               */
/************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <io.h>
#include <math.h>
#include <time.h>
#include <string.h>


#define OK 1
#define  ERROR 0
#define  TRUE 1
#define  FALSE 0

#define MAXSIZE 100
typedef int Status;
typedef char TElemType;
TElemType Nil2 =' ';        //字符型以空格为空，（整型Nil=0）

/******用于构造二叉树*******/
int index=1;
typedef char String[24];//定义一个字符型数组String，其中0号单元存放串的长度
String str;     //main()函数中用到

Status StrAssignBiTree(String T, char *chars)   //生成一个字符串T，其值等于chars
{
    int i;
    if (strlen(chars) > MAXSIZE)
        return ERROR;
    else
    {
        T[0]=strlen(chars);
        for (i=1; i<=T[0]; i++)
        {
            T[i]=*(chars+i-1);
        }
        return OK;
    }
}

/**************************************/


Status visitBiTree(TElemType e)
{
    printf("%c",e);
    return OK;
}

typedef struct BiTNode          /*定义结点结构*/
{
    TElemType data;                     //结点数据，TElemTypeChar型
    struct BiTNode *lchild, *rchild;        //定义左右孩子指针
}BiTNode, *BiTree;

//构造空的二叉树T
Status InitBiTree(BiTree *T)
{
    *T =NULL;
    return OK;
}

/*初始条件：二叉树T存在。操作结果：销毁二叉树*/
void DestroyBiTree(BiTree *T)
{
    if (*T)
    {
        if ((*T)->lchild)       //有左孩子
        {
            DestroyBiTree(&(*T)->lchild);       //销毁左孩子树
        }

        if ((*T)->rchild)
        {
            DestroyBiTree(&(*T)->rchild);
        }
        free(*T);   //释放根节点
        *T=NULL;    //空指针赋0
    }

}

#define ClearBiTree DestroyBiTree

/*  按前序输入二叉树中结点的值（这里设置的是一个字符）*/
/*  #表示空树，构造二叉链表表示二叉树T */
void CreateBiTree(BiTree *T)
{
    TElemType ch;
    ch=str[index++];

    if (ch=='#')        //空树
    {
        *T=NULL;
    }

    else
    {
        *T=(BiTree)malloc(sizeof(BiTNode));
        if (!*T)
            exit(OVERFLOW);     //表示未分配到合适大小的空间
        (*T)->data=ch;
        CreateBiTree(&(*T)->lchild);        //构造左子树
        CreateBiTree(&(*T)->rchild);        //构造右子树
    }
}

/*  初始条件：二叉树T存在 */
/*  操作结果：若T为空二叉树，返回TRUE；否则返回FALSE   */
Status isBiTreeEmpty(BiTree T)
{
    if(T)
        return FALSE;
    else
        return TRUE;
}


/*  初始条件：二叉树T存在。  操作结果：返回T的深度   */
int BiTreeDepth(BiTree T)
{
    int i,j;
    if(!T)
        return ERROR;
    if (T->lchild)
        i=BiTreeDepth(T->lchild);
    else
        i=0;
    if (T->rchild)
        j=BiTreeDepth(T->rchild);           //因为不一定是完全二叉树，所以有可能是各种奇怪的二叉树。因此既要判断左子树，也要判断右子树
    else
        j=0;

    return i>j?i+1:j+1;
}


/*  初始条件：二叉树T存在。 操作结果：返回T的根 */
TElemType Root(BiTree T)
{
    if (!T)
        return Nil2;
    else
        return T->data;
}

/*  初始条件：二叉树T存在，p指向T中的某个结点  */
/*  操作结果：返回p所指向结点的值 */
TElemType Value(BiTree p)
{
    return p->data;     //
}

//给p所指向的结点赋值为value
void Assign(BiTree p, TElemType value)
{
    p->data =value;
}

/*初始条件：二叉树T存在。操作结果：前序遍历T*/
void PreOrder(BiTree T)
{
    if (!T)
        return;
    printf("%c ",T->data);      //显示结点数据
    PreOrder(T->lchild);
    PreOrder(T->rchild);
}

/*  初始条件：二叉树T存在。操作结果：中序遍历T*/
void InOrder(BiTree T)
{
    if (!T)
        return;
    InOrder(T->lchild);
    printf("%c ",T->data);
    InOrder(T->rchild);
}

/*  后序遍历*/
void PostOrder(BiTree T)
{
    if(!T)
        return;
    PostOrder(T->lchild);
    PostOrder(T->rchild);
    printf("%c ",T->data);
}




int main()
{
    int i;
    BiTree T;
    TElemType e1;
    InitBiTree(&T);
    StrAssignBiTree(str,"ABDH#K###E##CFI###G#J##");

    CreateBiTree(&T);
    printf("构造空二叉树后，树是否为空？%d(1：空；0：否)，树的深度为%d\n",isBiTreeEmpty(T),BiTreeDepth(T));

    e1=Root(T);
    printf("树的根为%c\n",e1);

    printf("\n前序遍历结果：");
    PreOrder(T);
    printf("\n中序遍历结果：");
    InOrder(T);
    printf("\n后序遍历结果：");
    PostOrder(T);
    ClearBiTree(&T);
    printf("\n清除二叉树后，树是否为空？%d(1:空；0：否)，树的深度为%d\n",isBiTreeEmpty(T),BiTreeDepth(T));
    i=Root(T);
    if (!i)
        printf("树空，无根\n");

    getchar();
    return 0;


}
xyy_496
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构：树(Tree)【详解】
UniqueUnit的博客
02-26 15万+
树 一、知识框架 二、考纲内容 树的基本概念 二叉树 二叉树的定义及其主要特征；二叉树的顺序存储结构和链式存储结构；二叉树的遍历；线索二叉树的基本概念和构造 树、森林 树的存储结构；森林与二叉树的转换；树和森林的遍历 树与二叉树的应用 二叉排序树；平衡二叉树；哈夫曼树和哈弗编码 三、树的基本概念 1、树的定义 树是n（n>=0）个结点的有限集。当n = 0时，称为空树。在任意一棵非空树中应满足： 有且仅有一个特定的称为根的结点。 当n>1时，其余节点可分为m（m>
数据结构：树（基础概念操作图文解释）
weixin_46015333的博客
03-07 4093
本文比较全面的总结了树的概念及其性质，配有很多图片辅以理解，后又从递归和非递归两种方式实现了树的先序遍历、中序遍历和后续遍历，最后也实现了层序遍历并给出了部分遍历方式的过程解析。
数据结构算法--树详解
最新发布
jy18817386398的博客
03-22 487
二叉树：有序树；每个节点最多有2个子节点，子节点有左右之分。二叉树第i层有2^(i - 1)个节点。假如二叉树深度为K，则二叉树最多有2^(K - 1)个节点。
数据结构（十三）——树
weixin_34132768的博客
02-04 452
数据结构（十三）——树 一、树的简介 1、树的简介 树是一种非线性的数据结构，是由n（n >=0）个结点组成的有限集合。如果n==0，树为空树。如果n>0，树有一个特定的结点，根结点根结点只有直接后继，没有直接前驱。除根结点以外的其他结点划分为m（m>=0）个互不相交的有限集合，T0，T1，T2，...，Tm-1，每个结合是一棵树，称为根结点的子树。树的示例如下： 2、树的度 树...
数据结构：树
张维鹏的博客
06-24 3217
目录 1、二叉树： 2、二叉查找树： 3、平衡二叉树: 3.1、平衡查找树之AVL树： 3.2、平衡二叉树之红黑树： 4、B树： 5、B+树： 6、B*树： 7、Trie树：   1、二叉树： 　　二叉树的定义：每个结点至多只有两个子节点的树。 （1）满二叉树：叶子节点全部都在最底层，除了叶子节点，其余的每个节点都有两个的子节点。 ①一颗树深度为h，最大层数为k，深度与...
C语言数据结构——树
01-10
C语言数据结构，树相关知识，整理了一段时间，差不多有个雏形，大家可以参考学习。
自定义数据结构——树 v1.1.zip
06-03
实现了一个自定义的数据结构 —— 树，该自定义结构不同于二叉树及其他数据结构，每个节点的子节点个数不受限制，最大限度保留了数据的原始结构，并实现了其前序和后序遍历的方法。优点是节省了内存，但缺点则是基于...
算法与数据结构教材四(数据结构——树).doc
06-08
算法与数据结构教材四(数据结构——树).doc
数据结构中“树”的全面讲解
qq_65596720的博客
05-26 1574
​ 树结构是一种一对多的非线性结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因 为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。不要与现实中的树混在一起，当n>0时，树有且只有一个根结点。除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1
【计算机基本原理-数据结构】数据结构中树的详解
weixin_53543905的博客
04-26 1319
我们知道，实际应用当中，我们经常使用的是查找和排序操作，这在我们的各种管理系统、数据库系统、操作系统等当中，十分常用。数组：数组的下标寻址十分迅速，但计算机的内存是有限的，故数组的长度也是有限的，实际应用当中的数据往往十分庞大；而且无序数组的查找最坏情况需要遍历整个数组；后来人们提出了二分查找，二分查找要求数组的构造一定有序，二分法查找解决了普通数组查找复杂度过高的问题。任何一种数组无法解决的问题就是插入、删除操作比较复杂，因此，在一个增删查改比较频繁的数据结构中，数组不会被优先考虑。普通链表。
数据结构————树
mm1619902526的博客
01-07 818
如图，是一棵普通树 1.度数：结点拥有的子树数目称为结点的度。 2. 节点关系1.定义：二叉树是n(n>=0)个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树组成。 如图为普通二叉树 定义：若设二叉树的深度为h，除第 h 层外，其它各层 (1~h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集中在最左边，这就是完全二叉树。（就是说除最后一层外 其他层都是满的 且最后一层节点只能集中在左侧） 顺序存储适合完全二叉树 其他的树会
数据结构--树
椰汁菠萝
05-05 1206
一、树的概念 这是一颗大自然的树 这是数据结构中的树 二者看起来是如此的相像，现实中的树是根在地上，枝干往上长，叶子在整颗树的最顶端。而数据结构中的树如此相似却又刚好相反，树的根在上面，枝干往下长，叶子在树的最底端。先在脑子里有这么个概念，具体有关于树的术语在下文详细提及。 定义 树是一种非线性结构，由n（n >= 0）个结点组成，当n=0的时候，此时的树被称为空树。当n>0时，此时的树存在一个结点被称为根结点（如上图的A结点），而除根结点外的其它结点可以分为m个集合，每个集合本身又是一颗树
【数据结构】树
m0_61438674的博客
03-14 893
如果节点为空就返回空，如果该节点的值就是x那就返回该节点的指针，如果该节点的值不是要查找的值那就遍历它的左子树，用tmp1来接收左子树的查找结果，如果tmp1不是空说明在左子树中找到了所以返回tmp1。叶子节点就是该节点的左右子树==NULL ，如果节点为空返回0，如果该节点的左子树和右子树的=空那这个节点就是叶子节点 所以返回1。那最终的返回值就是左子树的叶子节点个数加右子树的叶子结点的个数。先求出左子树的高度，再求出右子树的高度，最终返回的高度就是该节点的左右子树的最大高度+1（自己）。
数据结构 --- 树(详解)
weixin_68539386的博客
01-04 994
hello , 树先生
VS2010无法创建新c++程序（新建win32控制台应用程序项目不成功）的解决办法
连421的博客
07-23 7648
部分内容转自https://blog.csdn.net/zhangying_496/article/details/77872117 我在配置OpenCV的时候，在VS2010中新建C++项目时出现问题，点确定后不能成功新建项目，一直停留在新建项目的页面。 在网上搜了很多，最后找到了一篇提供思路的解决办法。 下面是原文： ----------------------------------...
怎么在KeilMDK里使用数据结构——树
05-16
在这个示例代码中，我们首先定义了一个树节点结构体，包含了节点数据和左右子节点指针。然后我们定义了创建节点和插入节点的函数，使用递归的方式实现。最后我们定义了计算树深度的函数，并在main函数中使用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值