树（C语言）

最新推荐文章于 2024-10-08 16:10:58 发布
最新推荐文章于 2024-10-08 16:10:58 发布
阅读量255 收藏 1
点赞数 5
分类专栏： C语言数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_76640324/article/details/137482701
版权

顺序存储结构

typedef struct BNode {
    int data;
    struct BNode* Ichild, * rchild;
}BNode,*BTree;

遍历二叉树

1.先序
创建
void create(BTree& T) {
    char ch;
    scanf_s(&ch);
    if (ch == '#') {
        T = NULL;
    }
    else {
        T->data = ch;
        create(T->lchild);
        create(T->rchild);
    }
}

输出

法1：

void preorder(BTree T) {
    if (T == NULL) {
        cout << "空" << endl;
    }
else {
        cout << T->data;
        preorder(T->lchild);
        preorder(T->rchild);
    }
}

法2：

void pre(BTree T) {
    if (T != NULL) {
        cout << T->data;
        pre(T->lchild);
        pre(T->rchild);
    }
}

2.中序
void inorder(BTree T) {
    if (T == NULL) {
        cout << "空" << endl;
    }
    else {
        inorder(T->lchild);
        cout << T->data;
        inorder(T->rchild);
    }
}

3.后序
void post(BTree T) {
    if (T == NULL) {
        cout << "空" << endl;
    }
    else {
        post(T->lchild);
        post(T->rchild);
        cout << T->data;
    }
}

4.层次
//加上<malloc.h>头文件
​
BTree create(){
    int data,maxsize;
    BTree BT,T;
    Queue Q=init(maxsize);
    scanf("%d",&data);
    if(data!=noinfo){
        BT=(BTree)malloc(sizeof(BNode));
        BT->data=data;
        BT->lchild=BT->rchild=NULL;
        Add(Q,BT);
    }
    else return NULL;
    while(!isempty(Q)){
        T=Delete(Q);
        scanf("%d",&data);
        if(data==noinfo){
            T->lchild=NULL;
        }
        else{
            T->lchild=(BTree)malloc(sizeof(BNode));
            T->lchild->data=data;
            T->lchild->lchild=T->lchild->rchild=NULL;
            Add(Q,T->lchild);
        }
        scanf("%d",&data);
        if(data==noinfo){
            T->rchild=NULL;
        }
        else{
            T->rchild=(BTree)malloc(sizeof(BNode));
            T->rchild->data=data;
            T->rchild->lchild=T->rchild->rchild=NULL;
            Add(Q,T->rchild);
        }
    }
    return BT;
}

链式存储结构

typedef struct TNode {
    int data;
    struct INode* lchild, * parent, * rchild;
}TNode,*TTree;

创建二叉链表（空子节点表示为#）

void create(BTree& T) {
    char ch;
    scanf(“%c",&ch);
    if (ch == '#') {
        T = NULL;
    }
    else {
        T->data = ch;
        create(T->lchild);
        create(T->rchild);
    }
}

复制二叉树

int copy(BTree T, BTree& newT) {
    if (T == NULL) {
        newT = NULL;
        return 0;
    }
    else {
        newT = new BNode;
        newT->data = T->data;
        copy(T->lchild, newT->lchild);
        copy(T->rchild, newT->rchild);
    }
}

计算二叉树深度

int depth(BTree T) {
    if (T == NULL) {
        return 0;
    }
    else {
        int m = depth(T->lchild);
        int n = depth(T->rchild);
        if (m > n) {
            return m + 1;
        }
        else {
            return n + 1;
        }
    }
}

计算二叉树结点总数

int nodecount(BTree T) {
    if (T == NULL) {
        return 0;
    }
    else {
        return nodecount(T->lchild) + nodecount(T->rchild) + 1;
    }
}

计算二叉树叶子结点总数

int leafcount(BTree T) {
    if (T == NULL) {
        return 0;
    }
    if (T->lchild == NULL && T->rchild == NULL) {
        return 1;
    }
    else {
        return leafcount(T->lchild) + leafcount(T->rchild);
    }
}

二叉搜索树

动态查找（递归法)

int find(int x,BTree BT){
    if(!BT){
        return NULL;
    }
    if(x>BT->data){
        return find(x,BT->rchild);
    }
    else if(x<BT->data){
        return find(x,BT->lchild);
    }
    else{
        return BT->data;
    }
}

动态查找（非递归法）

int find(int x,BTree BT){
    while(BT){
        if(x>BT->data){
            BT=BT->rchild;
        }
        else if(x<BT->data){
            BT=BT->lchild;
        }
        else{
            break;
        }
    }
    return BT->data;
}

插入元素

BTree insert(BTree BT,int x){
    if(!BT){
        BT=(BTree)malloc(sizeof(BNode));
        BT->data=x;
        BT->lchild=BT->rchild=NULL;
    }
    else{
        if(x<BT->data){
            BT->lchild=insert(BT->lchild,x);
        }
        else if(x>BT->data){
            BT->rchild=insert(BT->rchild,x);
        }
    }
    return BT;
}

查找最小值

BTree findmin(BTree BT){
    if(!BT){
        return NULL;
    }
    else if(!BT->lchild){
        BT=BT->lchild;
    }
    return BT;
}

查找最大值

BTree findmax(BTree BT){
    if(!BT){
        return NULL;
    }
    else if(!BT->rchild){
        BT=BT->rchild;
    }
    return BT;
}

删除节点

BTree Delete(BTree BT,int x){
    BTree temp;
    if(!BT){
        printf("未找到删除元素");
    }
    else{
        if(x<BT->data){
            BT->lchild=Delete(BT->lchild,x);
        } 
        else if(x>BT->data){
            BT->rchild=Delete(BT->rchild,x);
        }
        else{
            if(BT->lchild&&BT->rchild){
                temp=findmin(BT->rchild);
                BT->data=temp->data;
                BT->rchild=Delete(BT->rchild,BT->data);
            }
            else{
                temp=BT;
                if(!BT->lchild){
                    BT=BT->rchild;
                }
                else{
                    BT=BT->lchild;
                }
                free(temp);
            }
        }
    }
    return BT;
}

平衡二叉树

插入操作
typedef struct AVLNode{
    int data;
    struct AVLNode* Left;
    struct AVLNode* Right;
    int Height;
}AVLNode,*AVLTree;
 int max(int a,int b){
    return a>b? a:b;
 }
 int GetHeight(AVLTree T){
    if(T==NULL){
        return 0;
    }
    else{
        int m=GetHeight(T->Left);
        int n=GetHeight(T->Right);
        if(m>n){
            return m+1;
        }
        else{
            return n+1;
        }
    }
}
AVLTree LeftRotation(AVLTree A){
    AVLTree B=A->Left;
    A->Left=B->Right;
    B->Right=A;
    A->Height=max(GetHeight(A->Left),GetHeight(A->Right))+1;
    B->Height=max(GetHeight(B->Left),A->Height)+1;
    return B; 
}
AVLTree RightRotation(AVLTree A){
    AVLTree B=A->Right;
    A->Right=B->Left;
    B->Left=A;
    A->Height=max(GetHeight(A->Left),GetHeight(A->Right))+1;
    B->Height=max(GetHeight(B->Left),A->Height)+1;
    return B; 
}
AVLTree DoubleLeftRightRotation(AVLTree A){
    A->Left=RightRotation(A->Left);
    return LeftRotation(A);
}
 AVLTree insert(AVLTree T,int x){
    if(!T){
        T=(AVLTree)malloc(sizeof(struct AVLNode));
        T->data=x;
        T->Height=1;
        T->Left=T->Right=NULL;
    }
    else if(x<T->data){
        T->Left=insert(T->Left,x);
        if(GetHeight(T->Left)-GetHeight(T->Right)==2){
            if(x<T->Left->data){
                T=LeftRotation(T);
            }
            else{
                T=DoubleLeftRightRotation(T);
            }
        }
    }
    else if(x>T->data){
        T->Right=insert(T->Right,x);
        if(GetHeight(T->Left)-GetHeight(T->Right)==-2){
            if(x>T->Right->data){
                T=RightRotation(T);
            }
            else{
                T=DoubleLeftRightRotation(T);
            }
        }
    }
    T->Height=max(GetHeight(T->Left),GetHeight(T->Right))+1;
    return T;
 }

左单旋算法
AVLTree LeftRotation(AVLTree A){
    AVLTree B=A->Left;
    A->Left=B->Right;
    B->Right=A;
    A->Height=max(GetHeight(A->Left),GetHeight(A->Right))+1;
    B->Height=max(GetHeight(B->Left),A->Height)+1;
    return B; 
}

右单旋算法
AVLTree RightRotation(AVLTree A){
    AVLTree B=A->Right;
    A->Right=B->Left;
    B->Left=A;
    A->Height=max(GetHeight(A->Left),GetHeight(A->Right))+1;
    B->Height=max(GetHeight(B->Left),A->Height)+1;
    return B; 
}

左右双旋算法
AVLTree DoubleLeftRightRotation(AVLTree A){
    A->Left=RightRotation(A->Left);
    return LeftRotation(A);
}

线索二叉树

结构

typedef struct BTNode {
    int data;
    int ltag, rtag;
    struct BTNode* lchild, * rchild;
}BTNode,*BTTree;

森林

结构

typedef struct PTNode {
    int data;
    int parent;
}PTNode;
#define max 100
typedef struct {
    PTNode nodes[max];
    int r, n;
}PTree;

树转化为二叉树

1.加线：兄弟之间加连线

2.抹线：对每个节点，除了左孩子，去除与其他孩子之间的关系

(兄弟相连留长子)

森林转化为二叉树

1.每棵树转化为二叉树

2.每棵树的根节点用线相连

3.第一棵树根节点为二叉树的根，一根节点为轴心，顺时针旋转

(树变二叉根相连)

二叉树转化成森林

1.抹线：二叉树根节点与其右孩子连线，及沿右分支搜索到的所有右孩子间的连线全部抹掉，使之变成孤立的二叉树

2.还原：将孤立的二叉树还原成树

(去掉全部右孩线，孤立二叉再还原)

知识の搬运工
关注
专栏目录
圣诞树c语言实现源码.zip
12-15
本压缩包“圣诞树c语言实现源码.zip”提供了一个用C语言编写的圣诞树图形绘制程序，通过学习和理解这个源码，可以加深对C语言控制字符输出、循环结构以及条件判断的理解。 首先，让我们来看看核心的源代码文件...
哈夫曼树C语言实例代码.cpp
03-10
代码为.cpp程序，可用DevC打开运行，或许有一些不合理的地方或者错误地方，烦请各位加以批评指正，共同进步。
哈夫曼树（C语言实现）
热门推荐
2021dragon的博客
06-18 9万+
文章目录哈夫曼树的基本概念哈夫曼树的构建构建思路代码实现哈夫曼编码的生成编码生成思路代码实现完整代码展示以及代码测试 哈夫曼树的基本概念 在认识哈夫曼树之前，你必须知道以下几个基本术语： 1、什么是路径？  给定N个权值作为N个结点，构造一棵二叉树，若该树的带权路径长度达到最小，则称该二叉树为哈夫曼树，也被称为最优二叉树。 哈夫曼树的构建 构建思路 代码实现 哈夫曼编码的生成 编码生成思路 代码实现 完整代码展示以及代码测试 ...
圣诞树c语言代码
weixin_35748962的博客
02-07 3966
圣诞树是一种视觉效果的程序设计模型，可以通过在控制台上使用字符和符号的不同组合来模拟出一棵带有装饰物的圣诞树的形象。以下是一个使用 C 语言实现圣诞树的简单示例代码： #include <stdio.h> int main(void) { printf(" *\n"); printf(" ***\n"); printf(" *****\n"); ...
二叉搜索树C语言代码实现
weixin_61819021的博客
05-20 1662
有些题里除了这个概念，不知道的话就蒙圈了。 先序遍历： root——>left——>right 中序遍历： left—— root ——>right 先弄一个只有四个节点的小型二叉树，实际上这种小型二叉树应用不大。 二叉树的真正应用是二叉搜索树，处理海量的数据。 代码很简单，两种遍历的代码也差不多 #include<stdio.h> #include<stdlib.h> typedef struct node{ int data; struct n
校门外的树C语言详解
qq_61466402的博客
11-22 6773
/*题目描述 某校大门外长度为 l 的马路上有一排树，每两棵相邻的树之间的间隔都是 1 米。 我们可以把马路看成一个数轴，马路的一端在数轴 0 的位置，另一端在 l 的位置；数轴上的每个整数点，即 0,1,2,…,l，都种有一棵树。 由于马路上有一些区域要用来建地铁。 这些区域用它们在数轴上的起始点和终止点表示。 已知任一区域的起始点和终止点的坐标都是整数，区域之间可能有重合的部分。 现在要把这些区域中的树（包括区域端点处的两棵树）移走。你的任务是计算将这些树都移走后，马路上还有多少棵树。 输入格式 .
vc圣诞树c语言,C语言打印圣诞树(示例代码)
weixin_27210125的博客
05-24 1万+
#include #include int main(int argc, char* argv[]) {int n = argc > 1 ? atoi(argv[1]) : 4;for (int j = 1; j <= n; j++) {int s = 1 << j, k = (1 << n) - s, x;for (int y = s - j; y >=...
二叉排序树C语言实现（超级详细代码）
nidayededaye2的博客
12-12 7294
今天来给大家讲解一下二叉排序树C语言代码实现 typedef int ElemType; // 自定义数据元素为整数。 // 二叉树的数据结构。 typedef struct BSTNode { ElemType data; // 存放结点的数据元素。 struct BSTNode* lchild; // 指向左子结点地址的指针。 struct BSTNode* rchild; // 指向右子结点地址的指针。 ..
B+树C语言实现
qq_49764697的博客
12-27 831
B+树C语言实现，已实现插入功能
题目 1099: 校门外的树 C语言
Lukegood的博客
10-19 854
注意把原来种树的地方设置为0,然后没有树了就设置为1就可以了.
二叉排序树c语言,数据结构：二叉查找树(C语言实现)(示例代码)
weixin_34345599的博客
05-19 555
?写在前面关于二叉树的基础知识，请看我的一篇博客:二叉树的链式存储说明：二叉排序树或者是一棵空树，或者是具有下列性质的二叉树：1.若其左子树不空，则左子树上所有结点的值均小于它的根结点的值；2.若其右子树不空，则右子树上所有结点的值均大于它的根结点的值;3.其左、右子树也分别为二叉排序树?二叉查找树的建立(插入)：说明：二叉树的创建是二叉树反复插入节点所构造出来的！若二叉树为空树，则插入元素作为树...
求100到1000有多少水仙花树 c语言
weixin_70639086的博客
02-01 729
水仙花数是指一个 3 位数，它的每个数位上的数字的 3次幂之和等于它本身。例如：1^3 + 5^3+ 3^3 = 153。
决策树c语言demo.rar
04-25
本文详细介绍了如何使用C语言实现决策树算法，包括构建决策树、剪枝处理以及使用决策树进行分类的过程。通过具体的代码实现和实例分析，读者可以深入了解决策树算法的原理和应用。 决策树是一种常用的分类和回归...
实现哈夫曼编码，构造哈夫曼树C语言.zip
11-10
哈夫曼编码实现哈夫曼编码，构造哈夫曼树C语言.zip实现哈夫曼编码，构造哈夫曼树C语言.zip实现哈夫曼编码，构造哈夫曼树C语言.zip实现哈夫曼编码，构造哈夫曼树C语言.zip实现哈夫曼编码，构造哈夫曼树C语言.zip
哈夫曼树c语言编写
08-30
哈夫曼树构造 输出
数据结构编程实践20讲(Python版)—06二叉搜索树
AnFany
10-08 1141
数据结构编程实践20讲(Python版)—06二叉搜索树
每日学习一个数据结构-树
wendao76的专栏
10-03 1157
树是由n（n≥0）个节点组成的有限集合。当n=0时，称为空树；当n>0时，为非空树。在非空树中，有且仅有一个特定的节点被称为根（root），其余节点可分为m（m>0）个互不相交的有限集T1, T2, …, Tm，其中每一个集合本身又是一棵树，并且被称为根的子树（Subtree）。访问时机：三种遍历方式的主要区别在于访问根节点的时机不同。在前序遍历中，根节点在左、右子节点之前被访问；在中序遍历中，根节点在左、右子节点之间被访问；在后序遍历中，根节点在左、右子节点之后被访问。应用场景。
逆变器PQ控制模型、逆变器并网模型（Simulink） 直流侧电压650V～2000V均可 交流测电压为380V 有功功率和无功
10-10
逆变器PQ控制模型、逆变器并网模型（Simulink） 直流侧电压650V～2000V均可 交流测电压为380V 有功功率和无功功率可达10kW或10kVar，甚至更高
SpringBoot+Vue工厂生产设备维护管理系统答辩PPT.ppt
最新发布
10-10
计算机毕业设计答辩PPT
哈夫曼树C语言实现与编码详解
该资源提供了一段C语言实现的哈夫曼树（Huffman Tree）编码的源代码，适用于学习数据结构的初学者。代码包含了详细的注释，易于理解，并且编写规范。哈夫曼树是一种特殊的二叉树，常用于数据压缩，通过构建最小带权...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值