C/C++平衡二叉树实现 —— 插入、删除、先序遍历、中序遍历、后序遍历、层序遍历（设计详解）

最新推荐文章于 2023-01-30 20:20:32 发布
最新推荐文章于 2023-01-30 20:20:32 发布
阅读量739 收藏 11
点赞数 4
分类专栏： C++ 文章标签： c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/demo_yo/article/details/117820781
版权

输出展示：
在这里插入图片描述

相关文章目录

MFC二叉树可视化绘制 （C++）—— 插入、删除、先序遍历、中序遍历、后序遍历、层序遍历（基于平衡二叉树实现）

文章目录

前言

该程序由c语言编写，可运行于vs环境下，可轻易转换成C++代码。

一、实现功能

实现操作：结点的插入、删除。
实现输出：输出先序遍历、中序遍历、后序遍历、层序遍历的结果。

二、代码设计

1. 定义平衡二叉树的结点结构

平衡二叉树的结点结构：

// 平衡二叉树的结点结构
typedef struct BiTNode
{
    int data;
    int bf;             // 平衡因子
    BiTNode* lchild, * rchild;
}BiTNode, * BiTree;

BiTree 为指向树结点的指针，用于表示树对象。

2. 定义层序遍历链队列相关结构和函数

链队列结构：

/* 链队列结点结构（用于层序遍历） */
typedef struct QNode {
    BiTree t;                   // 结点数据域
    struct QNode* next;        // 结点指针域
}QNode, * QueuePtr;

/* 链队列结构（用于层序遍历） */
typedef struct {
    QueuePtr front;     // 队首指针
    QueuePtr rear;      // 队尾指针
}LinkQueue;

初始化链队列函数、进队函数、出队函数定义：

/* 初始化链队列函数 */
Status InitQueue(LinkQueue& Q)
{
    // 创建一个带附加头结点的空链队列
    Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));
    if (!Q.front) {
        return ERROR;
    }
    Q.front->next = NULL;
    return OK;
}

/* 进队函数 */
/* e：插入元素 */
Status EnQueue(LinkQueue& Q, BiTree e)
{
    // 将元素e插入到链队列中
    QueuePtr p;
    p = (QueuePtr)malloc(sizeof(QNode));
    if (!p) {
        return ERROR;
    }
    p->t = e;
    p->next = NULL;
    Q.rear->next = p;
    Q.rear = p;
    return OK;
}

/* 出队函数 */
/* e：出队元素 */
Status DeQueue(LinkQueue& Q, BiTree& e)
{
    // 出队，将出队元素放入e中
    QueuePtr p;
    if (Q.rear == Q.front) {
        return ERROR;
    }
    p = Q.front->next;
    e = p->t;
    Q.front->next = p->next;
    if (Q.rear == p) {
        Q.rear = Q.front;
    }
    free(p);
    return OK;
}
3. 定义结点旋转函数 —— 用于二叉树的结点平衡

LL调整（左单旋）、RR调整（右单旋）、LR调整（先左旋再右旋）、RL调整（先右旋再左旋）。

关于平衡二叉树的旋转问题请参考：平衡二叉树的构造过程图解

// 右旋处理，即LL调整
void R_Rotate(BiTree* p)
{
    BiTree L;
    L = (*p)->lchild;
    (*p)->lchild = L->rchild;
    L->rchild = *p;
    *p = L;
}

// 左旋处理，即RR调整
void L_Rotate(BiTree* p)
{
    BiTree R;
    R = (*p)->rchild;
    (*p)->rchild = R->lchild;
    R->lchild = *p;
    *p = R;
}

// 左平衡旋转处理，包括 LL 和 LR 调整
void LeftBalance(BiTree* T)
{
    BiTree L, Lr;
    L = (*T)->lchild;
    switch (L->bf)
    {
    case 1:        // 新结点插入在T的左孩子的左子树上，为LL型，作右旋处理即LL调整
        (*T)->bf = L->bf = 0;
        R_Rotate(T);
        break;
    case -1:        // 新结点插入在T的左孩子的右子树上，为LR型，作双旋处理
        Lr = L->rchild;
        switch (Lr->bf)
        {
        case 1:
            (*T)->bf = -1;
            L->bf = 0;
            break;
        case 0:
            (*T)->bf = L->bf = 0;
            break;
        case -1:
            (*T)->bf = 0;
            L->bf = 1;
            break;
        }
        Lr->bf = 0;
        L_Rotate(&(*T)->lchild);      // 先对T的左子树进行左旋处理即RR调整
        R_Rotate(T);                  // 再对T进行右旋处理即LL调整
    }
}

// 右平衡旋转处理，包括 RR 和 RL 调整
void RightBalance(BiTree* T)
{
    BiTree R, Rl;
    R = (*T)->rchild;
    switch (R->bf)
    {
    case -1:        // 新结点插入在T的右孩子的右子树上，为RR型，作左旋处理即RR调整
        (*T)->bf = R->bf = 0;
        L_Rotate(T);
        break;
    case 1:        // 新结点插入在T的右孩子的左子树上，为RL型，作双旋处理
        Rl = R->lchild;
        switch (Rl->bf)
        {
        case 1:
            (*T)->bf = 0;
            R->bf = -1;
            break;
        case 0:
            (*T)->bf = R->bf = 0;
            break;
        case -1:
            (*T)->bf = 1;
            R->bf = 0;
            break;
        }
        Rl->bf = 0;
        R_Rotate(&(*T)->rchild);      // 先对T的左子树进行左旋即RR调整
        L_Rotate(T);                  // 再对T进行右旋即LL调整
    }
}
4. 定义结点插入函数
// 若在平衡二叉树T中不存在和 e 具有相同数据的结点，则插入数据元素为 e 的新结点，
// 若因插入使二叉排序树失去平衡，则要作平衡调整，
// 布尔变量taller表示 T 的深度是否增加，TRUE表示增加，FALSE表示没有增加

Status InsertAVL(BiTree* T, int e, Status* taller)
{
    if (!*T)
    {
        *T = (BiTree)malloc(sizeof(BiTNode));
        if (!*T) {
            return ERROR;
        }
        else {
            (*T)->data = e;
            (*T)->lchild = (*T)->rchild = NULL;
            (*T)->bf = 0;
            *taller = TRUE;
        }
    }
    else
    {
        // 树中已有和e具有相同数据的结点，则不再插入
        if (e == (*T)->data)
        {
            *taller = FALSE;
            return FALSE;
        }

        if (e < (*T)->data)    // 继续在T的左子树进行搜索
        {
            if (!InsertAVL(&(*T)->lchild, e, taller)) // InsertAVL( &(*T)->lchild, e, taller )得到的是T的左孩子结点(*T)->lchild的 data,bf 等相关信息
            {
                return FALSE;
            }

            // 如果e已插入到T的左子树中，且左子树深度增加
            if (*taller)
            {
                switch ((*T)->bf)      // 检查T的平衡因子
                {
                case 1:                // 原本左子树比右子树高，再加上此结点，导致不平衡，需要作LL或LR调整
                    LeftBalance(T);
                    *taller = FALSE;
                    break;
                case 0:                // 原本左右子树等高，再加上此结点，左子树增高
                    (*T)->bf = 1;
                    *taller = TRUE;
                    break;
                case -1:                // 原本右子树比左子树高，再加上此结点，左右子树变为等高
                    (*T)->bf = 0;
                    *taller = FALSE;
                    break;
                }
            }
        }
        else        // 在T的右子树进行搜索
        {
            if (!InsertAVL(&(*T)->rchild, e, taller))
            {
                return FALSE;
            }

            if (*taller)
            {
                switch ((*T)->bf)
                {
                case 1:                // 原先左子树比右子树高，现在左右子树等高
                    (*T)->bf = 0;
                    *taller = FALSE;
                    break;
                case 0:                // 原先左右子树等高，现在右子树增高
                    (*T)->bf = -1;
                    *taller = TRUE;
                    break;
                case -1:                // 原先右子树比左子树高，现在再加上此结点，导致不平衡，需要作 RR 或 RL 调整
                    RightBalance(T);
                    *taller = FALSE;
                    break;
                }
            }
        }
    }

    return TRUE;
}
5. 定义结点删除函数
// 若在平衡二叉树T中存在和 e 具有相同数据的结点，则删除数据元素为 e 的结点，
// 若因删除使二叉排序树失去平衡，则要作平衡调整，
// 布尔变量taller表示 T 的深度是否改变，TRUE表示改变，FALSE表示没有改变
Status DeleteAVL(BiTree* T, int e, Status* taller)
{
    if (!*T)    // 树为空，未找到删除结点
    {
        *taller = FALSE;
        return FALSE;
    }
    else
    {
        // 树中已有和e具有相同数据的结点，则不再插入
        if (e == (*T)->data)
        {
            if ((*T)->lchild != NULL && (*T)->rchild != NULL) {

            }
            return TRUE;
        }

        if (e < (*T)->data)    // 继续在T的左子树进行搜索
        {
            if (!DeleteAVL(&(*T)->lchild, e, taller)) // InsertAVL( &(*T)->lchild, e, taller )得到的是T的左孩子结点(*T)->lchild的 data,bf 等相关信息
            {
                return FALSE;
            }

            // 如果e已插入到T的左子树中，且左子树深度增加
            if (*taller)
            {
                switch ((*T)->bf)      // 检查T的平衡因子
                {
                case 1:                // 原本左子树比右子树高，再删除此结点，变为等高
                    (*T)->bf = 0;
                    *taller = TRUE;
                    break;
                case 0:                // 原本左右子树等高，再删除此结点，左子树降低
                    (*T)->bf = -1;
                    *taller = FALSE;
                    break;
                case -1:                // 原本右子树比左子树高，再删除此结点，不平衡
                    RightBalance(T);
                    *taller = FALSE;
                    break;
                }
            }
        }
        else        // 在T的右子树进行搜索
        {
            if (!DeleteAVL(&(*T)->rchild, e, taller))
            {
                return FALSE;
            }

            if (*taller)
            {
                switch ((*T)->bf)
                {
                case 1:                // 原先左子树比右子树高
                    LeftBalance(T);
                    *taller = FALSE;
                    break;
                case 0:                // 原先左右子树等高，右子树变低
                    (*T)->bf = 1;
                    *taller = FALSE;
                    break;
                case -1:                // 原先右子树比左子树高，变等高
                    (*T)->bf = 0;
                    *taller = TRUE;
                    break;
                }
            }
        }
    }
    return TRUE;
}
6. 定义二叉树遍历与输出函数
/* 前序遍历 */
void PreOrder(BiTree T)
{
    if (T == NULL)
    {
        return;
    }
    //strOrderResult = strOrderResult + to_string(T->data) + " ";
    printf("%d ", T->data);
    PreOrder(T->lchild);
    PreOrder(T->rchild);
}

/* 中序遍历 */
void MidOrder(BiTree T)
{
    if (T == NULL)
    {
        return;
    }
    MidOrder(T->lchild);
    //strOrderResult = strOrderResult + to_string(T->data) + " ";
    printf("%d ", T->data);
    MidOrder(T->rchild);
}

/* 后序遍历 */
void PostOrder(BiTree T)
{
    if (T == NULL)
    {
        return;
    }
    PostOrder(T->lchild);
    PostOrder(T->rchild);
    //strOrderResult = strOrderResult + to_string(T->data) + " ";
    printf("%d ", T->data);
}

/* 层序遍历 */
void LevelOrder(BiTree root)
{
    LinkQueue Q;
    BiTree p;
    if (root != NULL) {
        InitQueue(Q);
        EnQueue(Q, root);
        while (Q.front != Q.rear) {
            DeQueue(Q, p);
            //strOrderResult = strOrderResult + to_string(T->data) + " ";
            printf("%d ", p->data);
            if (p->lchild != NULL)  EnQueue(Q, p->lchild);
            if (p->rchild != NULL)  EnQueue(Q, p->rchild);
        }
    }
}

void OutputBiTree(BiTree T)
{
    if (T != NULL) {
        printf("%d", T->data);
        if (T->lchild != NULL || T->rchild != NULL) {
            printf("(");
            OutputBiTree(T->lchild);
            if (T->rchild != NULL) {
                printf(",");
            }
            OutputBiTree(T->rchild);
            printf(")");
        }
    }
}
7. main函数测试
int main(void)
{
    int i;
    int a[10] = { 2,1,0,3,4,5,6,9,8,7 };
    BiTree T = NULL;
    Status toller;

    for (i = 0; i < 10; i++)
    {
        InsertAVL(&T, a[i], &toller);
    }
    printf("二叉树括号表示格式输出：\n");
    OutputBiTree(T);
    printf("\n");
    printf("前序遍历\n");
    PreOrder(T);
    printf("\n");
    printf("中序遍历\n");
    MidOrder(T);
    printf("\n");
    printf("后序遍历\n");
    PostOrder(T);
    printf("\n");
    printf("层序遍历\n");
    LevelOrder(T);
    printf("\n");
    return 0;
}

三、运行结果

在这里插入图片描述

四、完整代码

#include <stdio.h>
#include <stdlib.h>
//#include <string>
//using namespace std;

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

//string strOrderResult = "";         // 可用于返回多种遍历结果

// 定义平衡二叉树的结点结构
typedef struct BiTNode
{
    int data;
    int bf;             // 平衡因子
    BiTNode* lchild, * rchild;
}BiTNode, * BiTree;

typedef int Status;

/* 链队列结点结构（用于层序遍历） */
typedef struct QNode {
    BiTree t;                   // 结点数据域
    struct QNode* next;        // 结点指针域
}QNode, * QueuePtr;

/* 链队列结构（用于层序遍历） */
typedef struct {
    QueuePtr front;     // 队首指针
    QueuePtr rear;      // 队尾指针
}LinkQueue;


/* 初始化链队列函数 */
Status InitQueue(LinkQueue& Q)
{
    // 创建一个带附加头结点的空链队列
    Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));
    if (!Q.front) {
        return ERROR;
    }
    Q.front->next = NULL;
    return OK;
}

/* 进队函数 */
/* e：插入元素 */
Status EnQueue(LinkQueue& Q, BiTree e)
{
    // 将元素e插入到链队列中
    QueuePtr p;
    p = (QueuePtr)malloc(sizeof(QNode));
    if (!p) {
        return ERROR;
    }
    p->t = e;
    p->next = NULL;
    Q.rear->next = p;
    Q.rear = p;
    return OK;
}

/* 出队函数 */
/* e：出队元素 */
Status DeQueue(LinkQueue& Q, BiTree& e)
{
    // 出队，将出队元素放入e中
    QueuePtr p;
    if (Q.rear == Q.front) {
        return ERROR;
    }
    p = Q.front->next;
    e = p->t;
    Q.front->next = p->next;
    if (Q.rear == p) {
        Q.rear = Q.front;
    }
    free(p);
    return OK;
}

// 右旋处理，即LL调整
void R_Rotate(BiTree* p)
{
    BiTree L;
    L = (*p)->lchild;
    (*p)->lchild = L->rchild;
    L->rchild = *p;
    *p = L;
}

// 左旋处理，即RR调整
void L_Rotate(BiTree* p)
{
    BiTree R;
    R = (*p)->rchild;
    (*p)->rchild = R->lchild;
    R->lchild = *p;
    *p = R;
}

// 左平衡旋转处理，包括 LL 和 LR 调整
void LeftBalance(BiTree* T)
{
    BiTree L, Lr;
    L = (*T)->lchild;
    switch (L->bf)
    {
    case 1:        // 新结点插入在T的左孩子的左子树上，为LL型，作右旋处理即LL调整
        (*T)->bf = L->bf = 0;
        R_Rotate(T);
        break;
    case -1:        // 新结点插入在T的左孩子的右子树上，为LR型，作双旋处理
        Lr = L->rchild;
        switch (Lr->bf)
        {
        case 1:
            (*T)->bf = -1;
            L->bf = 0;
            break;
        case 0:
            (*T)->bf = L->bf = 0;
            break;
        case -1:
            (*T)->bf = 0;
            L->bf = 1;
            break;
        }
        Lr->bf = 0;
        L_Rotate(&(*T)->lchild);      // 先对T的左子树进行左旋处理即RR调整
        R_Rotate(T);                  // 再对T进行右旋处理即LL调整
    }
}

// 右平衡旋转处理，包括 RR 和 RL 调整
void RightBalance(BiTree* T)
{
    BiTree R, Rl;
    R = (*T)->rchild;
    switch (R->bf)
    {
    case -1:        // 新结点插入在T的右孩子的右子树上，为RR型，作左旋处理即RR调整
        (*T)->bf = R->bf = 0;
        L_Rotate(T);
        break;
    case 1:        // 新结点插入在T的右孩子的左子树上，为RL型，作双旋处理
        Rl = R->lchild;
        switch (Rl->bf)
        {
        case 1:
            (*T)->bf = 0;
            R->bf = -1;
            break;
        case 0:
            (*T)->bf = R->bf = 0;
            break;
        case -1:
            (*T)->bf = 1;
            R->bf = 0;
            break;
        }
        Rl->bf = 0;
        R_Rotate(&(*T)->rchild);      // 先对T的左子树进行左旋即RR调整
        L_Rotate(T);                  // 再对T进行右旋即LL调整
    }
}

// 若在平衡二叉树T中不存在和 e 具有相同数据的结点，则插入数据元素为 e 的新结点，
// 若因插入使二叉排序树失去平衡，则要作平衡调整，
// 布尔变量taller表示 T 的深度是否增加，TRUE表示增加，FALSE表示没有增加

Status InsertAVL(BiTree* T, int e, Status* taller)
{
    if (!*T)
    {
        *T = (BiTree)malloc(sizeof(BiTNode));
        if (!*T) {
            return ERROR;
        }
        else {
            (*T)->data = e;
            (*T)->lchild = (*T)->rchild = NULL;
            (*T)->bf = 0;
            *taller = TRUE;
        }
    }
    else
    {
        // 树中已有和e具有相同数据的结点，则不再插入
        if (e == (*T)->data)
        {
            *taller = FALSE;
            return FALSE;
        }

        if (e < (*T)->data)    // 继续在T的左子树进行搜索
        {
            if (!InsertAVL(&(*T)->lchild, e, taller)) // InsertAVL( &(*T)->lchild, e, taller )得到的是T的左孩子结点(*T)->lchild的 data,bf 等相关信息
            {
                return FALSE;
            }

            // 如果e已插入到T的左子树中，且左子树深度增加
            if (*taller)
            {
                switch ((*T)->bf)      // 检查T的平衡因子
                {
                case 1:                // 原本左子树比右子树高，再加上此结点，导致不平衡，需要作LL或LR调整
                    LeftBalance(T);
                    *taller = FALSE;
                    break;
                case 0:                // 原本左右子树等高，再加上此结点，左子树增高
                    (*T)->bf = 1;
                    *taller = TRUE;
                    break;
                case -1:                // 原本右子树比左子树高，再加上此结点，左右子树变为等高
                    (*T)->bf = 0;
                    *taller = FALSE;
                    break;
                }
            }
        }
        else        // 在T的右子树进行搜索
        {
            if (!InsertAVL(&(*T)->rchild, e, taller))
            {
                return FALSE;
            }

            if (*taller)
            {
                switch ((*T)->bf)
                {
                case 1:                // 原先左子树比右子树高，现在左右子树等高
                    (*T)->bf = 0;
                    *taller = FALSE;
                    break;
                case 0:                // 原先左右子树等高，现在右子树增高
                    (*T)->bf = -1;
                    *taller = TRUE;
                    break;
                case -1:                // 原先右子树比左子树高，现在再加上此结点，导致不平衡，需要作 RR 或 RL 调整
                    RightBalance(T);
                    *taller = FALSE;
                    break;
                }
            }
        }
    }

    return TRUE;
}


// 若在平衡二叉树T中存在和 e 具有相同数据的结点，则删除数据元素为 e 的结点，
// 若因删除使二叉排序树失去平衡，则要作平衡调整，
// 布尔变量taller表示 T 的深度是否改变，TRUE表示改变，FALSE表示没有改变
Status DeleteAVL(BiTree* T, int e, Status* taller)
{
    if (!*T)    // 树为空，未找到删除结点
    {
        *taller = FALSE;
        return FALSE;
    }
    else
    {
        // 树中已有和e具有相同数据的结点，则不再插入
        if (e == (*T)->data)
        {
            if ((*T)->lchild != NULL && (*T)->rchild != NULL) {

            }
            return TRUE;
        }

        if (e < (*T)->data)    // 继续在T的左子树进行搜索
        {
            if (!DeleteAVL(&(*T)->lchild, e, taller)) // InsertAVL( &(*T)->lchild, e, taller )得到的是T的左孩子结点(*T)->lchild的 data,bf 等相关信息
            {
                return FALSE;
            }

            // 如果e已插入到T的左子树中，且左子树深度增加
            if (*taller)
            {
                switch ((*T)->bf)      // 检查T的平衡因子
                {
                case 1:                // 原本左子树比右子树高，再删除此结点，变为等高
                    (*T)->bf = 0;
                    *taller = TRUE;
                    break;
                case 0:                // 原本左右子树等高，再删除此结点，左子树降低
                    (*T)->bf = -1;
                    *taller = FALSE;
                    break;
                case -1:                // 原本右子树比左子树高，再删除此结点，不平衡
                    RightBalance(T);
                    *taller = FALSE;
                    break;
                }
            }
        }
        else        // 在T的右子树进行搜索
        {
            if (!DeleteAVL(&(*T)->rchild, e, taller))
            {
                return FALSE;
            }

            if (*taller)
            {
                switch ((*T)->bf)
                {
                case 1:                // 原先左子树比右子树高
                    LeftBalance(T);
                    *taller = FALSE;
                    break;
                case 0:                // 原先左右子树等高，右子树变低
                    (*T)->bf = 1;
                    *taller = FALSE;
                    break;
                case -1:                // 原先右子树比左子树高，变等高
                    (*T)->bf = 0;
                    *taller = TRUE;
                    break;
                }
            }
        }
    }
    return TRUE;
}

/* 前序遍历 */
void PreOrder(BiTree T)
{
    if (T == NULL)
    {
        return;
    }
    //strOrderResult = strOrderResult + to_string(T->data) + " ";
    printf("%d ", T->data);
    PreOrder(T->lchild);
    PreOrder(T->rchild);
}

/* 中序遍历 */
void MidOrder(BiTree T)
{
    if (T == NULL)
    {
        return;
    }
    MidOrder(T->lchild);
    //strOrderResult = strOrderResult + to_string(T->data) + " ";
    printf("%d ", T->data);
    MidOrder(T->rchild);
}

/* 后序遍历 */
void PostOrder(BiTree T)
{
    if (T == NULL)
    {
        return;
    }
    PostOrder(T->lchild);
    PostOrder(T->rchild);
    //strOrderResult = strOrderResult + to_string(T->data) + " ";
    printf("%d ", T->data);
}

/* 层序遍历 */
void LevelOrder(BiTree root)
{
    LinkQueue Q;
    BiTree p;
    if (root != NULL) {
        InitQueue(Q);
        EnQueue(Q, root);
        while (Q.front != Q.rear) {
            DeQueue(Q, p);
            //strOrderResult = strOrderResult + to_string(T->data) + " ";
            printf("%d ", p->data);
            if (p->lchild != NULL)  EnQueue(Q, p->lchild);
            if (p->rchild != NULL)  EnQueue(Q, p->rchild);
        }
    }
}

void OutputBiTree(BiTree T)
{
    if (T != NULL) {
        printf("%d", T->data);
        if (T->lchild != NULL || T->rchild != NULL) {
            printf("(");
            OutputBiTree(T->lchild);
            if (T->rchild != NULL) {
                printf(",");
            }
            OutputBiTree(T->rchild);
            printf(")");
        }
    }
}

// 对于实例，我们可以这样创建平衡二叉树
int main(void)
{
    int i;
    int a[10] = { 2,1,0,3,4,5,6,9,8,7 };
    BiTree T = NULL;
    Status toller;

    for (i = 0; i < 10; i++)
    {
        InsertAVL(&T, a[i], &toller);
    }
    printf("二叉树括号表示格式输出：\n");
    OutputBiTree(T);
    printf("\n");
    printf("前序遍历\n");
    PreOrder(T);
    printf("\n");
    printf("中序遍历\n");
    MidOrder(T);
    printf("\n");
    printf("后序遍历\n");
    PostOrder(T);
    printf("\n");
    printf("层序遍历\n");
    LevelOrder(T);
    printf("\n");
    return 0;
}
Whitemeen太白
关注
  • 4
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
C++ 遍历二叉树实例详解
12-31
C++ 遍历二叉树实例详解 2叉数又叫红黑树，关于2叉数的遍历问题，有很多，一般有三种常用遍历方法： (1)前序遍历(2)中序遍历(3)后续遍历  以下是经典示例： #include stdafx.h #include #include #include &lt...
数据结构------二叉平衡树(一)插入操作
kkxgx的专栏
08-14 3186
二叉平衡树是一种特殊的二叉树，它能有效的控制树的高度，避免产生普通二叉搜索树的“退化”树形 一，基本定义 1、二叉平衡树又称AVL树，它或是一棵空二叉树，或者是具有以下性质的二叉树。 （1）其根的左右子树高度只差的绝对值不超过1 （2）其根的左右子树都是二叉平衡树 二叉树结点上的平衡因子定义为该结点左子树的高度减去右子树的高度，即取值为-1，0，1 下面的研究都是基于二叉平衡搜索树，在
平衡二叉查找树（AVL）的查找、插入、删除
wenjianfeng的专栏
05-12 1254
一.平衡二叉查找树 平衡二叉查找树是带有平衡条件的二叉查找树。平衡条件：每个节点的左子树和右子树的高度差最多为1二叉查找树（其中空树的高度为-1）。 二、平衡二叉树算法思想 若向平衡二叉树中插入一个新结点后破坏了平衡二叉树的平衡性。首先要找出插入新结点后失去平衡的最小子树根结点的指针。然后再调整这个子树中有关结点之间的链接关系，使之成为新的平衡子树。当失去平衡的最小子树被调整为平衡子树...
平衡二叉树AVL树的创建，平衡，和删除节点，c/c++描述
zhangzhangkeji的博客
08-15 325
  平衡二叉树的左右子树的高度差小于等于1。或者说其左子树的高度减去右子树的高度，差值的绝对值小于等于1。平衡二叉树，仍然属于排序二叉树。其中序排列里，节点的关键字仍然按递增有序排列。   为了纪念对平衡二叉树的研究做出贡献的前苏联科学家，取其姓氏里的字母，平衡二叉树，也叫做AVL树。   每往AVL树里插入一个节点，由函数insertBST完成插入。都要对树里节点进行校平。   校平由函数checkBalance 完成，计算树里每个节点的平衡因子。可由后序递归完成（按节点左右根的顺序，依次校平每个节点的平
c++ 删除二叉树的子树_每日算法题 | 剑指offer 二叉树专题 （16） 平衡二叉树
weixin_40001805的博客
11-27 79
点击上方“Jerry的算法和NLP”，选择“星标”公众号 重磅干货，第一时间送达题目平衡二叉树题目要求输入一棵二叉树，判断该二叉树是否是平衡二叉树。| 备知识 平衡二叉树：它是一棵空树，或者它的左右子树的高度差不超过1，同时它的左右子树为一棵二叉树。而衡量树和平衡因子说的就是左右子树的高度差，可以为0,1,-1。如下图它就是一棵平衡二叉树：解题思路 二叉树的套路一般都...
c++ 删除二叉树的子树_平衡二叉树
weixin_39904268的博客
11-24 180
二叉树二叉数是每个节点最多有两个子树,或者是空树(n=0),或者是由一个根节点及两个互不相交的,分别称为左子树和右子树的二叉树组成。满二叉树有两个非空子树(二叉树中的每个结点恰好有两个孩子结点切所有叶子结点都在同一层)。也就是一个结点要么是叶结点，要么是有两个子结点的中间结点。深度为k且含有2^k-1个结点的二叉树。完全二叉树从左到右依次填充。从根结点开始，依次从左到右填充树结点。除最后一层外，每...
C++实现二叉树基本操作详解
12-26
本学年论文介绍了二叉树的定义，二叉树的存储结构，二叉树的相关术语，以此引入二叉树这一概念，为展开二叉树的基本操作做好理论铺垫。二叉树的基本操作主要包含以下几个模块：二叉树的遍历方法，计算二叉树的结点个...
c++先序二叉树的构建详解
08-26
"c++先序二叉树的构建详解" 在本篇文章中，我们将详细介绍c++先序二叉树的构建，包括二叉树的定义、构建、二叉树的遍历方法等相关知识点。 一、定义BinaryTreeNode类 在c++中，我们可以使用模板类来定义二叉树...
C++实现AVL Tree（平衡二叉树）的构建与增删
最新发布
weixin_51049319的博客
01-30 281
C++实现AVL Tree（平衡二叉树）的构建与增删
【基础算法】:平衡二叉树的插入
阳光心态，健康人生的博客
09-11 5064
关于平衡二叉树，其中的各项指标，比如说：LL,RR,LR,RL，这些东西都是些什么意思，请看下面的图： 对于一个平衡的节点，由于任意节点最多有两个儿子，因此高度不平衡时，此节点的两颗子树的高度差2.容易看出，这种不平衡出现在下面四种情况： 　　1、6节点的左子树3节点高度比右子树7节点大2，左子树3节点的左子树1节点高度大于右子树4节点，这种情况成为左左。 　　2、6
平衡二叉树插入、删除等操作的C++实现代码
06-15
用C++实现的二叉平衡树的插入、删除、中序遍历输出等操作
平衡二叉树的四种遍历方式
Kim_
12-05 5724
一、概念       平衡二叉树或者是棵空树，或者是具体下列性质的二叉查找树：它的左子树和右子树都是平衡二叉树，且左子树和右子树的高度只差的绝对值不超过1。若将二叉树结点的平衡因子定义为该节点的左子树的高度减去它的右子树的高度，则所有结点的平衡因子只可能为-1,0,1。只要有一个结点的平衡因子的绝对值大于1，那么这棵树就失去了平衡。   简单例子 下图为平衡二叉树 下图为非平衡二叉树 ...
平衡二叉树-C++实现
m0_55464171的博客
05-23 1084
目录前言：为什么需要平衡二叉树？二叉搜索树的局限性什么是平衡二叉树？平衡二叉树的递归定义平衡二叉树的功能平衡性调整：向上调整，4种方式右单旋左单旋LR双旋RL双旋插入：1种情况删除：3种情况求树的高度：后序遍历实现判断是否为平衡二叉树输出平衡二叉树的信息：中序遍历实现判断两棵AVL树是否相等平衡二叉树的赋值：防止内存泄漏清空：后序遍历，释放所有结点完整代码 前言：为什么需要平衡二叉树？ 二叉搜索树的局限性 相对于链表，二叉搜索树的静态查找具有高效性。但是，如果我们希望一棵二叉树既能实现查找操作，又能实现插入
C/C++实现平衡二叉树的插入、删除、查询和各种遍历
xwm1993的博客
05-22 7292
1 平衡二叉树的插入      关于平衡二叉树的定义什么的，就不再多说。直接说说各种功能的c语言实现。 首先插入的时候需要进行旋转以保证树始终保持平衡。而旋转的类型有四种：L-L型旋转，L-R型旋转，R-L型旋转，R-R型旋转。其中L-L型和R-R型只需要进行一次基本旋转操作就可以调整平衡；另外两种需要进行两次方向相反的旋转操作，才能达到目标。四种旋转类型如下：       然后定义两种基本的旋转...
平衡二叉树（可重复key）插入删除（c/c++实现）
From zero
04-17 1084
平衡二叉树插入，比较简单，主要工作在插入结点后的调平，通过递归调用InsertAVL，插入结点调整返回调整后的数高度是否变化，依次调整返回，平衡二叉树插入结点的调整有四种情况，实现主要是在R_Balance和L_Balance里。 删除结点要复杂一点，递归查找删除结点，找到后判断： 外界链表是否为空，如果不空取下一个，树不变 否则： 1）如果为叶子结点，直接删掉，调整返回 2）如果只有一
c++之平衡二叉树的删除（1）
weixin_42579072的博客
10-21 747
本文只讲平衡二叉树（AVL）的删除原理，具体代码实现请看后序文章 平衡二叉树的删除也涉及到删除后的连接问题。其删除一般分为4种情况： （1）删除叶子结点 （2）删除的结点只有左子树，没有右子树 （3）删除的结点只有右子树，没有左子树 （4）删除的结点既有左子树，又有右子树 （1）删除叶子结点 这个很简单，直接删除。然后判断父结点的平衡因子，然后进行旋转，维持AVL的平衡。 （2）删除的结点只...
平衡二叉树（C++实现）
qq_39559641的博客
11-04 8382
二叉树实现插入、查询、删除功能
平衡二叉树的c++实现
qq_41646522的博客
03-14 1069
插入节点： (为什么可以将其移动到另一方作为子树，考虑其左小于父节点以及右大于父节点的性质，即可理解可移动) 二叉树删除节点： 1.若删除节点为叶子节点==》直接删除 2.欲删除节点只有一个子树，删除该head,把子树移到head位置 3.欲删除节点有双子树，（右子树的最左节点为大于且最接近欲删除节点的值）找到该最接近节点node将其与欲删除节点交换，问题转换为{ 删除右子树中，值为node->key的节点（该节点为叶子节点或只有右子树的节点）<即转换为1，2情况> } AVLTree.
平衡二叉树AVL的c++实现
qq_36101436的博客
04-03 2958
1 先创建节点类，就是一个普通的节点类的创建，用结构体也可以，唯一值的注意的是要有一个表示当前节点高度的成员，因为节点高度是判断平衡二叉树是否平衡的标志。#include &lt;iostream&gt; using namespace std;template&lt;class T&gt;class TreeNode{public:    T val;    TreeNode&lt;T&gt;*...
二叉树遍历算法详解：先序、中序、后序递归实现
"二叉树遍历的三种递归算法定义，包括先序遍历、中序遍历和后序遍历。二叉树遍历是数据结构中的重要概念，主要应用于搜索、排序等问题。标准模板库（STL）是C++编程中的一个核心组件，包含各种数据结构和算法，如栈...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Whitemeen太白

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值