14-数据结构探险系列-树篇

最新推荐文章于 2024-10-01 05:04:32 发布
最新推荐文章于 2024-10-01 05:04:32 发布
阅读量102 收藏
点赞数
文章标签： 数据结构与算法
原文链接：https://yq.aliyun.com/articles/630810
版权

数据结构探险之树篇

本文及代码收录于个人编程笔记(整理中,欢迎Star):
https://github.com/mtianyan/Programming-Notebook

树的基本概念

什么是树？

树是节点的有限结合。

img_4729b4895dccb0256390a18c318712e2.jpe
img_ebe1e2b51ab23355e707a72b9160cc14.jpe

上图是我们在树中要基础的概念

  • 根节点：A; 双亲，父节点（是一个节点）：A

  • 孩子：B,C,D都是A的孩子。

  • 度：A的度为3，因为它接着三个节点BCD。b的度为2，有两个儿子EF。(直接的孩子，儿子)

  • 叶子（终端节点）：CEFGH & 根（非终端节点）：ABD。

  • 有序树 & 无序树：如果B的孩子EF。EF不可以换顺序就是有序树，可以换顺序而不影响逻辑就是无序树

  • 祖先：对E来说B和A都是它的祖先。对G来说D & A 是它的祖先。（从它一直向上一直到根节点。之前路过的所有节点）

  • 子孙：对A来说底下所有都是子孙。对D来说，G & H是它的子孙。（从该节点开始，伸出节点，以及伸出节点的子节点）

  • 树的深度

img_ee29254d2fc258aaaa0a4ea4e8c97e1c.jpe

  • 第一层结点深度为1,第二层2,第三层3.结点深度和当前所处的层数是统一的。

  • 树的深度是节点最大深度。

  • 森林

img_46dab9648243816120955ca65d000f4d.jpe

对于第一幅图，我们可以看出两个不同的子树。多棵树就组成了森林。

  • 二叉树
  1. 所有结点的度都小于等于2:
img_f0b75ef8ac9ce7033680b9d247be1f08.jpe

作图根节点度为3,不为二叉树。右边为二叉树。

  • 二叉树的遍历
img_67c390b0ad3765fa9fc158aab7a6eee5.jpe

遍历（具体是前中后是相对于二叉树的根来说的,左右一直是先左后右，前中后说的是根的遍历位置):

  • 前序遍历（先根, 然后左, 最后右）
  • 中序遍历 (先左，然后根，最后右)
  • 后序遍历 (先左，然后右，最后根)

树的应用：

  • 赫夫曼树（用于压缩软件）
  • 树能够实现人机对战，搜索树。

二叉树数组实现编码说明

二叉树编码要求
数组与树的算法转换

用数组元素为0,表达当前节点不存在节点。

父节点下标*2+1 该节点的左节点；父亲节点下标*2+2 该节点的右节点（基于这是个二叉树）

要求完成的基本操作:

  • 搜索节点：指定数组的下标
  • 添加节点：往哪一个下标的节点添加。左孩子还是右孩子，添加的节点。
  • 删除节点：删除节点的索引
  • 遍历：遍历数组的方法·（数组实现的就简单的按索引遍历）

二叉树数组实现编码实战

3-2-BinaryTreeArray

Tree.h

#ifndef TREE_H
#define TREE_H
class Tree
{
public:
    Tree(int size,int *pRoot);//创建树
    ~Tree();//销毁树
    int *SearchNode(int nodeIndex);//根据索引寻找节点
    bool AddNode(int nodeIndex, int direction, int *pNode);//添加节点
    bool DeleteNode(int nodeIndex, int *pNode); //删除节点
    void TreeTraverse();//遍历节点
private:
    int *m_pTree;
    int m_iSize;
};
#endif

Tree.cpp

#include"Tree.h"
#include<iostream>
using namespace std;

Tree::Tree(int size, int *pRoot)
{
    m_iSize = size;
    m_pTree = new int[size];
    for (int i = 0; i < size; i++)
    {
        m_pTree[i] = 0;
    }
    m_pTree[0] = *pRoot;
}

Tree::~Tree()
{
    delete[]m_pTree;
    m_pTree = NULL;
}

int *Tree::SearchNode(int nodeindex)
{
    if (nodeindex < 0 || nodeindex >= m_iSize)
    {
        return NULL;
    }
    if (m_pTree[nodeindex] == 0)
    {
        return NULL;
    }
    return &m_pTree[nodeindex];//由索引取值后取地址
}

bool Tree::AddNode(int nodeindex, int direction, int *pNode)
// direction决定往左插，还是往右插。
{
    if (nodeindex < 0 || nodeindex >= m_iSize || m_pTree[nodeindex] == 0)
    //节点合法性
    {
        return false;
    }
    switch (direction)
    {
    // 0值定义为左孩子
    case 0:
        // 不等于0，说明插入过了，这里我们的处理是，如果插过了，不允许替换。
        if (nodeindex * 2 + 1 >= m_iSize || m_pTree[nodeindex * 2 + 1] != 0)
        {
            return false;
        }
        m_pTree[nodeindex * 2 + 1] = *pNode;
        break;
    case 1:
        if (nodeindex * 2 + 2 >= m_iSize || m_pTree[nodeindex * 2 + 2] != 0)
        {
            return false;
        }
        m_pTree[nodeindex * 2 + 2] = *pNode;
        break;
    }
    return true;
}

bool Tree::DeleteNode(int nodeindex, int * pNode)
{
    if (nodeindex < 0 || nodeindex >= m_iSize)
    {
        return false;
    }
    if (m_pTree[nodeindex] == 0)
    {
        return false;
    }
    *pNode = m_pTree[nodeindex];
    m_pTree[nodeindex] = 0;

    return true;
}

void Tree::TreeTraverse()
{
    for (int i =0;i<m_iSize;i++)
    {
        cout << m_pTree[i] << " ";
    }
}

main.cpp

#include <iostream>
#include <stdlib.h>
#include "Tree.h"
using namespace std;
/********************************************************************
              数组---树  Tree【】=3 5 8 2 6 9 7
              3(0)                                左孩子小标=父节点下标*2+1
    5(1)               8(2)                       右孩子小标=父节点下标*2+2
 2(3)      6(4)  9(5)        7(6)
 
 **********************************************************************/
int main()
{
    int root = 3;
    Tree *pTree = new Tree(10, &root);
    int node1 = 5;
    int node2 = 8;
    //0号节点插入左孩子。
    pTree->AddNode(0, 0, &node1);
    //0号节点插入右孩子。
    pTree->AddNode(0, 1, &node2);
    
    int node3 = 2;
    int node4 = 6;
    int node5 = 9;
    int node6 = 7;
    pTree->AddNode(1, 0, &node3);
    pTree->AddNode(1, 1, &node4);
    pTree->AddNode(2, 0, &node5);
    pTree->AddNode(2, 1, &node6);
    
    pTree->TreeTraverse();
    
    // 传入节点值，找到index
    int *p = pTree->SearchNode(2);
    cout << endl;
    cout << "***************"<<endl;
    cout << "index:" << *p<<endl;
    cout << "***************"<<endl;
    // 删除传入index
    int temp;
    pTree->DeleteNode(6, &temp);
    cout << endl;
    cout << "delete node=" << temp << endl;
    
    pTree->TreeTraverse();
    cout << endl;
    delete pTree;
    pTree = NULL;
    
    return 0;
}

运行结果：

img_c8d9e8ee711e92e5637fd7003d1a9963.jpe
二叉树链表实现编码
/********************************************************************
  Tree(int size,int *pRoot);          //创建树
    ~Tree();                            //销毁树
    int * SearchNode(int nodeindex);//搜索结点
    bool AddNode(int nodeindex,int direction,int *pNode);//添加结点
    bool DeleteNode(int nodeindex,int * pNode);         //删除结点
    void PreorderTravers();   //前序遍历
    void InorderTravers();    //中序遍历
  void PostorderTravers();  //后序遍历
 ***********************************************************************/
  • 结点要素：索引、数据、左孩子指针、右孩子指针;结点左孩子指针找到左孩子。右孩子指针找到右孩子
  • 通过搜索先找到要挂载的结点,然后左右两边分别挂载左孩子右孩子。
  • 删除的时候进行级联删除，销毁树时要一级一级都删除。
#include<stdlib.h>
#include"Tree.h"
#include<iostream>
using namespace std;
/********************************************************************
    二叉树--链表实现 
              (0)                                  左孩子索引=父节点索引*2+1
     5(1)             8(2)                         右孩子索引=父节点索引*2+2
2(3)      6(4)  9(5)        7(6)
前序遍历：根左右0134256    中序遍历：左根右3140526   后序遍历：左右根 3415620
**********************************************************************/

int main(void)
{   
    int root=3;
    Tree *pTree=new Tree(10,&root);

    delete pTree;
    pTree=NULL;
    return 0;
}

必须指定一个节点，才能为它添加左右节点。删除节点会级联删除掉。

二叉树编码实战
父节点指针

结点要素:索引 数据 左孩子指针 右孩子指针 父结点指针

6-6-BinaryTreeArrayLinkedList

NULL 包含在<stdio.h>

Node.h

#ifndef NODE_H
#define NODE_H

class Node
{
public:
    Node();
    Node *SearchNode(int nodeIndex);
    // 杀完孩子之后自己判断自己是左是右，然后自杀
    void DeleteNode();
    void PreorderTraversal();   // 前序遍历
    void InorderTraversal();    // 中序遍历
    void PostorderTraversal();  // 后序遍历
    int index; //索引
    int data; // 数据
    Node *pLChild; // 左孩子指针
    Node *pRChild; // 右孩子指针
    Node *pParent; // 父节点指针
};

#endif

Node.cpp

#include "Node.h"
#include <iostream>
using namespace std;
Node::Node()
{
    index = 0;
    data = 0;
    pLChild = NULL;
    pRChild = NULL;
    pParent = NULL;
}

Node *Node::SearchNode(int nodeIndex)
{
  // 看自己是不是
    if (this->index == nodeIndex)
    {
        return this;
    }
    // 左右节点是不是
    Node *temp = NULL;
    if (this->pLChild != NULL)
    {
        if (this->pLChild->index == nodeIndex)
        {
            return this->pLChild;
        }
        // 注意没找到的情况继续往下找
        else
        {
            temp = this->pLChild->SearchNode(nodeIndex);
            if (temp != NULL)
            {
                return temp;
            }
        }
    }
    if (this->pRChild != NULL)
    {
        if (this->pRChild->index == nodeIndex)
        {
            return this->pRChild;
        }
        // 注意没找到的情况继续往下找
        else
        {
            temp = this->pRChild->SearchNode(nodeIndex);
            if (temp != NULL)
            {
                return temp;
            }
        }

    }

    return NULL;
}

void Node::DeleteNode()
{
    if (this->pLChild != NULL)
    {
        this->pLChild->DeleteNode();
    }
    if (this->pRChild != NULL)
    {
        this->pRChild->DeleteNode();
    }
    if (this->pParent != NULL)
    {
      // 判断自己是父节点的左孩子还是右孩子。
        if (this->pParent->pLChild == this)
        {
            this->pParent->pLChild = NULL;
        }
        if (this->pParent->pRChild == this)
        {
            this->pParent->pRChild = NULL;
        }
    }
  // 自杀
    delete this;

}
//先自己，然后左边然后右边
void Node::PreorderTraversal()
{
    cout << this->index << " " << this->data << endl;
    if (this->pLChild != NULL)
    {
        this->pLChild->PreorderTraversal();
    }
    if (this->pRChild != NULL)
    {
        this->pRChild->PreorderTraversal();
    }
}

void Node::InorderTraversal()
{
    
    if (this->pLChild != NULL)
    {
        this->pLChild->InorderTraversal();
    }
    cout << this->index << " " << this->data << endl;
    if (this->pRChild != NULL)
    {
        this->pRChild->InorderTraversal();
    }
}
void Node::PostorderTraversal()
//后序遍历
{
    if (this->pLChild != NULL)
    {
        this->pLChild->PostorderTraversal();
    }
    if (this->pRChild != NULL)
    {
        this->pRChild->PostorderTraversal();
    }
    cout << this->index << " " << this->data << endl;
}

Tree.h

#ifndef TREE_H
#define TREE_H
#include "Node.h"

class Tree
{
public:
    Tree(); //创建树
    ~Tree();//销毁树 del node 删除最根节点即可
    Node *SearchNode(int nodeIndex); //搜索节点
    bool AddNode(int nodeIndex, int direction, Node *pNode);//搜索节点基础上添加
    bool DeleteNode(int nodeIndex, Node *pNode);//删除结点
    void PreorderTraversal();   //前序遍历
    void InorderTraversal();    //中序遍历
    void PostorderTraversal();  //后序遍历

private:
    Node *m_pRoot;
};

#endif

Tree.cpp:

#include "Tree.h"
#include <iostream>
using namespace std;
Tree::Tree()
{
    m_pRoot = new Node();// 第一个节点
}

Tree::~Tree()
{
    DeleteNode(0, NULL);
    //m_pRoot->DeleteNode();
}

//删除结点为头结点。整棵树销毁
//删除和添加都需要找到节点

Node *Tree::SearchNode(int nodeIndex)
{
    return m_pRoot->SearchNode(nodeIndex);
}


bool Tree::AddNode(int nodeIndex, int direction, Node *pnode) {
    Node *temp = SearchNode(nodeIndex);
    // 挂载节点不存在
    if (temp == NULL)
    {
        return false;
    }

    Node *node = new Node();
    if (node == NULL)
    {
        return false;
    }
    // 要把pnode值保存下来。
    node->index = pnode->index;
    node->data = pnode->data;
    node->pParent = temp; //注意，要在添加时把父节点也记着登记上。
    
    //0挂左，1挂右
    if (direction == 0)
    {
        temp->pLChild = node;
    }
    if (direction == 1)
    {
        temp->pRChild = node;
    }
    
    return true;
};

// 删除节点(级联删除子节点)& 析构函数

bool Tree::DeleteNode(int nodeIndex, Node *pNode)
{
    Node *temp = SearchNode(nodeIndex);
    if (temp == NULL)
    {
        return false;
    }
    if (pNode != NULL)
    {
        pNode->data = temp->data;
    }
    // 把树中删除节点的操作下移到node中来解决
    temp->DeleteNode();
    return true;

}

void Tree::PreorderTraversal()
{
    m_pRoot->PreorderTraversal();
}
void Tree::InorderTraversal()
{
    m_pRoot->InorderTraversal();
}
void Tree::PostorderTraversal()
{
    m_pRoot->PostorderTraversal();
}

main.cpp:

#include "Tree.h"
#include <stdlib.h>
#include <iostream>
using namespace std;

/*
 二叉树--链表实现
 
 (0)                                  左孩子索引 = 父节点索引 * 2 + 1
 5(1)         8(2)                           右孩子索引 = 父节点索引 * 2 + 2
 2(3)   6(4)   9(5)   7(6)
 
 前序遍历：根左右0134256    中序遍历：左根右3140526   后序遍历：左右根 3415620
 */
int main()
{
    Node *node1 = new Node();
    node1->index = 1;
    node1->data = 5;
    
    Node *node2 = new Node();
    node2->index = 2;
    node2->data = 8;
    
    Node *node3 = new Node();
    node3->index = 3;
    node3->data = 2;
    
    Node *node4 = new Node();
    node4->index = 4;
    node4->data = 6;
    
    Node *node5 = new Node();
    node5->index = 5;
    node5->data = 9;
    
    Node *node6 = new Node();
    node6->index = 6;
    node6->data = 7;
    
    Tree *pTree = new Tree();
    pTree->AddNode(0, 0, node1);
    pTree->AddNode(0, 1, node2);
    pTree->AddNode(1, 0, node3);
    pTree->AddNode(1, 1, node4);
    pTree->AddNode(2, 0, node5);
    pTree->AddNode(2, 1, node6);
    
    // pTree->DeleteNode(6, NULL);
    cout << "前序遍历" << endl;
    pTree->PreorderTraversal();
    cout << "中序遍历" << endl;
    pTree->InorderTraversal();
    cout << "后序遍历" << endl;
    pTree->PostorderTraversal();
    delete pTree;
    pTree = NULL;
    return 0;
}

前序遍历：根左右0134256 中序遍历：左根右3140526 后序遍历：左右根 3415620

img_7fb544ab8ffabbf076364443de7f4fe8.jpe
weixin_33947521
关注
开源模型应用落地-LlamaIndex学习之旅-LLMs-集成vLLM（二）
没有卑微的工作，只有卑微的心态，与其抱怨，不如埋头实干
09-03 1846
LlamaIndex学习之旅-集成vLLM（entrypoints.api_server）
【ChatGPT】实用 Prompt 指令大全 —— 一文教你如何更好地挖掘 GPT 的价值
AI天才研究院
04-15 2万+
ChatGPT 是由 OpenAI 开发的一种先进的大型语言生成模型，能够理解和生成准确、自然且连贯的文本。文本生成数据分析内容审核语义理解自然语言推理以及其他众多任务ChatGPT是一种基于GPT-3.5架构的大型语言模型，由OpenAI公司开发。该模型在自然语言处理领域有着广泛的应用，可以用于文本生成、文本分类、情感分析、问答系统等任务。本文将从模型的架构、训练方式、优缺点等方面对ChatGPT进行详细介绍。一、模型架构。
数据结构探险之树篇
weixin_33682719的博客
09-11 103
数据结构探险之树篇 什么是树？ 树是节点的有限结合。 1正2倒 概念 根节点：A 双亲：A 孩子：A ：b,c,d 度：A的度为3，因为它接着三个节点BCD。b的度为2，EF.(直接的孩子) 叶子（终端节点）：CEFGH 根（非终端节点）：ABD。 有序树 & 无序树：如...
数据结构探险——树篇
u014114763的博客
05-30 151
@这篇文档是由C++代码实现的二叉树 二叉树就是每个结点至多只有两棵子树（即二叉树中不存在度大于2的结点），并且二叉树的子树有左右之分，其次序不能任意颠倒。 二叉树的实现可以采用数组或者链表，数组实现比较简单，本文是以链表形式实现的，其中每个结点内容包括父结点指针，左孩子指针，右孩子指针，位序，数据域。 本文是以Visual Studio中新建的C++win32的控制台应用程序实现的，其中建立了头...
15-数据结构探险系列-图篇
weixin_34162695的博客
07-29 188
数据结构探险之图篇 本文及代码收录于个人编程笔记(整理中,欢迎Star):https://github.com/mtianyan/Programming-Notebook 图的简介 什么是图？ 如下图：无向图 & 有向图(箭头分方向)。图可以看做节点和连线的集合，无向图中可以被认为是有来有回的两条线...
数据结构探险之线性表下篇：链表通讯录
weixin_34268579的博客
09-05 182
数据结构探险之线性表下篇：链表 链表实现 链表 顺序表的优缺点： 顺序表的优缺点 优点：遍历寻址很方便，基于数组效率高 缺点：插入时元素挪位。删除时元素挪位。 什么是链表？ 单链表 单向性：节点（数据域|指针域）指针域指向下一个节点。直到最后一个指针域指向NULL； 循环链...
摘星-上升篇
热门推荐
DIANZI520SUA的专栏
01-02 4万+
以下内容均来自阳光占星，如有冒犯，告知删除！ 上升金牛——歌者的哼唱 有这么一类人，可能有着细致柔和的五官，容易发胖的体质以及坚定的眼神。有点害羞与腼腆；喜欢哼唱着小曲，不喜欢拥挤的人群而喜欢宁静的自然。这样的一群人就是生活在我们身边的上升金牛。他们喜欢舒缓的生活节奏，喜欢按照自己的节奏去一点点的完成计划，不喜欢突如其来的变动扰乱了自己的生活。 金牛是一个喜欢稳定和安逸的星座，并且由于金牛的守护星为金星，上升金牛也诞生出更多的艺术色彩。但上升金牛的审美一直被吐槽，旁人就必须忍受他那万年...
计算机原理探险系列（六）-- 看图认识内存分配
Danny_idea的博客
05-05 3289
之前的几篇文章里面，我们相应介绍了计算机内部的进程，磁盘，cpu，网络等相关知识点，今天主要来一起探讨下关于计算机的内存分配问题。 有限的物理内存 计算机在运行的时候，其所拥有的内存空间其实是有限的。在早期的Dos操作系统中，通常就是4mb的内存，那时候的应用软件还不怎么流行，基本4mb的内存空间就足够程序运作了。不过到了后期阶段，随着各种硬件设备的不断完善，往往可能会存在内存空间小于程序的大小。（例如：内存空间4mb，程序大小16mb） 解决思路 设计一个虚拟存储器，将需要用到指定程序加载到内存中进行计算
开源模型应用落地-工具使用篇-向量数据库（三）
没有卑微的工作，只有卑微的心态，与其抱怨，不如埋头实干
02-18 3129
引入向量数据库，为AI服务赋能
面试技巧 面试复盘 编程技术 架构 看这一篇就够了
china19931017的博客
11-25 2281
神经网路与深度学习 Kubernetes实战 大型网站性能监测、分析与优化 Flume日志收集与MapReduce模式 ZooKeeper：分布式过程协同技术详解 自己动手写Java虚拟机 Java WebSocket编程 开发、部署和保护动态Web应用 SpringBoot揭秘：快速构建微服务体系 Web全栈工程师的自我修养 Apache Spark源码剖析 Wireshark数据包分析实战详解 深入剖析Tomcat-网上版本不够清晰 故重做 Kafka技术内幕 图文详解Kafka
【Unity】siki公开Unity相关课程下载目录
Get your hands dirty
11-12 1万+
一、最新课程 Shader Forge入门 链接： https://pan.baidu.com/s/1n8324ujcUYmeMb40si30RQ  密码：uxuq   强大的UI编辑器 - FairyGUI入门教程 链接： https://pan.baidu.com/s/1bmlElfaOFH5zGB92hILZKg  密码：jyqp   Unity初级案例 - 愤怒的小鸟...
数据库冒险手册：从索引优化到事务管理的深度探索之旅 ️
java专栏
06-30 701
在一些高级场景下，你甚至可以创建自己的索引类型，比如GiST、SP-GiST、GIN和BRIN等，以应对特殊的数据结构和查询需求。不过，这通常需要更深入的数据库知识和经验。-- 假设我们有一个地理位置相关的应用注释：这里展示了如何为地理空间数据类型创建GIST索引，这在处理点、线、面等空间数据查询时非常有效。索引，简而言之，就是数据库中用于加速数据检索的一类数据结构。它的工作原理类似书籍的目录，通过创建指向数据行的指针列表，使得查找特定值的速度大大加快。没有索引，数据库就需要逐行遍历整个表，效率极低。
编程题 7-14 求整数段和【PAT】
绯樱殇雪的博客
09-30 953
编程题 7-14 求整数段和
Python | Leetcode Python题解之第448题找到所有数组中消失的数字
最新发布
Mopes__的博客
10-01 366
Python | Leetcode Python题解之第448题找到所有数组中消失的数字
Java - LeetCode面试经典150题 - 哈希表 (二)
心如冰清，天塌不惊
09-28 905
否则，返回 false。给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那两个整数，并返回它们的数组下标。遍历字符串数组，将其中的字符串，进行排序，这样就形成一个唯一的字符串了，之后将原字符串追加到这个排序完的字符串映射的String列表中。这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 s 中的每个非空单词之间存在着双向连接的对应规律。将magazine中的每个字符的个数记录下来，用map映射成。
HashMap、HashTable与ConcurrentHashMap的区别与联系
0
09-29 689
是基于哈希表的 Map 接口实现，它存储的内容是键值对(key-value)。HashMap 的底层实现原理涉及数组、链表和红黑树的结合使用。
Golang | Leetcode Golang题解之第448题找到所有数组中消失的数字
weixin_66442839的博客
10-01 396
Golang | Leetcode Golang题解之第448题找到所有数组中消失的数字
SUUNTO X-Lander探险计算机中文操作指南
"SUUNTO松拓X-Lander中文说明书提供了这款户外探险设备的详细使用指南，包括各种功能的介绍和操作方法。" SUUNTO X-Lander是一款专业的探险计算机，结合了多种实用功能，如时间显示、海拔仪、气压计和罗盘，适用于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值