【数据结构——二叉树】二叉树及其应用2023（头歌习题）【合集】

已于 2023-12-31 23:16:18 修改
阅读量2.6k 收藏 45
点赞数 43
分类专栏： 数据结构（C语言） 文章标签： 数据结构 c语言 算法
于 2023-12-31 17:04:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_76435948/article/details/135316768
版权

目录

温馨提示：题目有点多，博客左右侧以及文章开头都有目录，用好目录链接，快速到达~

在这里插入图片描述

第1关：括号表示法创建二叉树

任务描述

本关任务：给出一棵二叉树的括号表示法，本题要求实现3个函数，根据给出的括号表示法创建该二叉树并输出。输出时，也按二叉树的括号表示法输出。然后再求出二叉树高度并输出。

相关知识

二叉树的括号表示法如图所示：
请添加图片描述

上面5棵二叉树中，从左至右，每棵二叉树的括号表示法依次为：A，A(B,C)，A(B(D),C)，A(B(,D),C(E))，A(B(D,E),C(F,G))。

编程要求

代码窗口中给出了二叉树类型定义文件binary_tree.h和实现文件binary_tree.cpp。您的任务是根据提示，在右侧编辑器补充代码，完成给定的3个函数。函数声明如下：

// 利用二叉树的括号表示法创建二叉树root
// 参数：二叉树的根结点指针root。
// 参数：二叉树的括号表示法字符串s。
void CreateTree(BTNode* &root, ElemType* s);
//以嵌套括号表示法输出一棵树
void DispTree(BTNode* root);
// 求二叉树的高度
// 参数：二叉树根节点root
int getHeight(BTNode* root);

测试说明

平台会对你编写的代码进行测试：

输入样例1：
A(B(D),C)

（对应二叉树如下）
请添加图片描述
输出样例1：
A(B(D),C)
3

输入样例2：
A(B(,D),C(E))

（对应二叉树如下）
请添加图片描述
输出样例2：
A(B(,D),C(E))
3

开始你的任务吧，祝你成功！

完整代码

#include "binary_tree.h"

//根据嵌套括号表示法的字符串生成链式存储的二叉树
void CreateTree(BTNode* &root, char str[]) {
	/*请在BEGIN和END之间实现你的代码*/
	/*****BEGIN*****/
	BTNode* St[60], * p; root = NULL;
	int top = -1, k, i = 0;	//栈顶指针
	char ch = str[i];
	while (ch != '\0'){
		switch (ch){
		case '(':top++; St[top] = p; k = 1; break;		
		case ')':top--;  break;							
		case ',': k = 2; break;							
		default:
			p = (BTNode*)malloc(sizeof(BTNode));		
			p->data = ch;								
			p->lchild = p->rchild = NULL;				
			if (root == NULL)				
				root = p;			
			else{
                k == 1 ? St[top]->lchild = p : St[top]->rchild = p;
			}
		}
		ch = str[++i];
	}

	/******END******/
}

//以嵌套括号表示法输出一棵二叉树
void DispTree(BTNode* root) {
	/*请在BEGIN和END之间实现你的代码*/
	/*****BEGIN*****/
	if (root != NULL){
		printf("%c", root->data);
		if (root->lchild != NULL || root->rchild != NULL){
			printf("(");
			DispTree(root->lchild);
			if (root->rchild != NULL)
				printf(",");
			DispTree(root->rchild);
			printf(")");
		}
	}

	/******END******/
}

// 求二叉树的高度
// 参数：二叉树根节点root
int getHeight(BTNode* root)
{
	/*请在BEGIN和END之间实现你的代码*/
	/*****BEGIN*****/
    int lchildh, rchildh;
	if (root == NULL) return 0;
	else{
		lchildh = getHeight(root->lchild);
		rchildh = getHeight(root->rchild);
		return (lchildh > rchildh) ? (lchildh + 1) : (rchildh + 1);
	}

	/******END******/
}
 

//
//  binary_tree.h

#ifndef __BTNODE_H
#define __BTNODE_H

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <iostream>
#include <algorithm>

using namespace std;

typedef char ElemType;

typedef struct BTNode {
    ElemType data;          //  树节点元素
    BTNode* lchild;         //  左子树指针
    BTNode* rchild;         //  右子树指针
    BTNode() {              //  树节点初始化
        lchild = NULL;
        rchild = NULL;
    }
    BTNode(ElemType item) { //  用元素初始化树节点
        data = item;
        lchild = NULL;
        rchild = NULL;
    }
    ~BTNode() {             //  释放树节点内存
        lchild = NULL;
        rchild = NULL;
    }
} BTNode;

//创建新结点的工具函数
BTNode* getNewNode(ElemType e);

// 利用二叉树的括号表示法创建二叉树root
// 参数：二叉树的根结点指针root。
// 参数：二叉树的括号表示法字符串s。
void CreateTree(BTNode* &root, ElemType* s);

//以嵌套括号表示法输出一棵树
void DispTree(BTNode* root);

// 求二叉树的高度
// 参数：二叉树根节点root
int getHeight(BTNode* root);

#endif /* __BTNODE_H */

在这里插入图片描述

第2关：先序序列创建二叉树

任务描述

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

相关知识

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

二叉树的前序遍历

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

如何创建一颗二叉树

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

struct BiTreeNode {
    char data;              //  树节点元素
    BiTreeNode* left;       //  左子树指针
    BiTreeNode* right;      //  右子树指针
};

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

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

二叉树的中序遍历

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

编程要求

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

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

测试说明

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

以下是平台的测试样例：

测试输入：ABC##D##EF###
预期输出：CBDAFE

测试输入：ABCD###E#F##G##
预期输出：DCBEFAG

开始你的任务吧，祝你成功！

完整代码

//
//  binary_tree.cpp

#include "binary_tree.h"

//创建新结点的工具函数
BTNode* getNewNode(char e)
{
    BTNode* p = (BTNode*)malloc(sizeof(BTNode));
    p->data = e;
    p->lchild = p->rchild = NULL;
    return p;
}


BTNode* CreateTree(char* s, int &i, int len)
// 利用先序遍历创建二叉树
// 参数：先序遍历字符串s，字符串初始下标i=0，字符串长度len。
// 返回：二叉树
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    if(s[i]=='#' || i>len){i++;return NULL;}
    BTNode* BTP = getNewNode(s[i++]);
    BTP->lchild = CreateTree(s,i,len);
    BTP->rchild = CreateTree(s,i,len);
    return BTP;

    /********** End **********/
}

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

    /********** End **********/
}


//
//  binary_tree.h

#ifndef __BTNODE_H
#define __BTNODE_H

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

typedef struct BTNode {
    char data;              //  树节点元素
    BTNode* lchild;       //  左子树指针
    BTNode* rchild;      //  右子树指针
    BTNode() {          //  树节点初始化
        lchild = NULL;
        rchild = NULL;
    }
    BTNode(char item) { //  用元素初始化树节点
        data = item;
        lchild = NULL;
        rchild = NULL;
    }
    ~BTNode() {         //  释放树节点内存
        lchild = NULL;
        rchild = NULL;
    }
} BTNode;

//创建新结点的工具函数
BTNode* getNewNode(char e);

BTNode* CreateTree(char* s, int &i, int len);
// 利用先序遍历创建二叉树
// 参数：先序遍历字符串s，字符串初始下标i=0，字符串长度len。
// 返回：二叉树

void InOrder(BTNode* root);
// 二叉树的中序遍历
// 参数：二叉树根节点root
// 输出：二叉树的中序遍历，中间没有空格，末尾不换行。

#endif /* __BTNODE_H */

在这里插入图片描述

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

任务描述

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

相关知识

为了完成本关任务，你需要掌握：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


#include "binary_tree.h"

//创建新结点的工具函数
BTNode* getNewNode(char e)
{
    BTNode* p = (BTNode*)malloc(sizeof(BTNode));
    p->data = e;
    p->lchild = p->rchild = NULL;
    return p;
}

// 计算该二叉树的深度
// 参数：二叉树根节点root
// 返回：二叉树的深度
int GetTreeDepth(BTNode* root)
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    if(!root)return 0;
    if(!root->lchild && !root->rchild)return 1;
    int deep=0;
	int deepl = GetTreeDepth(root->lchild);
    if(deep<deepl)deep=deepl;
	int deepr = GetTreeDepth(root->rchild);
    if(deep<deepr)deep=deepr;
	return deep+1;

    /********** End **********/
}

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

    /********** End **********/
}

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

    /********** End **********/
}



//
//  binary_tree.h

#ifndef binary_tree_h
#define binary_tree_h

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

typedef struct BTNode {
    char data;              //  树节点元素
    BTNode* lchild;         //  左子树指针
    BTNode* rchild;         //  右子树指针
    BTNode() {              //  树节点初始化
        lchild = NULL;
        rchild = NULL;
    }
    BTNode(char item) {     //  用元素初始化树节点
        data = item;
        lchild = NULL;
        rchild = NULL;
    }
    ~BTNode() {             //  释放树节点内存
        lchild = NULL;
        rchild = NULL;
    }
} BTNode;

//创建新结点的工具函数
BTNode* getNewNode(char e);

// 利用先序遍历创建二叉树
// 参数：先序遍历字符串s，字符串初始下标i=0，字符串长度len。
// 返回：二叉树
BTNode* CreateTree(char* s, int &i, int len);

// 计算该二叉树的深度
// 参数：二叉树根节点root
// 返回：二叉树的深度
int GetTreeDepth(BTNode* root);

// 计算该二叉树的总节点个数
// 参数：二叉树根节点root
// 返回：二叉树的总节点个数
int GetNodeNumber(BTNode* root);

// 计算该二叉树的叶子节点个数
// 参数：二叉树根节点root
// 返回：二叉树的叶子节点个数
int GetLeafNodeNumber(BTNode* root);


#endif /* binary_tree_h */

在这里插入图片描述

第4关：二叉树前序遍历递归和非递归算法

任务描述

本关任务：给定一棵二叉树，使用递归和非递归的方法实现二叉树的先（前）序遍历结果。

相关知识

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

递归法

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

递归伪代码

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

int fact(int n){
    if(n == 0)
        return 1;
    else
        return n * fact(n - 1);
}

二叉树左右子树性质

二叉树的每个节点最多只有两个分支，通常分支被称作左子树和右子树，并且二叉树的分支具有左右次序，不能颠倒。图1是一棵二叉树。
请添加图片描述

编程要求

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

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

测试说明

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

以下是平台的测试样例：

测试输入：ABC##D##EF###
预期输出：
AEFBDC
AEFBDC

测试输入：ABCD###E#F##G##
预期输出：
AGBEFCD
AGBEFCD

开始你的任务吧，祝你成功！

完整代码

//
//  binary_tree.cpp


#include "binary_tree.h"

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

    /********** End **********/
}

// 二叉树的前序遍历非递归算法
// 参数：二叉树根节点root
// 输出：二叉树的前序遍历，中间没有空格，末尾不换行。
void PreOrder_iter(BTNode* root)
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    BTNode *St[100000],*p;
    int top=-1;
    if(root!=NULL)
    {
        top++;
        St[top]=root;
        while(top>-1)
        {
            p=St[top];
            top--;
            printf("%c",p->data);
            if(p->rchild!=NULL)
            {
                top++;
                St[top]=p->rchild;
            }
            if(p->lchild!=NULL)
            {
                top++;
                St[top]=p->lchild;
            }
        }
        printf("\n");
    }

    /********** End **********/
}



//
//  binary_tree.h

#ifndef binary_tree_h
#define binary_tree_h

#include <bits/stdc++.h>

using namespace std;

typedef struct BTNode {
    char data;              //  树节点元素
    BTNode* lchild;         //  左子树指针
    BTNode* rchild;         //  右子树指针
    BTNode() {              //  树节点初始化
        lchild = NULL;
        rchild = NULL;
    }
    BTNode(char item) {     //  用元素初始化树节点
        data = item;
        lchild = NULL;
        rchild = NULL;
    }
    ~BTNode() {             //  释放树节点内存
        lchild = NULL;
        rchild = NULL;
    }
} BTNode;

//创建新结点的工具函数
BTNode* getNewNode(char e);

// 利用先序遍历创建二叉树
// 参数：先序遍历字符串s，字符串初始下标i=0，字符串长度len。
// 返回：二叉树
BTNode* CreateTree(char* s, int &i, int len);

// 二叉树的前序遍历
// 参数：二叉树根节点root
// 输出：二叉树的前序遍历，中间没有空格，末尾不换行。
void PreOrder(BTNode* root);

// 二叉树的前序遍历非递归算法
// 参数：二叉树根节点root
// 输出：二叉树的前序遍历，中间没有空格，末尾不换行。
void PreOrder_iter(BTNode* root);

#endif /* binary_tree_h */

在这里插入图片描述

第5关：二叉树中序遍历递归和非递归算法

任务描述

本关任务：给定一棵二叉树，使用递归和非递归的方法实现二叉树的中序遍历结果。

相关知识

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

递归法

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

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

int fact(int n){
    if(n == 0)
        return 1;
    else
        return n * fact(n - 1);
}

二叉树左右子树性质

二叉树的每个节点最多只有两个分支，通常分支被称作左子树和右子树，并且二叉树的分支具有左右次序，不能颠倒。图1是一棵二叉树。
请添加图片描述

编程要求

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

  • 在InOrder中使用递归算法实现二叉树中序遍历递归算法并输出结果，中间没有空格，末尾不换行。
  • 在InOrder_iter中实现二叉树的中序遍历非递归算法并输出结果，中间没有空格，末尾不换行。

测试说明

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

以下是平台的测试样例：

测试输入：ABC##D##EF###
预期输出：
CBDAFE
CBDAFE

测试输入：ABCD###E#F##G##
预期输出：
DCBEFAG
DCBEFAG

开始你的任务吧，祝你成功！

完整代码

//
//  binary_tree.cpp


#include "binary_tree.h"

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

    /********** End **********/
}

// 二叉树的中序遍历非递归算法
// 参数：二叉树根节点root
// 输出：二叉树的中序遍历，中间没有空格，末尾不换行。
void InOrder_iter(BTNode* root)
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    BTNode *St[100000],*p;
    int top=-1;
    if(root!=NULL)
    {
        p=root;
    while(top>-1||p!=NULL)
    {
        while(p!=NULL)
        {
            top++;
            St[top]=p;
            p=p->lchild;
        }
        if(top>-1)
        {
            p=St[top];
            top--;
            printf("%c",p->data);
            p=p->rchild;
        }
    }
        printf("\n");
    }


    /********** End **********/
}



//
//  binary_tree.h

#ifndef binary_tree_h
#define binary_tree_h

#include <bits/stdc++.h>

using namespace std;

typedef struct BTNode {
    char data;              //  树节点元素
    BTNode* lchild;         //  左子树指针
    BTNode* rchild;         //  右子树指针
    BTNode() {              //  树节点初始化
        lchild = NULL;
        rchild = NULL;
    }
    BTNode(char item) {     //  用元素初始化树节点
        data = item;
        lchild = NULL;
        rchild = NULL;
    }
    ~BTNode() {             //  释放树节点内存
        lchild = NULL;
        rchild = NULL;
    }
} BTNode;

//创建新结点的工具函数
BTNode* getNewNode(char e);

// 利用先序遍历创建二叉树
// 参数：先序遍历字符串s，字符串初始下标i=0，字符串长度len。
// 返回：二叉树
BTNode* CreateTree(char* s, int &i, int len);

// 二叉树的前序遍历
// 参数：二叉树根节点root
// 输出：二叉树的中序遍历，中间没有空格，末尾不换行。
void InOrder(BTNode* root);

// 二叉树的中序遍历非递归算法
// 参数：二叉树根节点root
// 输出：二叉树的中序遍历，中间没有空格，末尾不换行。
void InOrder_iter(BTNode* root);

#endif /* binary_tree_h */

在这里插入图片描述

第6关：层次遍历二叉树

任务描述

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

相关知识

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

队列基本操作

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

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

二叉树层次遍历

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

请添加图片描述

编程要求

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

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

测试说明

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

以下是平台的测试样例：

测试输入：ABC##D##EF###
预期输出：ABECDF

测试输入：ABCD###E#F##G##
预期输出：ABGCEDF

开始你的任务吧，祝你成功！

完整代码

//
//  binary_tree.cpp


#include "binary_tree.h"

// 二叉树的层次遍历（队列实现）
// 参数：二叉树根节点root
// 输出：二叉树的层次遍历，中间没有空格，末尾不换行。
void LevelOrder(BTNode* root)
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    queue<BTNode*> que;
    que.push(root);
    while(!que.empty()){
        int size=que.size();
        for(int i=1;i<=size;i++){
            BTNode* p=que.front();
            que.pop();
            cout << p->data;
            if(p->lchild)que.push(p->lchild);
            if(p->rchild)que.push(p->rchild);
        }
    }


    /********** End **********/
}


//
//  binary_tree.h

#ifndef binary_tree_h
#define binary_tree_h

#include <bits/stdc++.h>

using namespace std;

typedef struct BTNode {
    char data;              //  树节点元素
    BTNode* lchild;         //  左子树指针
    BTNode* rchild;         //  右子树指针
    BTNode() {              //  树节点初始化
        lchild = NULL;
        rchild = NULL;
    }
    BTNode(char item) {     //  用元素初始化树节点
        data = item;
        lchild = NULL;
        rchild = NULL;
    }
    ~BTNode() {             //  释放树节点内存
        lchild = NULL;
        rchild = NULL;
    }
} BTNode;

//创建新结点的工具函数
BTNode* getNewNode(char e);

// 利用先序遍历创建二叉树
// 参数：先序遍历字符串s，字符串初始下标i=0，字符串长度len。
// 返回：二叉树
BTNode* CreateTree(char* s, int &i, int len);

// 二叉树的层次遍历（队列实现）
// 参数：二叉树根节点root
// 输出：二叉树的层次遍历，中间没有空格，末尾不换行。
void LevelOrder(BTNode* root);

#endif /* binary_tree_h */

在这里插入图片描述

第7关：由前序和中序遍历序列构造二叉树

任务描述

本关任务要求采用前序遍历序列和中序遍历序列构造二叉树。

相关知识

给定一棵二叉树的前序遍历序列和中序遍历序列可以构造出这棵二叉树。例如前序序列是ABDECFG，中序序列是DBEAFCG，那么这颗二叉树的结构如图1所示。
树结点结构定义为：

struct BTNode{
        char data;
        struct BTNode* lchild;
        struct BTNode* rchild;
};

编程要求

本关任务是实现ConstructTree.cpp里的TNode* InPreToTree(char *pa, char *ia, int p1, int p2, int i1, int i2)。
该函数的功能是由前序遍历序列和中序遍历序列构造二叉树
前序序列为pa[p1:p2]
中序序列为ia[i1:i2]
返回所构造的二叉树的根指针
提示1：这是一个递归函数，在主程序中调用：
InPreToTree(pa,ia,0,n-1,0,n-1)，其中n是序列长度。
提示2：由于在DeleteTree()中是使用delete删除一个树结点，所以在InPreToTree()需要使用new来申请结点空间。

//ConstructTree.cpp
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include binary_tree.h"
/*
InPreToTree(): 由前序遍历序列和中序遍历序列构造二叉树
前序序列为pa[p1:p2]
中序序列为ia[i1:i2]
返回所构造的二叉树的根指针
*/
TNode* InPreToTree(char *pa, char *ia, 
                  int p1, int p2, int i1, int i2)
{
    //在begin和end之间添加你的代码
    /********* begin **********/
    
    /********* end ************/
}
void PrintPostTravel(BTNode* t)
{
    if(t==NULL) return;
    if(t->lchild) PrintPostTravel(t->lchild);
    if(t->rchild) PrintPostTravel(t->rchild);
    printf("%c", t->data);
}
void DeleteTree(BTNode* t)
{
    if(t==NULL) return;
    if(t->lchild) DeleteTree(t->lchild);
    if(t->rchild) DeleteTree(t->rchild);
    delete t;
}

测试说明

本关的测试过程如下：

平台编译step7/Main.cpp;
平台运行该可执行文件，并以标准输入方式提供测试输入；
平台获取该可执行文件的输出，然后将其与预期输出对比，如果一致则测试通过；否则测试失败。
输入格式：
输入前序序列
输入中序序列
输出格式：
输出后序序列

以下是平台对step7/Main.cpp的测试样例：

样例输入
ABDECFG
DBEAFCG

样例输出
Post Travel Result：DEBFGCA

开始你的任务吧，祝你成功！

完整代码

/*作答区文件*/
///
#include "binary_tree.h"
/


/**
	InPreToTree(): 由前序遍历序列和中序遍历序列构造二叉树
	前序序列为pa[p1:p2]
	中序序列为ia[i1:i2]
	返回所构造的二叉树的根指针
*/
BTNode* InPreToTree(char *pa, char *ia, int p1, int p2, int i1, int i2)
{
	/*请在BEGIN和END之间实现你的代码*/
	/*****BEGIN*****/
    BTNode *root=new BTNode;
    root->data=pa[p1];
    root->lchild=NULL;
    root->rchild=NULL;
    if(pa[p1]==pa[p2])
    return root;
    int a=i1;
    while(ia[a]!=root->data&&a<=i2)
    a++;
    if(ia[a]!=root->data)
        exit(0);
    int leftlen=a-i1;  
    if(leftlen>0)
    root->lchild=InPreToTree(pa,ia,p1+1,p1+leftlen,i1,a-1);
    int rightlen=i2-a;
    if(rightlen>0)
    root->rchild=InPreToTree(pa,ia,p2-rightlen+1,p2,a+1,i2);
    return root;

	/******END******/
}


//
//  binary_tree.h  头文件

#ifndef binary_tree_h
#define binary_tree_h

#include <bits/stdc++.h>

using namespace std;

typedef struct BTNode {
    char data;              //  树节点元素
    BTNode* lchild;         //  左子树指针
    BTNode* rchild;         //  右子树指针
    BTNode() {              //  树节点初始化
        lchild = NULL;
        rchild = NULL;
    }
    BTNode(char item) {     //  用元素初始化树节点
        data = item;
        lchild = NULL;
        rchild = NULL;
    }
    ~BTNode() {             //  释放树节点内存
        lchild = NULL;
        rchild = NULL;
    }
} BTNode;

/**
    InPreToTree(): 由前序遍历序列和中序遍历序列构造二叉树
    前序序列为pa[p1:p2]
    中序序列为ia[i1:i2]
    返回所构造的二叉树的根指针
*/
BTNode* InPreToTree(char *pa, char *ia, int p1, int p2, int i1, int i2);

#endif /* binary_tree_h */

在这里插入图片描述

第8关：由中序序列和后序序列构造二叉树

任务描述

本关任务要求采用中序遍历序列和后序遍历序列构造二叉树。

相关知识

给定一棵二叉树的中序遍历序列和后序遍历序列可以构造出这棵二叉树。例如后序序列是DEBFGCA，中序序列是DBEAFCG，那么这颗二叉树的结构如图1所示。
请添加图片描述

树结点结构定义为：

struct BTNode{
        char data;
        struct BTNode* lchild;
        struct BTNode* rchild;
};

编程要求

本关任务是实现ConstructTree.cpp里的BTNode* InPostToTree(char *post, char *in, int n)。
该函数的功能是由后序遍历序列和中序遍历序列构造二叉树
后序序列为post[0:n-1]
中序序列为in[0:n-1]
返回所构造的二叉树的根指针
提示1：这是一个递归函数，在主程序中调用：
InPostToTree(post,in,n)，其中n是序列长度。
提示2：由于在DeleteTree()中是使用delete删除一个树结点，所以在InPostToTree()需要使用new来申请结点空间。

//ConstructTree.cpp
#include "binary_tree.h"
/**
    InPostToTree(): 由后序遍历序列和中序遍历序列构造二叉树
    后序序列为post[0:n-1]
    中序序列为in[0:n-1]
    返回所构造的二叉树的根指针
*/
BTNode* InPostToTree(char *post, char *in, int n);
{
    //在begin和end之间添加你的代码
    /********* begin **********/
    
    /********* end ************/
}
void PrintPreTravel(BTNode* t)
{
    printf("%c", t->data);
    if(t==NULL) return;
    if(t->lchild) PrintPreTravel(t->lchild);
    if(t->rchild) PrintPreTravel(t->rchild);    
}
void DeleteTree(BTNode* t)
{
    if(t==NULL) return;
    if(t->lchild) DeleteTree(t->lchild);
    if(t->rchild) DeleteTree(t->rchild);
    delete t;
}

测试说明

本关的测试过程如下：

平台编译step8/Main.cpp;
平台运行该可执行文件，并以标准输入方式提供测试输入；
平台获取该可执行文件的输出，然后将其与预期输出对比，如果一致则测试通过；否则测试失败。
输入格式：
输入后序序列
输入中序序列

输出格式：
输出前序序列

以下是平台对step8/Main.cpp的测试样例：

样例输入
DEBFGCA
DBEAFCG

样例输出
Pre Travel Result：ABDECFG

开始你的任务吧，祝你成功！

完整代码

/*step8/ConstructTree.cpp 作答区文件*/
///
#include "binary_tree.h"
/


/**
	InPostToTree(): 由后序遍历序列和中序遍历序列构造二叉树
	后序序列为post[0:n-1]
	中序序列为in[0:n-1]
	返回所构造的二叉树的根指针
*/
BTNode* InPostToTree(char *post, char *in, int n)
{
	/*请在BEGIN和END之间实现你的代码*/
	/*****BEGIN*****/
    BTNode *s;
    char r,*p;
    int k;
    if (n<=0) return NULL;
    r=*(post+n-1);
    s=(BTNode *)malloc(sizeof(BTNode));
    s->data=r;
    for (p=in; p<in+n; p++)
        if (*p==r)
            break;
    k=p-in;
    s->lchild=InPostToTree(post,in,k);
    s->rchild=InPostToTree(post+k,p+1,n-k-1);
    return s;
    
	/******END******/
}
 

//
//  binary_tree.h  头文件

#ifndef binary_tree_h
#define binary_tree_h

#include <bits/stdc++.h>

using namespace std;

typedef struct BTNode {
    char data;              //  树节点元素
    BTNode* lchild;         //  左子树指针
    BTNode* rchild;         //  右子树指针
    BTNode() {              //  树节点初始化
        lchild = NULL;
        rchild = NULL;
    }
    BTNode(char item) {     //  用元素初始化树节点
        data = item;
        lchild = NULL;
        rchild = NULL;
    }
    ~BTNode() {             //  释放树节点内存
        lchild = NULL;
        rchild = NULL;
    }
} BTNode;

/**
    InPostToTree(): 由后序遍历序列和中序遍历序列构造二叉树
    后序序列为post[0:n-1]
    中序序列为in[0:n-1]
    返回所构造的二叉树的根指针
*/
BTNode* InPostToTree(char *post, char *in, int n);

#endif /* binary_tree_h */

在这里插入图片描述

第9关：二叉树的顺序存储及基本操作

任务描述

本关任务：以顺序结构存储二叉树，编写前序、中序、后序及层次顺序遍历二叉树的算法，并计算二叉树深度、所有结点总数。

相关知识

二叉树的定义

二叉树的递归定义：

  • 二叉树或者是一棵空树。
  • 或者是一棵由一个根结点和两棵互不相交的分别称做根结点的左子树和右子树所组成的非空树，左子树和右子树又同样都是一棵二叉树。

二叉树的逻辑示意图
请添加图片描述

二叉树与度为2的树的区别：

度为2的树至少有3个结点，而二叉树的结点数可以为0。
度为2的树不区分子树的次序，而二叉树中的每个结点最多有两个孩子结点，且必须要区分左右子树，即使在结点只有一棵子树的情况下也要明确指出该子树是左子树还是右子树。
二叉树的5种形态：
二叉树的五种形态
请添加图片描述

二叉树的性质

性质1 非空二叉树上叶结点数等于双分支结点数加1。即n0=n2+1。

约定：二叉树上叶结点数为n0，单分支结点数为n1，双分支结点数为n2，

性质2 非空二叉树上第i层上至多有 2

i−1
个结点，这里应有i≥1。

性质3 高度为h的二叉树至多有2

h
−1个结点（h≥1）。

满二叉树：在一棵二叉树中，当第i层的结点数为2
i−1
个时，则称此层的结点数是满的，当一棵二叉树中的每一层都满时，且叶子结点在同一层上，则称此树为满二叉树。

满二叉树特性：

  1. 除叶子结点以外的其他结点的度皆为2。

  2. 高度为h的满二叉树中的结点数为2
    h
    −1个。

  3. 层序编号：从根结点为1开始，按照层次从小到大、同一层从左到右的次序顺序编号。可以对满二叉树的结点进行连续编号。

满二叉树编号
请添加图片描述

完全二叉树：

完全二叉树：在一棵二叉树中，除最后一层外，若其余层都是满的，并且最后一层或者是满的，或者是在右边缺少连续若干个结点，则称此树为完全二叉树。

完全二叉树特性：

  1. 完全二叉树中至多只有最下边两层结点的度数小于2。

  2. 高度为h的完全二叉树若按层序编号,它与高度为h的满二叉树中结点的编号一一对应。

如下图所示的一棵完全二叉树，它与等高度的满二叉树相比，在最后一层的右边缺少了3个结点。

完全二叉树编号
请添加图片描述

性质4 对完全二叉树中编号为i的结点（1≤i≤n，n≥1，n为结点数）有：

（1）若 i⩽└ n/2 ┘，即2i≤n，则编号为i的结点为分支结点，否则为叶子结点。
（2）若n为奇数，则每个分支结点都既有左孩子结点，也有右孩子结点； 若n为偶数，则编号最大的分支结点只有左孩子结点，没有右孩子结点，其余分支结点都有左、右孩子结点。
（3）若编号为i的结点有左孩子结点，则左孩子结点的编号为2i；若编号为i的结点有右孩子结点，则右孩子结点的编号为(2i+1)。
（4）除树根结点外,若一个结点的编号为i，则它的双亲结点的编号为 └ i/2 ┘，也就是说，当i为偶数时，其双亲结点的编号为 i/2,它是双亲结点的左孩子结点，当i为奇数时，其双亲结点的编号为 (i−1)/2 ，它是双亲结点的右孩子结点。
请添加图片描述

二叉树的遍历

二叉树的遍历是指按一定的次序访问树中的所有结点，使每个结点恰好被访问一次。其中遍历次序保证了二叉树上每个结点均被访问一次且仅有一次。

二叉树常用的遍历有先序（根）遍历、中序（根）遍历、后序（根）遍历和层次遍历。

所谓先序、中序、后序，区别在于访问根结点的顺序。

1．先序遍历

若二叉树非空，则：
① 访问根结点；
② 先序遍历左子树；
③ 先序遍历右子树。
先序遍历序列的特点：其第一个元素值为二叉树中根结点值。

2．中序遍历

若二叉树非空，则：
① 中序遍历左子树；
② 访问根结点；
③ 中序遍历右子树。
中序遍历序列的特点：若已知二叉树的根结点值，以该值为界，将中序遍历序列分为两部分，前半部分为左子树的中序遍历序列，后半部分为右子树的中序遍历序列。

3．后序遍历

若二叉树非空，则：
① 后序遍历左子树；
② 后序遍历右子树；
③ 访问根结点。
后序遍历序列的特点：最后一个元素值为二叉树中根结点值。

4. 层次遍历

层次遍历是从根结点出发，按照从上向下，同一层从左向右的次序访问所有的结点。采用层次遍历得到的访问结点序列称为层次遍历序列。
层次遍历序列的特点：其第一个元素值为二叉树中根结点值。

例：图1表示一个二叉树
请添加图片描述

前序遍历：ABCDEF
中序遍历：CBDAFE
后序遍历：CDBFEA
层次遍历：ABECDF

二叉树也可以采用两种存储方式：顺序存储结构和链式存储结构。

二叉树的顺序存储结构

顺序存储一棵二叉树时，就是用一组连续的存储单元存放二叉树中的结点。

由二叉树的性质4可知，对于完全二叉树（或满二叉树），树中结点层序编号可以唯一地反映出结点之间的逻辑关系，所以可以用一维数组按从上到下、从左到右的顺序存储树中所有结点值，通过数组元素的下标关系反映完全二叉树或满二叉树中结点之间的逻辑关系。

一棵完全二叉树的顺序存储结构:

完全二叉树及其相应的顺序存储结构
请添加图片描述

一般的二叉树的顺序存储结构：

一般二叉树及其相应的顺序存储结构
请添加图片描述

二叉树顺序存储结构的类型定义如下：

typedef ElemType SqBinTree[MaxSize];

其中，ElemType为二叉树中结点的数据值类型，MaxSize为顺序表的最大长度。为了方便运算，通常将下标为0的位置空着，值为#的结点为空结点。

完全二叉树或满二叉树采用顺序存储结构比较合适，既能够最大可能地节省存储空间，又可以利用数组元素的下标确定结点在二叉树中的位置以及结点之间的关系。

对于一般二叉树，如果它接近于完全二叉树形态，需要增加的空结点个数不多，也可适合采用顺序存储结构。

如果需要增加很多空结点才能将一棵二叉树改造成为一棵完全二叉树，采用顺序存储结构会造成空间的大量浪费，这时不宜用顺序存储结构。例如：
请添加图片描述

编程要求

根据提示，在右侧编辑器补充代码。具体要求如下：

InitBiTree(SqBiTree &T)//构造空二叉树T。

CreateBiTree(SqBiTree &T)//按层序次序输入二叉树中结点的值(字符型或整型), 构造顺序存储的二叉树T

BiTreeEmpty(SqBiTree T)//判断二叉树T是否为空二叉树，若是则返回TRUE，否则FALSE

BiTreeDepth(SqBiTree T)//返回二叉树T的深度

PreOrderTraverse(SqBiTree T,void(*Visit)(TElemType))//先序遍历二叉树T，对每个结点调用函数Visit一次且仅一次

InOrderTraverse(SqBiTree T,void(*Visit)(TElemType))//中序遍历二叉树T，对每个结点调用函数Visit一次且仅一次

PostOrderTraverse(SqBiTree T,void(*Visit)(TElemType))//后序遍历二叉树T，对每个结点调用函数Visit一次且仅一次    

LevelOrderTraverse(SqBiTree T,void(*Visit)(TElemType)) // 层序遍历二叉树

测试说明

平台会对你编写的代码进行测试：

测试输入：ABCDEF###G##H

预期输出：
按先序遍历的结果为:ABDEGCFH
按中序遍历的结果为:DBGEAFHC
按后序遍历的结果为:DGEBHFCA
按层序遍历的遍历结果为:ABCDEFGH
该二叉树的高度为:4

开始你的任务吧，祝你成功！

完整代码

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>

#define OK  1
#define ERROR 0

#define MAX_TREE_SIZE  100

typedef  char TElemType ;

typedef  TElemType  SqBiTree[MAX_TREE_SIZE];

TElemType Nil='#';

void input(TElemType &x)	 // 函数变量
{
	scanf("%c",&x);
}

void visit(TElemType x)	 // 函数变量
{
	printf("%c",x);
}

void InitBiTree(SqBiTree &T)
{ // 构造空二叉树T。因为T是数组名，故不需要&
	int i;
	for(i=0;i<MAX_TREE_SIZE;i++)
		T[i]=Nil; // 初值为空(Nil在主程中定义)
}


void CreateBiTree(SqBiTree &T)
{ // 按层序次序输入二叉树中结点的值(字符型或整型), 构造顺序存储的二叉树T
	/********** Begin **********/ 
	int i=1;
	scanf("%s",T+1);
	while(T[i] != '\0')
		i++;
	T[i]='#';
	/********** End **********/
}

int BiTreeEmpty(SqBiTree T)
{ // 初始条件：二叉树T存在。操作结果：若T为空二叉树，则返回TRUE，否则FALSE
	if(T[1]==Nil) // 根结点为空，则树空
		return 1;
	else
		return 0;
}

int BiTreeDepth(SqBiTree T)
{ // 初始条件：二叉树T存在。操作结果：返回T的深度
	/********** Begin **********/ 
	int i=MAX_TREE_SIZE-1,j;
	while(T[i]=='#')
		i--;
	j=i;
	int dep=0;
	do{
		dep++;
		j=j/2;
	}while(j>=1);
	return dep;
	
	/********** End **********/
}
void PreTraverse(SqBiTree T,int e)
{ // PreOrderTraverse()调用
	/********** Begin **********/ 
	if(T[e] != '#'){
		visit(T[e]);
		PreTraverse(T,2*e);
		PreTraverse(T,2*e+1);
	}	
    
	/********** End **********/
}
void PreOrderTraverse(SqBiTree T,void(*Visit)(TElemType))
{ // 初始条件：二叉树存在，Visit是对结点操作的应用函数
	// 操作结果：先序遍历T，对每个结点调用函数Visit一次且仅一次
	if(!BiTreeEmpty(T)) // 树不空
		PreTraverse(T,1);
	printf("\n");
}

void InTraverse(SqBiTree T,int e)
{ // InOrderTraverse()调用
	/********** Begin **********/ 
	if(T[e] != '#'){
		InTraverse(T,2*e);
		visit(T[e]);
		InTraverse(T,2*e+1);
	}   
    
	/********** End **********/
}

void InOrderTraverse(SqBiTree T,void(*Visit)(TElemType))
{ // 初始条件：二叉树存在，Visit是对结点操作的应用函数
	// 操作结果：中序遍历T，对每个结点调用函数Visit一次且仅一次
	if(!BiTreeEmpty(T)) // 树不空
		InTraverse(T,1);
	printf("\n");
}

void PostTraverse(SqBiTree T,int e)
{ // PostOrderTraverse()调用
	/********** Begin **********/ 
	if(T[e] != '#'){
		PostTraverse(T,2*e);
		PostTraverse(T,2*e+1);
		visit(T[e]);
	}
	/********** End **********/
}

void PostOrderTraverse(SqBiTree T,void(*Visit)(TElemType))
{ // 初始条件：二叉树T存在，Visit是对结点操作的应用函数
	// 操作结果：后序遍历T，对每个结点调用函数Visit一次且仅一次
	if(!BiTreeEmpty(T)) // 树不空
		PostTraverse(T,1);
	printf("\n");
}

void LevelOrderTraverse(SqBiTree T,void(*Visit)(TElemType))
{ // 层序遍历二叉树
	/********** Begin **********/ 
	int dep=BiTreeDepth(T);
	int tree_max=pow(dep,2)-1;
	for(int i=1;i<tree_max;i++){
		if(T[i]=='#')
			continue;
		visit(T[i]);
	}
    printf("\n");
    
	/********** End **********/
}

int main()
{
	TElemType e;
	SqBiTree Bt,s;
	InitBiTree(Bt);
	CreateBiTree(Bt);    
	printf("按先序遍历的结果为:");
	PreOrderTraverse(Bt,visit);
	printf("按中序遍历的结果为:");
	InOrderTraverse(Bt,visit);
	printf("按后序遍历的结果为:");
	PostOrderTraverse(Bt,visit);
	printf("按层序遍历的遍历结果为:");
	LevelOrderTraverse(Bt,visit);  
	printf("该二叉树的高度为:%d\n",BiTreeDepth(Bt) );
	return 0;
}

在这里插入图片描述

剑心诀
关注
  • 43
    点赞
  • 踩
  • 45
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
层次遍历二叉树
weixin_46314022的博客
11-17 1644
void HierarchyOrder(BiTreeNode* root) // 二叉树的层次遍历（队列实现） // 参数：二叉树根节点root // 输出：二叉树的层次遍历，中间没有空格，末尾不换行。 { // 请在这里补充代码，完成本关任务 /********** Begin *********/ queue<BiTreeNode*> q; if(root!=NULL) { q.push(root); } while(!
【数据结构】—— chapter 05 二叉树的遍历和线索二叉树 (part2)
S_123789的博客
07-12 495
文章目录5.3 二叉树的遍历和线索二叉树5.3.1 二叉树的遍历1. 先序遍历2. 中序遍历3. 后序遍历4. 遍历算数表达式树5. 层次遍历6. 由遍历序列构造二叉树5.3.2 线索二叉树1. 引言2. 线索二叉树的存储结构3. 手算画出线索二叉树4. 二叉树的线索化（代码）5. 线索二叉树找前驱/后继（代码） 5.3 二叉树的遍历和线索二叉树 5.3.1 二叉树的遍历 遍历：按照某种次序把所有结点都访问一遍。 层次遍历：基于树的层次特性确定的次序规则。 先/中/后序遍历：基于树的递归特性确定的次序规则。
头歌 二叉树的二叉链表存储及基本操作
lmq886的博客
04-10 5310
【代码】头歌 二叉树的二叉链表存储及基本操作。
二叉树及其应用
2201_75986936的博客
04-28 217
平台将自动编译补全后的代码，并生成若干组测试数据，接着根据程序的输出判断程序是否正确。层次遍历要求先访问离根节点最近的层的节点，然后依次访问下一层的节点。为了完成本关任务，你需要掌握：1.队列基本操作，2.二叉树层次遍历。本关任务：给定一棵二叉树，借助队列实现层次遍历二叉树。本关的编程任务是补全右侧代码片段。
数据结构-树和二叉树
陆沉的博客
05-06 999
树的基本概念 树是由n（n≥0）个结点组成的有限集合（记为T）。 若n = 0为空树，若n > 0，这n个结点中有且仅有一个结点作为树的根结点，其余结点可分为m （m≥0）个互不相交的有限子集T1、T2、…、Tm，每个子集本身又是一棵树，称为根结点的子树。 树结构常用于表示具有层次关系的数据。一棵树 树的4种逻辑表示方法：1.树形表示法 2.文氏图表示法 3.凹入表示法 4.括号表示法 1. 结点的度与树的度     树中某个结点的子树的个数称为该结点的度
二叉树的括号表示法-＞构建二叉树
m0_74841979的博客
11-21 531
题目给出了很标准的表示法的一个样例：1(2(4,5),3);一目了然，非常标准，然而这天杀的题目居然在平台测试的时候还有这种玩意儿(一个简短的例子)1(2(3),4)。我:....... 很难想象这种不标准的括号表示法到底是谁在用。废话不多说，上硬货。事情的起因还是因为数据结构课的一个课后题，
C语言用括号表示法创建二叉树然后中序输出
LQBJY的博客
04-04 1233
(’ 表示把双亲节点存入栈，然后开辟一个新节点链接在双亲节点的左孩子上。树1：用括号表示法表示为A(B(D,E),C(F))树2:用括号表示法表示为1(2(4,5),3(6))‘,’ 表示开辟一个新节点链接在双亲节点的右孩子上。‘)’ 表示双亲节点链接结束，把双亲节点取出栈。
【数据结构】-二叉树的应用(二叉排序树)
RunningSnail的博客
08-12 3138
二叉排序树BST1.头文件及类型定义2.二叉排序树结点类型定义3.函数声明4.基本操作4.1 查找操作4.1.1 非递归查找4.1.2 递归查找4.2 插入操作4.2.1 非递归插入4.2.2 递归插入4.3 构造二叉排序树4.4 删除操作4.4.1 寻找最左下结点4.4.2 寻找最右下结点4.4.3 删除操作-用右子树中最左下结点填充4.4.4 删除操作-用左子树中最右下结点填充4.5 中序遍历4.6 main函数4.7 测试结果5.小结 1.头文件及类型定义 #include<stdio.h&gt
数据结构 线索二叉树 严蔚敏
12-14
线索二叉树是一种为了在非线性数据结构——二叉树中实现快速的前序、中序和后序遍历而设计的数据结构。这个概念由著名计算机科学家严蔚敏教授提出，它通过增加额外的线索（traversing links）来辅助遍历，使得在不...
数据结构——C语言描述习题及答案.doc
10-07
数据结构是计算机科学中至关重要的一个领域，它研究如何有效地组织和存储数据，以便于高效地访问和处理。C语言是一种强大的系统编程语言，常用于实现数据结构。 1. 数据结构指的是数据的组织方式，包括数据元素之间...
数据结构平时练习题(解答：潘江明)1
08-08
数据结构是计算机科学中的核心概念，它涉及到如何高效地组织和管理数据，以便于执行各种操作。本题涉及的知识点主要集中在数据结构的基础——线性结构、非线性...通过解答这些练习题，可以巩固和加深对数据结构的理解。
2016年考研核心考点——数据结构1
08-03
梦享团队编写的《2016年考研核心考点命题思路解密 数据结构》提供了丰富的练习题和详尽的解题思路，旨在帮助考生提高效率，举一反三。书中的题目来源于历年真题和名校期末考试，具有很高的参考价值。书中的特色包括...
《数据结构——用C语言描述(第二版)》-宁正元-电子教案
09-24
《数据结构——用C语言描述(第二版)》是由著名计算机教育专家宁正元编著的一本经典教材，主要面向计算机科学与技术专业的学生以及对数据结构感兴趣的编程爱好者。本书深入浅出地介绍了数据结构的基本概念、原理和...
C++实现二叉树(二叉链表)前序，中序，后序，层序遍历
weixin_73754150的博客
04-18 2100
若不为空，则将二叉树的根节点入队，然后开始队列不为空的判断，在此判断(循环)中：输出此结点，并对他的左右子树进行判断，左右子树不为空则进入队列，为空则直接跳过，最后再将遍历过的结点出队，这样一次判断(循环)便完成了。设二叉树中的结点均为一个字符，假设扩展二叉树的前序遍历序列有键盘输入，root为指向跟结点的指针，二叉链表的建立过程是：首先输入根节点，若输入的是一个“#”字符，则表明该二叉树为空树，也就是root=NULL；的语句顺序是：输出根节点，访问左子树，访问右子树；遍历，结果为：DGBAECF；
建立一棵用二叉树链表方式存储的二叉树，并对其进行遍历（先序，中序和后序），打印输出遍历结果
热门推荐
小白的Coding之旅
11-04 6万+
题目如下 代码如下 #include&amp;amp;amp;amp;lt;stdio.h&amp;amp;amp;amp;gt; #include&amp;amp;amp;amp;lt;stdlib.h&amp;amp;amp;amp;gt; #include&amp;amp;amp;amp;lt;malloc.h&amp;amp;amp;amp;gt; typedef struct Node//结构体 { char data;
二叉树遍历 递归算法与非递归算法
qq_41981045的博客
01-03 552
概要：本文整理了先序，中序，后续遍历算法的递归实现与非递归实现，同时会涉及到实现的原理，编程语言使用的是Java。 二叉树遍历的递归实现 节点结构如下： public static class Node { public int value; public Node left; public Node right; public Node(int data) { this....
头歌实践平台-数据结构-二叉树及其应用
toptopniba的博客
11-13 3352
【代码】头歌实践平台-数据结构-二叉树及其应用。
【数据结构】二叉树——顺序结构
Shun_Hua的博客
03-31 2775
二叉树的顺序结构，包括堆，堆排序，TOPK……
数据结构-第七章（树型查找）
最新发布
2203_75970230的博客
06-29 859
为了保证AVL树的平衡性，我们在插入删除时频繁地调整全树整体的拓扑结构，代价较大。(从目的入手，更好深入）因此，我们对二叉排序树不再进行高度平衡的限制(AVL树)，而进行适度平衡的限制(红黑树)。这样在保证查找效率的同时我们进行插入删除操作所付出的代价也更小，因此红黑树的实际应用更广泛，C++中的map和set(Java中的TreeMap和TreeSet)就是用红黑树实现的。一棵红黑树是满足如下红黑性质的二叉排序树:每个结点或是红色，或是黑色的。根结点是黑色的。
C语言实现：中序遍历二叉树的非递归算法
04-30
中序遍历二叉树的非递归算法可以借助栈来实现。具体步骤如下： 1. 创建一个空栈。 2. 将根节点入栈。 3. 当栈非空时，重复以下步骤： - 将栈顶节点出栈，输出它的值。 - 如果该节点有右子树，则将右子树入栈。 - 如果该节点没有右子树且有左子树，则将左子树入栈。 4. 当栈为空时，遍历结束。 下面是该算法的 C 语言实现： ```c #include <stdio.h> #include <stdlib.h> // 定义二叉树节点结构体 typedef struct Node { int data; struct Node *left; struct Node *right; } Node, *Tree; // 定义栈结构体 typedef struct Stack { Node *data[100]; // 栈的最大容量为 100 int top; // 栈顶指针 } Stack; // 初始化栈 void init(Stack *s) { s->top = -1; } // 判断栈是否为空 int is_empty(Stack *s) { return s->top == -1; } // 判断栈是否已满 int is_full(Stack *s) { return s->top == 99; } // 入栈 void push(Stack *s, Node *node) { if (is_full(s)) { printf("Error: Stack is full!\n"); return; } s->top++; s->data[s->top] = node; } // 出栈 Node* pop(Stack *s) { if (is_empty(s)) { printf("Error: Stack is empty!\n"); return NULL; } Node *node = s->data[s->top]; s->top--; return node; } // 中序遍历二叉树的非递归算法 void inorder_traversal(Tree tree) { if (tree == NULL) { return; } Stack s; init(&s); Node *p = tree; while (p || !is_empty(&s)) { while (p) { push(&s, p); p = p->left; } if (!is_empty(&s)) { p = pop(&s); printf("%d ", p->data); p = p->right; } } } // 创建二叉树 Tree create_tree() { Tree tree; int data; scanf("%d", &data); if (data == -1) { // 输入 -1 表示该节点为空 tree = NULL; } else { tree = (Tree)malloc(sizeof(Node)); tree->data = data; tree->left = create_tree(); tree->right = create_tree(); } return tree; } int main() { Tree tree = create_tree(); printf("中序遍历二叉树的结果为：\n"); inorder_traversal(tree); printf("\n"); return 0; } ``` 注意，这里的二叉树节点数据类型是 `Node`，而不是 `int`，因为每个节点包含了左右子树的指针。同时，这里的栈使用了数组实现，最大容量为 100，如果需要更大的容量可以根据实际情况进行修改。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

剑心诀

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值