c++简单实现二叉树、AVL、最大最小堆、霍夫曼、集合（问题：malloc,typedef,指针）

最新推荐文章于 2020-09-19 14:50:52 发布
最新推荐文章于 2020-09-19 14:50:52 发布
阅读量190 收藏
点赞数
分类专栏： c++数据结构 文章标签： 树 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37164093/article/details/100861488
版权

c++简单实现二叉树、AVL、最大最小堆、霍夫曼、集合（问题：malloc,typedef,指针）（代码只是大概思路不一定能运行）

前言

顺序查找
二分查找
树 n个结点构成集合 儿子兄弟表示法 所有结点结构相同省时省空间
二叉树
二叉树遍历 先序遍历 中序遍历 后序遍历 层序遍历
顺序存储结构 数组等实现的完全二叉树 他们的标号连续 结点父亲为i 左孩子为2i 右孩子为2i+1
一般的二叉树也可以补全结点为完全二叉树 但浪费空间
链表存储

typedef的使用

typedef的有无在c/c++ 中的区别 转载https://blog.csdn.net/rjw9999/article/details/6655821

在C中定义一个结构体类型要用typedef:

	typedef struct Student        
	{
	    int a;
	}Stu;

于是在声明变量的时候就可：Stu stu1;如果没有typedef就必须用struct Student stu1;来声明
但在c++里很简单，直接

	struct Student
	{
	int a;
	};

于是就定义了结构体类型Student，声明变量时直接Student stu2；

在c++中如果用typedef的话，又会造成区别：

	struct Student   
	{   
	    int a;   
	}stu1;      //stu1是一个变量   
	typedef struct Student2   
	{   
	    int a;   
	}stu2;      //stu2是一个结构体类型  typedef相当于定义了一个别名 
	*/

stack的使用

转载https://blog.csdn.net/zichen_ziqi/article/details/80807989

队列的使用

转自：http://www.169it.com/article/2718050585107790752.html

malloc/new 的使用方法与区别

本文链接：https://blog.csdn.net/qq_26816591/article/details/52214313

c++ NULL/nullptr 的区别

转载https://www.cnblogs.com/Philip-Tell-Truth/p/6594632.html
NULL 相当于0会当作int不会当作void*来看待

二叉树

#include <iostream>
#include <string>
#include <algorithm>
#include <queue> //顺序队列
#include <stack> //先进后出
using namespace std;
struct Node
{
    int value;
    Node *left = NULL;
    Node *right = NULL;
};
Node a;

二叉树遍历

二叉树遍历 先序遍历 先访问根结点 先序遍历左子树 先序遍历其右子树 根左右
void pre_traversal(Node *root)
{
    if (root)
    {
        cout << root->value;
        pre_traversal(root->left);
        pre_traversal(root->right);
    }
}
二叉树遍历 中序遍历 中序遍历左子树 访问根结点 中序遍历其右子树 左根右
void mid_traversal(Node *root)
{
    if (root)
    {
        mid_traversal(root->left);
        cout << root->value;
        mid_traversal(root->right);
    }
}
二叉树遍历 后序遍历 后序遍历左子树 后序遍历其右子树 访问根结点 左右根
void back_traversal(Node *root)
{
    if (root)
    {
        back_traversal(root->left);
        back_traversal(root->right);
        cout << root->value;
    }
}
二叉树非递归遍历 堆栈 中序遍历
void inorder_traversal(Node *root)
{
    Node *temp = root;
    stack<Node> s;               // 创建队列
    while (temp || !s.empty()) //栈不为空或当前结点不为空
    {
        while (temp)
        {
            s.push(*temp);
            temp = temp->left;
        } //当结点不为空时一直将左叶子结点插入
        if (!s.empty())
        {
          	temp = s.pop(); 
            cout << temp->value;
            temp = temp->right; //左根右
            //当前节点没有右右节点则弹出栈顶元素父节点
        }
    }
}
层序遍历 遍历的本质就是如何将树的二维结构变为一维的线性结构

假如我访问了左儿子怎么才能访问到右儿子
需要一个存储结构存放暂时不访问的结点
依靠队列 将结点放入 之后进行抛出并将结点的左右儿子放进去一步步操作

void level_traversal(Node *root)
{
    queue<Node> temp;
    if (!root)
        return; // 如果树为空返回
    temp.push(*root);
    while (!temp.empty())
    {
        Node *t = temp.pop;
        cout << t->value;
        if (t->left)
        {
            temp.push(*t->left);
        }
        if (t->right)
        {
            temp.push(*t->right);
        }
    }
}

二叉树结点/高度

输出二叉树的所有叶子结点
void child_traversal(Node *root)
{
    if (root)
    {
        if (!root->left && !root->right)
            cout << root->value;
        pre_traversal(root->left);
        pre_traversal(root->right);
    }
}
求二叉树的高度

递归 max(Hl,Hr)+1 先求左子树的最大高度 再求右子树的最大高度 采用后序遍历

int max_height(Node *root)
{
    int Hl, Hr, MaxH;
    if (root)
    {
        Hl = max_height(root->left);
        Hr = max_height(root->right);
        MaxH = (Hl > Hr) ? Hl : Hr;
        return (MaxH + 1);
    }
    else
        return 0;
}

二元运算的树表示及遍历 (中缀表达式不准当没括号时)
两个遍历序列 前中 或 中后 可确定唯一二元式序列 但是前后不行

同构

左右子树交换后可以得到相同结构 数组结构表示二叉树 静态链表递归每层对比

struct Tree
{
    int value;
    int L;
    int right;
} t1[size], t2[size];
void build()
{
    Tree R1, R2;
    R1 = build(); //首先找到根结点没有结点之乡的点为根结点
    R2 = build();
    if (check(R1, R2))
    {
        ...
    }
}
int check(Tree a, Tree b)
{
    if ((a == NULL) && (b == NULL))
        return 1;
    if ((a == NULL) && (b != NULL))
        || ((a != NULL) && (b == NULL)) return 0;
    if (/*判断ab两个树根结点是否相同*/)
        return 0;
    if (/*两个根结点左右位置不交换*/)
    { /*递归*/
    }
    else
    { /*递归*/
    }
}

binary search tree 二叉搜索树 左小右大 递归查找 / 循环查找

//二叉搜索树 递归查找 NULL=0FALSE=0TRUE记得是非零值
Node* binary_find(int value, Node *root)
{
    if (!root)
        return NULL;
    if (value > root->value)
    {
        binary_find(value, root->right);
    }
    else if (value < root->value)
    {
        binary_find(value, root->left);
    }
    else
        return root;
}

Node* binary_find2(int value, Node *root)
{
    while (root)
    {
        if (value > root->value)
        {
            root = root->right;
        }
        else if (value < root->value)
        {
            root = root->left;
        }
        else
            return root;
    }
    return NULL;
}
//为了防止二叉搜索树一边倒 查找效率取决于树的高度

查找二叉搜索树的最大 最小值

//查找二叉搜索树的最大 最小值
Node* FindMin(Node *root)
{
    if(!root) return NULL;
    else if (!root->left) return root;
    else return FindMin(root->left);
}
Node* FindMax(Node *root)
{
    if(root)
    {
        while(root->right) root = root->right;
    }
    return root;
}

二叉搜索树的插入删除

 //二叉搜索树的插入删除 
void insert(int a,Node* root)//返回插入结点
{
    if(!root)
    {
        root = (Node*)malloc(sizeof(Node));
        root->value = a;
        root->left = NULL;
        root->right = NULL;
    }
    else
    {
        if(a<root->value)
        {
            return insert(a,root->left);
        }
        else if(a>root->value)
        {
            return insert(a,root->right);
        }
    }
}
//二叉树的使用 例如字典序
/*二叉树删除结点 用另一节点代替套被删除的结点 右子树的最小元素或者是
左子树的最大元素 这样的好处是那么这个节点一定不会有两个孩子*/
void delete_binary(int x,Node* root)
{
    Node* temp;//用来存放替换的
    if(!root) cout<<"所要删除的元素不存在";
    else if(x<root->value) delete_binary(x, root->left);
    else if(x>root->value) delete_binary(x, root->right);
    else
    {
        if(root->left&&root->right) //左右孩子节点都存在时找右子树的最小节点
        {
            temp = FindMin(root->right);
            root->value = temp->value;
            delete_binary(temp->value,root->right); // 递归删除找到的替换的结点并找右子树最小的元素代替
        }
        else //只有一个孩子结点或者没有
        {
            temp = root;
            if(!left)//有右孩子或无子结点
            {
                root=root->right;
            }
            else if(!right)//有左孩子或无子结点
            {
                root=root->left;
            }
            free(temp);
        }
    }
}

平衡二叉树

平衡二叉树 任意一个结点左右两个子树的高度差不超过1
当插入的结点在发现者右子树的右边因而叫RR插入需要RR旋转(右单旋)
当插入的结点在发现者左子树的左边因而叫LL插入需要LL旋转(左单旋)
当插入的结点在发现者左子树的右子树因而叫LR插入需要LR旋转(左右旋转)
当插入的结点在发现者右子树的左子树因而叫RL插入需要RL旋转(右左旋转)

AVL 树的实现

typedef struct AVLNode *Position;
typedef Position AVLTree; /* AVL树类型 */
struct AVLNode{
    ElementType Data; /* 结点数据 */
    AVLTree Left;     /* 指向左子树 */
    AVLTree Right;    /* 指向右子树 */
    int Height;       /* 树高 */
};
 
int Max ( int a, int b )
{
    return a > b ? a : b;
}
 
AVLTree SingleLeftRotation ( AVLTree A )
{ /* 注意：A必须有一个左子结点B */
  /* 将A与B做左单旋，更新A与B的高度，返回新的根结点B */     
 
    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 DoubleLeftRightRotation ( AVLTree A )
{ /* 注意：A必须有一个左子结点B，且B必须有一个右子结点C */
  /* 将A、B与C做两次单旋，返回新的根结点C */
     
    /* 将B与C做右单旋，C被返回 */
    A->Left = SingleRightRotation(A->Left);
    /* 将A与C做左单旋，C被返回 */
    return SingleLeftRotation(A);
}
 
/*************************************/
/* 对称的右单旋与右-左双旋请自己实现 */
/*************************************/
 
AVLTree Insert( AVLTree T, ElementType X )
{ /* 将X插入AVL树T中，并且返回调整后的AVL树 */
    if ( !T ) { /* 若插入空树，则新建包含一个结点的树 */
        T = (AVLTree)malloc(sizeof(struct AVLNode));
        T->Data = X;
        T->Height = 0;
        T->Left = T->Right = NULL;
    } /* if (插入空树) 结束 */
 
    else if ( X < T->Data ) {
        /* 插入T的左子树 */
        T->Left = Insert( T->Left, X);
        /* 如果需要左旋 */
        if ( GetHeight(T->Left)-GetHeight(T->Right) == 2 )
            if ( X < T->Left->Data ) 
               T = SingleLeftRotation(T);      /* 左单旋 */
            else 
               T = DoubleLeftRightRotation(T); /* 左-右双旋 */
    } /* else if (插入左子树) 结束 */
     
    else if ( X > T->Data ) {
        /* 插入T的右子树 */
        T->Right = Insert( T->Right, X );
        /* 如果需要右旋 */
        if ( GetHeight(T->Left)-GetHeight(T->Right) == -2 )
            if ( X > T->Right->Data ) 
               T = SingleRightRotation(T);     /* 右单旋 */
            else 
               T = DoubleRightLeftRotation(T); /* 右-左双旋 */
    } /* else if (插入右子树) 结束 */
 
    /* else X == T->Data，无须插入 */
 
    /* 别忘了更新树高 */
    T->Height = Max( GetHeight(T->Left), GetHeight(T->Right) ) + 1;
     
    return T;
}

堆heap 优先队列的实现

堆heap 优先队列的实现
数组实现 插入-元素总是插入到尾部 删除-查找最大胡哦最小关键字
数组中删去需要移动的元素 复杂度O(n)因为删去一个元素时需要将元素向前移
链表的实现 相对于数组来讲 删除结点 复杂度O(1) 指针指向下一个元素即可
有序数组 logn
二叉树叶子结点为最大值
堆 完全二叉树进行存储 结点为最大值/最小值 最大堆/最小堆

堆的构造

typedef struct HNode *Heap; /* 堆的类型定义 */
struct HNode {
    int *Data; /* 存储元素的数组 */
    int Size;          /* 堆中当前元素个数 */
    int Capacity;      /* 堆的最大容量 */
};
typedef Heap MaxHeap; /* 最大堆 */
typedef Heap MinHeap; /* 最小堆 */
 
#define MAXDATA 1000  /* 该值应根据具体情况定义为大于堆中所有可能元素的值 */
 
MaxHeap CreateHeap( int MaxSize )
{ /* 创建容量为MaxSize的空的最大堆 */
 
    MaxHeap H = (MaxHeap)malloc(sizeof(struct HNode));
    H->Data = (int *)malloc((MaxSize+1)*sizeof(int));
    H->Size = 0;
    H->Capacity = MaxSize;
    H->Data[0] = MAXDATA; /* 定义"哨兵"为大于堆中所有可能元素的值*/
 
    return H;
}
bool IsFull( MaxHeap H )
{
    return (H->Size == H->Capacity);
}

元素插入

  /* 将元素X插入最大堆H，其中H->Data[0]已经定义为哨兵 */
bool Insert( MaxHeap H, int X )
{
    int i;
    if ( IsFull(H) ) { 
        printf("最大堆已满");
        return false;
    }
    i = ++H->Size; /* i指向插入后堆中的最后一个元素的位置 */
    for (i; H->Data[i/2] < X; i/=2 )
        H->Data[i] = H->Data[i/2]; /* 上滤X */
    H->Data[i] = X; /* 将X插入 */
    return true; //插入到最后位置再与父元素减缓
}
 
#define ERROR -1 /* 错误标识应根据具体情况定义为堆中不可能出现的元素值 */
 
bool IsEmpty( MaxHeap H )
{
    return (H->Size == 0);
}

删除元素

 /* 从最大堆H中取出键值为最大的元素，并删除一个结点 */
int DeleteMax( MaxHeap H )
{ 
    int Parent, Child;
    int MaxItem, X;
 
    if ( IsEmpty(H) ) {
        printf("最大堆已为空");
        return ERROR;
    }
 
    MaxItem = H->Data[1]; /* 取出根结点存放的最大值 */
    /* 用最大堆中最后一个元素从根结点开始向上过滤下层结点 */
    X = H->Data[H->Size--]; /* 注意当前堆的规模要减小 取出左后一个数 并且size变小 */
    for( Parent=1; Parent*2<=H->Size; Parent=Child ) // 与子结点比较 并交换下滤
    {
        Child = Parent * 2;
        if( (Child!=H->Size) && (H->Data[Child]<H->Data[Child+1]) )
            Child++;  /* Child指向左右子结点的较大者 */
        if( X >= H->Data[Child] ) break; /* 找到了合适位置 */
        else  /* 下滤X */
            H->Data[Parent] = H->Data[Child];
    }
    H->Data[Parent] = X;
 
    return MaxItem;
}

建造最大堆

/*----------- 建造最大堆 -----------
可以考虑每次选出数组中最大的元素进行插入  
也可以将整个数组构造好之后再重新整理顺序
*/
void PercDown( MaxHeap H, int p )
{ /* 下滤：将H中以H->Data[p]为根的子堆调整为最大堆 */
    int Parent, Child;
    int X;
 
    X = H->Data[p]; /* 取出根结点存放的值 */
    for( Parent=p; Parent*2<=H->Size; Parent=Child ) {
        Child = Parent * 2;
        if( (Child!=H->Size) && (H->Data[Child]<H->Data[Child+1]) )
            Child++;  /* Child指向左右子结点的较大者 */
        if( X >= H->Data[Child] ) break; /* 找到了合适位置 */
        else  /* 下滤X */
            H->Data[Parent] = H->Data[Child];
    }
    H->Data[Parent] = X;
}
 
void BuildHeap( MaxHeap H )
{ /* 调整H->Data[]中的元素，使满足最大堆的有序性  */
  /* 这里假设所有H->Size个元素已经存在H->Data[]中 */
 
    int i;

    /* 从最后一个结点的父节点开始，到根结点1 */
    for( i = H->Size/2; i>0; i-- )
        PercDown( H, i );
}

哈夫曼树 依赖最小堆

哈夫曼树 依靠每个元素的概率来建树 带权路径最小
哈夫曼的构造 每次把权值最小的两棵二叉树合并
利用最小堆来实现选择数组中的最小元素效率要比排序算法要好

struct HuffmanTree
{
    int weight;
    HuffmanTree* Left; 
    HuffmanTree* Right;
};
HuffmanTree* huffman(MinHeap H)
{
    int i;
    HuffmanTree* temp;
    BuildMinHeap(H);//构建最小堆
    for(i=1;i<H->Size;i++)
    {
        temp = (HuffmanTree*)malloc(sizeof(HuffmanTree));
        temp->Left = DeleteMin(H);
        temp->Right = DeleteMin(H);
        temp->weight = temp->Left->weight+ temp->Right->weight;
        insert(H,temp);
    }
    temp = pop(H);//将最后值弹出
    return temp;
}

集合相交

/*
集合相交 或者线路连通 那么若各结点相连 
根节点相同则说明是交集或者是连通
数组中每个元素的类型描述
*/
typedef struct {
    ElementType  Data;
    int parent;
}SetType;
/*循环遍历每个元素的parent 一层层向上遍历 若最后根结点相同 那么集合相同*/
Yanqingdi
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉堆：最大堆
07-08
使用c++实现最大堆。提供常见操作，如插入、删除、堆化数组、堆排序、上下调整、向下调整。
最大堆和最小堆和平衡二叉树_最小堆二叉树
从零开始的教程世界
07-21 2168
最大堆和最小堆和平衡二叉树A Min Heap Binary Tree is a Binary Tree where the root node has the minimum key in the tree. 最小堆二叉树是二叉树，其中根节点在树中具有最小密钥。 The above definition holds true for all sub-trees in the tree. Thi...
数据结构与算法：最大堆
xylitolz的博客
09-07 567
这里写自定义目录标题堆堆和普通树的区别二叉堆最大堆向堆中添加元素和SiftUp从堆中取出元素和siftDown完整的代码 堆 堆是用数组实现的二叉树，堆根据**“堆属性”来排序**，“堆属性”决定了树中节点的位置。 堆分为两种：最大堆和最小堆，两者的差别在于节点的排序方式。在最大堆中，父节点的值比每一个子节点的值都要大。在最小堆中，父节点的值比每一个子节点的值都要小。这就是所谓的**“堆属性”**，并且这个属性对堆中的每一个节点都成立。 根据这一属性，那么最大堆总是将其中的最大值存放在树的根节点。而对于最小
最大堆、最小堆C++实现
几番风雨的专栏
06-23 1480
最近学习了最大堆、最小堆数据结构，这个并不难懂，但在编程、编写学习笔记时，发现有不少错误、理解不深刻，有比较多的细节需要注意的，特别是孩子节点的访问条件、几个节点之间的比较出了不少错误，但经过一番努力，终于解决了。下面是最大堆的实现过程 最大堆、最小堆 C++实现 最大堆概念：每个节点的值都大于其子节点的值的完全二叉树。 最小堆概念：每个节点的值都小于或等于其子节点的值的完全二叉树。   使用数...
大小堆的实现（C++）
u014524930的博客
03-02 5680
过了一段时间了，还是记录一下，最近感觉记忆力下降的很快啊。大小堆的构造首先得知道大小堆是个什么，大小堆是一种二叉树，它的要求比起平衡树来说是简单一些的，只有一个，就是所有父节点必须大于自己的子节点，但是没有什么左孩子必须小于右孩子这种。到这里其实大小堆的作用很容易看出，最大堆就是根节点最大，最小堆就是根节点最小，可以用于排序。作为测试，这里使用整形数组作为初始化数据，二叉树可以直接使用c++单循环...
AVL搜索二叉树C语言源代码
12-07
AVL搜索二叉树是一种自平衡的二叉搜索树，由G. M. Adelson-Velsky和E. M. Landis在1962年提出，因此得名AVL树。这种数据结构的主要特点是其左右子树的高度差不超过1，从而确保了搜索、插入和删除操作的高效性。下面...
数据结构二叉树，c语言简单实现
01-12
在实际项目中，可能还需要根据具体需求添加其他功能，如平衡二叉树（AVL树、红黑树等）、二叉堆等。对于压缩包内的文件，可能是具体的二叉树实例或练习题目，通过读取文件内容并解析，可以进一步进行二叉树操作和...
数据结构从入门到精通-二叉树的实现和遍历
03-18
除了上述基本操作，二叉树还有其他扩展形式，比如平衡二叉树（AVL树、红黑树等）、堆（最大堆、最小堆）、二叉查找树等。这些特殊类型的二叉树在性能上有更优秀的表现，适用于特定的场景需求。 在实际编程中，理解...
C语言实现二叉树的基本操作.zip
最新发布
06-13
1. **节点定义**：首先，我们需要为二叉树定义一个结构体，包含节点值、指向左子节点和右子节点的指针。例如： ```c typedef struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; } ...
【数据结构与算法】二叉树的实现C语言代码
03-12
在实际应用中，二叉树的概念和实现经常用于解决各种问题，比如搜索算法（二分查找）、排序（二叉堆）、编译器的语法分析等。熟练掌握二叉树的原理和操作是成为一名优秀程序员的关键技能之一。通过学习和实践C语言...
C，C++创建二叉树，以及3种遍历
gate0088的专栏
10-22 1万+
C++ 实现                                                                         ——引用是C++不同于C的地方 //其中扩充结点用'0'号表示。即‘0’表示空树节点 #include #include #include #include using namespace std; #def
最大堆(max-heap)和最小堆(min-heap)
Tim's Blog
11-15 8480
在STL中，二叉堆是通过priority_queue的类模板实现的，标准头文件是。在STL中实现的是最大堆(max-heap)。 成员函数有： void push (const Object & x); const Object & top() const; void pop(); bool empty(); void clear(); 优先队列模版用如下参数初始化：项类型，容器类型（几乎总
堆树（最大堆、最小堆）详解
热门推荐
渴望，就奋力追寻...
03-16 6万+
一、堆树的定义 堆树的定义如下： （1）堆树是一颗完全二叉树； （2）堆树中某个节点的值总是不大于或不小于其孩子节点的值； （3）堆树中每个节点的子树都是堆树。 当父节点的键值总是大于或等于任何一个子节点的键值时为最大堆。 当父节点的键值总是小于或等于任何一个子节点的键值时为最小堆。如下图所示，左边为最大堆，右边为最小堆。 二、堆树的操作 以最大堆为例进行讲解
C++ 数据结构-------二叉树实现
u011641755的博客
10-01 1567
最近写了一个简单的二叉树，仅供查考，代码如下： #include using namespace std; typedef char T; class bst {     struct Node     {         T data;         Node* L;         Node* R;         Node(const T& d):data(
C++实现简单二叉树
燚淼的博客
05-22 7367
C++实现简单二叉树
二叉树
typedef_struct的博客
09-27 305
二叉树（未完成）struct Node{ bool have_value; int v; Node *left,*right; Node():have_value(false),left(NULL),left(NULL){} };char s[maxn]; bool read_input(){ failed = false; root
C++ 最大堆
ChanJose的博客
03-14 2176
#include &lt;iostream&gt; #include &lt;stack&gt; const int DefaultSize = 100; template &lt;class T&gt; class MaxHeap{ public: MaxHeap(int sz = DefaultSize); MaxHeap(T arr[], int n); ~Ma...
数据结构之最小堆的实现C++版
weixin_30853329的博客
11-03 208
完全二叉树之所以用数组的方式存在，在于他的一个特性 若子节点为i,则父节点为（i-1）/2，注意c++特性，该结果肯定是个整数。 若父节点为j,则子节点必为2*j+1;则在数组里面可以非常方便的通过下标去获取。 建堆的核心思想: 　　堆在index的值为heap[index]，然后其两个孩子的值边可求得，左孩子为heap[index*2+1]，右孩子为heap[index*2+2]...
求左叶子树之和
lixiansen1511的博客
09-19 463
package com.huike; public class TreeNode { int val;//节点值 TreeNode left;//左节点 TreeNode right;//右节点 //构造方法对节点初始化 TreeNode(int x) { val = x; } TreeNode(){ } public Tr.
平衡二叉树代码实现c语言
04-24
平衡二叉树（AVL树）是一种自平衡的二叉搜索树，它的左子树和右子树的高度差不超过1。下面是一个简单的平衡二叉树的代码实现（C语言）： ```c #include #include // 定义平衡二叉树节点结构 typedef struct ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值