264-C++ 二叉树

最新推荐文章于 2024-03-10 15:20:09 发布
最新推荐文章于 2024-03-10 15:20:09 发布
阅读量125 收藏 1
点赞数
分类专栏： java 后端 文章标签： java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67266585/article/details/123592699
版权
java 同时被 2 个专栏收录
289 篇文章 11 订阅
订阅专栏
后端
17 篇文章 0 订阅
订阅专栏

1.树的定义
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
二叉树是最简单的树形结构
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
如果一个节点的左孩子是一个棵满二叉树，它的右孩子也是一棵满二叉树，那么这棵树是否一定是一个满二叉树？

答案：不一定
这种情况就不是一颗满二叉树
在这里插入图片描述
如果一个节点的左孩子是一个棵完全二叉树，它的右孩子也是一棵完全二叉树，那么这棵树是否一定是一个完全二叉树呢？

答案：不一定
在这里插入图片描述
如果是满二叉树，可以用顺序表存储，如果是普通二叉树，使用顺序表浪费的空间很多，所以一般不使用顺序表存储普通二叉树
在这里插入图片描述
三叉链表的存储密度要比二叉链表的存储密度要小
原因是三叉链表要有三个指针来表示节点和节点之间的关系，而二叉链表只有两个，但是三叉链表要比二叉链表要好一点，好在三叉链表找父节点的时候要比二叉链表好找的多的多

一般排序二叉树、VL树、红黑树都采取的是三叉链表的方式，因为需要不断的进行回溯，需要访问父节点
在这里插入图片描述
下面存储的都是下标，如果没有左边的图，可以根据右边的表来推测出图是什么样的
在这里插入图片描述
在这里插入图片描述
实际上都是递归的访问形式
中序遍历的结果：CBDAE
在这里插入图片描述
先序遍历的第一个节点就是根节点，然后以该根节点为分界点，将先序遍历左边分为左先序遍历和右先序遍历，将中序遍历左边分为左中序遍历和右中序遍历，新产生的左先序遍历和右先序遍历的第一个节点都是根节点，然后依次进行下去
在这里插入图片描述
根据先序序列和中序序列创建二叉树

//根据先序遍历和中序遍历打印出序列
BtNode* CreatePI(const char* ps, const char* is, int n)
{
    BtNode* s = NULL;
    if (n >= 1)//还有数据
    {
        s = Buynode();//购买一个节点
        s->data = ps[0];
        int pos = FindIs(is, n, ps[0]);
        if (pos == -1) exit(1);
        s->leftchild = CreatePI(ps+1,is,pos);
        s->rightchild = CreatePI(ps+pos+1,is+pos+1,n-pos-1);
    }
    return s;
}
//根据先序和中序可以推测出结构
BtNode* CreateBinartTreePI(const char*ps, const char* is, int n)
{
    if (ps == NULL || is == NULL || n <= 0) return NULL;
    else return CreatePI(ps, is, n);
}
int main()
{
    char ps[] = { "ABCDEFGH" };
    char is[] = { "CBEDFAGH" };
    char ls[] = { "CEFDBHGA" };
    int n = strlen(ps);
    BinaryTree root = NULL;
    root = CreateBinartTreePI(ps, is, n);
    PreOrder(root);
    cout << endl;
    InOrder(root);
    cout << endl;
    PastOrder(root);
    cout << endl;
    return 0;
}

在这里插入图片描述
通过中序序列和后序序列创建二叉树

BtNode* CreateIL(const char* is, const char* ls, int n)
{
    BtNode* s = NULL;
    if (n > 0)//还有数据
    {
        s = Buynode();//购买一个节点
        s->data = ls[n-1];//下标是从0开始的，最后一个元素的下标是n-1
        int pos = FindIs(is, n, ls[n-1]);
        if (pos == -1) exit(1);
        s->leftchild = CreateIL(is, ls , pos);
        s->rightchild = CreateIL(is + pos + 1, ls + pos,n-pos-1);
    }
    return s;
}
//根据后序和中序可以推测出结构
BtNode* CreateBinartTreeIL(const char* is, const char* ls, int n)
{
    if (is == NULL || ls == NULL || n <= 0) return NULL;
    else return CreateIL(is,ls, n);
}
int main()
{
    char ps[] = { "ABCDEFGH" };
    char is[] = { "CBEDFAGH" };
    char ls[] = { "CEFDBHGA" };
    int n = strlen(ps);
    BinaryTree root = NULL;
    //root = CreateBinartTreePI(ps, is, n);
    root = CreateBinartTreeIL(is, ls, n);
    PreOrder(root);
    cout << endl;
    InOrder(root);
    cout << endl;
    PastOrder(root);
    cout << endl;
    return 0;
}

中序遍历(递归和非递归版本)

//中序遍历
void InOrder(BtNode* p)
{
    if (p != NULL)
    {
        InOrder(p->leftchild);
        cout << p->data << " ";
        InOrder(p->rightchild);
    }
}
void NiceInOrder(BtNode* ptr)
{
    if (ptr == NULL) return;
    std::stack<BtNode*> st;
    while (ptr != NULL || !st.empty())
    {
        while (ptr != NULL)
        {
            st.push(ptr);
            ptr = ptr->leftchild;
        }
        ptr = st.top();
        st.pop();
        cout << ptr->data;
        ptr = ptr->rightchild;
    }
}
void StkNiceInOrder(BtNode* ptr)
{
    if (ptr == NULL) return;
    stack<StkNode> st;
    st.push(StkNode(ptr));
    while (!st.empty())
    {
        StkNode node = st.top(); st.pop();
        if (++node.pos == 2)//中序遍历，当第二次出栈时打印
        {
            cout << node.pnode->data;
            if (node.pnode->rightchild != NULL)//可能还存在右子树
            {
                st.push(StkNode(node.pnode->rightchild));
            }
        }
        else
        {
            st.push(node);//记得入栈
            if (node.pnode->leftchild != NULL)
            {
                st.push(StkNode(node.pnode->leftchild));
            }
        }
    }
}

只有先序序列和后序序列是无法创建二叉树的
先序遍历(递归和非递归版本)

//先序遍历
void PreOrder(BtNode* p)
{
    if (p != NULL)
    {
        cout << p->data << " ";
        PreOrder(p->leftchild);
        PreOrder(p->rightchild);
    }
}
void NicePreOrder(BtNode* ptr)
{
    if (ptr == NULL) return;
    stack<BtNode*> st;
    st.push(ptr);
    while (!st.empty())
    {
        ptr = st.top();
        st.pop();
        cout << ptr->data;
        if (ptr->rightchild != NULL)
        {
            st.push(ptr->rightchild);
        }
        if (ptr->leftchild != NULL)
        {
            st.push(ptr->leftchild);
        }
    }
}

后序遍历的优化(递归和非递归版本)
NicePastOrder函数中元素出栈三次时，肯定左子树和右子树都访问过了，第一次将元素入栈，将元素出栈，pos值为1，再次入栈(这一步很重要)，判断左子树是否存在，如果存在，将左孩子入栈，左孩子处理完毕后，再将元素出栈，pos值变为2，再次入栈(这一步很重要)，判断右子树是否存在，如果存在，将右孩子入栈，右孩子处理完毕后，再将元素出栈，pos值变为3，打印该元素

//后序遍历
void PastOrder(BtNode* p)
{
    if (p != NULL)
    {
        PastOrder(p->leftchild);
        PastOrder(p->rightchild);
        cout << p->data << " ";
    }
}
void NicePastOrder(BtNode* ptr)
{
    if (ptr == NULL) return;
    std::stack<BtNode*> st;
    BtNode* tag = NULL;
    while (ptr != NULL || !st.empty())
    {
        while (ptr != NULL)
        {
            st.push(ptr);
            ptr = ptr->leftchild;
        }
        ptr = st.top();
        st.pop();
        if (ptr->rightchild == NULL || ptr->rightchild == tag)
        {
            cout << ptr->data;
            tag = ptr;
            ptr = NULL;
        }
        else
        { 
            st.push(ptr);
            ptr =ptr->rightchild;
        }
    }
}
void StkNicePastOrder(BtNode* ptr)
{
    if (ptr == NULL) return;
    stack<StkNode> st;
    st.push(StkNode(ptr));
    while (!st.empty())
    {
        StkNode node = st.top(); st.pop();
        if (++node.pos == 3)
        {
            cout << node.pnode->data;
        }
        else
        {
            st.push(node);
            if (node.pos == 1 && node.pnode->leftchild != NULL)
            {
                st.push(StkNode(node.pnode->leftchild));
            }
            else if (node.pos == 2 && node.pnode->rightchild != NULL)
            {
                st.push(StkNode(node.pnode->rightchild));
            }
        }
    }
}

层次遍历，从左往右一层一层输出

void LevelOrder(BtNode* ptr)
{
    if (ptr == NULL) return;
    queue<BtNode*> qu;
    qu.push(ptr);
    while (!qu.empty())
    {
        ptr = qu.front(); 
        qu.pop();
        cout << ptr->data;
        if (ptr->leftchild != NULL)
        {
            qu.push(ptr->leftchild);
        }
        if (ptr->rightchild != NULL)
        {
            qu.push(ptr->rightchild);
        }
    }
}

计算二叉树节点的个数count，左子树的个数+右子树的个数+1

int Count(BtNode* ptr)
{
    if (ptr == NULL) return 0;
    return Count(ptr->leftchild) + Count(ptr->rightchild) + 1;
}

计算二叉树的深度depth,左子树和右子树中深度大的+1

int Depth(BtNode* ptr)
{
    if (ptr == NULL) return 0;
    return std::max(Depth(ptr->leftchild),Depth(ptr->rightchild)) + 1;
}

Z型打印

void ZLevelOrder(BtNode* ptr)
{
    if (ptr == NULL) return;
    stack<BtNode*> ast;
    stack<BtNode*> bst;
    ast.push(ptr);
    while (!ast.empty() || !bst.empty())
    {
        while (!ast.empty())
        {
            ptr = ast.top(); ast.pop();
            cout << ptr->data;
            if (ptr->leftchild != NULL)
            {
                bst.push(ptr->leftchild);
            }
            if (ptr->rightchild != NULL)
            {
                bst.push(ptr->rightchild);
            }
        }
        while (!bst.empty())
        {
            ptr = bst.top(); bst.pop();
            cout << ptr->data;
            if (ptr->rightchild != NULL)
            {
                ast.push(ptr->rightchild);
            }
            if (ptr->leftchild != NULL)
            {
                ast.push(ptr->leftchild);
            }
        }
    }
}

判断是否是满二叉树

bool Is_FullBiary(BtNode* ptr)
{
    if (ptr == NULL) return true;//空树是满二叉树
    bool tag = true;
    queue<BtNode*> aqu;
    queue<BtNode*> bqu;
    int s = 1;
    aqu.push(ptr);
    while (!aqu.empty() || !bqu.empty())
    {
        if (aqu.size() != s)
        {
            tag = false;
            break;
        }
        while (!aqu.empty())
        {
            ptr = aqu.front(); aqu.pop();
            if (ptr->leftchild != NULL)
            {
                bqu.push(ptr->leftchild);
            }
            if (ptr->rightchild != NULL)
            {
                bqu.push(ptr->rightchild);
            }
        }
        s += s;
        if (s != bqu.size())
        {
            tag = false;
            break;
        }
        while (!bqu.empty())
        {
            ptr = bqu.front(); bqu.pop();
            if (ptr->leftchild != NULL)
            {
                aqu.push(ptr->leftchild);
            }
            if (ptr->rightchild != NULL)
            {
                aqu.push(ptr->rightchild);
            }
        }
        s += s;
    }
    return tag;
}
额 无语
关注
专栏目录
265-C++ 二叉树代码
weixin_45964837的博客
03-18 513
typedef char ElemType; typedef struct BtNode//BinaryTreeNode { ElemType data; struct BtNode* leftchild; struct BtNode* rightchild; }BtNode,*BinaryTree; struct StkNode { BtNode* pnode; int pos; public: StkNode(BtNode* p) :pnode(p), p
C++数据结构---二叉树
Rookie_Ws的博客
04-22 3404
树 树的概念 树是一种能分层存储数据的数据结构，树中的每个元素被称为树的节点，每个节点有若干个指针指向子节点 从节点的角度来看，树是由唯一的起始结点引出的节点集合，这个起始结点被称为根(root)， 树中节点的子树数目称为节点的度 树的度指其中节点的度最大值。比如1号节点的孩子是2、3、4，则1号节点的度数是3，且1号节点的度是最大的，故该树的度为3。 二叉树 二叉树是指对于树中的每个节点而言，最多由两个子节点，即任意节点的度小于等于2 层数：从根节点到某个节点的路径长度，根节点为0层 高度：最大层数+
二叉树代码（C++实现）
lanjiangyu的博客
03-23 321
【代码】二叉树代码（C++实现）
C++二叉树的代码实现（含迭代器）
m0_51797936的博客
06-27 1952
带迭代器二叉树的C++实现
二叉树（C++,代码）
qq_74156152的博客
07-27 454
C++ 实现前序建树 复制树 求二叉树深度 求节点数 求叶子节点数 前序遍历 中序遍历 后序遍历
C++实现一颗完整的二叉树——纯代码
qq_48201696的博客
05-31 1403
#ifndef CLEARN_BTREE_H #define CLEARN_BTREE_H #include<iostream> #include<vector> #include<string> #include<list> using namespace std; //定义树的类型，采用二叉链式存储结构 typedef struct node{ char val; node *left; node *right; } BTNode.
C++数据结构-计算二叉树最大的宽度
11-05
在C++编程中，数据结构是至关重要的一个领域，它涉及到如何有效地组织和管理数据，以便于高效地访问和操作。二叉树是一种常见的数据结构，它的每个节点最多有两个子节点，通常分为左子节点和右子节点。在这个问题中...
C++ 数据结构学习 ---- 二叉树
qq_58240448的博客
10-23 1501
学习c++数据结构---二叉树
C++编程-翻转二叉树
weixin_43979090的博客
04-27 515
题目： 给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。 示例 1： 输入：root = [4,2,7,1,3,6,9] 输出：[4,7,2,9,6,3,1] 示例 2： 输入：root = [2,1,3] 输出：[2,3,1] 示例 3： 输入：root = [] 输出：[] 代码1： /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *lef
计算机网络 -计算二叉树深度
12-21
在计算机科学领域，二叉树是一种基础的数据结构，它的每个节点最多有两个子节点，通常分为左子节点和右子节点。二叉树的深度是指从根节点到最远叶子节点的最长路径上边的数目。在某些算法和数据处理中，理解并计算...
c++二叉树实现代码
10-20
本实验报告仅用于学习,严禁商业用途造成后果本人概不负责
c++ 语言实现 二叉树 数据结构代码
06-23
C++语言实现数据结构中的二叉树代码 详细
C++编写二叉树源代码
11-18
欢迎大家来访问C++编写二叉树源代码121111111111
C++二叉树源代码程序
02-09
C++二叉树源代码程序，有调试界面~~~
便于复习的二叉树遍历的简单c++代码
12-26
因为数据结构考试，然后自己总结的二叉树遍历代码。通俗易懂，自己写写就可以记住的代码，摒除掉了伪代码记忆的难点。
二叉树的C++实现（纯代码）
weixin_44001521的博客
12-28 2776
#include"pch.h" #include<iostream> #include<stdio.h> using namespace std; //利用上次实验实现的栈的结构知识来做本次实验的辅助工具 #define MaxSize 200 //定义目标数据类型--字符类型 typedef char elem; //定义树结点，属性有：数据，左右指针 typedef...
镜像二叉树C++代码
weixin_33869377的博客
11-22 186
本文为镜像二叉树的C++代码，为了代码简洁，将空节点和某个节点具有空孩子的情况放到了同一个逻辑下进行判断。   typedef struct { int value; BTNode *pLeft; BTNode *pRight; }BTNode; void BTMirror(BTNode *pHead) { if (pHead == NU...
C++实现二叉树
最新发布
qq_45285738的博客
03-10 1107
接下来，你将看到，输出先序、层序遍历结果等内容，如下：（注：中序后序，操作类似于前序遍历，没有实现）1.2 实现二叉树的访问 --- 先中后序访问、层序访问。1.3 计算树的深度、节点数、复制树。2.1 首先创建出一棵二叉树。1.1 实现二叉树的创建。
二叉搜索树讲解及其C++代码实现
m0_56745306的博客
06-04 1100
文章概述：本文介绍了二叉搜索树的概念、一般操作和其C++代码实现。不是很了解二叉搜索树请先看教材和讲解然后参照代码自己动手试一试；如果只是需要实现代码&测试代码，请直接查看第四节。参考教材：清华大学《数据结构》第2版教材（殷人昆主编）...
C++二叉树基础与应用详解
二叉树及其应用是针对C++程序员和有一定编程基础的学习者的一份资料，主要探讨了二叉树的理论概念和在C++中的实际应用。二叉树是一种特殊的树形数据结构，每个节点最多有两个子节点，通常用于解决搜索、排序和数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值