二叉树与查找PTA练习题

集美大学课程实验报告-实验4：树、二叉树与查找

项目名称	内容
课程名称	数据结构
班级	网安2411
指导教师	郑如滨
学生姓名	吴承桓
学号	202421336026
实验项目名称	树、二叉树与查找
上机实践日期	2025/4/25
上机实践时间	2学时

一、目的（本次实验所涉及并要求掌握的知识点）

以下内容请根据实际情况编写

掌握创建二叉树与树及二叉树上的基本操作
熟练掌握熟练掌握树的递归结构及在其上的递归算法
掌握二叉树的层次遍历

二、实验内容与设计思想

以下请根据实际情况编写

题目1：先序序列创建二叉树

程序相关伪代码

伪代码
    算法：前序序列创建二叉树及中序遍历

数据结构：
  结构体 TreeNode:
    字符 data
    TreeNode* left
    TreeNode* right
    构造函数(字符 x):
      data ← x
      left ← null
      right ← null

函数 createTree(字符串 str, 整型引用 index):
  如果 index ≥ str的长度 或 str[index] = '#':
    index ← index + 1
    返回 null
  否则:
    node ← 新建 TreeNode(str[index])
    index ← index + 1
    node.left ← createTree(str, index)
    node.right ← createTree(str, index)
    返回 node

函数 inorderTraversal(TreeNode* root):
  如果 root = null:
    返回
  inorderTraversal(root.left)
  输出 root.data + " "
  inorderTraversal(root.right)

函数 freeTree(TreeNode* root):
  如果 root = null:
    返回
  freeTree(root.left)
  freeTree(root.right)
  删除 root

主程序：
  当 读取到字符串 str:
    index ← 0
    root ← createTree(str, index)
    inorderTraversal(root)
    输出 换行
    freeTree(root)
  返回 0

程序代码

#include <iostream>
#include <string>

using namespace std;

struct TreeNode {
    char data;
    TreeNode* left;
    TreeNode* right;
    TreeNode(char x) : data(x), left(nullptr), right(nullptr) {}
};

TreeNode* createTree(const string& str, int& index) {
    if (index >= str.size() || str[index] == '#') {
        index++;
        return nullptr;
    }
    TreeNode* node = new TreeNode(str[index]);
    index++;
    node->left = createTree(str, index);
    node->right = createTree(str, index);
    return node;
}

void inorderTraversal(TreeNode* root) {
    if (root == nullptr) {
        return;
    }
    inorderTraversal(root->left);
    cout << root->data << " ";
    inorderTraversal(root->right);
}

void freeTree(TreeNode* root) {
    if (root == nullptr) {
        return;
    }
    freeTree(root->left);
    freeTree(root->right);
    delete root;
}

int main() {
    string str;
    while (cin >> str) {
        int index = 0;
        TreeNode* root = createTree(str, index);
        inorderTraversal(root);
        cout << endl;
        freeTree(root);
    }
    return 0;
}

题目2：先序输出叶子节点

函数相关伪代码

伪代码
     函数 先序打印叶子节点(二叉树节点 BT)
    如果 BT 为空 则
        返回
    结束如果
    
    如果 BT的左子为空 且 BT的右子为空 则
        输出 " " + BT.数据
        返回
    结束如果
    
    递归调用 先序打印叶子节点(BT的左子)
    递归调用 先序打印叶子节点(BT的右子)
结束函数

函数代码

相关主要代码
     void PreorderPrintLeaves( BinTree BT )
{
    if(BT==NULL)return;
    if(BT->Left==NULL&&BT->Right==NULL)
    {
        printf(" %c",BT->Data);
        return;
    }
    PreorderPrintLeaves(BT->Left);
    PreorderPrintLeaves(BT->Right);
}

题目3：求二叉树高度

函数相关伪代码

伪代码
  函数 获取树高(二叉树节点 BT)
    如果 BT 为空 则
        返回 0
    结束如果
    
    左子树高度 ← 递归调用 获取树高(BT的左子)
    右子树高度 ← 递归调用 获取树高(BT的右子)
    
    如果 左子树高度 > 右子树高度 则
        返回 左子树高度 + 1
    否则
        返回 右子树高度 + 1
    结束如果
结束函数

函数代码

相关主要代码
   int GetHeight( BinTree BT )
{
    if(BT==NULL) return 0;
    int lefthigh=GetHeight(BT->Left);
    int righthigh=GetHeight(BT->Right);
    return (lefthigh>righthigh)?(lefthigh+1):(righthigh+1);
}

题目4：二叉树层次遍历

程序相关伪代码

伪代码
// 定义树节点结构
结构体 TreeNode {
    字符 val
    TreeNode* left
    TreeNode* right
}

// 递归构建二叉树
函数 buildTree(字符串 s, 整数 index) -> TreeNode*:
    如果 index >= s的长度 或 s[index] == '#':
        返回 空指针
    创建新节点 node，值为 s[index]
    node的左子节点 = buildTree(s, 2 * index)
    node的右子节点 = buildTree(s, 2 * index + 1)
    返回 node

// 层次遍历二叉树
函数 levelOrder(TreeNode* root):
    如果 root 为空:
        输出 "NULL"
        返回
    初始化队列 q
    将 root 加入队列 q
    布尔值 first = true
    当 q 不为空:
        取出队列首节点 node
        如果 first 为 false:
            输出 " "
        输出 node.val
        first = false
        如果 node.left 不为空:
            将 node.left 加入队列 q
        如果 node.right 不为空:
            将 node.right 加入队列 q
    输出换行

// 主程序
主函数:
    读取输入字符串 s
    如果 s 的长度 <= 1:
        输出 "NULL"
        返回
    root = buildTree(s, 1)
    levelOrder(root)
    返回 0

程序代码

相关主要代码
#include <iostream>
#include <queue>
#include <string>
using namespace std;

struct TreeNode {
    char val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(char x) : val(x), left(nullptr), right(nullptr) {}
};

TreeNode* buildTree(const string& s, int index) {
    if (index >= s.size() || s[index] == '#') {
        return nullptr;
    }
    TreeNode* node = new TreeNode(s[index]);
    node->left = buildTree(s, 2 * index);
    node->right = buildTree(s, 2 * index + 1);
    return node;
}

void levelOrder(TreeNode* root) {
    if (!root) {
        cout << "NULL" << endl;
        return;
    }
    queue<TreeNode*> q;
    q.push(root);
    bool first = true;
    while (!q.empty()) {
        TreeNode* node = q.front();
        q.pop();
        if (!first) {
            cout << " ";
        }
        cout << node->val;
        first = false;
        if (node->left) {
            q.push(node->left);
        }
        if (node->right) {
            q.push(node->right);
        }
    }
    cout << endl;
}

int main() {
    string s;
    getline(cin, s);
    if (s.size() <= 1) {
        cout << "NULL" << endl;
        return 0;
    }
    TreeNode* root = buildTree(s, 1);
    levelOrder(root);
    return 0;
}