树-C实现

最新推荐文章于 2024-07-06 22:34:06 发布
最新推荐文章于 2024-07-06 22:34:06 发布
阅读量288 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构

注意事项

1.可能存在变量名大小问题
2.注意定义例如ElementType

二叉树

层次建立二叉树

BinTree* CreateBinTree(){
    int Data;
    BinTree* BT,*T;
    Queue* Q = CreateQueue();
    scanf("%d",&Data); //建立根节点
    if(Data){
        BT = (BinTree*)malloc(sizeof(BinTree));
        BT->Data = Data;
        Add(Q,BT);
    }else{
        return NULL;
    }
    while(!IsEmptyQ(Q)){  
        T = DeleteQ(Q);
        scanf("%d",&Data);   //读入左孩子
        if(!Data)
            T->Left = NULL;
        else{
            T->Left = (BinTree*)malloc(sizeof(BinTree));
            T->Left->Data = Data;
            AddQ(Q,T->Left);
        }
        scanf("%d",&Data);//读入右孩子
        if(!Data)
            T->Right = NULL;
        else{
            T->Right = (BinTree*)malloc(sizeof(BinTree));
            T->Right->Data = Data;
            AddQ(Q,T->Right);
        }
    }
    return BT;
}

树的高度

int PostOrderGetHeight(BinTree *BT){
    int HL,HR,MaxH;
    if(BT){
        HL = PostOrderGetHeight(BT->Left);
        HR = PostOrderGetHeight(BT->Right);
        MaxH = HL > HR ? HL : HR;
        return (MaxH + 1);
    }else{
        return 0;
    }
}

层次遍历

void LevelOrderTraversal ( BinTree BT){
    Queue *Q;
    BinTree* T;
    if(!BT)
        return;
    Q = CreateQueue();
    AddQ(Q,BT);
    while(!IsEmptyQ(Q)){
        T = DeleteQ(Q);
        printf("%d",T->Data);
        if(T->Left)
            AddQ(Q,T->Left);
        if(T->Right)
            AddQ(Q,T->Right);
    }
}

后序非递归

void PostOrder(BinTree *BT){
    BinTree *cur;
    BinTree *Pre = NULL;
    Stack *S = CreateStack();
    Push(S,BT);
    while(!IsEmpty()){
        cur = PtrS->Data[(PtrS->Top)]; 
        if( (cur->Left == NULL && cur->Right == NULL) || (pre != NULL && (pre == cur->Left ||pre == cur->Right ))){
            printf("%d",cur->Data);
            Pop(S);
            pre = cur;
        }else{
            if(cur->Right)
                Push(cur->Right);
            if(cur->Left)
                Push(cur->Left);
        }
    }
}

前序非递归

void PreOrder(BinTree *BT){
    BinTree *T;
    Stack *S = CreateStack();
    T = BT;
    while(T || !IsEmpty(S) ){
        while(T){  一直向左并将沿途结点压入堆栈
            printf("%d",T->Data);//打印结点
            Push(S,T);
            T = T->Left;
        }
        T = Pop(S); //结点弹出堆栈
        T = T->Right;//转向右子树
    }
}

中序非递归

void InOrder(BinTree *BT){
    BinTree *T;
    Stack *S = CreateStack();
    T = BT;
    while(T || !IsEmpty(S) ){
        while(T){  一直向左并将沿途结点压入堆栈
            Push(S,T);
            T = T->Left;
        }
        T = Pop(S); //结点弹出堆栈
        printf("%d",T->Data);//打印结点
        T = T->Right;//转向右子树
    }
}

递归后中前

void PostOrderTraversal(BinTree *BT){
    if(BT){
        PostOrderTraversal(BT->Left);
        PostOrderTraversal(BT->Right);
        printf("%d",BT->Data);
    }
}
void InOrderTraversal(BinTree *BT){
    if(BT){
        InOrderTraversal(BT->Left);
        printf("%d",BT->Data);
        InOrderTraversal(BT->Right);
    }
}
void PreOrderTraversal(BinTree *BT){
    if(BT){
        printf("%d",BT->Data);
        PreOrderTraversal(BT->Left);
        PreOrderTraversal(BT->Right);
    }
}

二叉搜索树

按值查找

//递归
BinTree* Find(ElementType X, BinTree* BST){
    if(!BST)
        return NULL; //查找失败
    if(X > BST->Data)
        return Find(X , BST->Right);
    else
        if(X < BST->Data)
            return Find(X, BST->Left);
    else
        return BST;
}
//迭代
BinTree* iterFind( ElementType X, BinTree* BST){
    while(BST)
    {
        if(X > BST->Data)
            BST=BST->Right;
        else if(X < BST->Data)
            BST=BST->Left;
        else
            return BST;
    }
    return NULL;
}

查找最小

BinTree* FindMin( BinTree* BST){
    if(BST)
        while(BST->Left)
            BST=BST->Left;
    return BST;
}
BinTree* FindMin( BinTree* BST){
    if(!BST)
        return NULL;
    else
        if(!BST->Left)
            return BST;
    else
        return FindMin(BST->Left);
}

查找最大

BinTree* FindMax( BinTree* BST){
    if(BST)
        while(BST->Right)
            BST=BST->Right;
    return BST;
}
BinTree* FindMax( BinTree* BST){
    if(!BST)
        return NULL;
    else
        if(!BST->Right)
            return BST;
    else
        return FindMin(BST->Right);
}

插入

BinTree* Insert( ElementType X ,BinTree* BST){
    if(!BST){
        BST = (BinTree*)malloc(sizeof(BinTree));
        BST->Data = X;
        BST->Left = BST->Right = NULL;
    }else{
        if(X < BST->Data)
            BST->Left = Insert(X,BST->Left);
        else if(X > BST->Data)
            BST->Right = Insert(X,BST->Right);
    }
    return BST;
}

删除

BinTree* Delete(ElementType X, BinTree *BST){
    BinTree* tmp;
    if(!BST)
        printf("No Found");
    else
        if(X < BST->Data)
            BST->Left = Delete(X,BST->Left); //左子树递归删除
        else
            if(X > BST->Data)
                BST->Right = Delete(X,BST->Right); //右子树递归删除
            else if(BST->Left && BST->Right){   //左右节点都存在
                tmp = FindMin(BST->Right);  //先找到右边最小 或者左边最大
                BST->Data = tmp->Data;
                BST->Right = Delete(BST->Data,BST->Right); //删除那个元素
            }else{ //被删除的结点有一个或没有子结点
                tmp = BST;
                if(!BST->Left)
                    BST = BST->Right;
                else if(!BST->Right)
                    BST = BST->Left;
                free(tmp);
            }
    return BST;
}

平衡二叉树

实现结构

typedef struct AVLTreeNode{
    ElementType Data;
    struct AVLTreeNode* Left;
    struct AVLTreeNode* Right;
    int Height;
}AVLTree;

插入以及调整函数

AVLTree* AVL_insertion(ElementType X ,AVLTree* T) //AVL树插入
AVLTree* SingleLeftRotation(AVLTree* A); //左单旋
AVLTree* DoubleLeftRightRotation(AVLTree* A);//左右双旋
AVLTree* SingleRightRotationRotation(AVLTree* A);//右单选
AVLTree* DoubleRightLeftRotation(AVLTree* A);//右左双旋
AVLTree* DoubleRightLeftRotation(AVLTree* A){
    A->Right = SingleLeftRotation(A->Right);
    return SingleRightRotation(A);
}
AVLTree* SingleRightRotation(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), GetHeight(B->Right)) + 1;
    return B;
}
AVLTree* DoubleLeftRightRotation(AVLTree* A){
    A->Left = SingleRightRotation(A->Left);
    return SingleLeftRotation(A);
}
AVLTree* SingleLeftRotation(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* AVL_insertion(ElementType X ,AVLTree* T){
    if(!T){ //如果插入的是空树
        T = (AVLTree*)malloc(sizeof(AVLTree));
        T->Data = X;
        T->Height = 0;
        T->Left = T->Right = NULL;
    }else if(X < T->Data){ 
        T->Left = AVL_insertion(X,T->Left);
        if(GetHeight(T->Left) - GetHeight(T->Right) == 2) //需要左旋
            if(X < T->Left->Data)
                T = SingleLeftRotation(T);   //左单旋
            else
                T = DoubleLeftRightRotation(T); //左右双旋
    }else if(X > T->Data){
        T->Right = AVL_insertion(X,T->Left);
        if(GetHeight(T->Left) - GetHeight(T->Right) == -2)  //需要右旋
            if(X < T->Left->Data)
                T = SingleRightRotation(T); //右单旋
            else
                T = DoubleRightLeftRotation(T);//右左双旋
    }
    //else X == T->Data , 无需插入
    T->Height = Max(GetHeight(T->Left) , GetHeight(T->Right) ) + 1; //更新高度
    return T;
}

最大堆

实现结构

typedef struct Heap{
    ElementType *Elements;
    int Size;
    int Capacity;
}MaxHeap;

创建

MaxHeap* Create(int MaxSize){
    MaxHeap *H = (MaxHeap)malloc(sizeof(MaxHeap));
    H->Elements = (ElementType*)malloc(   (MaxSize + 1)  * sizeof(ElementType) );
    H->Size = 0;
    H->Capacity = MaxSize;
    H->Elements[0] = MaxData; //     哨兵 ：大于堆中所有元素
    return H;
}

插入

void Insert(MaxHeap H,ElementType item){
    int i;
    if(IsFull(H)){
        printf("最大堆满");
        return;
    }
    i = ++H->Size;
    for(;H->Elements[i / 2] < item ; i /= 2)
        H->Elements[i] = E->Elements[i / 2];
    H->Elements[i] = item;
}

删除

Elements DeleteMax(MaxHeap *H){
    int Parent,Child;
    ElementType MaxItem,tmp;
    if(IsEmpty(H)){
        printf("最大堆空")
        return;
    }
    MaxItem = H->Elements[1];
    tmp = H->Elements[H->Size --]; 
    for(Parent = 1 ; Parent * 2 <= H->Size ; Parent = Child){
        Child = Parent * 2;
        if( (Child != H->Size) && (H->Elements[Child] < H->Elements[Child + 1])  ) //第一个判断是否有右儿子
            Child ++;
        if(tmp >= H->Elements[Child])
            break;
        else //移动到下一层
            H->Elements[Parent] = H->Elements[Child];
    }
    H->Elements[Parent] = tmp;
    return MaxItem;
}

建立

MaxHeap* BuildMaxHeap(MaxHeap *H){
    //调整H中的元素，使有序
    int Parent,Child,i;
    ElementType tmp;
    for( i = H->Size / 2 ; i > 0 ; i --){ //从最后一个结点的父结点开始
        tmp = H->Elements[i];
        for(Parent = i ; Parent * 2 <= H->Size ; Parent = Child){
            Child = Parent * 2;
            if( (Child != H->Size) && (H->Elements[Child] < H->Elements[Child + 1 ]))
                Child ++;
            if(tmp >= H->Elements[Child] )
                break;
            else
                H->Elements[Parent] = H->Elements[Child];
        }//内部for循环对以H->Elements[i]为根的子树调整
        H->Elements[Parent] = tmp;
    }
    return H;
}

哈夫曼树和集合

哈夫曼树结构及建立

typedef struct TreeNode{
    int Weight;
    struct TreeNode *Left;
    struct TreeNode *Right;
}HuffmanTree;

HuffmanTree* Huffman(MinHeap H){
    int i;
    HuffmanTree * T;
    BuildMinHeap(H);
    for(i = 1 ; i < H->Size ; i ++){
        T = (HuffmanTree*)malloc(sizeof(HuffmanTree));
        T->Left = DeleteMin(H);
        T->Right = DeleteMin(H);
        T->Weight = T->Left->Weight + T->Right->Weight;
        Insert(H,T);
    }
    T = DeleteMin(H);
    return T;
}

集合结构以及查找合并函数

int Find(SetType *S ,ElementType X);//在数组S中查找元素X，返回X元素的树根结点在S中的下标
void Union(SetType *S,ElementType X1,ElementType X2);//实现元素合并
void Union(SetType *S,ElementType X1,ElementType X2){
    int Root1,Root2;
    Root1 = Find(S,X1);
    Root2 = Find(S,X2);
    if( Roo1 != Root2)
        S[Root2].Parent = Root1;
}
int Find(SetType *S ,ElementType X){
    for(i = 0 ; i < MaxSize && S[i].Data != X ; i ++);
    if(i > MaxSize)
        return -1;
    for(;S[i].Parent >= 0 ; i = S[i].Parent);
    return i;
}
melttt
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
树的操作—c语言实现
beirdu的专栏
01-17 5464
前言 　　本文包含二叉树、二叉查找树、Av树等的定义和相关操作，由于部分记录在印象笔记中，给出了文章链接。 一.树的遍历 　　遍历树形目录，先序遍历和后序遍历分别实现打印目录结构和统计目录下文件个数。先根遍历、后根遍历 二.BST定义及其基本操作 　　印象笔记链接 二.AvTree定义及其基本操作 1.简介 　　AvTree是BST的一种，但是其每个节点的左子树和右子树的高度最
《数据结构》(7) - 树和二叉树
weixin_52142420的博客
08-27 379
文章目录前言一、树概念及结构1.树的概念2.树的特点3.树的相关名词二、树的表示1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、树概念及结构 1.树的概念 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上.
C语言树的实现
05-16
二叉树递归先中后，非递归中，层序，树深，任意树的孩子-兄弟建立方法及树深
AVL（自平衡二叉树）树的实现（C语言）
c_living的博客
07-23 5162
AVL树是可以在插入、删除节点之后进行自平衡的树，平衡的定义是结点的左子树和右子树的深度差不超过1，也就： | Deep（LeftChild） - Deep（RightChild）| &lt;= 1，整棵树的平衡也就是树的每个结点都是满足上述情况。那么下面我们要解决问题就是当树在插入数据和删除数据的时候，如果树不平衡了我们该怎么办。 上面就是我们在插入或者删除的时候可能导致的树的不平衡的所...
从B树谈到R树之B树的c实现
jinghuainfo
08-31 381
从B树谈到R树之B树的c实现 作者：weedge，July。编程艺术室出品。 前言 代码大全的作者Steve McConnell曾称，他所见识的任何一本书都不是某一个人能完全独立即能完成的。吾深以为然。 本blog内的文章十有八九系我个人参考资料原创所作，与此同时十有二三系本人与吾的朋友共同创作完成。所以，诸君在浏览本博客内任何一篇文章时，务必尊重他人劳动成果。当然，有任何问题，欢迎随时不吝指...
红黑树-基于C语言实现的红黑树数据结构.zip
03-21
红黑树是一种自平衡二叉查找树，由Rudolf Bayer在1972年提出，它的设计目标是在保持查询效率的同时，通过特定的规则...理解并熟练掌握红黑树的原理和C语言实现，对于提升编程技能和解决复杂问题的能力具有重要意义。
决策树-机器学习 -C语言期末课设
10-26
在C语言实现决策树时，你需要考虑以下几个关键点： 1. 数据处理：读取像`traindata.txt`这样的训练数据文件，通常包含特征和对应的类别标签。数据应被解析并存储为结构化的数据类型，便于后续计算。 2. 特征选择：...
常用数据结构 - C语言实现
06-18
NOTONLLY的划分树模板.cpp NOTONLLY的后缀数组模板.cpp RMQ-ST算法.cpp RMQ线段树.cpp SBT.cpp SBT2.cpp splay伸展树.cpp ST表.cpp Treap.cpp Trie树.cpp 二叉堆.cpp 二维线段树.cpp 后缀数组.cpp 后缀数组模板.cpp ...
基于c语言实现哈夫曼树-
01-31
自用，作业，可用
圣诞树代码-C语言.zip
12-03
本压缩包“圣诞树代码-C语言.zip”包含了一个使用C语言编写的程序，该程序能够在控制台上绘制出一棵生动的圣诞树，为节日增添一份科技的趣味性。这个项目不仅展示了C语言的基础语法，还体现了控制台图形输出的艺术性...
树的实现与操作(C语言实现)
。烊了
07-04 7811
首先来简单说下一些关于的基本概念。 树是一种非线性的数据结构 1，树是由 n(n>=0) 个结点组成的有限集合 如果n = 0 ,称为空树 如果n > 0,则： 有一个特定的称之为根（root）的结点，它只有直接后继，但没有直接前驱 除了根以外的其他结点划分为：m(m>=0)个互不相交的有限集合，T0,T1,T2…Tn-1,每个集合又是一棵树，并且称之为根的子树
数据结构——树的C语言实现
zxr916的博客
03-15 1028
文章目录1.什么是树？2.如何判断是否是树？3.树的基本术语4.树的表示方法5.二叉树的定义6.特殊二叉树7.二叉树的性质8.二叉树的抽象数据类型定义9.二叉树的存储结构9.1顺序存储9.2 链表存储10.二叉树的遍历10.1 二叉树的遍历方法1.递归遍历2.层序遍历10.2 二叉树遍历的C语言实现1.递归遍历的实现2.层序遍历的实现 1.什么是树？ 2.如何判断是否是树？ 3.树的基本术语 4.树的表示方法 5.二叉树的定义 6.特殊二叉树 7.二叉树的性质 8.二叉树的抽象数据类型定义
树（普通树）的C代码实现
jjjstephen的博客
09-06 2798
由于树（普通树）的结构复杂，难以以偏概全，所以在插入子树函数中书写不当，能力所限，欢迎一起交流！ 树的抽象数据类型 ADT 树（Tree） Data 树是由一个根节点和若干棵子树构成。树中结点具有相同数据类型及层次关系 Operation InitTree(*T):构造空树 DestroyTree(*T):销毁树 CreateTree(*T,definition):按definition中给出的定义来构造树 ClearTree(*T):若树T存在，则将树T清为空树 TreeEm
数据结构-树（c语言实现篇）
CHAKMING1的博客
07-29 3257
数据结构之二叉树（c语言实现篇）
树和二叉树 C语言实现
WTF
11-30 1万+
1、基本概念 树是树型结构的简称，它是一种重要的非线性数据结构。 树的表示：通常使用广义表表示方法，即每棵树的根作为由子树构成的表的名字而放在表的前面，如下图的树对应的广义表表示为： A（B（D，E（H，I），F），C（G）） 结点的度：树中每个结点具有的非空子树数或者说后继结点数被定义为该结点的度。（如上图中，B结点度为3，A和E结点度都为2，C结点度为1，其余结点度均为0） 树的
数据结构—树的实现（C语言）
热门推荐
huihuituboshu的博客
03-20 1万+
1、树的概念    树形结构是节点之间以及分支关系定义的层次结构。作为一种重要的非线性结构，树形结构中一个节点最多只有一个前驱节点，但是可以有多个后继节点。2、树的存储结构    在计算机中，树有多种的存储方式，下面介绍一种动态的“左子/右兄”二叉链表表示方法。#include "mytree.h" #include &lt;vector&gt; using namespace std; #d...
数据结构之---二叉树C实现
weixin_33898233的博客
03-06 303
学过数据结构的都知道树，那么什么是树？ 树（tree）是包含n（n>0）个结点的有穷集，其中： （1）每个元素称为结点（node）； （2）有一个特定的结点被称为根结点或树根（root）。 （3）除根结点之外的其余数据元素被分为m（m≥0）个互不相交的集合T1，T2，……Tm-1，其中每一个集合Ti（1<=i<=m）本身也...
[数据结构] 基于交换的排序 冒泡排序&&快速排序
最新发布
水墨不写bug
07-06 399
让右下标先走，向左寻找比key小的值，找到后停下来：停下来后：左下标再向右寻找比key大的值，找到后停下来：此时，交换两个下标对应的值：接下来继续执行上述步骤（R先走），我展示关键步骤：两下标找到要求目标并交换：直到遇到特殊情况：两下标相遇这时停止停止循环，将最左侧元素与相遇处的元素交换位置：即可完成一次二分。
[数据结构] 基于插入的排序 插入排序&希尔排序
水墨不写bug
07-06 616
插入排序&&希尔排序 实现原理
最小生成树-prim C语言实现
11-29
以下是使用C语言实现Prim算法求解最小生成树的示例代码： ```c #include #include #define V 5 // 图的顶点数 int minKey(int key[], bool mstSet[]) { int min = INT_MAX, min_index; for (int v = 0; v ; v...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值