C++练习6-1：二叉树

最新推荐文章于 2022-07-07 13:29:01 发布
最新推荐文章于 2022-07-07 13:29:01 发布
阅读量130 收藏 1
点赞数
文章标签： 数据结构与算法 c/c++
原文链接：https://my.oschina.net/mingfu/blog/527526
版权 
一次贴代码太多，先贴二叉树的类定义头文件和实现文件：
//tree.h
#include <iostream>
#include <cstdlib>
#include <cassert>
#include <exception>
#include <stdexcept>
#include <vector>
#include <algorithm>

#define NODE_NUMBER 100
#define FOUR_SPACE 4
#define MIDDLE_SCREEN 60
#define LEFT_CHILD  10
#define RIGHT_CHILD 20
using namespace std;
typedef int  T;

typedef struct btree_node
{
  btree_node *left,*right;
  int level;
  int screen_x;
  T value;
}BTREE_NODE;

class CBinaryTree{
  public:
    CBinaryTree(T array[],int size);
    BTREE_NODE *GetTreeRoot(void);
    void TraversePreOrder(BTREE_NODE *r);
    void TraverseByMiddleOrder(BTREE_NODE *r);
    void TraverseByBehindOrder(BTREE_NODE *r);
    int TreeDepth(BTREE_NODE *r);
    int GetElementLayer(T element);  
    void PrintTree(void);    
    ~CBinaryTree(void);

  protected:
    BTREE_NODE * _InsertByLocation(BTREE_NODE *r,
               BTREE_NODE *new_node);
    void _OutPutValue(T value);
    void _MiddleOrderAdd(BTREE_NODE *r, vector<BTREE_NODE> *coll);
    int _GetElementLayer(T element);
    void _SetLayerForEachNode(BTREE_NODE *pTmp, 
                int layer);
    void _SetPositionForEachNode(BTREE_NODE *pTmp, 
          int layer ,int wide);
    int _CalculateDigitalBits(T value);
    void _PrintLeftChildValue(vector<BTREE_NODE>::iterator pos, 
                              int wide);
    void _PrintRightChildValue(vector<BTREE_NODE>::iterator pos, 
                              int wide);
    void _PrintStartSpace(vector<BTREE_NODE> *last, 
                           vector<BTREE_NODE> *now);
    int _DetectNextNodePosition(vector<BTREE_NODE>::iterator pos_now, 
                             vector<BTREE_NODE> *now);
    int _DetectNextNodeType(vector<BTREE_NODE>::iterator pos_last, 
                          vector<BTREE_NODE>*last);
    void _PrintCurrentLayerNode(vector<BTREE_NODE> *last, vector<BTREE_NODE> *now, int wide);
    int _CalculateTreeWide(vector<BTREE_NODE> *coll, int depth);
    inline void _PrintSpace(int number);  
    int _RemoveRepeat(T *array, int len);  
    
  private:
    BTREE_NODE *pMemStart;
    BTREE_NODE *TreeRoot; 
};
//tree.cpp
#include "tree.h"
#include <iostream>
#include <cstdlib>
#include <cassert>
#include <exception>
#include <stdexcept>
#include <algorithm>
#include <typeinfo>

CBinaryTree::CBinaryTree(T array[],int size)
{
  BTREE_NODE *pNew;
  BTREE_NODE *pTmp =NULL;
  assert(array);

  CBinaryTree::pMemStart = new BTREE_NODE[size];
  if(NULL!=CBinaryTree::pMemStart){
     pNew=CBinaryTree::pMemStart;
     for(int i=0;i<size;i++,pNew++){
        pNew->value=array[i];
        pNew->left=pNew->right=NULL;
        if(0==i){
           CBinaryTree::TreeRoot = pNew;
           continue;
        }
        pTmp = CBinaryTree::_InsertByLocation(CBinaryTree::TreeRoot, pNew);
        if(pTmp->value > pNew->value)
          pTmp->left = pNew;
        else
          pTmp->right = pNew;
     }
   }

   cout<<"construct OK!";
}

CBinaryTree::~ CBinaryTree(void)
{
  if(NULL!=CBinaryTree::pMemStart){
     delete CBinaryTree::pMemStart;
     CBinaryTree::pMemStart=NULL;
  }
  cout<<"destruct OK!";
}

BTREE_NODE * CBinaryTree::_InsertByLocation(BTREE_NODE *r,
                                     BTREE_NODE *new_node)
{
  assert(r and new_node);
  
  if(NULL==r->left and  NULL==r->right)
    return r;

  if(new_node->value < r->value){
    if(NULL!=r->left)
       return CBinaryTree::_InsertByLocation(r->left,new_node);
  }
  else{
    if(NULL!=r->right)
       return  CBinaryTree::_InsertByLocation(r->right,new_node);
  }

  return r;
}

void CBinaryTree::_OutPutValue(T value)
{
  if((typeid(value)) == typeid(int))
    cout<<" "<<value;
  else if(( typeid(value)) == typeid(char)){
    cout<<" " ;
    cout.put(value);
  }
  else
  cout<<"unsupport type";
  return;
}

void CBinaryTree::TraversePreOrder(BTREE_NODE *r)
{
  assert(r);
  if((NULL == r->left)and (NULL==r->right)){
   CBinaryTree::_OutPutValue(r->value);
   return;
  }
  
  CBinaryTree::_OutPutValue(r->value);
  if(r->left)
     CBinaryTree::TraversePreOrder(r->left);
  
  if(r->right)
     CBinaryTree::TraversePreOrder(r->right);
}

BTREE_NODE * CBinaryTree::GetTreeRoot(void)
{
  return TreeRoot;
}

void  CBinaryTree::TraverseByBehindOrder(BTREE_NODE *r)
{
  assert(r);

  if((NULL == r->left)and (NULL==r->right)){
    CBinaryTree::_OutPutValue(r->value);
    return;
  }

  if(r->left)
     CBinaryTree::TraverseByBehindOrder(r->left);
    
  if(r->right)
     CBinaryTree::TraverseByBehindOrder(r->right);
  CBinaryTree::_OutPutValue(r->value);  
}

void CBinaryTree::TraverseByMiddleOrder(BTREE_NODE *r)
{
  assert(r);

  if((NULL == r->left)and (NULL==r->right)){
    CBinaryTree::_OutPutValue(r->value);
   return;
  }

  if(r->left)
     CBinaryTree::TraverseByMiddleOrder(r->right);
    
  CBinaryTree::_OutPutValue(r->value);
  if(r->right)
     CBinaryTree::TraverseByMiddleOrder(r->right);
}

void CBinaryTree::_MiddleOrderAdd(BTREE_NODE *r, vector<BTREE_NODE> *coll)
{
  assert(r and coll);

  if((NULL == r->left)and (NULL==r->right)){
   coll->push_back(*r);
   return;
  }

  if(r->left)
    CBinaryTree::_MiddleOrderAdd(r->left, coll);
    
  coll->push_back(*r);
  if(r->right)
    CBinaryTree::_MiddleOrderAdd(r->right, coll);
}

int CBinaryTree::TreeDepth(BTREE_NODE *r)
{
    int r_high=0, l_high=0;

    if(r->right)
    r_high = CBinaryTree::TreeDepth(r->right);

    if(r->left)
    l_high = CBinaryTree::TreeDepth(r->left);

    return r_high>l_high ? r_high+1:l_high+1;
}

int CBinaryTree::_GetElementLayer(T element)
{
    BTREE_NODE *r=CBinaryTree::TreeRoot;
    int count=0;
    bool find = false;
    while(1){
       count ++;
       if(r->value == element){
          find = true;
          break;
       }
       else if(r->value > element)
          if(r->left) r = r->left;
          else break;
       else
          if(r->right) r = r->right;
          else break;
    }
    if (find)
      return count;
    else
      return -1;
}

int CBinaryTree::_RemoveRepeat(T *array, int len)
{
  int i,j, r=0;

  for(i=0; i<len; i++)
  {
     for(j=0; j<r; j++)
       if(array[j]==array[i]) break;
     if(j==r)
       array[r++] = array[i];
  }
  return r;
}

inline void CBinaryTree::_PrintSpace(int number)
{
  for(int i=0;i<number; i++) cout<<" ";
}

int CBinaryTree::_CalculateTreeWide(vector<BTREE_NODE> *coll, int depth)
{
  int wide=0;
  vector<BTREE_NODE>::iterator pos;
  vector<BTREE_NODE>coll_now;
  
  for(int i=2; i<depth; i++){
    for(pos=coll->begin(); pos!=coll->end(); ++pos){
      if(pos->level==i) coll_now.push_back(*pos);
    }
    if((int) coll_now.size()>wide) 
      wide=coll_now.size();
    coll_now.clear();
  }
  return wide;
}

void CBinaryTree::_SetLayerForEachNode(BTREE_NODE *pTmp, int layer)
{
  if(NULL == pTmp) return;

  if(CBinaryTree::_GetElementLayer(pTmp->value) == layer)
    pTmp->level = layer;
  
  if(NULL!=pTmp->left) 
    CBinaryTree::_SetLayerForEachNode(pTmp->left, layer+1); 
 
  if(NULL!=pTmp->right);
    CBinaryTree::_SetLayerForEachNode(pTmp->right, layer+1);

  return ;
}

void CBinaryTree::_SetPositionForEachNode(BTREE_NODE *pTmp,int layer ,int wide)
{
    if(NULL == pTmp) return;

  if(CBinaryTree::_GetElementLayer(pTmp->value) == layer)
    pTmp->level = layer;
  
  if(NULL!=pTmp->left){
    if(wide>0){
      if(pTmp->left)
      pTmp->left->screen_x = pTmp->screen_x-wide-FOUR_SPACE;
    }
    else{
      if(pTmp->left)
      pTmp->left->screen_x = pTmp->screen_x-FOUR_SPACE;
    }
    
    CBinaryTree::_SetPositionForEachNode(pTmp->left, layer+1, wide-2); 
  }
 
  if(NULL!=pTmp->right);{
    if(wide>0){
       if(pTmp->right)
       pTmp->right->screen_x = pTmp->screen_x+wide+FOUR_SPACE;
    }
    else{
       if(pTmp->right)
       pTmp->right->screen_x = pTmp->screen_x+FOUR_SPACE;
    }
    CBinaryTree::_SetPositionForEachNode(pTmp->right, layer+1,wide-2);
  }
  return ;
}

int CBinaryTree::_CalculateDigitalBits(T value)
{
   int cnt=1;

   if(typeid(value) != typeid(char)){
     for(int i=10; (int)(value/i)>0; i=i*10)
      cnt++;
   }
   return cnt;
}

void CBinaryTree::_PrintLeftChildValue(vector<BTREE_NODE>::iterator pos, 
                              int wide)
{
   CBinaryTree::_OutPutValue(pos->value);
   if(wide>1)
   for(int i=0; i<wide; i++) cout<<"_";
   switch(CBinaryTree::_CalculateDigitalBits(pos->value))
   {
     case 1:
       cout<<"__/";//x__/
       break;
     case 2:
       cout<<"_/";//xx_/
       break;
     case 3:
       cout<<"/";//xxx/
       break;
     default:
       break;
   } 
}

void CBinaryTree::_PrintRightChildValue(vector<BTREE_NODE>::iterator pos, 
                              int wide)
{
    switch(CBinaryTree::_CalculateDigitalBits(pos->value))
    {
      case 1:
        cout<<"\\__";
        break;
      case 2:
        cout<<"\\_";
        break;
      case 3:
        cout<<"\\";
        break;
      default:
        break;
    }
    if(wide>1)
    for(int i=0; i<wide; i++) cout<<"_";
    CBinaryTree::_OutPutValue(pos->value);
}

void  CBinaryTree::_PrintStartSpace(vector<BTREE_NODE> *last, 
                           vector<BTREE_NODE> *now)
{
   vector<BTREE_NODE>::iterator pos_last;
   pos_last= last->begin();
   while(!pos_last->left && !pos_last->right)
      ++pos_last;    
   if(pos_last->left)
     CBinaryTree::_PrintSpace(MIDDLE_SCREEN+now->begin()->screen_x);
   else
     CBinaryTree::_PrintSpace(MIDDLE_SCREEN+pos_last->screen_x);
}

int CBinaryTree::_DetectNextNodePosition(vector<BTREE_NODE>::iterator pos_now, 
                             vector<BTREE_NODE> *now)
{
  int position=pos_now->screen_x;
   if(pos_now!=--now->end()){
      ++pos_now;
      return pos_now->screen_x - position;
   }
   else
      return 0;
}

int CBinaryTree::_DetectNextNodeType(vector<BTREE_NODE>::iterator pos_last, 
                          vector<BTREE_NODE>*last)
{
  vector<BTREE_NODE>::iterator pos_tmp;

   if(pos_last!=last->end()){
     pos_tmp=++pos_last;
     if(!pos_last->left && !pos_last->right){
        while(pos_last!=last->end() && !pos_last->left && !pos_last->right)
        ++pos_last;
     }
   }
   
   if(pos_last==last->end())
   return 0;
   
   if(pos_last!=last->end() && pos_last->left){
    return LEFT_CHILD;
   }

   if(pos_last!=last->end() && pos_last->right){
    return RIGHT_CHILD;
   }
   
   return 0;
}

void CBinaryTree::_PrintCurrentLayerNode(vector<BTREE_NODE> *last, 
                              vector<BTREE_NODE> *now, int wide)
{
   vector<BTREE_NODE>::iterator pos_now,pos_last,pos_tmp;
   int interval=0;
   int next_node_type=0;  

   CBinaryTree::_PrintStartSpace(last,now);
   for(pos_last=last->begin(),pos_now=now->begin();
      pos_last!=last->end() and pos_now!=now->end();++pos_last)
   {
      if(pos_last!=last->end() && !pos_last->left && !pos_last->right)
      continue;
      
      if(pos_last->left){
         CBinaryTree::_PrintLeftChildValue(pos_now, wide);
         interval = CBinaryTree::_DetectNextNodePosition(pos_now,now);
         ++pos_now;
         if(pos_last->right){
            CBinaryTree::_PrintRightChildValue(pos_now,wide);
            interval = CBinaryTree::_DetectNextNodePosition(pos_now, now);
            next_node_type = CBinaryTree::_DetectNextNodeType(pos_last, last);
            if(next_node_type == LEFT_CHILD)
              CBinaryTree::_PrintSpace(interval);
            else if(next_node_type == RIGHT_CHILD)
              CBinaryTree::_PrintSpace(interval-FOUR_SPACE-
                         CBinaryTree::_CalculateDigitalBits(pos_now->value));
            ++pos_now;
         }
         else{  
            next_node_type = CBinaryTree::_DetectNextNodeType(pos_last, last);
            if(next_node_type == LEFT_CHILD){
              --pos_now;
              CBinaryTree::_PrintSpace(interval-FOUR_SPACE);
              ++pos_now;
            }
            else if(next_node_type == RIGHT_CHILD){
              CBinaryTree::_PrintSpace(interval-FOUR_SPACE-FOUR_SPACE);
            }
         }
      }
      else{
         if(pos_last->right){
            CBinaryTree::_PrintRightChildValue(pos_now,wide);
            interval = CBinaryTree::_DetectNextNodePosition(pos_now, now);
            
            next_node_type = CBinaryTree::_DetectNextNodeType(pos_last, last);
            if(next_node_type == LEFT_CHILD)
              CBinaryTree::_PrintSpace(interval);
            else if(next_node_type == RIGHT_CHILD)
              CBinaryTree::_PrintSpace(interval-FOUR_SPACE);
            ++pos_now;
         }
      }
   }

   cout<<endl;
}

void CBinaryTree::PrintTree(void)
{
  vector<BTREE_NODE> coll, coll_last, coll_now;
  vector<BTREE_NODE>::iterator pos;
  BTREE_NODE *pTmp = CBinaryTree::TreeRoot;
  int depth =CBinaryTree::TreeDepth(pTmp), wide;

  CBinaryTree::_SetLayerForEachNode(pTmp, 1);
  CBinaryTree::_MiddleOrderAdd(CBinaryTree::TreeRoot, &coll);

  wide = CBinaryTree::_CalculateTreeWide(&coll,depth);
  if(wide*6 >MIDDLE_SCREEN){
  cout<<"tree is too wide!"<<endl;
  return ;
  }

  coll.clear(); 
  CBinaryTree::_SetPositionForEachNode(pTmp, 1, wide);
  
  CBinaryTree::_MiddleOrderAdd(CBinaryTree::TreeRoot, &coll);
  cout<<endl<<""<<endl;
  CBinaryTree::_PrintSpace(MIDDLE_SCREEN-CBinaryTree::_CalculateDigitalBits(CBinaryTree::TreeRoot->value)/2);
  CBinaryTree::_OutPutValue(CBinaryTree::TreeRoot->value);
  cout<<endl;
  
  for(int i=2; i<=depth; i++)
  { 
     coll_now.clear();
     coll_last.clear();
     for(pos=coll.begin(); pos!=coll.end(); ++pos){
       if(pos->level==i-1) coll_last.push_back(*pos);
       if(pos->level==i) coll_now.push_back(*pos);
     }
     CBinaryTree::_PrintCurrentLayerNode(&coll_last, &coll_now, wide);
     wide -= 2;
     cout<<endl;
  }
  cout<<""<<endl;
}


转载于:https://my.oschina.net/mingfu/blog/527526

chouci9270
关注
算法练习篇之：二叉树的深度
香农三定律的博客
10-06 723
算法练习篇之：二叉树的深度题目描述解题思路图示代码实现总结 题目描述 二叉树的深度 要求：输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。 解题思路 二叉树的深度定义，依据题目要求可以理解为，从根节点开始，其有左右子树的存在，左右子树的节点又有其左右子树，这种结构下，采用递归形式可以简化问题，我们只需对根节点的左右子树分别进行...
树的基本知识
u011484045的专栏
06-26 587
树 树是数据结构最基础的东西，下面杂说下树的一些基本知识。 树中的一个结点拥有的子树数称为该结点的度(Degree)。 一棵树的度指的是树中所有结点中，结点的最大度数作为树的度。 度为零的结点称为叶子结点或者终端结点。 度不为零的结点称为分支结点或者非终端结点。其中，除根节点之外的分支节点称为内部结点。
C++练习6-2:二叉树
chouci9270的博客
11-07 287
接上一个练习： //test.cpp二叉树类测试 #include"tree.h" #include<iostream> usingnamespacestd; intmain(void) { Tarray[]={27,12,42,9,36,1,28,22,19,...
机试练习：二叉树的深度
一个程序媛的成长记录❤
08-17 182
题目： 输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。 /* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL...
二叉树基础OJ题（二叉树的遍历、分治算法、数据结构、C语言）
分享学习方面的一些笔记
07-07 554
在学习完二叉树的基本知识后，主要包括前序遍历以及分治算法的思想，再通过下面几道基础OJ题提高理解
leetcode答案-LeetCode:题目练习
06-30
- LeetCode 提供了多种编程语言的题目，包括但不限于 C++, Java, Python, JavaScript 等。 - 题目分为三个难度级别：Easy, Medium, Hard，适合不同水平的开发者进行挑战。 - 平台上的题目涵盖排序、搜索、图论、...
LeetCode-1-30:先定一个小目标，1-30题
03-04
这个压缩包文件"LeetCode-1-30"显然包含了从LeetCode上选取的前30道题目，可能是作为初学者的练习计划或者是为了准备面试而设定的目标。让我们逐一探讨这些题目可能涵盖的知识点，以及它们如何帮助提升C++编程技能。...
java猜字母游戏源码-LeetCode-Algorithm:算法学习笔记，练习代码(C++/Java/Python)
06-05
二叉树(以下代码都是在刷LeetCode时写的, 所有只有功能函数, 请见谅！另外前序、中序、后序遍历算法都给出了递归和非递归两种实现方式) :wrench:(其中删除节点操作在LeetCode刷题时使用了, 中序遍历给出了递归、使用...
[C++算法入门]-二叉树打印练习题
最新发布
09-26
该资源提供了入门级别的C++算法练习，旨在帮助读者熟悉二叉树的打印操作和相关算法。文档中包含了一系列的练习题，涵盖了二叉树的构建、遍历和打印等方面。 通过完成这些练习，读者将能够掌握二叉树的基本概念和...
K-Leetcode:Leetcode练习
03-28
《K-Leetcode: LeetCode练习与C++编程技巧探索》 LeetCode，一个深受程序员喜爱的在线编程平台，提供丰富的算法题目，旨在提升编程技能，尤其是对于数据结构和算法的理解。本项目“K-Leetcode”显然是针对LeetCode...
二叉树训练~树的遍历~解题报告
xiaosuC的博客
02-17 253
树的遍历 文章目录树的遍历题目描述：Input：Output：Sample Input：Sample Output：二叉树遍历：思路分析：代码： 题目描述： 给定一棵二叉树的后序遍历和中序遍历，请你输出其层序遍历的序列。 这里假设键值都是互不相等的正整数。 Input： 输入第一行给出一个正整数N（≤30），是二叉树中结点的个数。 第二行给出其后序遍历序列。第三行给出其中序遍历序列。数字 间以空...
【九度OJ】题目1078：二叉树遍历 解题报告
负雪明烛
03-03 857
【九度OJ】题目1078：二叉树遍历 解题报告标签（空格分隔）： 九度OJhttp://ac.jobdu.com/problem.php?pid=1078题目描述：二叉树的前序、中序、后序遍历的定义： 前序遍历：对任一子树，先访问跟，然后遍历其左子树，最后遍历其右子树； 中序遍历：对任一子树，先遍历其左子树，然后访问根，最后遍历其右子树； 后序遍历：对任一子树，先遍历其左子树，然后遍历其右子树
苏州OJ c005: 二叉树遍历
Code & Data & Finance
11-22 1124
【问题描述】 　　小明学完了树的基本知识，想做二叉树遍历的程序设计练习.根据二叉树的深度从数据文件中读入n个整数生成顺序存储的二叉树，做各种遍历的输出。小明发现输出的数据中有不少重复的，为此他先将重复的数据过滤掉，然后再生成二叉树的结构。现在要求你从数据文件中读取若干个整数，生成一个满二叉树，然后输出一个二叉树遍历的序列。 【输入】 　　输入文件bintree.in包含2行； 　　第一行是
树--1.基本知识
林竹清_清清清
03-07 325
1.在计算机中树采用多重链表存储（定长型 不定长型） 2.满二叉树：深度为h，含有2^h -1个结点，下图为完全二叉树 . 3.二叉树性质：（1）第i层至多有2^(i-1)个结点    （2）深度为h的最多含有2^h -1个结点（满二叉树）    （3）一颗二叉树有n0个叶节点，n2个度数为2的节点，则n0=n2+1   （4）完全二叉树深度|logn| +1    （5） 4.树
10、二叉树的遍历+查找
ajiaoci0000的博客
04-13 83
1 package ren.laughing.datastructure.baseImpl; 2 3 import ren.laughing.datastructure.base.Iterator; 4 import ren.laughing.datastructure.base.LinkedList; 5 import ren.laughing.dat...
ＭＩＤＰ程序设计基本知识
zhugenqiang的专栏
07-12 962
１。系统参数的提取MIDLet在运作时，必须通过java.lang.System.getProperty()函数来取得系统属性。他们分别是：（１）microedition.profiles;取得系统支持的所有Profile信息（２）microedition.configuration:取得系统所支持的Configuration信息（３）microediton.locale;取得系统目前所使用的地区
【LeetCode】104.二叉树的最大深度 （JAVA）
qq_44162521的博客
05-13 159
练习题：二叉树的最大深度 题目要求： 给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明:叶子节点是指没有子节点的节点。 示例： 给定二叉树 [3,9,20,null,null,15,7]， 3 / \ 9 20 / \ 15 7 返回它的最大深度3 。 解：已知当前节...
第11-12周练习题树与选择题
热门推荐
韩旭051的博客
11-18 1万+
2-1 下列线索二叉树中（用虚线表示线索），符合后序线索树定义的是：(2分) 后序遍历 dbca 所以 d前驱动为null，d后继b b没有左孩子，前驱为d。 C没有孩子，前驱为b，后继为a a有左右孩子 所以选B 作者: DS课程组 单位: 浙江大学 2-2 引人线索二叉树的目的的是（ ）。(2分) 加快查找结点的前驱或后继的速度 为了能在二叉树中方便...
题目1078：二叉树遍历
wujiezhainan的专栏
06-05 566
时间限制：1 秒 内存限制：32 兆 特殊判题：否 提交：831 解决：515 题目描述： 二叉树的前序、中序、后序遍历的定义： 前序遍历：对任一子树，先访问跟，然后遍历其左子树，最后遍历其右子树； 中序遍历：对任一子树，先遍历其左子树，然后访问根，最后遍历其右子树； 后序遍历：对任一子树，先遍历其左子树，然后遍历其右子树，最后访问根。 给定
北邮C++实践：二叉树遍历与IP地址处理
1. "二叉树前序遍历.txt"：这很可能是包含有关二叉树数据结构的前序遍历算法的练习题目和/或解题代码。前序遍历是树结构遍历算法中的一种，它按照“根节点-左子树-右子树”的顺序访问树的所有节点。这一知识点是数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值