数据结构之二叉树

最新推荐文章于 2021-12-25 19:18:15 发布
转载 最新推荐文章于 2021-12-25 19:18:15 发布 · 87 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/Aiahtwo/p/11191682.html
文章标签：

#数据结构与算法

本文详细介绍了二叉树的创建过程及其遍历方法，并提供了完整的C++代码实现，包括节点计数、叶子节点计数及树深度计算等功能。

一.二叉树如何表示输入：

 

二.二叉树完整代码

 

#include <iostream>
#include<cstdio>
#include<cstdlib>

using namespace std;

typedef struct BinaryTreeNode
{
    int data;
    struct BinaryTreeNode *Left;
    struct BinaryTreeNode *Right;
}Node;


//创建二叉树，顺序依次为中间节点->左子树->右子树
Node* createBinaryTree()
{
    Node *p;
    int ch;
    cin>>ch;
    if(ch == 0)     //如果到了叶子节点，接下来的左、右子树分别赋值为0
    {
        p = NULL;
    }
    else
    {
        p = (Node*)malloc(sizeof(Node));//动态分配空间
        p->data = ch;
        p->Left  = createBinaryTree();  //递归创建左子树
        p->Right = createBinaryTree();  //递归创建右子树
    }
    return p;
}

//先序遍历
void preOrderTraverse(Node* root)
{
    if( root )
    {
        cout<<root->data<<' ';
        preOrderTraverse(root->Left);
        preOrderTraverse(root->Right);
    }
}

//中序遍历
void inOrderTraverse(Node* root)
{
    if( root )
    {
        inOrderTraverse(root->Left);
        cout<<root->data<<' ';
        inOrderTraverse(root->Right);
    }
}

//后序遍历
void lastOrderTraverse(Node* root)
{
    if( root )
    {
        lastOrderTraverse(root->Left);
        lastOrderTraverse(root->Right);
        cout<<root->data<<' ';
    }
}

//二叉树节点总数目
int Nodenum(Node* root)
{
    if(root == NULL)
    {
        return 0;
    }
    else
    {
        return 1+Nodenum(root->Left)+Nodenum(root->Right);

    }
}

//二叉树的深度
int DepthOfTree(Node* root)
{
    if(root)
    {
        return DepthOfTree(root->Left)>DepthOfTree(root->Right)?DepthOfTree(root->Left)+1:DepthOfTree(root->Right)+1;
    }
    if( root == NULL )
    {
        return 0;
    }
}

//二叉树叶子节点数
int Leafnum(Node* root)
{
    if(!root)
    {
        return 0;
    }
    else if(  (root->Left == NULL) && (root->Right == NULL) )//两边都是空，才说明它是叶子节点
    {
        return 1;
    }
    else
    {
        return  (Leafnum(root->Left) + Leafnum(root->Right)) ;
    }
}


int main()
{
    Node *root = NULL;
    root = createBinaryTree();
    printf("二叉树建立成功");
    cout<<endl;

    cout<<"二叉树总节点数为："<<Nodenum(root)<<endl;

    cout<<"二叉树深度为："<<DepthOfTree(root)<<endl;

    cout<<"二叉树叶子节点数为："<<Leafnum(root)<<endl;

    cout<<"前序遍历结果:"<<endl;
    preOrderTraverse(root);
    cout<<endl;

    cout<<"中序遍历结果:"<<endl;
    inOrderTraverse(root);
    cout<<endl;

    cout<<"后序遍历结果:"<<endl;
    lastOrderTraverse(root);
    cout<<endl;

    return 0;
}

 

  1 #include<bits/stdc++.h>
  2 using namespace std;
  3 
  4 typedef struct BinaryTreeNode
  5 {
  6     int date;
  7     struct BinaryTreeNode*Left;
  8     struct BinaryTreeNode*Right;
  9 }Node;
 10 
 11 Node* createBinaryTree()
 12 {
 13     Node *p;
 14     int val;
 15     cin>>val;
 16     if(val==0)
 17         p=NULL;
 18     else
 19     {
 20         p=(Node*)malloc(sizeof(Node));
 21         p->date=val;
 22         p->Left=createBinaryTree();
 23         p->Right=createBinaryTree();
 24     }
 25     return p;
 26 }
 27 
 28 void preOrderTraverse(Node* root){
 29     if(root!=NULL)
 30     {
 31         cout<<root->date<<" ";
 32         preOrderTraverse(root->Left);
 33         preOrderTraverse(root->Right);
 34     }
 35 }
 36 
 37 void inOrderTraverse(Node* root){
 38     if(root!=NULL)
 39     {
 40         preOrderTraverse(root->Left);
 41         cout<<root->date<<" ";
 42         preOrderTraverse(root->Right);
 43     }
 44 }
 45 
 46 void lastOrderTraverse(Node* root){
 47     if(root!=NULL)
 48     {
 49         preOrderTraverse(root->Left);
 50         preOrderTraverse(root->Right);
 51         cout<<root->date<<" ";
 52     }
 53 }
 54 
 55 int Nodenum(Node* root)//二叉树节点数
 56 {
 57     if(root==NULL)
 58         return 0;
 59     else
 60         return Nodenum(root->Left)+Nodenum(root->Right)+1;
 61 }
 62 
 63 int DepthofTree(Node* root)
 64 {
 65     if(root)
 66         return DepthofTree(root->Left)>DepthofTree(root->Right)?DepthofTree(root->Left)+1:DepthofTree(root->Right)+1;
 67     if(root==NULL)
 68         return 0;
 69 }
 70 
 71 int Leafnum(Node* root)
 72 {
 73     if(!root)
 74         return 0;
 75     else if(root->Left==NULL&&root->Right==NULL)
 76         return 1;
 77     else
 78         return Leafnum(root->Left)+Leafnum(root->Right);
 79 }
 80 
 81 
 82 int main(){
 83     Node *root=NULL;
 84     root=createBinaryTree();
 85     cout<<endl;
 86     cout<<"二叉树总节点数为："<<Nodenum(root)<<endl;
 87 
 88     cout<<"二叉树深度为："<<DepthofTree(root)<<endl;
 89 
 90     cout<<"二叉树叶子节点数为："<<Leafnum(root)<<endl;
 91 
 92     cout<<"前序遍历结果:"<<endl;
 93     preOrderTraverse(root);
 94     cout<<endl;
 95 
 96     cout<<"中序遍历结果:"<<endl;
 97     inOrderTraverse(root);
 98     cout<<endl;
 99 
100     cout<<"后序遍历结果:"<<endl;
101     lastOrderTraverse(root);
102     cout<<endl;
103 
104     return 0;
105 }
View Code

 

 

  1 #include<bits/stdc++.h>
  2 using namespace std;
  3 typedef struct TreeNode{
  4     int data;
  5     struct TreeNode* left1;
  6     struct TreeNode* right1;
  7 }Node;
  8 
  9 Node* createTreeNode()
 10 {
 11     Node* p;
 12     int val;
 13     cin>>val;
 14     if(val==0)
 15         p=NULL;
 16     else
 17     {
 18        p=(Node*)malloc(sizeof(Node));
 19        p->data=val;
 20        p->left1=createTreeNode();
 21        p->right1=createTreeNode();
 22     }
 23     return p;
 24 }
 25 
 26 //先序遍历
 27 void PreCheck(Node* root)
 28 {
 29     if(root!=NULL)
 30     {
 31         cout<<root->data<<" ";
 32         PreCheck(root->left1);
 33         PreCheck(root->right1);
 34     }
 35 }
 36 
 37 //中序遍历
 38 void InCheck(Node* root)
 39 {
 40     if(root!=NULL)
 41     {
 42         PreCheck(root->left1);
 43         cout<<root->data<<" ";
 44         PreCheck(root->right1);
 45     }
 46 }
 47 
 48 //后序遍历
 49 void LastCheck(Node* root)
 50 {
 51     if(root!=NULL)
 52     {
 53         PreCheck(root->left1);
 54         PreCheck(root->right1);
 55         cout<<root->data<<" ";
 56     }
 57 }
 58 
 59 //节点总数
 60 int TreeNum(Node* root)
 61 {
 62     if(root==NULL)
 63         return 0;
 64     else
 65        return 1+TreeNum(root->left1)+TreeNum(root->right1);
 66 }
 67 
 68 //叶叶子节点总数
 69 int LeafNum(Node* root)
 70 {
 71     if(root==NULL)
 72         return 0;
 73     else if(root->left1==NULL&&root->right1==NULL)
 74          return 1;
 75     else
 76       return  LeafNum(root->left1)+LeafNum(root->right1);
 77 }
 78 
 79 //二叉树的深度
 80 int DepthTree(Node* root)
 81 {
 82     if(root==NULL)
 83        return 0;
 84     else
 85         return DepthTree(root->left1)>DepthTree(root->right1)?DepthTree(root->left1)+1:DepthTree(root->right1)+1;
 86 }
 87 
 88 int main()
 89 {
 90     Node* p=NULL;
 91     cout<<"创建二叉树"<<endl;
 92     p=createTreeNode();
 93     cout<<"二叉树创建成功"<<endl;
 94     cout<<endl;
 95     cout<<"先序遍历"<<endl;
 96     PreCheck(p);
 97     cout<<endl;
 98     cout<<"中序遍历"<<endl;
 99     InCheck(p);
100     cout<<endl;
101     cout<<"后序遍历"<<endl;
102     LastCheck(p);
103     cout<<endl;
104     cout<<TreeNum(p)<<endl;
105     cout<<LeafNum(p)<<endl;
106     cout<<DepthTree(p)<<endl;
107 }
View Code

 

　　

 

转载于:https://www.cnblogs.com/Aiahtwo/p/11191682.html

37 | 二叉树
微信号：RunsenLiu
07-05 1164
如果要删除的节点有两个子节点，需要找到这个节点的右子树的最小节点，把它替换到要删除的节点上，然后再删除掉这个最小节点，因为最小节点肯定没有左子节点。被删除的节点有左子树，或者有右子树，而且只有其中一个，那么只要把当前删除节点的父节点指向被删除节点的左子树或者右子树就行。二叉树的遍历是指从二叉树的根结点出发，按照某种次序依次访问二叉树中的所有结点，使得每个结点被访问一次，且仅被访问一次。满二叉树：在一棵二叉树中。没有子节点的节点叫作叶子节点或者叶节点，图中的G，H，I，J，K，L。方法是为了方便打印。
二叉树
weixin_33800593的博客
09-18 95
二叉树：二叉树是每个节点最多只有两个子节点的树，且子节点有左右之分。 满二叉树：一棵深度为k，且有2^k-1个节点的二叉树称为满二叉树。 完全二叉树：二叉树中，每个节点的序号都与相同的深度满二叉树序号完全一致，称为完全二叉树。 二叉树的遍历：二叉树的遍历通常有三种主要的方法，前序遍历、中序遍历和后序遍历，三种方法都是递归实现的。 1. 前序遍历...
【数据结构】二叉树
weixin_30251829的博客
03-31 96
二叉树节点 #pragma once #include <stdlib.h> template<class T>class BinaryTreeNode { public: T data; BinaryTreeNode<T>* leftchild; BinaryTreeNode<T>* rightchild; BinaryTre...
JavaScript数据结构之二叉树的查找算法示例
01-21
本文实例讲述了JavaScript数据结构之二叉树的查找算法。分享给大家供大家参考，具体如下： 前面文章介绍了二叉树的遍历，现在谈谈在二叉树中进行查找。对二叉查找树来说，一般有以下三类查找：最大值，最小值和给定...
C语言数据结构之二叉树的非递归后序遍历算法
01-01
C语言数据结构之二叉树的非递归后序遍历算法 前言： 前序、中序、后序的非递归遍历中，要数后序最为麻烦，如果只在栈中保留指向结点的指针，那是不够的，必须有一些额外的信息存放在栈中。 方法有很多，这里只举一...
数据结构之二叉树.rar
12-05
本资料“数据结构之二叉树.rar”深入探讨了如何使用数组来实现二叉树的各种操作，包括插入、删除以及遍历，采用C++语言进行编程，并体现了面向对象的设计思想。 首先，我们要理解二叉树的基本概念。二叉树是由节点...
二叉树详解
u012256398的专栏
03-25 195
        树是一种比较重要的数据结构，尤其是二叉树。二叉树是一种特殊的树，在二叉树中每个节点最多有两个子节点，一般称为左子节点和右子节点（或左孩子和右孩子），并且二叉树的子树有左右之分，其次序不能任意颠倒。本篇博客将详细为大家解析二叉树。   首先介绍两个概念： 满二叉树：在一棵二叉树中，如果所有分支结点都有左孩子和右孩子结点，并且叶子结点都集中在二叉树的最下层，这样的树叫做满二叉...
微信HOOK之二叉树获取信息 201-12-25
weixin_44183918的博客
12-25 1309
微信获取二叉树信息
二叉树查找树
weixin_41837346的博客
01-02 229
二叉查找树（Binary Search Tree） 二叉搜索树 快速查找，插入，删除 定义：每个节点，都不大于它的右子节点，且不小于它的左子节点 查找：递归：大找右边，小找左边，找到或没了返回 插入：递归：大找右空，不空往右；小找左空，不空往左 删除 先找，并记录父节点 无子节点，父节点指向null 一个子节点，父节点指向它 2个子节点，替换和删除（右侧最小节点） 排序：中序遍历，复杂度O...
二叉树（2）
weixin_44054248的博客
01-26 121
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录一、二叉树的遍历：二、实现二叉树的基本方法 一、二叉树的遍历： 二叉树不是线性结构，遍历起来就比较复杂。遍历：按照一定的顺序不重复的访问到这个集合的所有元素 1.前序遍历：先访问（打印，修改，比较，等等。。。）根节点，递归遍历左子树，递归遍历右子树 2.中序遍历：先递归遍历左子树，访问根节点，递归遍历右子树， 3.后序遍历：先递归遍历左子树，遍历右子树，访问根节点 4.层序遍历：一层一层往下遍
二叉树就是这么简单
weixin_33868027的博客
03-24 816
一、二叉树就是这么简单 本文撇开一些非常苦涩、难以理解的概念来讲讲二叉树，仅入门观看(或复习).... 首先，我们来讲讲什么是树： 树是一种非线性的数据结构，相对于线性的数据结构(链表、数组)而言，树的平均运行时间更短(往往与树相关的排序时间复杂度都不会高) 在现实生活中，我们一般的树长这个样子的： 但是在编程的世界中，我们一般把树**“倒”**过来看，这样容易我们分析： 一般的树是有很多...
C++实现数据结构之二叉树探索
在数据结构领域中，二叉树是一种非常基础且重要的结构。二叉树是每个节点最多有两个子树的树结构，通常子树被称作“左子树”和“右子树”。由于其结构的特殊性，二叉树在搜索、排序、查找等操作中具有较高的效率。在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值