二叉树算法总结

最新推荐文章于 2022-03-25 10:19:33 发布
最新推荐文章于 2022-03-25 10:19:33 发布
阅读量493 收藏
点赞数
分类专栏： C++ 文章标签： 二叉树 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24625045/article/details/50001069
版权

关于二叉树，最近被这些搞得头昏脑涨。于是专门写了程序。直接放代码了。

#include<stdlib.h>
#include<stdio.h>

//二叉树结点的描述
typedef struct BiTNode
{
    int data;
    struct BiTNode *lchild, *rchild;      //左右孩子
}BiTNode,*BiTree;

BiTNode* createBiTNode(int data)
{
    BiTNode *tmp;
    tmp=(BiTNode*)malloc(sizeof(BiTNode));
    tmp->data=data;
    tmp->lchild=tmp->rchild=0;
    return tmp;
}

//按先序遍历创建二叉树void
void createBiTree(BiTNode **root)    //二级指针作为函数参数
{
    int data; //要插入的数据
    scanf("%d", &data);
    if(data==0)
        *root = NULL;
    else
    {
        *root = createBiTNode(data);
        printf("请输入%d的左孩子(必须比父节点的数据小 按0跳过输入):",data);
        createBiTree(&((*root)->lchild));
        printf("请输入%d的右孩子(必须比父节点的数据大 按0跳过输入):",data);
        createBiTree(&((*root)->rchild));
    }
}


//前序遍历的算法程序
void preOrder(BiTNode *root)
{
    if(root==NULL)
        return ;
    printf("%d ", root->data); //输出数据
    preOrder(root->lchild); //递归调用，前序遍历左子树
    preOrder(root->rchild); //递归调用，前序遍历右子树
}

//中序遍历的算法程序
void inOrder(BiTNode *root)
{
    if(root==NULL)
        return ;
    inOrder(root->lchild); //递归调用，前序遍历左子树
    printf("%d ", root->data); //输出数据
    inOrder(root->rchild); //递归调用，前序遍历右子树
}

//后序遍历的算法程序
void postOrder(BiTNode *root)
{
    if(root==NULL)
        return ;
    postOrder(root->lchild);      //递归调用，前序遍历左子树
    postOrder(root->rchild);      //递归调用，前序遍历右子树
    printf("%d ", root->data);    //输出数据
}

BiTNode* search_BiTNode(BiTNode *root,int data)
{
    while(root)
    {
        if(data<root->data)
        {
            root=root->lchild;
        }
        else if(data>root->data)
        {
            root=root->rchild;
        }
        else
        {
            return root;
        }
    }
    return NULL;
}

void add_BiTNode(BiTNode *root,int data)
{
    BiTNode *tmp,*p=root;
    while(p)
    {
        if(p->data>data)
        {
            tmp=search_BiTNode(p,p->data);//记录父节点
            p=p->lchild;
        }
        else if(p->data<data)
        {
            tmp=search_BiTNode(p,p->data);//记录父节点
            p=p->rchild;
        }
        else
        {
            printf("已有该数据，不能重复添加！\n");
            return;
        }
    }
    if(tmp->data<data)
    {
        p=createBiTNode(data);
        tmp->rchild=p;
        printf("添加成功！\n");
    }
    else
    {
        p=createBiTNode(data);
        tmp->lchild=p;
        printf("添加成功！\n");
    }
}

void change_BiTNode(BiTNode *root,int data)
{
    BiTNode *T=search_BiTNode(root,data);
    if(!T)
    {
        printf("未找到结点！错误！\n");
        return;
    }
    printf("请输入新数据：");
    scanf("%d",&T->data);
    printf("数据修改成功！\n");
}

void delete_BiTNode(BiTNode *root,int data)
{
    BiTNode *tmp=search_BiTNode(root,data);
    BiTNode *p=root;//记录T的父结点
    if(!tmp)
    {
        printf("未找到结点！错误！\n");
        return;
    }
    while(p)
    {
        if(p->data>data)
        {
            tmp=search_BiTNode(p,p->data);//记录父节点
            p=p->lchild;
        }
        else if(p->data<data)
        {
            tmp=search_BiTNode(p,p->data);//记录父节点
            p=p->rchild;
        }
        else
            break;
    }
    if(!p->lchild&&!p->rchild)//p为叶子结点
    {
        if(tmp->data>p->data)
        {
            tmp->lchild=NULL;//p的父结点指针置零
            free(p);//释放内存
        }
        else
        {
            tmp->rchild=NULL;
            free(p);
        }
    }
    else if(p->lchild&&!p->rchild)//p有左孩子没右孩子
    {
        if(tmp->data>p->data)
        {
            tmp->lchild=p->lchild;
            free(p);//释放内存
        }
        else
        {
            tmp->rchild=p->lchild;
            free(p);
        }
    }
    else if(!p->lchild&&p->rchild)//p有右孩子没有左孩子
    {
        if(tmp->data>p->data)
        {
            tmp->lchild=p->rchild;
            free(p);//释放内存
        }
        else
        {
            tmp->rchild=p->rchild;
            free(p);
        }
    }
    else if(p->lchild&&p->rchild)//两个孩子都有
    {
        /**由于这部分情况很复杂，有机会再做总结**/
        return;
    }
}


int depth(BiTNode *T)   //树的深度
{
    if(T==NULL)
        return 0;
    return (depth(T->lchild)>depth(T->rchild)?depth(T->lchild):depth(T->rchild))+1;
}

int countNode(BiTNode *T)
{
     if(T==NULL)
        return 0;
     return 1+countNode(T->lchild)+countNode(T->rchild);
}

int main()
{
    BiTNode *root=NULL; //定义一个根结点
    int op;
    int data;
    do
    {
        system("cls");
        printf("\t\t本程序实现二叉树的基本操作。\n");
        printf("可以进行建立二叉树，递归先序、中序、后序遍历，增加，删除，修改，搜索等操作。\n");
        printf("\n");
        printf("|--------------------------------------------------------------|\n");
        printf("|                    二叉树的基本操作如下:                     |\n");
        printf("|                        1.创建二叉树                          |\n");
        printf("|                        2.递归先序遍历                        |\n");
        printf("|                        3.递归中序遍历                        |\n");
        printf("|                        4.递归后序遍历                        |\n");
        printf("|                        5.查找二叉树元素                      |\n");
        printf("|                        6.添加二叉树元素                      |\n");
        printf("|                        7.修改二叉树元素                      |\n");
        printf("|                        8.删除二叉树元素                      |\n");
        printf("|                        9.二叉树的深度                        |\n");
        printf("|                        10.二叉树的结点个数                   |\n");
        printf("|                        11.清空二叉树元素                     |\n");
        printf("|                        0.退出程序                            |\n");
        printf("|--------------------------------------------------------------|\n");
        printf("\t\t请选择功能：");
        scanf("%d",&op);
        switch(op)
        {
        case 1:
            system("cls");
            printf("请建立二叉树并输入二叉树的根节点：");
            createBiTree(&root);
            system("pause");
            break;
        case 2:
            system("cls");
            if(root)
            {
                printf("递归先序遍历二叉树的结果为：");
                preOrder(root);
                printf("\n");
            }
            else
                printf("\t二叉树为空！\n");
            system("pause");
            break;
        case 3:
            system("cls");
            if(root)
            {
                printf("递归中序遍历二叉树的结果为：");
                inOrder(root);
                printf("\n");
            }
            else
                printf("\t二叉树为空！\n");
            system("pause");
            break;
        case 4:
            system("cls");
            if(root)
            {
                printf("递归后序遍历二叉树的结果为：");
                postOrder(root);
                printf("\n");
            }
            else
                printf("\t二叉树为空！\n");
            system("pause");
            break;
        case 5:
            {
                system("cls");
                BiTNode *T;
            if(root)
            {
                printf("请输入要查找的数据：");
                scanf("%d",&data);
                T=search_BiTNode(root,data);
                if(T)
                {
                    printf("已找到数据！\n");
                }
                else
                {
                    printf("未能找到数据！\n");
                }
            }
            else
            {
                printf("\t二叉树为空！\n");
            }
            system("pause");
            break;
            }
        case 6:
            system("cls");
            if(root)
            {
                printf("请输入你想要添加的结点数据：");
                scanf("%d",&data);
                add_BiTNode(root,data);
            }
            else
                printf("\t二叉树为空！\n");
            system("pause");
            break;
        case 7:
            system("cls");
            if(root)
            {
                printf("请输入你想要修改的结点数据：");
                scanf("%d",&data);
                change_BiTNode(root,data);
            }
            else
                printf("\t二叉树为空！\n");
            system("pause");
            break;
        case 8:
            {
                system("cls");
                if(root)
                {
                    printf("请输入要删除的元素值:");
                    scanf("%d",&data);
                    delete_BiTNode(root,data);
                }
                else
                    printf("\t二叉树为空！\n");
                system("pause");
                break;
            }
        case 9:
            system("cls");
            if(root)
                printf("这棵二叉树的深度为：%d\n",depth(root));
            else
                printf("\t二叉树为空！\n");
            system("pause");
            break;
        case 10:
            system("cls");
            if(root)
                printf("这棵二叉树的结点个数为：%d\n",countNode(root));
            else
                printf("\t二叉树为空！\n");
            system("pause");
            break;
        case 11:
            system("cls");
            if(root)
            {
                free(root);
                root=NULL;
                printf("清空二叉树成功！\n");
            }
            else
                printf("\t二叉树为空！\n");
            system("pause");
            break;
        default:
            printf("程序运行结束，按任意键退出！\n");
        }
    }while(op);

    if(root)
    {
        free(root);
    }
    system("pause");
    return 0;
}
-左鸢-
关注
专栏目录
二叉树相关算法汇总（详细）
泛泛之素
06-05 1万+
二叉树基本知识 二叉树（Binary Tree）是n（n≥0）个有限元素的集合，该集合或者为空，或者由一个称为根（root）的元素及两个不相交的、被分别称为左子树和右子树的二叉树组成。当集合为空时，称该二叉树为空二叉树。 二叉树常见概念： 结点的度。结点所拥有的子树的个数称为该结点的度。 叶子结点。度为0的结点称为叶子结点，或者称为终端结点。 分支结点。度不为0的结点称为分支结点，或者称为非终端结点。一棵树的结点除叶子结点外，其余的都是分支结点。 左孩子、右孩子、双亲。树中一个结点的子树的根结点称为这个结
算法-二叉树算法总结
攻城老湿的博客
01-03 328
1 二叉树的遍历 1.1 前序遍历 递归 // 144. 二叉树的前序遍历 // 给你二叉树的根节点 root ，返回它节点值的 前序 遍历。 class Solution { public List<Integer> preorderTraversal(TreeNode root) { List<Integer> res = new Array...
《算法总结》——二叉树
kangjielearning的博客
03-16 287
树 1、树是一种经常用到的数据结构，用来模拟具有树状结构性质的数据集合。 2、树里的每一个节点有一个值和一个包含所有子节点的列表。从图的观点来看，树也可视为一个拥有N个节点和N-1条便的一个有向无环图。 把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 树的特点 (01) 每个节点有零个或多个子节点； (02) 没有父节点的节点称为根节点； (03) 每一个非根节点有且只有一个父节点； (04) 除了根节点外，每个子节点可以分为多个不相交的子树。 树的基本术语 若一个结点有子树
二叉树算法总结（2）
xunbaobao123的博客
03-25 162
二叉树算法总结（2） 一.构造最大二叉树 TreeNode constructMax(int[] nums){ if(nums.length == 0) return null; int maxnum = Integer.MIN_VALUE; int index =0; for(int i=0;i<nums.length;i++){ if (nums[i]>maxnum) maxnum = nums[i]; index=i; } TreeNode root = n
树与二叉树算法总结
07-14
树与二叉树算法总结 树与二叉树是计算机科学中非常重要的一部分，掌握树与二叉树的算法对于数据结构和算法设计非常重要。本文将对树与二叉树的基本概念、性质、运算和应用进行总结。 一、树的基本概念 树是一种非...
数据结构之树与二叉树算法总结
12-23
### 数据结构之树与二叉树算法总结 #### 一、引言 在计算机科学领域，数据结构扮演着至关重要的角色。其中，树形结构因其灵活性和高效性被广泛应用于各种场景之中。本文将深入探讨树与二叉树的相关概念，并通过具体...
二叉树遍历算法总结
KISS
06-20 970
文章目录前提要素深度优先搜索DFS经典遍历算法前序遍历递归版迭代版中序遍历递归版迭代版后序遍历递归版迭代版Morris遍历算法中序遍历前序遍历后序遍历广度优先搜索BFS按层遍历参考资料 前提要素 //二叉树节点结构 public static class TreeNode { public int val; public TreeNode left; public TreeNode right; public TreeNode(int x) { val = x; } public Tre
JS实现的二叉树算法完整实例
12-28
本文实例讲述了JS实现的二叉树算法。分享给大家供大家参考，具体如下： <... //今天学习了下二叉树算法，总结在这里 //1全局变量 binary Tree =bt //1.1 node function Node() { //bt节点 th
二叉树算法题总结
qq_31984717的博客
12-09 879
1.二叉树的节点数计算 class CountNodes { public: int count(TreeNode* root) { if (!root) return 0; int size = 1 +count(root-&gt;left); size += count(root-&gt;right); return size; } }; 2.二...
关于二叉树的算法总结
小七自学博客
03-25 3969
关于二叉树的算法总结 文章目录关于二叉树的算法总结二叉树的种类满二叉树完全二叉树二叉搜索树平衡二叉搜索树二叉树的存储方式数组存储方式的分析链式存储方式的分析树存储方式的分析能二叉树的遍遍历方式深度优先遍历广度优先遍历Leecode 二叉树的种类 满二叉树 满二叉树：如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。 这棵二叉树为满二叉树，也可以说深度为k，有2^k-1个节点的二叉树。 完全二叉树 完全二叉树的定义如下：在完全二叉树中，除了最底层节点可能没填满
二叉树常用算法总结
weixin_30716725的博客
10-24 88
　　最近在复习算法，做了一下编程之美上面关于二叉树的三道题，感觉顺便就把二叉树总结下算了，于是就有了这篇文章，这些算法有些是自己思考出来的，比如重建二叉树，有些是以前的知识还有些是看了网上其它大牛总结而成，现在贴出来分享，希望大家指正。感觉算法的学习重要的不是算法本身而是算法背后的思想，就是一些本质上的东西，或者说思考的过程，这些才是真正重要的。对于二叉树来说，最重要的是它的递归特性，这是由它的定...
二叉树各种计算公式总结
热门推荐
uninnco的博客
09-18 10万+
1.n个节点的二叉树一共有(2n!)/(n，(n+1)!)中 2.n层二叉树的第n层最多为2^(n-1)个 3.二叉树节点计算公式 N = n0+n1+n2，度为0的叶子节点比度为2的节点数多一个。N=1*n1+2*n2+1 4.对任何一棵二叉树T，如果其终端节点数为n0，度为2的节点数为n2，则n0=n2+1 5.具有n个节点的完全二叉树的深度为log2(n) + 1
二叉树算法题汇总
一念永恒
05-19 1万+
目录 二叉树的遍历 前序遍历 中序遍历 后序遍历 层次遍历 基础算法 求二叉树中的节点个数 求二叉树的深度（高度） 求二叉树第k层的节点个数 求二叉树中叶子节点的个数 判断两棵二叉树是否相同的树 判断二叉树是不是平衡二叉树 求二叉树的镜像 判断两个二叉树是否互相镜像 判断是否为二分查找树BST 本文的实例代码基于JAVA编写 首先给出节点的数据结构 publi...
二叉树基本算法的总结
qq_33404590的博客
09-10 294
二叉树的构建 树的构造函数后面就直接简写（主要是针对数组中树的擦欧哦中） 一、 普通二叉树 思路： 可以利用层次遍历建立 // 利用层次遍历构造普通二叉树 function createTree(arr) { const bt = new TreeNode(arr.shift()); let queue = []; queue.push(bt); while (arr.length) { //当数组中还有元素的时候 let cu
二叉树算法
番茄炒蛋炒饭的博客
11-20 355
问题一：完成一个函数，输入一颗二叉树，该函数输出它的镜像。二叉树节点定义如下： struct BinaryTreeNode { int m_nValue; BinaryTreeNode *m_pLeft; BinaryTreeNode *m_pRight; }; 解题思路：二叉树的镜像过程可以理解为所有左右子节点交换的过程，先前序遍历这个树的每个...
二叉树常见算法题总结
Linias的博客
04-05 583
https://github.com/lxsnwu/Algorithm/tree/master/%E4%BA%8C%E5%8F%89%E6%A0%91
二叉树各种计算公式
易大飞
07-01 4万+
1. n个节点的二叉树一共有((2n)!)/(n! * (n+1)!)种2. n层二叉树的第n层最多为2^(n-1)个3. 二叉树节点计算公式 N = n0+n1+n2，度为0的叶子节点比度为2的节点数多一个。N=1*n1+2*n2+14. 对任何一棵二叉树T，如果其终端节点数为n0，度为2的节点数为n2，则n0=n2+15. 具有n个节点的完全二叉树的深度为log2(n) + 16. B-树，除...
C++二叉树算法详解：遍历、线索化
"C++经典算法 二叉树 遍历和线索...总结来说，掌握二叉树的遍历算法和线索二叉树的概念及其实现，对于理解和应用C++中的经典算法至关重要。无论是面试、编程竞赛还是实际开发，这些基础知识都是解决问题的关键工具。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值