解决二叉树的编程问题

最新推荐文章于 2022-07-10 15:27:14 发布
最新推荐文章于 2022-07-10 15:27:14 发布
阅读量914 收藏 2
点赞数
文章标签：  用链式存储结构表示二叉树（Binary Tree） 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40323256/article/details/88111150
版权

目录

（一）二叉树定义

（二）二叉树的相关术语

（三）二叉树的主要性质

二叉树的存储结构

1．顺序存储结构

2．二叉链式存储结构

 用链式存储结构表示二叉树（Binary Tree）代码实现：

3．三叉链表存储结构

二叉树的遍历方法及递归实现

注意：如果中序遍历和后序遍历序列相同，则该树只有左子树没有右子树。如果中序遍历和先序遍历序列相同，则该树只有右子树没有左子树。

1.先序遍历（DLR）：先从二叉树的根开始，然后到左子树，再到右子树

2.中序遍历（LDR）：先从左子树开始，然后到根，再到右子树

3.后序遍历（LRD）：先从左子树开始，然后到右子树，再到根

4.层次遍历：从根结点开始，从上到下，从左到右依次访问

最优二叉树-哈夫曼树（Haffman）：https://mp.csdn.net/postedit

（一）二叉树定义

二叉树（Binary Tree）是n(n>=0)个有限元素的集合，该集合或者为空，或者由一个称为根（root）的元素及两个不相交的，被分别称为左子树和右子树的二叉树组成。当集合为空时，称该二叉树为空二叉树。在二叉树中，一个元素也称为一个结点。

二叉树由五种基本形态：

（二）二叉树的相关术语

（1）结点的度。结点所拥有的子树的个数称为该结点的度。

（2）叶结点。度为0的结点称为叶结点，或者称为终端结点。

（3）分支结点。度不为0的结点称为分支结点，或称为非终端结点。一棵树的结点除了叶结点外，其余的都是分支结点。

（4）孩子，兄弟，双亲。顾名思义，不多做解释

（5）路径，路径长度。

（6）祖先，子孙。在树种，如果有一条路径从结点M到结点N，那么M就称为N的祖先，而N称为M的子孙。

（7）结点的层数。规定树的根结点的层数为1，其余结点的层数等于它的双亲结点的层数加1.

（8）树的深度。树中所有结点的最大层数称为树的深度。

（9）树的度。树中各结点度的最大值称为该树的度。二叉树的最大度为2.

（10）满二叉树。在一棵二叉树中，如果所有分支结点都存在左子树和右子树，并且所有叶子结点都在同一层上，这样的一棵二叉树称为满二叉树。

（11）完全二叉树。一棵深度为K的有n个结点的二叉树，对树中的结点按从上到下，从左到右的顺序进行编号，如果编号为i（1<=i<=n）的结点与满二叉树中编号为i的结点在二叉树中的位置相同，则这棵二叉树称为完全二叉树。完全二叉树的特点是：叶子结点只能出现在最下层和次下层，且最下层的叶子结点集中在树的左部。显然，一棵满二叉树必定是一棵完全二叉树，但完全二叉树未必是满二叉树。

 

（三）二叉树的主要性质

1.一颗非空二叉树的第i层上最多有个结点。(i>=1)。

2.一颗深度为k的二叉树中，最多具有个结点。（k>=1）

3.对任何一棵二叉树，如果其叶结点有n个，度为2的非叶子结点有m个，则n = m + 1。

4.具有n个结点的完全二叉树的深度k为。
5.对于有n个结点的完全二叉树，按层次对结点进行编号（从上到下，从左到右），对于任意编号为i的结点：

二叉树的存储结构

二叉树是非线性结构，即每个数据结点至多只有一个前驱，但可以有多个后继。

它可采用顺序存储结构和链式存储结构。而链式存储结构有可以分为二叉链表存储结构、 三叉链表存储结构（带双亲指针的二叉链表存储结构）

1．顺序存储结构

二叉树的顺序存储，就是用一组连续的存储单元存放二叉树中的结点。因此，必须把二叉树的所有结点安排成为一个恰当的序列，结点在这个序列中的相互位置能反映出结点之间的逻辑关系，用编号的方法从树根起，自上层至下层，每层自左至右地给所有结点编号,缺点是有可能对存储空间造成极大的浪费，在最坏的情况下，一个深度为k且只有k个结点的右单支树需要2k-1个结点存储空间。依据二叉树的性质，完全二叉树和满二叉树采用顺序存储比较合适，树中结点的序号可以唯一地反映出结点之间的逻辑关系，这样既能够最大可能地节省存储空间，又可以利用数组元素的下标值确定结点在二叉树中的位置，以及结点之间的关系

    对于一般的二叉树，如果仍按从上至下和从左到右的顺序将树中的结点顺序存储在一维数组中，则数组元素下标之间的关系不能够反映二叉树中结点之间的逻辑关系，只有增添一些并不存在的空结点，使之成为一棵完全二叉树的形式，然后再用一维数组顺序存储。如图5-6给出了一棵一般二叉树改造后的完全二叉树形态和其顺序存储状态示意图。显然，这种存储对于需增加许多空结点才能将一棵二叉树改造成为一棵完全二叉树的存储时，会造成空间的大量浪费，不宜用顺序存储结构。最坏的情况是右单支树，如图7.9所示，一棵深度为k的右单支树，只有k个结点，却需分配2k－1个存储单元。

 

2．二叉链式存储结构

 二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。

通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址。其结点结构为：

其中，data域存放某结点的数据信息；lchild与rchild分别存放指向左孩子和右孩子的指针，当左孩子或右孩子不存在时，相应指针域值为空（用符号∧或NULL表示）。利用这样的结点结构表示的二叉树的链式存储结构被称为二叉链表.

                                                  二叉树的二叉链表表示示意图

 用链式存储结构表示二叉树（Binary Tree）代码实现：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 用链式存储结构表示二叉树
{
    class Program
    {
        static void Main(string[] args)
        {
        }
    }
    public class Node<T>
    {
        private T data;//数据域
        private Node<T> lChild;//左孩子
        private Node<T> rChild;//右孩子

        public T Data { get => data; set => data = value; }
        public Node<T> LChild { get => lChild; set => lChild = value; }
        public Node<T> RChild { get => rChild; set => rChild = value; }

        public Node()
        {
            data = default(T);
            LChild = null;
            rChild = null;
        }
        public Node (T val)
        {
            data = val;
            LChild = null;
            rChild = null;
        }
        public Node(Node <T> plchild,Node <T> prchild)
        {
            data = default(T);
            lChild = plchild;
            rChild = prchild;
        }
        public Node (T val ,Node <T> plchild,Node <T> prchild)
        {
            data = val;
            lChild = plchild;
            rChild = prchild;
        }
    }

    public class LinkBiTree<T>
    {
        private Node<T> head;//头引用

        public Node<T> Head { get => head; set => head = value; }

        //构造函数
        public LinkBiTree()
        {
            head = null;
        }
        public LinkBiTree (T val)
        {
            Node<T> p = new Node<T>(val);
            head = p;
        }
        public LinkBiTree (T val,Node <T> plchild,Node <T> prchild)
        {
            Node<T> p = new Node<T>(val, plchild, prchild);
            head = p;
        }

        /// <summary>
        /// 获取根结点
        /// </summary>
        /// <returns></returns>
        public Node <T> Root()
        {
            return head;
        }

        /// <summary>
        /// 判断二叉树是否为空
        /// </summary>
        /// <returns></returns>
        public bool IsEmpty()
        {
            if(head ==null)
            {
                return true;
            }else
            {
                return false;
            }
        }

        /// <summary>
        /// 判断是否是叶子结点
        /// </summary>
        /// <param name="p"></param>
        /// <returns></returns>
        public bool IsLeaf(Node <T> p)
        {
            if((p!=null )&&(p.LChild ==null )&&(p.RChild ==null))
            {
                return true;
            }else
            {
                return false;
            }
        }
        /// <summary>
        /// 获取结点的左孩子结点
        /// </summary>
        /// <param name="p"></param>
        /// <returns></returns>
        public Node <T> GetLChild(Node <T> p)
        {
            return p.LChild;
        }

        /// <summary>
        /// 获取结点的右孩子结点
        /// </summary>
        /// <param name="p"></param>
        /// <returns></returns>
        public Node <T> GetRChild(Node <T> p)
        {
            return p.RChild;
        }

        /// <summary>
        /// 将结点p的左子树插入值为val的新结点，原来的左子树称为新结点的左子树
        /// </summary>
        /// <param name="val"></param>
        /// <param name="p"></param>
        public void InsertL(T val,Node <T> p)
        {
            Node<T> temp = new Node<T>(val);
            temp.LChild = p.LChild;
            p.LChild = temp;
        }

        /// <summary>
        /// 将结点p的右子树插入值为val的新结点，原来的右子树称为新结点的右子树
        /// </summary>
        /// <param name="val"></param>
        /// <param name="p"></param>
        public void InsertR(T val, Node<T> p)
        {
            Node<T> temp = new Node<T>(val);
            temp.RChild = p.RChild;
            p.RChild = temp;
        }

        /// <summary>
        /// 若p或者p.Lchild非空，则删除p的左子树
        /// </summary>
        /// <param name="p"></param>
        /// <returns></returns>
        public Node <T> DeleteL(Node <T> p)
        {
            if((p==null )||(p.LChild ==null))
            {
                return null;
            }
            Node<T> temp = p.LChild;
            p.LChild = null;
            return temp;
        }

        /// <summary>
        ///  若p或者p.Rchild非空，则删除p的右子树
        /// </summary>
        /// <param name="p"></param>
        /// <returns></returns>
        public Node <T> DeleteR(Node <T> p)
        {
            if((p==null )||p.RChild ==null)
            {
                return null;
            }
            Node<T> temp = p.RChild;
            p.RChild = null;
            return temp;
        }

        /// <summary>
        /// 在二叉树中查找值为value的结点
        /// </summary>
        /// <param name="root"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public Node <T> Search(Node <T> root,T value)
        {
            Node<T> p = root;
            if(p ==null)
            {
                return null;
            }
            if(!p.Data.Equals(value)) //很疑惑为什么要有“！”，我觉得不要“！”
            {
                return p;
            }
            if(p .LChild !=null)
            {
                return Search(p.LChild, value);
            }
            if(p .RChild !=null)
            {
                return Search(p.RChild, value);
            }
            return null;
        }

        /// <summary>
        /// 先序遍历
        /// </summary>
        /// <param name="p"></param>
        public void PreOrder(Node <T> p)
        {
            if(IsEmpty())
            {
                Console.WriteLine("Tree is empty");
                return;
            }
            if(p!=null)
            {
                Console.WriteLine(p.Data);
                PreOrder(p.LChild);
                PreOrder(p.RChild);
            }
        }

        /// <summary>
        /// 中序遍历
        /// </summary>
        /// <param name="p"></param>
        public void InOrder(Node <T> p)
        {
            if (IsEmpty())
            {
                Console.WriteLine("Tree is empty");
                return;
            }
            if (p != null)
            {
                PreOrder(p.LChild);
                Console.WriteLine(p.Data); 
                PreOrder(p.RChild);
            }
        }

        /// <summary>
        /// 后序遍历
        /// </summary>
        /// <param name="p"></param>
        public void PostOrder(Node<T> p)
        {
            if (IsEmpty())
            {
                Console.WriteLine("Tree is empty");
                return;
            }
            if (p != null)
            {
                PreOrder(p.LChild);
                PreOrder(p.RChild);
                Console.WriteLine(p.Data);
            }
        }

        /// <summary>
        /// 层次遍历
        /// </summary>
        /// <param name="root"></param>
        public void LevelOrder(Node <T > root)
        {
            if(root==null)
            {
                return;
            }
            CSeqQuene<Node<T>> sq = new CSeqQuene<Node<T>>(50);//使用队列的方式存储数据,先进先出
            sq.EnQuene(root);
            while (!sq .IsEmpty())//队列非空，结点没有处理完
            {
                Node<T> temp = sq.DeQuene();
                Console.WriteLine("{0}", temp);
                if(temp .LChild !=null)
                {
                    sq.EnQuene(temp.LChild);
                }
                if(temp .RChild !=null)
                {
                    sq.EnQuene(temp.RChild);
                }
            }
        }
    }
    
}

3．三叉链表存储结构

  为了方便访问某结点的双亲，还可以给链表结点增加一个双亲字段parent,用来指向其双亲结点。每个结点由四个域组成，其结点结构为：

 这种存储结构既便于查找孩子结点，又便于查找双亲结点；但是，相对于二叉链表存储结构而言，它增加了空间开销。利用这样的结点结构表示的二叉树的链式存储结构被称为三叉链表。

  尽管在二叉链表中无法由结点直接找到其双亲，但由于二叉链表结构灵活，操作方便，对于一般情况的二叉树，甚至比顺序存储结构还节省空间。因此，二叉链表是最常用的二叉树存储方式。

二叉树的遍历方法及递归实现

二叉树的遍历是指按照某种顺序访问二叉树中的每个结点，使每个结点被访问一次且仅被访问一次。

通过一次完整的遍历，可使二叉树中的结点信息由非线性排列变为某种意义上的线性序列，也就是说，遍历操作使非线性结构线性化。

对于二叉树的遍历方式，如果限定先左后右，则有三种遍历方式：先序遍历，中序遍历，后序遍历

三种遍历都有一个规律，就是：逆时针沿着二叉树外缘移动，即方向相同。并且，三种遍历都有一个“若二叉树为空，遍历结束”的判断

注意：如果中序遍历和后序遍历序列相同，则该树只有左子树没有右子树。如果中序遍历和先序遍历序列相同，则该树只有右子树没有左子树。

 

1.先序遍历（DLR）：先从二叉树的根开始，然后到左子树，再到右子树

上图中：先序遍历序列是ABDCEF，重点是记住第一个字母“A”是根，出发点是根“A”

        /// <summary>
        /// 先序遍历
        /// </summary>
        /// <param name="p"></param>
        public void PreOrder(Node <T> p)
        {
            if(IsEmpty())
            {
                Console.WriteLine("Tree is empty");
                return;
            }
            if(p!=null)
            {
                Console.WriteLine(p.Data);
                PreOrder(p.LChild);
                PreOrder(p.RChild);
            }
        }

2.中序遍历（LDR）：先从左子树开始，然后到根，再到右子树

上图中：中序遍历序列是DBAECF，重点是记住中序遍历的根位置，是在序列的第一个字母和最后一个字母之间，出发点是左子树的最下边的左边的开始

        /// <summary>
        /// 中序遍历
        /// </summary>
        /// <param name="p"></param>
        public void InOrder(Node <T> p)
        {
            if (IsEmpty())
            {
                Console.WriteLine("Tree is empty");
                return;
            }
            if (p != null)
            {
                PreOrder(p.LChild);
                Console.WriteLine(p.Data); 
                PreOrder(p.RChild);
            }
        }

3.后序遍历（LRD）：先从左子树开始，然后到右子树，再到根

上图中：后序遍历序列式DBECFCA,重点是知道了根是最后面一个字母“A”， 出发点是左子树的最下边左边

        /// <summary>
        /// 后序遍历
        /// </summary>
        /// <param name="p"></param>
        public void PostOrder(Node<T> p)
        {
            if (IsEmpty())
            {
                Console.WriteLine("Tree is empty");
                return;
            }
            if (p != null)
            {
                PreOrder(p.LChild);
                PreOrder(p.RChild);
                Console.WriteLine(p.Data);
            }
        }

4.层次遍历：从根结点开始，从上到下，从左到右依次访问

层次遍历的算法（用队列存储数据）：

（1）从队列中取出一个结点引用，并访问该结点；

（2）若结点的左子树非空，则将该结点的左子树引用入队；

（3）若结点的右子树非空，则将该结点的右子树引用入队。

/// <summary>
        /// 层次遍历
        /// </summary>
        /// <param name="root"></param>
        public void LevelOrder(Node <T > root)
        {
            if(root==null)
            {
                return;
            }
            CSeqQuene<Node<T>> sq = new CSeqQuene<Node<T>>(50);//使用队列的方式存储数据,先进先出
            sq.EnQuene(root);
            while (!sq .IsEmpty())//队列非空，结点没有处理完
            {
                Node<T> temp = sq.DeQuene();
                Console.WriteLine("{0}", temp);
                if(temp .LChild !=null)
                {
                    sq.EnQuene(temp.LChild);
                }
                if(temp .RChild !=null)
                {
                    sq.EnQuene(temp.RChild);
                }
            }
        }

 

最优二叉树-哈夫曼树（Haffman）：https://mp.csdn.net/postedit

 

疆~
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
树（二叉树）系列算法编程考题
qq_20110551的博客
08-01 3639
树（二叉树）系列算法编程考题 部分内容是从网上其他博客中整理而来，方便大家对相关内容有一个总结。 主要进行以下几个方面的总结 1）计算一棵树的深度（高度）非递归实现 2）计算一棵树的宽度（并输出每一层的宽度） 3）判断一棵树是否是平衡二叉树（至少两种方法） 4）输出一棵树的所有路径（从根节点到叶子结点） 5）判断两棵树是否相同 6）判断一棵树是否是另一棵树的子树 7）判断一棵树是否是对称二...
二叉树的编程
weixin_66044522的博客
01-15 361
一.树的遍历 二.统计叶子的数量 三.求树的高度 四.拷贝二叉树 五.释放二叉树 binaryTree.h ​ #pragma once #include<stdio.h> #include<string> #include<stdlib.h> struct BinaryNode { char ch;//数据域 struct BinaryNode* lChild;//左孩子节点 struct BinaryNode* rChild;//右孩子节点 }; //遍
数据结构二叉树的编程基本问题
YYYYYEEEETTTTTTTEEEE的专栏
08-14 628
1 在创建二叉树的时候 一定要明白你当前的位置：也就是说在CreateBiTree函数里面，你当前的位置是什么   用C语言实现时，由于C语言不支持引用操作，所以只能传递地址，因此当前涵数CreateBiTree(BiTree *T)的T是一个指针变量，其指向一个BiTree类型的单元，这个单元就是lchild或者rchild。所以在向这个函数传递参数的时候，传递的也是lchild或者rchild
二叉树的编程与实现（C语言）
热门推荐
timerring的博客
07-10 5万+
一 、目的： 掌握指针变量、动态变量的含义； 掌握二叉树的结构特征，以及各种存储结构的特点及适用范围； 掌握指针类型描述、访问和处理二叉树的运算三 、内容： 已知以二叉树表作为存储结构，写出按层次顺序遍历二叉树的算法。 算法思想：本算法采用一个队列q，先将二叉树根结点入队列，然后退队列，输出该结点，若它有左子树，便将左子树根结点入队列；若有右子树，便将右子树根结点入队列，直到队列空为止。因为队列的特点是先进先出，从而达到按层次顺序遍历二叉树的目的。 四 、要求： 实现二叉树表的层次遍历算法，并给出应用。
二叉树编程
qq_35927741的博客
03-06 220
题目描述 请根据二叉树的前序遍历，中序遍历恢复二叉树，并打印出二叉树的右视图 输入：[1,2,4,5,3],[4,2,5,1,3] 输出：[1,3,5] //解析： 先重构二叉树 然后利用层次遍历的方式打印出二叉树的右子树 class Solution { public: /** * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可 * 求二叉树的右视图 * @param xianxu int整型vector 先序遍历 * @para
解决二叉树的编程问题(共25张PPT).pptx
11-13
解决二叉树的编程问题 本资源摘要信息涵盖了二叉树的基本概念、逻辑结构、存储结构、基本操作和主要性质等方面的知识点。 一、基本概念 * 二叉树的定义：二叉树是一种树形结构，由一个根结点和两个不相交的子树...
二叉树遍历问题二叉树遍历问题
10-20
二叉树遍历是计算机科学中处理树结构数据时的一项基本操作，主要应用于数据的检索、存储和操作。在二叉树中，每个节点最多有两个子节点，分别称为左子节点...熟练掌握这四种遍历方法有助于理解和解决涉及树结构的问题。
二叉树遍历问题-二叉树遍历问题
11-12
这些遍历方法为处理复杂的数据结构和问题提供了基础，例如在编译器中解析语法树、构建搜索引擎索引、解决游戏中的路径寻找问题等。 了解和掌握二叉树遍历对于提升编程技能至关重要，无论是面试还是实际项目开发，都...
二叉树遍历问题 关于二叉树遍历问题的一些总结
07-05
二叉树遍历是计算机科学中处理树结构数据时常用的一种技术，对于理解和解决与树相关的算法问题至关重要。本文将深入探讨二叉树的三种遍历方法：先序遍历、中序遍历和后序遍历，并提供相关算法模板。 1. **先序遍历*...
c语言编程题之树操作二叉树的最大深度.zip
最新发布
04-02
在C语言编程中，二叉树是一种非常重要的...总的来说，理解和掌握二叉树的最大深度计算有助于提升C语言编程中的算法思维和问题解决能力。在面对类似问题时，能灵活运用不同的解题策略，有助于提高程序的效率和可读性。
每日编程(43）---二叉树
LYue123的博客
04-15 472
题目：二叉树的层次遍历 II 题目描述： 给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历） 例如： 给定二叉树 [3,9,20,null,null,15,7], 3 / 9 20 / 15 7 返回其自底向上的层次遍历为： [ [15,7], [9,20], [3] ] 分析： 二叉树层析遍历，借助队列，每次要将当前队列遍历...
二叉树漫游——编程技术与技巧总结（上）：递归技术
瀞心：软件人生
03-19 1992
二叉树漫游——编程技术与技巧总结（上）：递归技术               本系列分三篇文章，分别对二叉树编程中的常用技术和技巧进行了总结。第一篇是关于二叉树编程的递归技术的；第二篇讨论如何将递归程序转化为非递归程序；第三篇讨论二叉树编程的其它方法和技术。
C语言创建二叉树过程中遇到的一些问题
u014285517的专栏
12-31 5233
其实这些问题以前也遇到过，不过没总结，遇到又要搞段时间，现在总结下。 比如我们要创建颗如下二叉树，按前序输入，则为AB#D##C##： 开始代码写成下面这样： #define TElemType char typedef struct BiTNode { TElemType data; struct BiTNode *lchild,*rchild; }BiTNode,*BiTre
二叉树原理及编程详解(一)完全二叉树|堆排序|遍历|重建
祥瑞的技术博客
07-27 1506
目录 一、二叉树基础概念 1.1 基础概念： 1.2 二叉树的性质 二、二叉树的遍历 2.1 三种遍历方法 2.2 二叉树的构建 2.3 重建方法及解析 2.4 重建二叉树的代码实现 c++重建二叉树 python重建二叉树 三、二叉树编程汇总 3.1 树的子结构 c++树的子结构 3.2 镜像二叉树 c++镜像二叉树 3.3 按层打印二叉树 c++按层打印二叉树...
二叉树编程题总结
beashaper_的博客
06-16 1261
求二叉树的最远两个结点的距离 由前序遍历和中序遍历重建二叉树 判断一棵树是否是完全二叉树 求二叉树两个节点的最近公共祖先 将二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向 求二叉树的最远两个结点的距离 短短的代码中其实涉及到了三道题目： 利用已知序列递归的建一棵二叉树 递归的求一棵树的深度 求二叉树中距离最远的两个节点的距离 利用类似的思...
二叉树的用途-（未完）
LearnLHC的博客
03-01 1万+
二叉树 二叉树是一种重要的数据结构，与数组、向量、链表都是一种顺序容器，它们提供了按位置访问数据的手段。但是有一个缺点，它们都是按照位置来确定数据，想要通过值来获取数据，只能通过遍历的方式。而二叉树在很大程度上解决了这个缺点，二叉树是按值来保存元素，也按值来访问元素。 二叉树由一个个节点组成，一个节点最多只能有两个子节点，从根节点开始左右扩散，分左子节点和右子节点，向下一直分支。 许多实际问...
二叉树常见问题
愿世界和平的IT劝退师
04-08 393
二叉树节点定义如下： struct BinaryTreeNode {     int Value;     BinaryTreeNode*  Left;     BinaryTreeNode*  Right; }; 相关链接： 轻松搞定面试中的链表题目 题目列表： 1. 求二叉树中的节点个数 2. 求二叉树的深度 3. 前序遍历，中序遍历，后序遍历 4.分层遍
二叉树的常见问题
子夜写字的地方
04-23 1692
据结构中的重要性就不言而喻了，这儿简单记录一下自己碰到的一些关于二叉树的常见操作。当然要明确解决这些问题的“根节点思路”了————递归递归recursion。 二叉树的最大深度与最小深度 最大深度是指二叉树根节点到该树叶子节点的最大路径长度。而最小深度自然就是其到叶子节点的最小路径长度了。 **主要思路：**采用二叉树递归的思想，自底向上，当到达叶子节点时，自然达到了“递归边界”，而叶子节点的子...
5.4 二叉树的存储结构
qq_45785650的博客
07-27 278
一、二叉树的顺序存储 #define MaxSize 100 struct TreeNode{ ElemType value; //结点中的数据元素 bool isEmpty; //结点是否为空 }; //定义一个长度为MaxSize的数组t，按照从上至下，从左至右的顺序依次存储完全二叉树中的各个结点 TreeNode t[MaxSize]; //初始化时，所有的结点都标记为空 for(int i=0;i<MaxSize;i++){ t[i].isEmpty=true; }

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值