精华内容
下载资源
问答
  • /*二叉树的各种操作复习*/ #include #define BACK_ODER -1 #define IN_ODER 0 ...#define LEVEL_ODER 2//层次遍历 typedef struct _Node{ char data; struct _Node *lchild; struct _Node *rchild
    /*二叉树的各种操作复习*/
    #include <stdio.h>
    
    #define BACK_ODER   -1
    #define IN_ODER     0
    #define PRE_ODER    1
    #define LEVEL_ODER  2//层次化遍历
    typedef struct _Node{
    	char data;
    	struct _Node *lchild;
    	struct _Node *rchild;
    } Node,*Tree;
    
    /* 生成二叉树的普通方法
     * 按先序次序输入二叉树中结点的值
     * 构造二叉链表表示的二叉树T。输入空格表示空子树。 */
    Node * CreateTree()
    {
        char ch;
        Node *T;
        scanf("%c",&ch);
        if(ch==' ') /* 空 */
            return NULL;
        else
        {
            T=(Node *)malloc(sizeof(Node));
            if(!T)
                exit(0);
            T->data=ch; /* 生成根结点 */
            T->lchild = CreateTree(); /* 构造左子树 */
            T->rchild = CreateTree(); /* 构造右子树 */
        }
        return T;
    }
    /* 由先根序列和中根序列生成二叉树
     * 递归法。pre 是先跟序列,in是中根序列
     * pre_s是先根序列的起始,pre_e是先跟序列的结束
     * in_s是中根序列的起始,in_e是中根序列的结束
     */
    Node *Convert(char pre[], int pre_s, int pre_e,
                  char in [], int in_s , int in_e )
    {
    
    
        int i = in_s;
        Node *p;
        if(in_s > in_e)return NULL;
        for(i=in_s;i<in_e&&in[i]!=pre[pre_s];i++);//找到中跟中的头所在位置
        p = (Node *)malloc(sizeof(Node));
        p->data = pre[pre_s];
        //注意以下递归过程是关键
        p->lchild = Convert(pre, pre_s+1, pre_s+i-in_s,
                            in,  in_s,i-1);
        p->rchild = Convert(pre, pre_s+i-in_s+1,pre_e,
                            in,  i+1,in_e);
        return p;
    }
    /* 求二叉树的度 */
    int GetDegree(const Tree head)
    {
        int degree = 0;
        int m,n;
        if(!head)return 0;
    
        if(head->lchild && head->rchild) return 2;
        else if(!head->lchild && !head->rchild) return 0;
        else {
            m = GetDegree(head->lchild) ;
            n = GetDegree(head->rchild) ;
            if(2==m || 2==n)return 2;
            else return 1;
        }
        return degree;
    }
    /* 求二叉树的高度 */
    int GetHight(const Tree head)
    {
        int m,n;
        if(!head)return 0;
        m = GetHight(head->lchild);
        n = GetHight(head->rchild);
        return 1 + (m > n ? m : n);
    }
    /* 输出二叉树中某个指定元素的祖父节点(包括自己)
     * 递归思想:如果那个节点在我的子树中,那么我是祖父节点
     * 返回值 :1表示子树中有 ,0表示无 */
    int GetGrandPa(const Tree head, const char e)
    {
       if(!head)return 0;
       if(GetGrandPa(head->lchild,e) || GetGrandPa(head->rchild,e) || e==head->data)//子树中有此节点
       {
           printf("%c",head->data);
           return 1;
       }
       else return 0;
    }
    /* 遍历二叉树,参数oder控制遍历方式 */
    void Tranverse(Node *head,int oder)
    {
    	if(!head)return ;
    	if(LEVEL_ODER == oder)
    	{
    	    LevTranverse(&head,1);
            return;
    	}
        if(PRE_ODER == oder) printf("%c\t",head->data);
    	Tranverse(head->lchild,oder);
    	if(IN_ODER == oder) printf("%c\t",head->data);
    	Tranverse(head->rchild,oder);
    	if(BACK_ODER == oder) printf("%c\t",head->data);
    	return;
    }
    /* 层次化遍历,采用递归思想而不用队列。
     * 递归思想:把当前层遍历的同时把下一层存储好
     * nodes[]作为队列用,存储的当前层的节点
     * count记录当前层的元素个数 */
    void LevTranverse(const Node* nodes[], int count)
    {
        int i=0, j=0;
        Node *nextNodes[100] = {0};
        if(0 == count) return;
        for(i = 0,j=0; i<count; i++)
        {
            printf("%c\t",nodes[i]->data);
            if(nodes[i]->lchild)nextNodes[j++] = nodes[i]->lchild;
            if(nodes[i]->rchild)nextNodes[j++] = nodes[i]->rchild;
        }
        LevTranverse(nextNodes,j);
        return;
    }
    
    /* 构建二叉排序树 */
    int InsertBiSearchTree(Node *head,char ch)
    {
        Node *p,*pre,*newNode;
        if(NULL == head)return 1;
        p = head;
        while(p)
        {
            pre = p;
            if(ch == p->data)return 1;
            if(ch < p->data)p = p->lchild;
            else p = p->rchild;
        }
        newNode = (Node *)malloc(sizeof(Node));
        newNode->lchild = newNode->rchild = NULL;
        newNode->data = ch;
        if(ch < pre->data)pre->lchild = newNode;
        else pre->rchild = newNode;
        return 0;
    }
    Node* CreateBiSearchTree(void)
    {
        char a;
        Node *p,*head,*q,*pre;
        scanf("%c",&a);
        if(' ' == a)return NULL;
        p = (Node *)malloc(sizeof(Node));
        p->lchild = p->rchild = NULL;
        p->data = a;
        head = p;
        while(1)
        {
            scanf("%c",&a);
            if(' ' == a)break;
            InsertBiSearchTree(head,a);
        }
        return  head;
    }
    /* 求一棵树的查找长度(查找成功) */
    int GetSearchLength(Node *head,int hight)
    {
        if(NULL == head)return 0;
        return hight
                + GetSearchLength(head->lchild,hight+1)
                + GetSearchLength(head->rchild,hight+1);
    
    }
    
    int main(int argc, char *argv[])
    {
        char pre[]= "abcde";
    	char in[] = "bcade";
    
    	Node *head = Convert(pre,0,strlen(pre)-1,
                       in ,0,strlen(in)-1);
    
        printf("Hight : %d\n",GetHight(head));
        printf("Degree : %d\n",GetDegree(head));
        if(!GetGrandPa(head,'c'))printf("No grandpa !");printf("\n");
        Tranverse(head,LEVEL_ODER);printf("\n");
    
        printf("Now create BiSearchTree..\n");
        head = CreateBiSearchTree();
        Tranverse(head,IN_ODER);printf("\n");
        printf("%d\n",GetSearchLength(head,1));
        return 0;
    }
    

    展开全文
  • 降维问题:顺序、链式存储结构的二叉树递归遍历、层次遍历求高度 全部源代码在最后 一、概要设计 测试数据:如图所示森林 森林采用兄弟孩子链表表示法。 森林的数据输入采取输入兄弟孩子链表表示法下的等价二叉树的...

    降维问题:顺序、链式存储结构的二叉树递归遍历、层次遍历求高度
    全部源代码在最后

    一、概要设计

    测试数据:如图所示森林
    在这里插入图片描述
    森林采用兄弟孩子链表表示法。
    森林的数据输入采取输入兄弟孩子链表表示法下的等价二叉树的扩展先序遍历形成的线性串的方法(原理为森林先序遍历结果与等价二叉树的先序遍历结果相同)
    在这里插入图片描述
    输入数据:ABEK..F..CG..DH.I.J...L.MN...

    算法设计

    以链式存储结构为例
    递归遍历求高度:由于孩子兄弟链表表示法是把兄弟当儿子,所以对应二叉树的所有左子树的最大高度便是森林的高度。这样,在求二叉树高度的算法上可以改进,将左子树给定权重1,右子树给定权重0;即只需

    if(root == NULL) return 0;
    return max(GetHeightByRecursion(root->firstson) + 1, GetHeightByRecursion(root->nextbrother));
    

    层次遍历求高度:利用队列,将第一个儿子入队,再进行一系列循环操作

    实验结果

    在这里插入图片描述

    二、 详细设计

    1. 链式存储结构

    • 森林链表
    template<typename T>
    struct ForestNode
    {
    	T data;
    	ForestNode<T>* firstson;
    	ForestNode<T>* nextbrother;
    	ForestNode()
    	{
    		firstson = NULL;
    		nextbrother = NULL;
    	}
    };
    
    • 森林类
    template<typename T>
    class Forest
    {
    public:
    	Forest() {};
    	~Forest(){};
    	ForestNode<T>* getFirstTreeRoot(){};
    	void build(ForestNode<T>* & node){};
    	void deleteAll(ForestNode<T>* node){};
    	int LevelTraversalAndReturnHeight(ForestNode<T>* root){};
    	int GetHeightByRecursion(ForestNode<T>* root){};
    private:
    	ForestNode<T>* FirstTreeRoot;
    };
    
    • 构造函数
     Forest() 
    	{
    		FirstTreeRoot = new ForestNode<T>;
    	};
    
    • 析构函数
     ~Forest()
    	{
    		deleteAll(FirstTreeRoot);
    	}
    
    • 获得第一个根结点
    ForestNode<T>* getFirstTreeRoot() { return FirstTreeRoot; };
    
    • 通过输入先序拓展遍历序列递归建立森林
    void build(ForestNode<T>* & node)
    	{
    		T nodedata;
    		nodedata = cin.get();
    		if (nodedata == '.')
    		{
    			node = NULL;
    			return;
    		}
    		node = new ForestNode<T>;
    		node->data = nodedata;
    		build(node->firstson);
    		build(node->nextbrother);
    	}
    
    • 删除子树
    void deleteAll(ForestNode<T>* node)
    		{
    			if (node == NULL) return;
    			deleteAll(node->firstson);
    			deleteAll(node->nextbrother);
    			delete node;
    		}
    
    • 层次遍历并返回高度
    int LevelTraversalAndReturnHeight(ForestNode<T>* root)
    	{
    		queue<ForestNode<T>*> Queue;
    		Queue.push(root);
    		int height = 0;
    		while (Queue.size() != 0)
    		{
    			cout << "level" << height + 1 << ":";
    			int len = Queue.size();
    			ForestNode<T>* node;
    			for (int i = 1; i <= len; i++)
    			{
    				node = Queue.front();
    				Queue.pop();
    				while (node != NULL)
    				{
    					cout << node->data << " ";
    					if (node->firstson != NULL) Queue.push(node->firstson);
    					node = node->nextbrother;
    				}
    				cout << "   ";
    			}
    			cout << endl;
    			height++;
    		}
    		return height;
    	}
    
    • 递归遍历求高度()
    int GetHeightByRecursion(ForestNode<T>* root)
    	{
    		if(root == NULL) return 0;
    		return max(GetHeightByRecursion(root->firstson) + 1, GetHeightByRecursion(root->nextbrother));
    	}
    

    2.顺序存储结构

    template<typename T>
    class SeqForest
    {
    public:
    	SeqForest(int totalnum)
    	{
    		if (totalnum > 0)
    		{
    			this->totalnum = totalnum;
    			array = new T[totalnum + 1];
    			memset(array, ' ', (totalnum + 1) * sizeof(T));
    		}
    	}
    	~SeqForest()
    	{
    		delete[]array;
    	}
    	void build(int index = 1)
    	{
    		T data;
    		data = cin.get();
    		if (data == '.'||index>totalnum) return;
    		array[index] = data;
    		build(2 * index);
    		build(2 * index + 1);
    	}
    	int GetHeightByRecursion(int i = 1)
    	{
    		if (i> totalnum || array[i] == ' ') return 0;
    		return max(GetHeightByRecursion(2 * i) + 1, GetHeightByRecursion(2 * i + 1));
    	}
    	int LevelTraversalAndReturnHeight(int i = 1)
    	{
    		queue<int> Queue;
    		Queue.push(i);
    		int height = 0;
    		while (!Queue.empty())
    		{
    			cout << "level" << ++height << ":";
    			int len = Queue.size();
    			for (int j = 1; j <= len; j++)
    			{
    				int index = Queue.front();
    				Queue.pop();
    				while (array[index] != ' ')
    				{
    					if (array[2 * index] != ' ') Queue.push(2 * index);
    					cout << array[index] << " ";
    					index = 2 * index + 1;
    				}
    			}
    			cout << endl;
    		}
    		return height;
    	}
    private:
    	int totalnum;
    	T* array;
    };
    

    三、全部源代码

    #include<iostream>
    #include<algorithm>
    #include<queue>
    using namespace std;
    
    //顺序存储结构
    template<typename T>
    class SeqForest
    {
    public:
    	SeqForest(int totalnum)
    	{
    		if (totalnum > 0)
    		{
    			this->totalnum = totalnum;
    			array = new T[totalnum + 1];
    			memset(array, ' ', (totalnum + 1) * sizeof(T));
    		}
    	}
    	~SeqForest()
    	{
    		delete[]array;
    	}
    	void build(int index = 1)
    	{
    		T data;
    		data = cin.get();
    		if (data == '.'||index>totalnum) return;
    		array[index] = data;
    		build(2 * index);
    		build(2 * index + 1);
    	}
    	int GetHeightByRecursion(int i = 1)
    	{
    		if (i> totalnum || array[i] == ' ') return 0;
    		return max(GetHeightByRecursion(2 * i) + 1, GetHeightByRecursion(2 * i + 1));
    	}
    	int LevelTraversalAndReturnHeight(int i = 1)
    	{
    		queue<int> Queue;
    		Queue.push(i);
    		int height = 0;
    		while (!Queue.empty())
    		{
    			cout << "level" << ++height << ":";
    			int len = Queue.size();
    			for (int j = 1; j <= len; j++)
    			{
    				int index = Queue.front();
    				Queue.pop();
    				while (array[index] != ' ')
    				{
    					if (array[2 * index] != ' ') Queue.push(2 * index);
    					cout << array[index] << " ";
    					index = 2 * index + 1;
    				}
    			}
    			cout << endl;
    		}
    		return height;
    	}
    private:
    	int totalnum;
    	T* array;
    };
    //链式存储结构
    template<typename T>
    struct ForestNode
    {
    	T data;
    	ForestNode<T>* firstson;
    	ForestNode<T>* nextbrother;
    	ForestNode()
    	{
    		firstson = NULL;
    		nextbrother = NULL;
    	}
    };
    template<typename T>
    class Forest
    {
    public:
    	Forest() 
    	{
    		FirstTreeRoot = new ForestNode<T>;
    	};
    	~Forest()
    	{
    		deleteAll(FirstTreeRoot);
    	}
    	ForestNode<T>* getFirstTreeRoot() { return FirstTreeRoot; };
    	void build(ForestNode<T>* & node)
    	{
    		T nodedata;
    		nodedata = cin.get();
    		if (nodedata == '.')
    		{
    			node = NULL;
    			return;
    		}
    		node = new ForestNode<T>;
    		node->data = nodedata;
    		build(node->firstson);
    		build(node->nextbrother);
    	}
    		void deleteAll(ForestNode<T>* node)
    		{
    			if (node == NULL) return;
    			deleteAll(node->firstson);
    			deleteAll(node->nextbrother);
    			delete node;
    		}
    	int LevelTraversalAndReturnHeight(ForestNode<T>* root)
    	{
    		queue<ForestNode<T>*> Queue;
    		Queue.push(root);
    		int height = 0;
    		while (Queue.size() != 0)
    		{
    			cout << "level" << height + 1 << ":";
    			int len = Queue.size();
    			ForestNode<T>* node;
    			for (int i = 1; i <= len; i++)
    			{
    				node = Queue.front();
    				Queue.pop();
    				while (node != NULL)
    				{
    					cout << node->data << " ";
    					if (node->firstson != NULL) Queue.push(node->firstson);
    					node = node->nextbrother;
    				}
    				cout << "   ";
    			}
    			cout << endl;
    			height++;
    		}
    		return height;
    	}
    	int GetHeightByRecursion(ForestNode<T>* root)
    	{
    		if(root == NULL) return 0;
    		return max(GetHeightByRecursion(root->firstson) + 1, GetHeightByRecursion(root->nextbrother));
    	}
    private:
    	ForestNode<T>* FirstTreeRoot;
    };
    int main()
    {
    	cout << "Seqeuence storage structure:" << endl;
    	SeqForest<char> sequenceBT(200);
    	cout << "Please enter the expanded forest preorder list of Child brother list notation:";
    	sequenceBT.build();
    	cout << "Get height by recursion traversal:" << endl;
    	cout << sequenceBT.GetHeightByRecursion() << endl;
    	cout << "Forest's level traversal and get height:" << endl;
    	cout << sequenceBT.LevelTraversalAndReturnHeight() << endl;
    	cout << endl;
    	cout << "List storage structure:" << endl;
    	Forest<char> forest;
    	ForestNode<char>* root = forest.getFirstTreeRoot();
    	cin.get();
    	cout << "Please enter the expanded forest preorder list of Child brother list notation:";
    	forest.build(root);
    	cout << "Get height by recursion traversal:";
    	cout << forest.GetHeightByRecursion(root) << endl;
    	cout << "Forest's level traversal and get height:" << endl;
    	cout << forest.LevelTraversalAndReturnHeight(root) << endl;
    }
    
    展开全文
  • 利用顺序栈,循环结束条件用队列非空判断,当栈为空时,二叉树即遍历完。 1、首先将根节点入队,然后进入循环。 2、每次循环将队首节点出队,并依次将当前处理节点的左、右孩子入队。用一个指针来标记层尾节点,当队...

    思路
    利用顺序栈,循环结束条件用队列非空判断,当栈为空时,二叉树即遍历完。

    1、首先将根节点入队,然后进入循环。

    2、每次循环将队首节点出队,并依次将当前处理节点的左、右孩子入队。用一个指针来标记层尾节点,当队头指针=层尾指针时,说明遍历完了一层,层数+1并更新层尾指针指向的层尾节点。

    3、循环处理直到队列为空即遍历完二叉树所有节点。
    .

    
    typedef struct BiTNode {   //二叉树节点定义
    	char data;
    	struct BiTNode* lchild, * rchild;
    }BiTNode, * BiTree;
    
    
    typedef struct {      //顺序队列定义
    	BiTree* base;     //以指向BiTNode的指针作为元素
    	int front;
    	int rear;
    }SqQueue;
    
    
    //层次遍历得到二叉树高度
    int LevelGetBiTreeHeight(BiTree T) {
    	if (T == NULL)	 return 0;    //树为空
    
    	SqQueue Q;
    	BiTree temp;
    	int level = 0;  //记录层数
    	int last = 1;  //last标记当前层的最后一个节点
    
    	InitQueue(Q);
    
    	EnQueue(Q, T);      //队首节点入队
    
    	while (Q.front < Q.rear) {
    		DeQueue(Q, temp);      //队首节点出队
    
    		if (temp->lchild)
    			EnQueue(Q, temp->lchild);    //将当前输出节点的左孩子入队
    
    		if (temp->rchild)
    			EnQueue(Q, temp->rchild);    //将当前输出节点的右孩子入队
    
    		if (Q.front == last) {      //处理分层
    			level++;
    			last = Q.rear;      //改变层尾
    		}
    	}
    	return level;    //返回层数即为高度
    
    }
    

    以上

    展开全文
  • 所谓层次遍历,是将二叉树中的元素从根节点按照节点层数一层层的输出。 代码如下: int GetDepth(bitreenode *root) { int depth=0; bitreenode *p=root; queue&lt;bitreenode*&gt; q; q.push(p); //...

    来自大佬群主的第二题

    所谓层次遍历,是将二叉树中的元素从根节点按照节点层数一层层的输出。

    代码如下:

    int GetDepth(bitreenode *root)
    {
        int depth=0;
        bitreenode *p=root;
        queue<bitreenode*> q;
        q.push(p);  //根指针入队
        while(!q.empty())
        {
            depth++;  //高度加一
            int width=q.size();  //获取当前层次宽度
            for(int i=0;i<width;i++)
            {
                p=q.front();  //获取队顶元素
                q.pop();  //弹出队顶元素
                if(p->leftchild!=NULL)  //左孩子入队
                    q.push(p->leftchild);
                if(p->rightchild!=NULL)  //右孩子入队
                    q.push(p->rightchild);
            }
    
        }
        cout<<depth<<endl;
    }

     

    展开全文
  • 设置level变量记录层数,last变量记录该层最右结点,在层次遍历出队时,让队列的front指针与last对比,相等证明该层遍历完了,last=rear,同时level+1,直至遍历完成,即队列为空,此时level即为二叉树的高度。...
  • 两种及以上存储结构(建议 顺序存储结构和链式存储结构各一)、两种及以上方法(建议 递归遍历和层次遍历方法各一)。分析各代码性能。 抽象数据类型(二叉树)独立模块实现。 其它要求同作业-01要求。 二、实验环境...
  • #二叉树的创建、先序、中序、后序遍历、层次遍历高度、结点数、叶子结点数、左右结点交换 下面展示一些 内联代码片。 #include <stdio.h> #include <iostream> #include <malloc.h> #...
  • 数据结构-二叉树的非层次遍历以及应用(输出叶子结点,求树高度的定义以节点的堆栈和队列的结构堆栈的操作前序,中序,和后序的非递归遍历使用堆栈可以对二叉树进行层次遍历输出的叶子结点求树高度前序...
  • 利用层次遍历非递归二叉树高度

    万次阅读 多人点赞 2016-09-30 17:47:42
    利用层次遍历非递归二叉树高度主要的思想是:一层一层地出队列 — 在我们每次访问完一层时,这时队列中存储的刚好是下一层的所有元素。所以在下一次循环开始时,首先记录该层的元素个数,一次性访问完这一层的所有...
  • 对刷题过程中的牵扯到层次遍历的代码总结。 1. 基础版,层次遍历java代码的实现(利用的是队列): /** * Definition for binary tree with next pointer. * public class TreeLinkNode { * int val; *...
  • 创建二叉树,遍历二叉树.详细介绍了层次遍历和后序遍历的应用. 层次遍历:高度,的宽度,每一层节点个数等 后序遍历:根节点到某节点的路径,两个节点的最近公共祖先等.
  • 本程序建树方法采用“先序遍历+空用0表示” 结点和的构建 class Node { public: char data; Node *left,*right; Node() { left=right=NULL; } }; class Tree { private: Node *Root; public: ...
  • // 层次遍历输出高度 public int levelOfTree (Node head) { int level = 0 ; // 记录的层数 int front = 0 ; // 标记当前取出的节点标号 int rear = 0 ; // 标记当前存入队列的节点标号...
  • 思路:我们首先要抓住后序遍历的特点(左右根),这就导致后序遍历的最后一个数就一定是的根节点. 然后中序遍历的特点是左根右,那么我们可以从后序白遍历得到的根节点分出一棵的左子树和右子. 这样子,递归到叶子...
  • 蓝桥杯:完全二叉树的权值(层次遍历求最大和是那一层) 问题描述 给定一棵包含 N 个节点的完全二叉树,上每个节点都有一个权值,按从上到下、从左到右的顺序依次是 A1, A2, · · · AN,如下图所示: 现在小明...
  • //二叉树的bfs计算的宽度 int cal_max_width(BTNode *b){ int Qsize=100005; St que[Qsize]; //循环队列 int front=0,rear=0; if(b==NULL) return 0; rear=(rear+1)%Qsize; que[rear].p=b,que[rear].depth=1; int...
  • 一、以动态二叉链表为存储结构,实现如下操作: 1. 二叉树的建立, 2. 先序遍历的非递归算法, 3. 按层次遍历的算法, 4. 将二叉树的深度作为递归参数,实现计算的深度的递归算法
  • import java.util.LinkedList; import java.util.Queue;public class Main { //非递归求高度 public static int bTNonRecursiveHeight(Node root){ int front=-1,rear=-1; int level=0,last=0;
  • 求树的深度(层次遍历

    千次阅读 2016-10-25 21:51:56
    题目描述: 二叉树采用二叉链表存储,设计一个非递归算法二叉树的高度。 核心代码: (全部代码请参照本博客判断完全二叉树) void Leveltravel(BiTree Bt) { if(Bt) { int max; Sq q;BiTree e; InitSq(q...
  • 数据结构系列(1)——二叉树的构造、层次遍历、节点个数、高度题目分析解题步骤解题代码 题目分析 当我们通过前序序列和中序序列构造出二叉树后,再进行层次遍历: 解题步骤 我们首先通过二叉树的前序...
  • // 层次遍历求树高度,还可以利用的后序遍历求树高度 int depth_noRecursion( Bitree head ) { int height = 0; if( NULL == head ) { height = -1; return height; } queue< pNode > qu; ...
  • 二叉树的层次遍历 Time Limit: 1000MS Memory Limit: 65536KB Problem Description 已知一颗二叉树的前序遍历和中序遍历,二叉树的层次遍历。 Input 输入数据有多组,输入T,代表有T组测试...
  • (3)层次遍历

    2016-07-16 09:27:14
    问题描述:输入一颗二元,从上往下按层打印的每个结点,同一层中按照从左往右的顺序打印。 例如输入 8 / / 6 10 / / / / 5 7 9 11 输出8 6 10 5 7 9 11。 代码如下:#include #include using ...
  • 二叉树遍历算法 (递归的、非递归的中序、前序、后序遍历 和 层次遍历 以及 二叉树的宽度和深度)
  • 层次遍历算法: int Height_Tree(BiTree T) { BiTNode* Q[100];//用数组做队列 int front = -1;//当前访问的节点 int rear = -1;//下一层新加入的节点 int level = 0, last = 0;//当前层的最后一个节点 ...
  • import java.util.LinkedList;... System.out.println("层次遍历"); pt.levelQueueOrder(); System.out.println(); System.out.println("的深度"); System.out.println(pt.depth()); } }
  • #include <iostream> #include <stdlib.h> #include <stdio.h> #include <queue> #define Maxsize 100 using namespace std;...//利用非递归中序遍历求二叉排序的深度 int BSTDeepth(B.

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,508
精华内容 8,203
关键字:

层次遍历求树的高度