数据结构之二叉树

最新推荐文章于 2022-10-07 22:41:24 发布
最新推荐文章于 2022-10-07 22:41:24 发布
阅读量290 收藏 1
点赞数 2
分类专栏： C/C++ 数据结构与算法 文章标签： 二叉树 数据结构

非常经典的二叉树总结，分享如下。转自：51CTO博客作者天山老妖S，http://blog.51cto.com/9291927/2083190。

数据结构（十四）——二叉树

一、二叉树简介

1、二叉树简介

二叉树是由n（n>=0）个结点组成的有序集合，集合或者为空，或者是由一个根节点加上两棵分别称为左子树和右子树的、互不相交的二叉树组成。
二叉树的五种形态：
数据结构（十四）——二叉树

2、二叉树的存储结构模型

树的另一种表示法：孩子兄弟表示法
A、每个结点都有一个指向其第一个孩子的指针
B、每个结点都有一个指向其第一个右兄弟的指针
数据结构（十四）——二叉树
孩子兄弟表示法的特性：
A、能够表示任意的树形结构
B、每个结点包含一个数据成员和两个指针成员
C、孩子结点指针和兄弟结点指针构成树杈

3、满二叉树

如果二叉树中所有分支结点的度数都为2，并且叶子结点都在统一层次上，则二叉树为满二叉树。
数据结构（十四）——二叉树

4、完全二叉树

如果一棵具有n个结点的高度为k的二叉树，树的每个结点都与高度为k的满二叉树中编号为1——n的结点一一对应，则二叉树为完全二叉树。
完全二叉树的特性：
A、同样结点数的二叉树，完全二叉树的高度最小
B、完全二叉树的叶子结点仅出现在最下边两层，并且最底层的叶子结点一定出现在左边，倒数第二层的叶子结点一定出现在右边。
C、完全二叉树中度为1的结点只有左孩子。
数据结构（十四）——二叉树

5、二叉树的特性

A、在二叉树的第i层上最多有2^(i-1)个结点（i>=1）。
B、高度为k的二叉树，最多有2^k-1个结点（k>=0）。
C、对任何一棵二叉树，如果其叶结点有n个，度为2的非叶子结点有m个，则
n = m + 1。
D、具有n个结点的完全二叉树的高度为logn + 1
E、对于有n个结点的完全二叉树，按层次对结点进行编号（从上到下，从左到右），对于任意编号为i的结点：
数据结构（十四）——二叉树

二、二叉树的操作

1、二叉树的存储结构实现

数据结构（十四）——二叉树
二叉树结点包含四个固定的成员：结点的数据域、指向父结点的指针域、指向左子结点的指针域、指向右子结点的指针域。结点的数据域、指向父结点的指针域从TreeNode模板类继承而来。
二叉树结点的实现：

    template <typename T>
  class BTreeNode:public TreeNode<T>
  {
  public:
    BTreeNode<T>* m_left;//左子结点
    BTreeNode<T>* m_right;//右子结点
    BTreeNode()
    {
        m_left = NULL;
        m_right = NULL;
    }

    //工厂方法，创建堆空间的结点
    static BTreeNode<T>* NewNode()
    {
      BTreeNode<T>* ret = new BTreeNode<T>();
      if(ret != NULL)
      {
          //堆空间的结点标识为true
          ret->m_flag = true;
      }
      return ret;
    }
  };

2、二叉树的结点查找

A、基于数据元素的查找
定义基于数据元素查找的函数
数据结构（十四）——二叉树

virtual BTreeNode<T>* find(BTreeNode<T>* node, const T& value)const
      {
          BTreeNode<T>* ret = NULL;
          //如果根节点node
          if(node != NULL)
          {
              if(node->value == value)
              {
                  ret = node;
              }
              else
              {
                  //查找左子树
                  if(ret == NULL)
                  {
                      ret = find(node->m_left, value);
                  }
                  //如果左子树没有找到，ret返回NULL，查找右子树
                  if(ret == NULL)
                  {
                      ret = find(node->m_right, value);
                  }
              }
          }
          return ret;
      }

    BTreeNode<T>* find(const T& value)const
    {
        return find(root(), value);
    }

B、基于结点的查找
定义基于结点查找的函数
数据结构（十四）——二叉树

virtual BTreeNode<T>* find(BTreeNode<T>* node, BTreeNode<T>* obj)const
      {
          BTreeNode<T>* ret = NULL;
          if(node != NULL)
          {
              //根节点node为目标结点
              if(node == obj)
              {
                  ret = node;
              }
              else
              {
                  //查找左子树
                  if(ret == NULL)
                  {
                      ret = find(node->m_left, obj);
                  }
                  //如果左子树没有找到，ret返回NULL，继续查找右子树
                  if(ret == NULL)
                  {
                      ret = find(node->m_right, obj);
                  }
              }
          }
          return ret;
      }
    BTreeNode<T>* find(TreeNode<T>* node)const
    {
        return find(root(), dynamic_cast<BTreeNode<T>*>(node));
    }

3、二叉树的结点插入

根据插入的位置定义二叉树结点的位置枚举类型：

  enum BTNodePos
    {
        Any,
        Left,
        Right
    };

在node结点的pos位置插入newnode结点的功能函数如下：
数据结构（十四）——二叉树

virtual bool insert(BTreeNode<T>* newnode, BTreeNode<T>* node, BTNodePos pos)
      {
          bool ret = true;
          //插入的位置为Any
          if(pos == Any)
          {
              //如果没有左子结点，插入结点作为左子结点
              if(node->m_left == NULL)
              {
                  node->m_left = newnode;
              }
              //如果有左子结点，没有右子结点，插入结点作为右子结点
              else if(node->m_right == NULL)
              {
                  node->m_right = newnode;
              }
              //如果node结点的左右子结点不为空，插入失败
              else
              {
                  ret = false;
              }
          }
          else if(pos == Left)
          {
              //如果指定插入左子结点，如果没有左子结点，插入结点
              if(node->m_left == NULL)
              {
                  node->m_left = newnode;
              }
              else
              {
                  ret = false;
              }
          }
          else if(pos == Right)
          {
              //如果指定插入右子结点，如果没有右子结点，插入结点
              if(node->m_right == NULL)
              {
                  node->m_right = newnode;
              }
              else
              {
                  ret = false;
              }
          }
          else
          {
              ret = false;
          }
          return ret;
      }

A、插入新结点
数据结构（十四）——二叉树

 //插入结点，无位置要求
    bool insert(TreeNode<T>* node)
    {
       return insert(dynamic_cast<BTreeNode<T>*>(node), Any);
    }
    //插入结点，指定插入位置
    virtual bool insert(BTreeNode<T>* node, BTNodePos pos)
    {
        bool ret = true;
        if(node != NULL)
        {
            if(this->m_root == NULL)
            {
                node->parent = NULL;
                this->m_root = node;
            }
            else
            {
               BTreeNode<T>* np = find(node->parent);
               if(np != NULL)
               {
                   ret = insert(dynamic_cast<BTreeNode<T>*>(node), np, pos);
               }
               else
               {
                   THROW_EXCEPTION(InvalidParameterException, "Parameter invalid...");
               }
            }
        }
        else
        {
            THROW_EXCEPTION(InvalidParameterException, "Parameter invalid...");
        }
        return ret;
    }

B、插入数据元素
数据结构（十四）——二叉树

 //插入数据，指定插入位置和父结点
    virtual bool insert(const T& value, TreeNode<T>* parent, BTNodePos pos)
    {
        bool ret = true;
        BTreeNode<T>* node = BTreeNode<T>::NewNode();
        if(node != NULL)
        {
            node->parent = parent;
            node->value = value;
            ret = insert(node, pos);
            if(!ret)
            {
                delete node;
            }
        }
        else
        {
            THROW_EXCEPTION(NoEnoughMemoryException, "No enough memory...");
        }

        return ret;
    }
    //插入数据，指定父结点
    bool insert(const T& value, TreeNode<T>* parent)
    {
        return insert(value, parent, Any);
    }

4、二叉树的结点删除

删除功能函数的定义：
数据结构（十四）——二叉树

virtual void remove(BTreeNode<T>* node, BTree<T>* ret)
      {
          ret = new BTree<T>();
          if(ret == NULL)
          {
              THROW_EXCEPTION(NoEnoughMemoryException, "No enough memory...");
          }
          else
          {
              if(node == root())
              {
                  this->m_root = NULL;
              }
              else
              {
                  BTreeNode<T>* parent = dynamic_cast<BTreeNode<T>*>(node->parent);
                  if(parent->m_left == node)
                  {
                      parent->m_left = NULL;
                  }
                  else if(parent->m_right == node)
                  {
                      parent->m_right = NULL;
                  }
                  node->parent = NULL;
              }
              ret->m_root = node;
          }
      }

A、基于数据元素值删除

 //根据数据元素删除结点
    SharedPointer< Tree<T> > remove(const T& value)
    {
        BTree<T>* ret = NULL;
        BTreeNode<T>* node = find(value);
        if(node == NULL)
        {
            THROW_EXCEPTION(InvalidParameterException, "No value...");
        }
        else
        {
            remove(node, ret);
        }
        return ret;
    }

B、基于结点删除

 //根据结点删除结点
    SharedPointer< Tree<T> > remove(TreeNode<T>* node)
    {
        BTree<T>* ret = NULL;
        node = find(node);
        if(node != NULL)
        {
            remove(dynamic_cast<BTreeNode<T>*>(node), ret);
        }
        else
        {
            THROW_EXCEPTION(InvalidParameterException, "No node...");
        }
        return ret;
    }

5、二叉树的清空

将二叉树中所有在堆空间分配的结点销毁。
清除node结点为根节点的二叉树的功能函数：
数据结构（十四）——二叉树

virtual void free(BTreeNode<T>* node)
      {
          if(node != NULL)
          {
              free(node->m_left);
              free(node->m_right);
          }
          //如果结点在堆空间分配
          if(node->flag())
          {
              delete node;
          }
      }
    //清空树
    void clear()
    {
        free(root());
        this->m_root = NULL;
    }

6、二叉树的属性操作

A、树中结点的数量
定义计算某个结点为根结点的树的结点的数量
数据结构（十四）——二叉树

 int count(BTreeNode<T>* node) const
      {
          int ret = 0;
          if(node != NULL)
          {
              ret = count(node->m_left) + count(node->m_right) + 1;
          }
          return ret;
      }
    //树的结点数目访问函数
    int count()const
    {
        return count(root());
    }

B、树的高度
获取node结点为根结点的二叉树的高度的功能函数：
数据结构（十四）——二叉树

 int height(BTreeNode<T>* node) const
      {
          int ret = 0;
          if(node != NULL)
          {
              int l = height(node->m_left);
              int r = height(node->m_right);
              ret = ((l > r)?l:r) + 1;
          }
          return ret;
      }
    //树的高度访问函数
    int height()const
    {
        return height(root());
    }

C、树的度
获取node为根结点的二叉树的度的功能函数：
数据结构（十四）——二叉树

 int degree(BTreeNode<T>* node) const
      {
          int ret = 0;
          if(node != NULL)
          {
              //根结点的度数
              ret = (!!node->m_left + !!node->m_right);
              //左子树的度
              if(ret < 2)
              {
                  int l = degree(node->m_left);
                  if(ret < l)
                  {
                      ret = l;
                  }
              }
              //右子树的度数
              if(ret < 2)
              {
                  int r = degree(node->m_left);
                  if(ret < r)
                  {
                      ret = r;
                  }
              }
          }
          return ret;
      }
    //树的度访问函数
    int degree()const
    {
        return degree(root());
    }

7、二叉树的层次遍历

二叉树的遍历是指从根结点出发，按照某种次序依次访问二叉树中的所有结点，使得每个结点被访问依次，且仅被访问一次。
根据游标思想，提供一组遍历的先关函数，按层次访问二叉树中的数据元素。
数据结构（十四）——二叉树
引入一个队列，辅助遍历二叉树。
LinkedQueue<BTreeNode<T>*> m_queue;
层次遍历的过程如下：
数据结构（十四）——二叉树

 //将根结点压入队列
    bool begin()
    {
      bool ret = (root() != NULL);
      if(ret)
      {
          //清空队列
          m_queue.clear();
          //根节点加入队列
          m_queue.add(root());
      }
      return ret;
    }
    //判断队列是否为空
    bool end()
    {
        return (m_queue.length() == 0);
    }

    //队头元素弹出，将队头元素的孩子压入队列中
    bool next()
    {
      bool ret = (m_queue.length() > 0);
      if(ret)
      {
          BTreeNode<T>* node = m_queue.front();
          m_queue.remove();//队头元素出队
          //将队头元素的子结点入队
          if(node->m_left != NULL)
          {
              m_queue.add(node->m_left);
          }
          if(node->m_right != NULL)
          {
              m_queue.add(node->m_right);
          }
      }
      return ret;
    }
    //访问队头元素指向的数据元素
    T current()
    {
      if(!end())
      {
          return m_queue.front()->value;
      }
      else
      {
          THROW_EXCEPTION(InvalidOperationException, "No value at current Node...");
      }
    }

8、二叉树的克隆

定义克隆node结点为根结点的二叉树的功能函数：
数据结构（十四）——二叉树

BTreeNode<T>* clone(BTreeNode<T>* node)
      {
          BTreeNode<T> * ret = NULL;
          if(node != NULL)
          {
              ret = BTreeNode<T>::NewNode();
              if(ret != NULL)
              {
                  ret->value = node->value;
                  //左子树
                  ret->m_left = clone(node->m_left);
                  //右子树
                  ret->m_right = clone(node->m_right);
                  //如果左子树不为空，设置左子树的父结点
                  if(ret->m_left != NULL)
                  {
                      ret->m_left->parent = ret;
                  }
                  //如果右子树不为空，设置右子树父结点
                  if(ret->m_right != NULL)
                  {
                      ret->m_right->parent = ret;
                  }
              }
              else
              {
                  THROW_EXCEPTION(NoEnoughMemoryException, "No enough memory...");
              }
          }
          return ret;
      }
    SharedPointer<BTreeNode<T>> clone()const
    {
        BTree<T>* ret = new BTree<T>();
        if(ret != NULL)
        {
            ret->m_root = clone(root());
        }
        else
        {
            THROW_EXCEPTION(NoEnoughMemoryException, "No enough memory...");
        }
        return ret;
    }

9、二叉树的比较

判断两棵二叉树中的数据元素是否对应相等
定义二叉树相等比较的功能函数：
数据结构（十四）——二叉树

bool equal(BTreeNode<T>* l, BTreeNode<T>* r)const
      {
          bool ret = true;
          //二叉树自比较
          if(l == r)
          {
              ret = true;
          }
          //两棵二叉树都不为空
          else if(l != NULL &&  r != NULL)
          {
             ret = (l->value == r->value) && (equal(l->m_left, r->m_left)) && (l->m_right, r->m_right);
          }
          //有一棵二叉树为空，一棵二叉树不为空
          else
          {
              ret = false;
          }
          return ret;
      }

    bool operator ==(const BTree<T>& tree)const
    {
        return equal(root(), tree.root());
    }

    bool operator !=(const BTree<T>& tree)const
    {
        return !(*this == tree);//使用==比较
    }

10、二叉树的相加

将当前二叉树与参数btree二叉树中对应的数据元素相加，返回一棵在堆空间创建的新的二叉树。
二叉树相加实例如下：
数据结构（十四）——二叉树
定义将两棵二叉树相加的功能函数：
数据结构（十四）——二叉树

 BTreeNode<T>* add(BTreeNode<T>* l, BTreeNode<T>* r)const
      {
          BTreeNode<T>* ret = NULL;
          //二叉树l为空
          if(l == NULL && r != NULL)
          {
            ret = clone(r);
          }
          //二叉树r为空
          else if(l != NULL && r == NULL)
          {
            ret = clone(l);
          }
          //二叉树l和二叉树r不为空
          else if(l != NULL && r != NULL)
          {
              ret = BTreeNode<T>::NewNode();
              if(ret != NULL)
              {
                  //根节点数据元素相加
                  ret->value = l->value + r->value;
                  //左子树相加
                  ret->m_left = add(l->m_left, r->m_left);
                  //右子树相加
                  ret->m_right = add(l->m_right, r->m_right);
                  //左子树不为空，设置左子树的父结点为当前结点
                  if(ret->m_left != NULL)
                  {
                      ret->m_left->parent = ret;
                  }
                  //右子树不为空，设置右子树的父结点为当前结点
                  if(ret->m_right != NULL)
                  {
                      ret->m_right->parent = ret;
                  }
              }
              else
              {
                  THROW_EXCEPTION(NoEnoughMemoryException, "No enough memory...");
              }
          }
          return ret;
      }
        SharedPointer<BTree<T>> add(const BTree<T>& other)const
    {
        BTree<T>* ret = new BTree<T>();
        if(ret != NULL)
        {
            ret->m_root = add(root(), other.root());
        }
        else
        {
            THROW_EXCEPTION(NoEnoughMemoryException, "No enough memoty...");
        }
        return ret;
    }

三、二叉树的典型遍历方式

二叉树有先序、中序、后序三种遍历方式，三种遍历方法的不同主要是取决于根节点的遍历顺序。

1、前序遍历

如果二叉树为空，则无操作，直接返回。
如果二叉树非空，则执行以下操作：
A、访问根结点；
B、先序遍历左子树；
C、先序遍历右子树。
先序遍历实现代码：
数据结构（十四）——二叉树

void preOrderTraversal(BTreeNode<T>* node, LinkedQueue<BTreeNode<T>*>& queue)
{
      if(node != NULL)
      {
          queue.add(node);
          preOrderTraversal(node->m_left, queue);
          preOrderTraversal(node->m_right, queue);
      }
 }

先序遍历二叉树示例：
数据结构（十四）——二叉树

2、中序遍历

如果二叉树为空，则无操作，直接返回。
如果二叉树非空，则执行以下操作：
A、中序遍历左子树；
B、访问根结点；
C、中序遍历右子树。
中序遍历实现代码：
数据结构（十四）——二叉树

void inOrderTraversal(BTreeNode<T>* node, LinkedQueue<BTreeNode<T>*>& queue)
{
  if(node != NULL)
  {
      inOrderTraversal(node->m_left, queue);
      queue.add(node);
      inOrderTraversal(node->m_right, queue);
  }
}

中序遍历二叉树示例：
数据结构（十四）——二叉树

3、后序遍历

如果二叉树为空，则无操作，直接返回。
如果二叉树非空，则执行以下操作：
A、后序遍历左子树；
B、后序遍历右子树；
C、访问根结点。
后序遍历实现代码：
数据结构（十四）——二叉树

void postOrderTraversal(BTreeNode<T>* node, LinkedQueue<BTreeNode<T>*>& queue)
{
  if(node != NULL)
  {
      postOrderTraversal(node->m_left, queue);
      postOrderTraversal(node->m_right, queue);
      queue.add(node);
  }
}

后序遍历二叉树示例：
数据结构（十四）——二叉树

4、遍历算法的封装

定义遍历方式的枚举类型：

  enum BTTraversal
    {
        PreOder,
        InOder,
        PostOder
    };

根据参数order选择遍历的方式，返回数组保存了二叉树遍历结点

 SharedPointer<Array<T>> traversal(BTTraversal order)
    {
        DynamicArray<T>* ret = NULL;
        LinkedQueue<BTreeNode<T>*> queue;//保存遍历二叉树的结点
        switch (order)
        {
            case PreOder:
                preOrderTraversal(root(), queue);
                break;
            case InOder:
                inOrderTraversal(root(), queue);
                break;
            case PostOder:
                postOrderTraversal(root(), queue);
                break;
            default:
                THROW_EXCEPTION(InvalidParameterException, "Parameter invalid...");
                break;
        }
        ret = new DynamicArray<T>(queue.length());
        if(ret != NULL)
        {
            for(int i = 0; i < ret->length(); i++, queue.remove())
            {
                ret->set(i, queue.front()->value);
            }
        }
        else
        {
            THROW_EXCEPTION(NoEnoughMemoryException, "No enough memory...");
        }

        return ret;
    }

四、线索化二叉树

1、线索化二叉树简介

线索化二叉树是将二叉树转换为双向链表的过程（将非线性的二叉树转换为线性的链表）。
二叉树的线索化能够反映某种二叉树的遍历次序（结点的先后访问次序）。
线索化二叉树的过程：
数据结构（十四）——二叉树
二叉树线索化的实现：
数据结构（十四）——二叉树
通过某种遍历方式遍历二叉树，根据遍历次序将二叉树结点依次存储到辅助队列中，最后将辅助队列中保存的结点依次出队并连接（连接时，原二叉树结点的m_left指针作为双向链表结点的m_prev指针，指向结点的前驱；原二叉树结点的m_right结点作为双向链表结点的m_next指针，指向结点的后继），成为双向链表。

    void traversal(BTTraversal order, LinkedQueue<BTreeNode<T>*>& queue)
    {
        switch (order)
        {
        case PreOrder:
            preOrderTraversal(root(), queue);
            break;
        case InOrder:
            inOrderTraversal(root(), queue);
            break;
        case PostOrder:
            postOrderTraversal(root(), queue);
            break;
        case LevelOrder:
            levelOrderTraversal(root(), queue);
            break;
        default:
            THROW_EXCEPTION(InvalidParameterException, "Parameter invalid...");
            break;
        }
    }

2、层次遍历算法

增加层次遍历方式LevelOrder到遍历方式枚举类型中。

enum BTTraversal
{
    PreOrder,//先序遍历
    InOrder,//中序遍历
    PostOrder,//后序遍历
    LevelOrder//层次遍历
};

层次遍历算法：
A、将根结点入队
B、访问队头元素指向的二叉树结点
C、将队头元素出队，队头元素的孩子入队
D、判断队列是否为空，如果非空，继续B；如果为空，结束。
数据结构（十四）——二叉树
层次遍历二叉树的实例如下：
数据结构（十四）——二叉树

//层次遍历
    void levelOrderTraversal(BTreeNode<T>* node, LinkedQueue<BTreeNode<T>*>& queue)
    {
        if(node != NULL)
        {
            //辅助队列
            LinkedQueue<BTreeNode<T>*> temp;
            //根结点压入队列
            temp.add(node);
            while(temp.length() > 0)
            {
                BTreeNode<T>* n = temp.front();
                //如果左孩子不为空，将左孩子结点入队
                if(n->m_left != NULL)
                {
                    temp.add(n->m_left);
                }
                //如果右孩子不为空，将右孩子结点入队
                if(n->m_right != NULL)
                {
                    temp.add(n->m_right);
                }
                //将队列的队头元素出队
                temp.remove();
                //将队列的队头元素入队输出队列
                queue.add(n);
            }
        }
    }

3、队列中结点的连接

将队列中的所有结点连接成为一个线性的双向链表
数据结构（十四）——二叉树

void connect(LinkedQueue<BTreeNode<T>*>& queue)
    {
        BTreeNode<T>* ret = NULL;
        if(queue.length() > 0)
        {
            //返回队列的队头元素指向的结点作为双向链表的首结点
            ret = queue.front();
            //双向链表的首结点的前驱设置为空
            ret->m_left = NULL;
            //创建一个游标结点，指向队列队头
            BTreeNode<T>* slider = queue.front();
            //将队头元素出队
            queue.remove();
            while(queue.length() > 0)
            {
                //当前游标结点的后继指向队头元素
                slider->m_right = queue.front();
                //当前队头元素的前驱指向当前游标结点
                queue.front()->m_left = slider;
                //将当前游标结点移动到队头元素
                slider = queue.front();
                //将当前队头元素出队，继续处理新的队头元素
                queue.remove();
            }
            //双向链表的尾结点的后继为空
            slider->m_right = NULL;
        }
    }

4、线索化二叉树的实现

线索化二叉树函数接口的设计：
BTreeNode<T>* thread(BTTraversal order)
A、根据参数order选择线索化的方式（先序、中序、后序、层次）
B、返回值是线索化二叉树后指向链表首结点的指针
C、线索化二叉树后，原有的二叉树被破坏，二叉树的所有结点根据遍历次序组建为一个线性的双向链表，对应的二叉树应为空。
线索化二叉树的流程：
数据结构（十四）——二叉树

 BTreeNode<T>* thread(BTTraversal order)
    {
        BTreeNode<T>* ret = NULL;
        LinkedQueue<BTreeNode<T>*>* queue;
        //遍历二叉树，并按遍历次序将结点保存到队列
        traversal(order, queue);
        //连接队列中的结点成为双向链表
        ret = connect(queue);
        //将二叉树的根节点置空
        this->m_root = NULL;
        //将游标遍历的辅助队列清空
        m_queue.clear();
        //返回双向链表的首结点
        return ret;
    }
JIN_嫣熙
关注
专栏目录
将满二叉树转化为求和二叉树_二叉树_
09-30
输入共3行：第一行为满二叉树中结点个数n（n<1024）；第二行为n个整数，表示二叉树的先序遍历序列；第三行也有n个整数，表示二叉树的中序遍历序列。整数间以空格分割。
数据结构（十四）——二叉树
weixin_34205826的博客
03-05 347
数据结构（十四）——二叉树 一、二叉树简介 1、二叉树简介 二叉树是由n（n>=0）个结点组成的有序集合，集合或者为空，或者是由一个根节点加上两棵分别称为左子树和右子树的、互不相交的二叉树组成。二叉树的五种形态： 2、二叉树的存储结构模型 树的另一种表示法：孩子兄弟表示法A、每个结点都有一个指向其第一个孩子的指针B、每个结点都有一个指向其第一个右兄弟的指针孩子兄弟表示法的特性：A、能够表示任...
数据结构与算法学习笔记（八）二叉树
xueguchen的博客
09-09 1086
二叉树
树——二叉树的克隆、比较和相加
05-26 259
1，二叉树的克隆操作： 1，SharedPointer< BTree<T> > clone() const： 1，克隆当前树的一份拷贝； 2，返回值为堆空间中的一棵新二叉树（与当前树相等）： 1，保存数据元素，树的属性一模一样； ...
[算法相关] Path Sum-二叉树相加之和
Binbin_Sun的博客
04-28 1162
链接：https://leetcode.com/problems/path-sum/ Given a binary tree and a sum, determine if the tree has a root-to-leaf path such that adding up all the values along the path equals the given sum. Fo
JavaScript数据结构之二叉树的查找算法示例
01-21
本文实例讲述了JavaScript数据结构之二叉树的查找算法。分享给大家供大家参考，具体如下： 前面文章介绍了二叉树的遍历，现在谈谈在二叉树中进行查找。对二叉查找树来说，一般有以下三类查找：最大值，最小值和给定...
C语言数据结构之二叉树的非递归后序遍历算法
01-01
C语言数据结构之二叉树的非递归后序遍历算法 前言： 前序、中序、后序的非递归遍历中，要数后序最为麻烦，如果只在栈中保留指向结点的指针，那是不够的，必须有一些额外的信息存放在栈中。 方法有很多，这里只举一...
数据结构之二叉树.rar
12-05
本资料“数据结构之二叉树.rar”深入探讨了如何使用数组来实现二叉树的各种操作，包括插入、删除以及遍历，采用C++语言进行编程，并体现了面向对象的设计思想。 首先，我们要理解二叉树的基本概念。二叉树是由节点...
Leetcode048--二叉树的遍历组合相加
蜕变的快乐
05-29 1365
二叉树的遍历组合相加，也就是对二叉树进行一些处理
二叉树的克隆、比较与相加
洋葱汪的博客
05-31 862
目录 1、二叉树的克隆操作 2、二叉树比较操作的定义 3、二叉树的相加操作 1、二叉树的克隆操作 二叉树的克隆操作 －SharedPointer< BTree<T> > clone() const ●克隆当前树的一份拷贝 ●返回值为堆空间中的一棵新二叉树（与当前树相等...
第六十八课 二叉树的比较与相加
diaozhiwa5526的博客
09-24 153
克隆操作也是递归实现的。 添加克隆函数： 1 #ifndef BTREE_H 2 #define BTREE_H 3 4 #include "Tree.h" 5 #include "BTreeNode.h" 6 #include "Exception.h" 7 #include "LinkQueue.h" ...
二叉查找树
aijianxie8808的博客
07-03 210
在文章《常用数据结构及复杂度》中，介绍了一些计算机程序设计中常用的线性数据结构，包括 Array、ArrayList、LinkedList<T>、List<T>、Stack<T>、Queue<T>、Hashtable 和 Dictionary<T> 等。并简单介绍了这些数据结构的内部实现原理和常用操作的运算复杂度，以及如何选择合...
算法-二叉树：合并两颗二叉树
weixin_60952096的博客
02-09 1503
算法-二叉树：合并两颗二叉树 思路解析： 使用t1和t2节点同时遍历两棵树，将两颗树的每个根节点相加； 如果t1为空，那么合并之后就是t2； 如果t2为空，那么合并之后就是t1。 方法一：采用递归，下面程序使用前序遍历（前中后都可）。 TreeNode* plusTree(TreeNode* t1,TreeNode* t2){ if(t1 == NULL) return t2; if(t2 == NULL) return t1; //重新定义了一棵树，也可以不定义而是直接加到t1
二叉树的探讨与理解
小桥Dopey的博客
03-03 209
 二叉树的题目普遍可以用递归和迭代的方式来解前序遍历：根 -&gt; 左 -&gt; 右中序遍历：左 -&gt; 根 -&gt; 右后序遍历：左 -&gt; 右 -&gt; 根/** * */ package BinaryTree; /** * @author heqy * @date 2018年2月7日 上午10:11:24 * @description 二叉树创建和遍历 */ ...
数据结构（一）-----二叉树
Windsearcher的博客
11-09 631
  一、二叉树简介 1、二叉树简介 二叉树是由n（n&gt;=0）个结点组成的有序集合，集合或者为空，或者是由一个根节点加上两棵分别称为左子树和右子树的、互不相交的二叉树组成。     性质一：对于任何一棵二叉树T，若叶子节点数为n0，度数为2的节点数为n2，则n0=n2+1    假设二叉树节点总数为n,度数为1的节点个数为n1，则n=n0+n1+n2成立，除根节点外，其它节点...
python QTreeWidgetItem下面有几个子tree_【用Python金融建模】从二叉树谈起:衍生品Option期权定价模型的构建...
weixin_39947314的博客
11-09 320
内容首发乐学偶得（http://lexueoude.com) 公众号： 乐学Fintech用代码理解分析解决金融问题在金融里面很多地方都出现过一个理念就是“货币的时间价值”，例如我们之前聊过的利用Python对项目进行估值判断 就是利用这一重要的思想：我们做出的决定，都是把未来的一系列现金流的【流入】和【流出】进行折现，通过我们理性人在做决定的时候，是选择对我们有利的事情——也就是折现到现在NP...
二叉树模型
fengweicun的博客
10-07 292
二叉树
数据结构二叉树详解
"数据结构二叉树优选ppt资料.ppt" 这份资料主要涵盖了数据结构中的核心概念——二叉树。二叉树是数据结构中的一个重要组成部分，它是一种特殊的树形结构，每个节点最多有两个子节点，通常称为左子节点和右子节点。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值