作业5：二叉树及其应用

第1关：实现二叉树的创建

任务描述

本关任务：利用先序遍历创建二叉树，并给出相应二叉树的中序遍历结果。

相关知识

为了完成本关任务，你需要掌握：1.二叉树的前序遍历，2.如何创建一颗二叉树，3.二叉树的中序遍历。

二叉树的前序遍历

前序遍历preorder traversal是指按照先根节点，再左节点，最后右节点的次序访问二叉树中所有的节点，使得每个节点被访问且仅被访问一次。 例：图1表示一个二叉树，前序遍历的顺序如节点上面数字所示，结果为ABCDEF。

如何创建一颗二叉树

本关基于二叉链表存储定义了树节点数据结构：

1. struct BiTreeNode {
2. char data; // 树节点元素
3. BiTreeNode* left; // 左子树指针
4. BiTreeNode* right; // 右子树指针
5. };

利用先序遍历创建二叉树，我们需要知道先序遍历的叶子节点，通过增加符合#表示叶子节点的子节点，则图1的先序遍历为：ABC##D##EF###。

• 根据先序遍历的过程，首先创建根节点，然后使用递归的方法创建左子树节点，直到遇到符号#，表示到了叶子节点，回溯父节点并创建右子树节点。
• 伪代码如下：
  1. BiTreeNode* CreatBiTree(char* s, int &i, int len)
  2. {
  3. root = new BiTreeNode(s[i++]); //创建根节点
  4. root->left = CreatBiTree(s, i, len); //递归创建左子树
  5. root->right = CreatBiTree(s, i, len); //递归创建右子树
  6. return root;
  7. }

二叉树的中序遍历

中序遍历inorder traversal是指按照先左节点，再根节点，最后右节点的次序访问二叉树中所有的节点，使得每个节点被访问且仅被访问一次。 例：图2表示一个二叉树，中序遍历的顺序如节点上面数字所示，结果为CBDAFE。

编程要求

本关的编程任务是补全右侧代码片段CreatBiTree和InOrder中Begin至End中间的代码，具体要求如下：

• 在CreatBiTree中，利用先序遍历创建二叉树，并返回二叉树根节点指针。
• 在InOrder中，完成二叉树的中序遍历，并输出遍历结果，中间没有空格，末尾不换行。

测试说明

平台将自动编译补全后的代码，并生成若干组测试数据，接着根据程序的输出判断程序是否正确。

以下是平台的测试样例：

测试输入：ABC##D##EF###

预期输出：CBDAFE

测试输入：ABCD###E#F##G##

预期输出：DCBEFAG

上答案：

//
//  binary_tree.cpp
//  BinaryTreeApp
//
//  Created by ljpc on 2018/5/3.
//  Copyright © 2018年 ljpc. All rights reserved.
//

#include "binary_tree.h"


BiTreeNode* CreatBiTree(char* s, int &i, int len)
// 利用先序遍历创建二叉树
// 参数：先序遍历字符串s，字符串初始下标i=0，字符串长度len。
// 返回：二叉树
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    BiTreeNode*root;
    char item=s[i++];
    if(i>=len||item=='#')//当字符串下标上溢或对应的位置为空时，将结点指针指向空
    {
        root=NULL;
    }
    else{
        root=new BiTreeNode(item);
        root->left=CreatBiTree(s,i,len);
        root->right=CreatBiTree(s,i,len);
    }
    return root;
    
    /********** End **********/
}

void InOrder(BiTreeNode* root)
// 二叉树的中序遍历
// 参数：二叉树根节点root
// 输出：中间没有空格，末尾不换行。
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    if(root!=NULL){
        InOrder(root->left);
        printf("%c",root->data);
        InOrder(root->right);
    }
    
    /********** End **********/

}

第2关：计算二叉树的深度和节点个数

任务描述

本关任务：给定一棵二叉树，计算该二叉树的深度、总节点个数和叶子节点个数。

相关知识

为了完成本关任务，你需要掌握：1.二叉树深度概念，2.二叉树节点，3.二叉树叶子节点概念。

二叉树深度概念

二叉树的深度指的是二叉树中最大的结点层数。例如：图1所示的二叉树最大的节点层数为3，所以该二叉树深度为3。

二叉树节点

二叉树的节点包含一个数据元素及两个指向子树的分支，例如：图1所示的二叉树的总节点个数为6。

二叉树叶子节点概念

叶子节点是度为0的节点，二叉树节点的度为子树的个数。例如：图1所示的二叉树叶子节点为C，D和F，个数为3。

编程要求

本关的编程任务是补全右侧代码片段GetTreeDepth、GetNodeNumber和GetLeafNodeNumber中Begin至End中间的代码，具体要求如下：

• 在GetTreeDepth中计算该二叉树的深度，返回深度值。
• 在GetNodeNumber中计算该二叉树的总的节点个数，返回节点个数。
• 在GetLeafNodeNumber中计算该二叉树的叶子节点个数，返回叶子节点个数。

测试说明

平台将自动编译补全后的代码，并生成若干组测试数据，接着根据程序的输出判断程序是否正确。

以下是平台的测试样例：

测试输入：ABC##D##EF###

预期输出： 3 6 3

测试输入：ABCD###E#F##G##

预期输出： 4 7 3

上答案：

//
//  binary_tree.cpp
//  BinaryTreeApp
//
//  Created by ljpc on 2018/5/3.
//  Copyright © 2018年 ljpc. All rights reserved.
//

#include "binary_tree.h"

int GetTreeDepth(BiTreeNode* root)
// 计算该二叉树的深度
// 参数：二叉树根节点root
// 返回：二叉树的深度
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    int m,n;
     if(root==NULL)
     {
         return 0;
  
     }
     else 
     {
         m=GetTreeDepth(root->left);
         n=GetTreeDepth(root->right);
         if(m>n)
         {
             return m+1;
         }
         else return n+1;
     }
    /********** End **********/
}

int GetNodeNumber(BiTreeNode* root)
// 计算该二叉树的总节点个数
// 参数：二叉树根节点root
// 返回：二叉树的总节点个数
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    if(root==NULL)
    {
        return 0;
    }
    else return GetNodeNumber(root->left)+GetNodeNumber(root->right)+1;
    
    /********** End **********/
}

int GetLeafNodeNumber(BiTreeNode* root)
// 计算该二叉树的叶子节点个数
// 参数：二叉树根节点root
// 返回：二叉树的叶子节点个数
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    if(root==NULL)
    {
        return 0;
    }
    else if(root->left==NULL&&root->right==NULL)
    {
        return 1;
    }
    else 
    return GetLeafNodeNumber(root->left)+GetLeafNodeNumber(root->right);
    /********** End **********/
}

第3关：递归实现二叉树左右子树交换

任务描述

本关任务：给定一棵二叉树，使用递归的方法实现二叉树的左右子树交换，并输出交换后的二叉树的先（前）序遍历结果。

相关知识

为了完成本关任务，你需要掌握：1.递归算法，2.二叉树左右子树性质，3.二叉树先序遍历。

递归法

递归算法recursion algorithm在计算机科学中是指一种通过重复将问题分解为同类的子问题而解决问题的方法。其核心是将原始问题转化为子问题。 例如：计算n阶乘的程序在数学上可以定义为：

fact(n)={1n×fact(n−1)​n=0n>0​

则递归算法求n阶乘的伪代码为：

1. int fact(int n){
2. if(n == 0)
3. return 1;
4. else
5. return n * fact(n - 1);
6. }

二叉树左右子树性质

二叉树的每个节点最多只有两个分支，通常分支被称作左子树和右子树，并且二叉树的分支具有左右次序，不能颠倒。左右子树交换实例如下：图1是原始二叉树，图2是图1交换左右子树后的二叉树。

编程要求

本关的编程任务是补全右侧代码片段BiTreeChange和PreOrder中Begin至End中间的代码，具体要求如下：

• 在BiTreeChange中使用递归算法实现二叉树左右子树交换。
• 在PreOrder中实现二叉树的先序遍历并输出结果，中间没有空格，末尾不换行。

测试说明

平台将自动编译补全后的代码，并生成若干组测试数据，接着根据程序的输出判断程序是否正确。

以下是平台的测试样例：

测试输入：ABC##D##EF###

预期输出：AEFBDC

测试输入：ABCD###E#F##G##

预期输出：AGBEFCD

上答案：
 

//
//  binary_tree.cpp
//  BinaryTreeApp
//
//  Created by ljpc on 2018/5/3.
//  Copyright © 2018年 ljpc. All rights reserved.
//

#include "binary_tree.h"


BiTreeNode* BiTreeChange(BiTreeNode* root)
// 实现二叉树左右子树的交换（递归法）
// 参数：二叉树根节点root
// 返回：二叉树
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    if(root==NULL)
    {
        return NULL;
    }
    BiTreeNode*temp=root->left;
    root->left=root->right;
    root->right=temp;
    if(root->left!=NULL){
        BiTreeChange(root->left);
    }
    if(root->right!=NULL){
        BiTreeChange(root->right);
    }
    return root;
    
    /********** End **********/
}


void PreOrder(BiTreeNode* root)
// 二叉树的前序遍历
// 参数：二叉树根节点root
// 输出：二叉树的前序遍历，中间没有空格，末尾不换行。
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    if(root==NULL)
    {
        return ;
    }
    printf("%c",root->data);
    if(root->left!=NULL)
    {
        PreOrder(root->left);
    }
    if(root->right!=NULL)
    {
        PreOrder(root->right);
    }
    /********** End **********/
}

第4关：非递归实现二叉树左右子树交换

任务描述

本关任务：给定一棵二叉树，使用非递归的方式实现二叉树左右子树交换，并输出后序遍历结果。

相关知识

为了完成本关任务，你需要掌握：1.栈的基本操作，2.二叉树后序遍历。

栈的基本操作

本关卡提供C++ STL模板栈Stack的相关操作和功能。

• 使用实例如下：
  1. stack<int> s; // 创建栈对象
  2. s.push(3); // 元素入栈
  3. s.push(4);
  4. cout<<s.size()<<endl; //打印栈表元素个数
  5. while(!s.empty()) {
  6. cout<<s.top()<<endl; // 打印栈顶元素
  7. s.pop(); // 出栈
  8. }

二叉树后序遍历

后序遍历postorder traversal是指按照先左节点，再右节点，最后根节点的次序访问二叉树中所有的节点，使得每个节点被访问且仅被访问一次。例如：图1的后序遍历顺序为节点上的数字，结果为：CDBFEA。

编程要求

本关的编程任务是补全右侧代码片段BiTreeChangeStack和PostOrder中Begin至End中间的代码，具体要求如下：

• 在BiTreeChangeStack中使用栈结构实现二叉树左右子树交换。
• 在PostOrder中实现二叉树的后序遍历并输出结果，中间没有空格，末尾不换行。

测试说明

平台将自动编译补全后的代码，并生成若干组测试数据，接着根据程序的输出判断程序是否正确。

以下是平台的测试样例：

测试输入：ABC##D##EF###

预期输出：FEDCBA

测试输入：ABCD###E#F##G##

预期输出：GFEDCBA

上答案：

//
//  binary_tree.cpp
//  BinaryTreeApp
//
//  Created by ljpc on 2018/5/3.
//  Copyright © 2018年 ljpc. All rights reserved.
//

#include "binary_tree.h"


BiTreeNode* BiTreeChangeStack(BiTreeNode* root)
// 实现二叉树左右子树的交换（栈实现）
// 参数：二叉树根节点root
// 返回：二叉树
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    stack<BiTreeNode*>s;
    BiTreeNode*temp=NULL,*node=root;
    if(root==NULL)return NULL;
    s.push(root);
    while(!s.empty()){
    	temp=node->left;
    	node->left=node->right;
    	node->right=temp;
    	if(node->right!=NULL){
    		s.push(node->right);
		}
		if(node->left!=NULL){
			node=node->left;
		}else{
			node=s.top();
        	s.pop();
		}
	}
	return node;
    

    /********** End **********/

}


void PostOrder(BiTreeNode* root)
// 二叉树的后序遍历
// 参数：二叉树根节点root
// 输出：二叉树的后序遍历，中间没有空格，末尾不换行。
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    if(root==NULL)
    {
        return ;
    }
    if(root->left!=NULL)
    {
        PostOrder(root->left);
    }
    if(root->right!=NULL)
    {
        PostOrder(root->right);
    }
    printf("%c",root->data);
    
    /********** End **********/
}

第5关：层次遍历二叉树

任务描述

本关任务：给定一棵二叉树，借助队列实现层次遍历二叉树。

相关知识

为了完成本关任务，你需要掌握：1.队列基本操作，2.二叉树层次遍历。

队列基本操作

本关卡提供C++ STL模板队列queue的相关操作和功能。

• 使用实例如下：
  1. queue<int> q; // 创建队列对象
  2. q.push(3); // 元素入队列
  3. q.push(4);
  4. cout<<q.size()<<endl; //打印队列元素个数
  5. while(!q.empty()) {
  6. cout<<q.front()<<endl; // 打印队首元素
  7. q.pop(); // 移除队首元素
  8. }

二叉树层次遍历

层次遍历要求先访问离根节点最近的层的节点，然后依次访问下一层的节点。例如：图1的层次遍历顺序为节点上的数字，结果为：ABECDF。

编程要求

本关的编程任务是补全右侧代码片段HierarchyOrder中Begin至End中间的代码，具体要求如下：

• 在HierarchyOrder中实现二叉树的层次遍历并输出结果，中间没有空格，末尾不换行。

测试说明

平台将自动编译补全后的代码，并生成若干组测试数据，接着根据程序的输出判断程序是否正确。

以下是平台的测试样例：

测试输入：ABC##D##EF###

预期输出：ABECDF

测试输入：ABCD###E#F##G##

预期输出：ABGCEDF

上答案：

//
//  binary_tree.cpp
//  BinaryTreeApp
//
//  Created by ljpc on 2018/5/3.
//  Copyright © 2018年 ljpc. All rights reserved.
//

#include "binary_tree.h"

void HierarchyOrder(BiTreeNode* root)
// 二叉树的层次遍历（队列实现）
// 参数：二叉树根节点root
// 输出：二叉树的层次遍历，中间没有空格，末尾不换行。
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    queue<BiTreeNode*>q;
    q.push(root);
    if(root==NULL)
    {
        return ;
    }
    while(!q.empty())
    {
        BiTreeNode*node=q.front();
        q.pop();
        printf("%c",node->data);
        if(node->left!=NULL)
        {
            q.push(node->left);
        }
        if(node->right!=NULL)
        {
            q.push(node->right);
        }

    }


    /********** End **********/

}