精华内容
下载资源
问答
  • 二叉树的层次遍历c++
    2021-03-14 19:20:20

    二叉树层次遍历

    • 与二叉树先序、中序遍历使用栈类似,二叉树的层次遍历的实现是基于队列这个数据结构来实现的。
    • 主要算法思想是首先建一个队列并将树的根节点入队,然后当树不为空的时候持续访问队首节点并将其左右子节点入队,直至队列为空。
    void AVLTree<T>::printTree() {  //层次遍历
    	Node<T>* pos = root;  //当前位置
    	queue<Node<T>*> q;
    	q.push(root);  //根节点入队
    	while (!q.empty()) {  //队列非空
    		Node<T>* node = q.front();
    		q.pop();  //弹出队首
    		cout << node->key << '\t';
    		if (node->lchild != nullptr) {  //左孩子非空则入队
    			q.push(node->lchild);
    		}
    		if (node->rchild != nullptr) {  //右孩子非空则入队
    			q.push(node->rchild);
    		}
    	}
    }
    
    更多相关内容
  • 二叉树层次遍历c++

    2021-08-01 21:08:39
    层次遍历算法层次遍历代码完整测试代码 算法 借助一个队列,先将二叉树根节点入队列,然后出队列,访问出队结点。 若出队结点有左子树,则将左子树根结点入队; 若出队结点有右子树,则将右子树根节点入队。 然后出...


    树的层次遍历,又称为树的广度遍历

    算法

    大致思路:

    1. 借助一个队列,先将二叉树根节点入队列,然后出队列,访问出队结点。
    2. 若出队结点有左子树,则将左子树根结点入队;
      若出队结点有右子树,则将右子树根节点入队。
    3. 然后出队,访问出队结点,重复 2,直至队列为空

    具体算法步骤:
    ① 若树非空,则根节点入队
    ② 若队列非空,队头元素出队并访问,同时将该元素的左右孩子依次入队
    ③ 重复②直到队列为空

    层次遍历代码

    void LevelOrder(BiTree T){
        LinkQueue Q;
        InitQueue(Q);
        BiTree p=T;
        EnQueue(Q,p);
        while(!IsEmpty(Q)){
            DeQueue(Q, p);
            visit(p);
            if(p->lchild){
                EnQueue(Q,p->lchild);//左子树不空,则左子树根节点入队列
            }
            if(p->rchild){
                EnQueue(Q,p->rchild);//右子树不空,则右子树根节点入队列
            }
        }
        /*因为在DeQueue时会执行free操作,所以这里不用再销毁队列
        if(IsEmpty(Q)){
            printf("\nQueue Empty\n");
        }*/
    }
    

    完整测试代码

    //队列的链式存储,链队列   不带头结点
    //实际上是一个同时带有队头指针和队尾指针的单链表
    //头指针指向头结点,尾指针指向尾结点
    #include<stdlib.h>
    #include<stdio.h>
    #define Elemtype BiTree
    #define ElemType char
    typedef struct BiTNode{
        ElemType data;
        struct BiTNode *lchild,*rchild;
    }BiTNode,*BiTree;
    
    
    typedef struct LinkNode{//链式队列结点
        Elemtype data;
        struct LinkNode *next;
    }LinkNode;
    typedef struct{//链式队列
        LinkNode *front,*rear;//队列的队头和队尾指针
    }LinkQueue;
    
    
    
    
    void InitQueue(LinkQueue &Q){
        Q.front=Q.rear=NULL;
    }
    
    bool IsEmpty(LinkQueue Q){
        return (Q.front==NULL);
        //或者return (Q.rear==NULL);
    }
    
    bool EnQueue(LinkQueue &Q, Elemtype x){
        LinkNode *s=(LinkNode*)malloc(sizeof(LinkNode));
        s->data=x;
        s->next=NULL;
        if(Q.front==NULL){//原来为空队列
    
            Q.front = s;
            Q.rear=s;
        }
        else{
            Q.rear->next = s;//新结点插到尾部
            Q.rear=s;//@@@修改尾指针!!!
            //printf("???%d \n",Q.rear->data);
        }
        return true;
    }
    
    bool DeQueue(LinkQueue &Q, Elemtype &x){
        if(Q.front == NULL){//@@@
            printf("空队列\n");
            return false;
        }
        LinkNode *p=Q.front;//p指向此次出队的结点
        x=Q.front->data;
        Q.front=p->next;
        if(Q.rear==p){//此次出队的是最后一个结点
            Q.front=Q.rear=NULL;
        }
        free(p);//@@@
        p=NULL;
        return true;
    }
    
    bool PrintQueue(LinkQueue Q){
        if(!Q.front){
            printf("空队列无法打印\n");
            return false;
        }
        LinkNode *p=Q.front;
        printf("Queue is:");
        while(p){
            printf("%d ",p->data);
            p=p->next;
        }
        printf("\n");
        return true;
    }
    
    void visit(BiTree T){
        printf("%c ",T->data);
    }
    
    void LevelOrder(BiTree T){
        LinkQueue Q;
        InitQueue(Q);
        BiTree p=T;
        EnQueue(Q,p);
        while(!IsEmpty(Q)){
            DeQueue(Q, p);
            visit(p);
            if(p->lchild){
                EnQueue(Q,p->lchild);//左子树不空,则左子树根节点入队列
            }
            if(p->rchild){
                EnQueue(Q,p->rchild);//右子树不空,则右子树根节点入队列
            }
        }
        /*因为在DeQueue时会执行free操作,所以这里不用再销毁队列
        if(IsEmpty(Q)){
            printf("\nQueue Empty\n");
        }*/
    }
    
    //按前序输入二叉树中节点的值(一个字符)
    // ' '表示空树, 构造二叉链表表示二叉树T
    bool CreateBiTree(BiTree &T){
        ElemType ch;
    
        scanf("%c",&ch);//@@@
        if(ch == '#'){
            //printf("您要创建一棵空树吗?\n");
            T=NULL;//
            return false;
        }
        else{
            T=(BiTree)malloc(sizeof(BiTNode));
            if(!T){
                printf("malloc failure\n");
                return false;
            }
            T->data=ch;//生成根节点
            CreateBiTree(T->lchild);//构造左子树
            CreateBiTree(T->rchild);//构造右子树
            return true;
        }
    }
    
    
    bool DestroyBiTree(BiTree T){//@@@
        if(T == NULL){
            //printf("空结点#\n");
            return false;
        }
        DestroyBiTree(T->lchild);
        DestroyBiTree(T->rchild);
        printf("销毁%c\n",T->data);
        free(T);//@@@
        T=NULL;//防止产生野指针
        return true;
    }
    
    int main(){
        BiTree T=NULL;//@@@
        printf("按前序输入二叉树中节点的值(输入#表示空节点)\n");
        CreateBiTree(T);
    
        printf("层次遍历结果为:\n");
        LevelOrder(T);
    
        printf("\n\n开始destroy二叉树(按后序遍历来销毁):\n\n");
        DestroyBiTree(T);
    
        return 0;
    
    }
    

    按前序遍历的结果输入二叉树的结点(#表示空节点)
    ABD##E##CFH##I##G##
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode() : val(0), left(nullptr), right(nullptr) {} * TreeNode(int x) : val(x), ...
    /**
     * Definition for a binary tree node.
     * struct TreeNode {
     *     int val;
     *     TreeNode *left;
     *     TreeNode *right;
     *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
     *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
     *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
     * };
     */
    class Solution {
    public:
        
        //final result, contains vectors represent nodes of each level
        vector<vector<int>> result;
        
        
        vector<vector<int>> levelOrder(TreeNode* root) {
            if(root == NULL)
                return result;
            queue<TreeNode> level;
            level.push(*root); 
            travel(level);
            return result;
        }
        
        
        void travel(queue<TreeNode> levelFather){
            queue<TreeNode> level;
            vector<int> levelResult;
            while(!levelFather.empty()){
                TreeNode node = levelFather.front();
                levelFather.pop();
                levelResult.push_back(node.val);
                if(node.left != NULL)
                    level.push(*(node.left));
                if(node.right != NULL)
                    level.push(*(node.right));
            }
            result.push_back(levelResult);
            if(!level.empty())
                travel(level);
        }
        
    };
    
    展开全文
  • 102.二叉树层次遍历 107. 二叉树的层序遍历 II 199. 二叉树的右视图 637. 二叉树的层平均值 429. N叉树的层序遍历 515. 在每个树行中找最大值 116. 填充每个节点的下一个右侧节点指针 117. 填充每个节点的下一个...

    二叉树的层次遍历

    102.二叉树的层次遍历

    思路:二叉树层次遍历可以使用队列来进行遍历。

    class Solution {	//二叉树的层次遍历
    public:
    	vector<vector<int>> levelOrder(TreeNode* root) {
    		vector<vector<int>> result;
    		queue<TreeNode*> que;
    		if (root != nullptr){
    			que.push(root);
    		}
    		while (!que.empty()) {
    			vector<int> temp;
    			int length = que.size();
    			for (int i = 0; i < length; ++i) {
    				TreeNode* tempNode = que.front();
    				que.pop();
    				temp.push_back(tempNode->val);
    				if (tempNode->left) {
    					que.push(tempNode->left);
    				}
    				if (tempNode->right) {
    					que.push(tempNode->right);
    				}
    			}
    			result.push_back(temp);
    		}
    		return result;
    	}
    };
    

    107. 二叉树的层序遍历 II

    思路:在上一题的基础上,把最后得到的结果直接反转即可。

    class Solution {	//107. 二叉树的层序遍历 II
    public:
    	vector<vector<int>> levelOrderBottom(TreeNode* root) {
    		vector<vector<int>> result;
    		queue<TreeNode*> que;
    		if (root != nullptr){
    			que.push(root);
    		}
    		while (!que.empty()) {
    			vector<int> temp;
    			int length = que.size();
    			for (int i = 0; i < length; ++i) {
    				TreeNode* tempNode = que.front();
    				que.pop();
    				temp.push_back(tempNode->val);
    				if (tempNode->left) {
    					que.push(tempNode->left);
    				}
    				if (tempNode->right) {
    					que.push(tempNode->right);
    				}
    			}
    			result.push_back(temp);
    		}
    		reverse(result.begin(), result.end());
    		return result;
    	}
    };
    

    199. 二叉树的右视图

    思路:本题可以使用双向队列deque,在102题的基础上稍作修改,在队列遍历完每一层时,将队列的最后一个节点加入到结果集result。这里改成双向队列,是因为双向队列可以直接取到队列尾部的值。

    class Solution {	//199. 二叉树的右视图
    public:
    	vector<int> rightSideView(TreeNode* root) {
    		vector<int> result;
    		deque<TreeNode*> que;
    		if (root != nullptr){
    			que.push_back(root);
    		}
    		while (!que.empty()) {
    			result.push_back(que.back()->val);
    			int length = que.size();
    			for (int i = 0; i < length; ++i) {
    				TreeNode* tempNode = que.front();
    				que.pop_front();
    				if (tempNode->left) {
    					que.push_back(tempNode->left);
    				}
    				if (tempNode->right) {
    					que.push_back(tempNode->right);
    				}
    			}
    		}
    		return result;
    	}
    };
    

    637. 二叉树的层平均值

    思路:在102题的基础上,略作修改即可。

    class Solution {	//637. 二叉树的层平均值
    public:
    	vector<double> averageOfLevels(TreeNode* root) {
    		vector<double> result;
    		queue<TreeNode*> que;
    		if (root != nullptr){
    			que.push(root);
    		}
    		while (!que.empty()) {
    			double sum = 0;
    			int length = que.size();
    			for (int i = 0; i < length; ++i) {
    				TreeNode* tempNode = que.front();
    				que.pop();
    				sum += tempNode->val;
    				if (tempNode->left) {
    					que.push(tempNode->left);
    				}
    				if (tempNode->right) {
    					que.push(tempNode->right);
    				}
    			}
    			double average = sum / (double)length;
    			result.push_back(average);
    		}
    		return result;
    	}
    };
    

    429. N叉树的层序遍历

    思路:N叉树的层次遍历与二叉树的层次遍历流程相同,不同的地方在于二叉树是每次将队首节点的左右孩子加入队列,而N叉树是将队首节点的所有孩子加入队列,只要遍历存孩子节点的动态数组,将其加入队列即可。

    class Solution {	//429. N叉树的层序遍历
    public:
    	vector<vector<int>> levelOrder(Node* root) {
    		vector<vector<int>> result;
    		queue<Node*> que;
    		if (root != nullptr) {
    			que.push(root);
    		}
    		while (!que.empty()) {
    			vector<int> temp;
    			int length = que.size();
    			for (int i = 0; i < length; ++i) {
    				Node* node = que.front();
    				que.pop();
    				temp.push_back(node->val);
    				int size = (node->children).size();
    				for (int j = 0; j < size; ++j) {
    					que.push(node->children[j]);
    				}
    			}
    			result.push_back(temp);
    		}
    		return result;
    	}
    };
    

    515. 在每个树行中找最大值

    思路:先用队列层序遍历,然后把每一层用优先级队列存储,优先级队列的队首就是树行中的最大值。

    class Solution {	//515. 在每个树行中找最大值 使用队列和优先级队列
    public:
    	class myComparison {
    	public:
    		bool operator()(TreeNode* p1, TreeNode* p2) {
    			return p1->val < p2->val;
    		}
    	};
    	vector<int> largestValues(TreeNode* root) {
    		vector<int> result;
    		
    		queue<TreeNode*> que;
    		if (root) {
    			que.push(root);
    		}
    		while (!que.empty()) {
    			int length = que.size();
    			priority_queue<TreeNode*, vector<TreeNode*>, myComparison> p_que;
    			for (int i = 0; i < length; ++i) {
    				TreeNode* node = que.front();
    				que.pop();
    				p_que.push(node);
    				if (node->left) {
    					que.push(node->left);
    				}
    				if (node->right) {
    					que.push(node->right);
    				}
    			}
    			result.push_back(p_que.top()->val);
    		}
    		return result;
    	}
    };
    
    int main() {
    	TreeNode* p6 = new TreeNode(9);
    	TreeNode* p5 = new TreeNode(3);
    	TreeNode* p4 = new TreeNode(5);
    	TreeNode* p3 = new TreeNode(2, nullptr, p6);
    	TreeNode* p2 = new TreeNode(3, p4, p5);
    	TreeNode* p1 = new TreeNode(1, p2, p3);
    	Solution s;
    	vector<int> result = s.largestValues(p1);
    
    	for (int i : result) {
    		cout << i << "\t";
    	}
    	cout << endl;
    	return 0;
    }
    

    116. 填充每个节点的下一个右侧节点指针
    117. 填充每个节点的下一个右侧节点指针II

    思路:用队列进行层次遍历,遍历每一层时,取出队首元素并弹出,next指针指向下一个队首元素即可。

    class Node {
    public:
    	int val;
    	Node* left;
    	Node* right;
    	Node* next;
    
    	Node() : val(0), left(NULL), right(NULL), next(NULL) {}
    
    	Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}
    
    	Node(int _val, Node* _left, Node* _right, Node* _next)
    	: val(_val), left(_left), right(_right), next(_next) {}
    };
    
    
    class Solution {	//116、117. 填充每个节点的下一个右侧节点指针
    public:
    	Node* connect(Node* root) {
    		if (root == nullptr) return root;
    		queue<Node*> que;
    		que.push(root);
    		while (!que.empty()) {
    			int size = que.size();
    			Node* node = nullptr;
    			for (int i = 0; i < size; ++i) {
    				node = que.front();
    				que.pop();
    				
    				if (i < size - 1) {
    					node->next = que.front();
    				}
    				if (node->left) {
    					que.push(node->left);
    				}
    				if (node->right) {
    					que.push(node->right);
    				}
    			}
    		}
    		return root;
    	}
    };
    
    int main() {
    	Node* p7 = new Node(7);
    	Node* p6 = new Node(6);
    	Node* p5 = new Node(5);
    	Node* p4 = new Node(4);
    	Node* p3 = new Node(3, p6, p7, nullptr);
    	Node* p2 = new Node(2, p4, p5, nullptr);
    	Node* p1 = new Node(1, p2, p3, nullptr);
    	Solution s;
    	s.connect(p1);
    
    	return 0;
    }
    

    104. 二叉树的最大深度

    思路:用队列层次遍历时记录层数。

    class Solution {	//104. 二叉树的最大深度
    public:
    	int maxDepth(TreeNode* root) {
    		int result = 0;
    		queue<TreeNode*> que;
    		if (root != nullptr){
    			que.push(root);
    		}
    		while (!que.empty()) {
    			int length = que.size();
    			for (int i = 0; i < length; ++i) {
    				TreeNode* tempNode = que.front();
    				que.pop();
    				if (tempNode->left) {
    					que.push(tempNode->left);
    				}
    				if (tempNode->right) {
    					que.push(tempNode->right);
    				}
    			}
    			result++;
    		}
    		return result;
    	}
    };
    

    111. 二叉树的最小深度

    思路:用队列对二叉树进行层次遍历,在遍历时,记录层次,如果遇见叶子节点,就层数加1并返回记录的结果。

    class Solution {	//111. 二叉树的最小深度
    public:
    	int minDepth(TreeNode* root) {
    		int result = 0;
    		queue<TreeNode*> que;
    		if (root != nullptr){
    			que.push(root);
    		}
    		while (!que.empty()) {
    			int length = que.size();
    			for (int i = 0; i < length; ++i) {
    				TreeNode* tempNode = que.front();
    				que.pop();
    				if (tempNode->left == nullptr&&tempNode->right == nullptr) {
    					result++;
    					return result;
    				}
    				if (tempNode->left) {
    					que.push(tempNode->left);
    				}
    				if (tempNode->right) {
    					que.push(tempNode->right);
    				}
    			}
    			result++;
    		}
    		return result;
    	}
    };
    

    参考资料:代码随想录

    展开全文
  • 二叉树遍历 C++

    2021-07-20 22:05:12
    二叉树遍历包括前序遍历、中序遍历、后序遍历三种基本方式, 二叉树遍历概念代码递归遍历1. 先序遍历2. 中序遍历3. 后序遍历非递归遍历1. 先序遍历2. 中序遍历3. 后序遍历 概念 二叉树遍历: 是指从根结点出发...
  • 二叉树层次遍历C++

    千次阅读 2019-03-22 17:08:09
    层次遍历二叉树,从上往下,每层从左往右: BFS问题,本题用queue来解决 详细解决思路: 二叉树见下图,我们要打印的顺序是:1,2,3,4,5,6,7,8,9,10;可以看到我们先要打印根节点,之后打印第二层...
  • 层次遍历二叉树是大家再熟悉不过的二叉树操作了,看到这个算法通常会联想到队列,没错,叨叨Chen设计的层次遍历算法也是用到了队列(先进先出),下面一起进入算法游乐场吧。It's show time!Punchline--------------...
  • 本文详细讲述了C++实现二叉树遍历序列的求解方法,对于数据结构与算法的学习有着很好的参考借鉴价值。具体分析如下: 一、由遍历序列构造二叉树    如上图所示为一个二叉树,可知它的遍历序列分别为:  先序遍历...
  • 二叉树遍历c++代码实现

    万次阅读 2018-06-12 22:55:25
    二叉树遍历是指从根结点出发,按照某种次序依次访问二叉树中所有结点,使得每个结点被访问一次且仅被访问一次。二叉树遍历方式常用的有四种:前序遍历、中序遍历、后序遍历和层序遍历二叉树结点的定义代码如下...
  • 二叉树层次遍历c++

    千次阅读 2020-08-13 00:33:41
    层次遍历 :对于一颗二叉树,从根结点开始,按从上到下,从左到右的顺序访问每一个结点 思路 使用队列 1,将根结点入队 2,队不为空时循环:出列一个结点,打印它 ①有左孩子,将左孩子入队 ②有右孩子,将右孩子...
  • 二叉树层次遍历也称广度优先遍历,是一种按照逐层遍历的二叉树遍历方式。广度优先遍历需要借助辅助队列来存取各个节点。实现方法如下: //层次遍历 void LevelOrder(BiTree T) { LinkQueue Q;//辅助队列 ...
  • 二叉树层次遍历算法——C/C++

    万次阅读 多人点赞 2019-06-16 00:32:47
    二叉树层序遍历 1、算法思想 用一个队列保存被访问的当前节点的左右孩子以实现层序遍历。 在进行层次遍历的时候,设置一个队列结构,遍历从二叉树的根节点...此过程不断进行,当队列为空时,二叉树层次遍历结束...
  • 二叉树层次遍历c++实现

    千次阅读 2017-07-19 08:07:04
    二叉树层次遍历c++实现
  • 二叉树层次遍历思路就是使用队列进行存储,当出队一个元素,则将其左右子树入队。
  • 二叉树层次遍历C++实现)

    千次阅读 2019-08-09 21:47:48
    思路 利用队列,让根节点先进队列,然后只要队列不空,就把...二叉树定义 typedef struct bitnode { struct bitnode *lchild; struct bitnode *rchild; int data; } BiTNode,*BiTree; 这里说明一下 BiTNode * Bi...
  • 故知道该题主要考察二叉树基本的层次遍历方法,需要打印出每层节点的关键字。 二叉树层次遍历实现思路是用一个队列记录每层节点,当记录第一层节点时,弹出第一层节点进行访问,访问的同时需要遍历对应节点的左右...
  • 二叉树层次遍历 c++

    2013-05-14 19:27:33
    #include #include #define N 10 using namespace std; struct BTnode{ int value; BTnode *left; BTnode *right; }; void fromTop2Bottom(BTnode *root){ if(!root) ...que.push_b
  • 二叉树遍历(层次遍历)(前中后序遍历)(C++实现) 实现代码 /* author : eclipse email : eclipsecs@qq.com time : Mon Apr 20 16:02:40 2020 */ #include<bits/stdc++.h> using namespace std; struct ...
  • 目的:使用C++模板设计并逐步完善二叉树的抽象数据类型(ADT)。 内容: (1)请参照链表的ADT模板,设计二叉树并逐步完善的抽象数据类型。(由于该环境目前仅支持单文件的编译,故将所有内容都集中在一个源文件内...
  • 7-1 二叉树层次遍历 (25 分) 编写程序,要求实现(1)按先序遍历序列建立二叉树的二叉链表;(2)按层次遍历二叉树C++: 构成二叉链表的结点类代码如下: typedef struct BiNode { char data; //结点数据域 ...
  • 102 二叉树的层序遍历 leetcode 102 二叉树的层序遍历 题述: 给你二叉树的根节点 root ,返回其节点值的 层序遍历 。 (即逐层地,从左到右访问所有节点)。 示例1: 输入:root = [3,9,20,null,null,15,7] 输出...
  • 二叉树层次遍历

    2022-05-11 21:26:56
    目的:使用C++模板设计并逐步完善二叉树的抽象数据类型(ADT)。 内容:(1)请参照链表的ADT模板,设计二叉树并逐步完善的抽象数据类型。(由于该环境目前仅支持单文件的编译,故将所有内容都集中在一个源文件内。...
  • 实现树的层次遍历 利用c++代码实现。。。。。。。
  • 主要是记录一下二叉树层次遍历的经典面试题 1.二叉树的层序遍历 原题链接 1.1题意: 给你二叉树的根节点 root ,返回其节点值的 层序遍历 。 (即逐层地,从左到右访问所有节点)。 1.2思路: 层次遍历一个二叉树...
  • 层次遍历二叉树

    2014-10-24 12:14:16
    层次遍历二叉树
  • 给定一个二叉树,返回其节点值自底向上的层次遍历。(即按从叶子节点所在层到根节点所在的层,逐层从左向右遍历)按照层序遍历的思路,将每一层的遍历结果暂存在一个vector中,再将最终的结果集合逆序即可。首先输入...
  • class Solution { /** * @param root : The root of binary tree. * @return : buttom-up level order a list of lists of integer */ public: stack> a; vector> b; queue q; v
  • 二叉树层次遍历后输出 c++

    千次阅读 2018-08-01 13:17:18
    给定一个二叉树,返回其按层次遍历的节点值。 (即逐层地,从左到右访问所有节点)。 /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * ...
  • 二叉树有多种遍历方法,有层次遍历、深度优先遍历、广度优先遍历等。涉及到的代码都用Java编写。1. 首先给出二叉树节点类树节点:class TreeNode { int val; //左子树 TreeNode left; //右子树 TreeNode right; //...
  • 先序遍历、中序遍历、后序遍历(递归),层次遍历 代码: #include <iostream> using namespace std; #define MAXSIZE 10 //二叉树节点 typedef struct biNode{ char data; biNode* lchild; biNode* ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,387
精华内容 4,154
关键字:

二叉树的层次遍历c++