实验06 二叉树遍历及应用2022

已于 2023-02-18 16:13:39 修改
阅读量510 收藏 1
点赞数
分类专栏： 数据结构实验 文章标签： 数据结构 c++ Powered by 金山文档
于 2023-02-17 09:42:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62431082/article/details/129078621
版权

A. 【程序填空】二叉树三种遍历

题目描述

给定一颗二叉树的特定先序遍历结果，空树用字符‘0’表示，例如AB0C00D00表示如下图

请完成以下程序填空，建立该二叉树的二叉链式存储结构，并输出该二叉树的先序遍历、中序遍历和后序遍历结果

输入

第一行输入一个整数t，表示有t个二叉树

第二行起输入每个二叉树的特定先序遍历结果，空树用字符‘0’表示，连续输入t行

输出

每个二叉树输出三行，对应先序遍历、中序遍历和后序遍历结果

输入：

2
AB0C00D00
AB00C00

输出：

ABCD
BCAD
CBDA
ABC
BAC
BCA

代码：

#include <iostream>
#include <string>
using namespace std;
class BiTreeNode {
public:
    char  data;                    //数据域
    BiTreeNode* leftChild, * rightChild;    //左右子树指针
    BiTreeNode() :leftChild(NULL), rightChild(NULL) {}
    ~BiTreeNode() {}
};

class BiTree {
private:
    BiTreeNode* root;    //根结点指针
    string sTree;        //建树字符串
    int pos;            //标识建树字符串的当前字符位置
    BiTreeNode* CreateTree();//建树私有函数
    void PreOrder(BiTreeNode* t);    //先序遍历实现
    void InOrder(BiTreeNode* t);    //中序遍历实现
    void PostOrder(BiTreeNode* t);    //后序遍历实现
public:
    BiTree() :root(NULL) {};
    void Create(string vArray);    //建树公有接口，参数是特定的先序遍历字符串
    void PreOrder();            //先序遍历公有接口
    void InOrder();                //中序遍历公有接口
    void PostOrder();            //后序遍历公有接口
};
//二叉树公有接口的实现
void BiTree::Create(string vArray)
{
    pos = 0;
    sTree.assign(vArray);    //把参数保存到内部字符串
    root = CreateTree();    //建树成功后root指向根结点
}
void BiTree::PreOrder()
{
    PreOrder(root);
}
void BiTree::InOrder()
{
    InOrder(root);
}
void BiTree::PostOrder()
{
    PostOrder(root);
}

//请完成上述类内部的私有函数实现
/********** Write your code here! **********/
BiTreeNode* BiTree::CreateTree() {
    BiTreeNode* T=new BiTreeNode;
    char c = sTree[pos++];
    if (c == '0') T = NULL;
    else {
        T->data = c;
        T->leftChild=CreateTree();
        T->rightChild =CreateTree();
    }
    return T;
}

void BiTree::PreOrder(BiTreeNode* t) {
    if (t == NULL) return;
    else {
        cout << t->data;
        PreOrder(t->leftChild);
        PreOrder(t->rightChild);
    }
}
void BiTree::InOrder(BiTreeNode* t) {
    if (t == NULL) return;
    else {
        InOrder(t->leftChild);
        cout << t->data;
        InOrder(t->rightChild);
    }
}

void BiTree::PostOrder(BiTreeNode* t) {
    if (t == NULL) return;
    else {
        PostOrder(t->leftChild);
        PostOrder(t->rightChild);
        cout << t->data;
    }
}
/*******************************************/
//主函数
int main()
{
    int t;
    string vArray;
    cin >> t;
    while (t--)
    {
        cin >> vArray;
        BiTree myTree;
        myTree.Create(vArray);
        myTree.PreOrder();        cout << endl;
        myTree.InOrder();        cout << endl;
        myTree.PostOrder();        cout << endl;
    }
    return 0;
}

B. DS二叉树--叶子数量

题目描述

计算一颗二叉树包含的叶子结点数量。

提示：叶子是指它的左右孩子为空。

建树方法采用“先序遍历+空树用0表示”的方法，即给定一颗二叉树的先序遍历的结果为AB0C00D00，其中空节点用字符‘0’表示。则该树的逻辑结构如下图。

输入

第一行输入一个整数t，表示有t个测试数据

第二行起输入二叉树先序遍历的结果，空树用字符‘0’表示，输入t行

输出

逐行输出每个二叉树的包含的叶子数量

输入：

3
AB0C00D00
AB00C00
ABC00D00E00

输出：

2
2
3

代码：

#include <iostream>
#include <string>
using namespace std;
class BiTreeNode {
public:
    char  data;                    //数据域
    BiTreeNode* leftChild, * rightChild;    //左右子树指针
    BiTreeNode() :leftChild(NULL), rightChild(NULL) {}
    ~BiTreeNode() {}
};

class BiTree {
private:
    BiTreeNode* root;    //根结点指针
    string sTree;        //建树字符串
    int pos;            //标识建树字符串的当前字符位置
    BiTreeNode* CreateTree();//建树私有函数
    void PreOrder(BiTreeNode* t);    //先序遍历实现
    void InOrder(BiTreeNode* t);    //中序遍历实现
    void PostOrder(BiTreeNode* t);    //后序遍历实现
    int Leafnum(BiTreeNode* t);
public:
    BiTree() :root(NULL) {};
    void Create(string vArray);    //建树公有接口，参数是特定的先序遍历字符串
    void PreOrder();            //先序遍历公有接口
    void InOrder();                //中序遍历公有接口
    void PostOrder();            //后序遍历公有接口
    int Leafnum();
};
//二叉树公有接口的实现
void BiTree::Create(string vArray)
{
    pos = 0;
    sTree.assign(vArray);    //把参数保存到内部字符串
    root = CreateTree();    //建树成功后root指向根结点
}
void BiTree::PreOrder()
{
    PreOrder(root);
}
void BiTree::InOrder()
{
    InOrder(root);
}
void BiTree::PostOrder()
{
    PostOrder(root);
}

int BiTree::Leafnum() {
     return Leafnum(root);
}
//请完成上述类内部的私有函数实现
/********** Write your code here! **********/
BiTreeNode* BiTree::CreateTree() {
    BiTreeNode* T = new BiTreeNode;
    char c = sTree[pos++];
    if (c == '0') T = NULL;
    else {
        T->data = c;
        T->leftChild = CreateTree();
        T->rightChild = CreateTree();
    }
    return T;
}

void BiTree::PreOrder(BiTreeNode* t) {
    if (t == NULL) return;
    else {
        cout << t->data;
        PreOrder(t->leftChild);
        PreOrder(t->rightChild);
    }
}
void BiTree::InOrder(BiTreeNode* t) {
    if (t == NULL) return;
    else {
        InOrder(t->leftChild);
        cout << t->data;
        InOrder(t->rightChild);
    }
}

void BiTree::PostOrder(BiTreeNode* t) {
    if (t == NULL) return;
    else {
        PostOrder(t->leftChild);
        PostOrder(t->rightChild);
        cout << t->data;
    }
}
int BiTree::Leafnum(BiTreeNode* t) {
    if (t == NULL) return 0;
    else if ((t->leftChild == NULL) && (t->rightChild == NULL)) return 1;
    else return Leafnum(t->leftChild) + Leafnum(t->rightChild);

}
/*******************************************/
//主函数
int main()
{
    int t;
    string vArray;
    cin >> t;
    while (t--)
    {
        cin >> vArray;
        BiTree myTree;
        myTree.Create(vArray);
        cout << myTree.Leafnum()<<endl;
    }
    return 0;
}

C. DS二叉树——二叉树之父子结点

题目描述

给定一颗二叉树的逻辑结构如下图，（先序遍历的结果，空树用字符‘0’表示，例如AB0C00D00），建立该二叉树的二叉链式存储结构。

编写程序输出该树的所有叶子结点和它们的父亲结点

输入

第一行输入一个整数t，表示有t个二叉树

第二行起，按照题目表示的输入方法，输入每个二叉树的先序遍历，连续输入t行

输出

第一行按先序遍历，输出第1个示例的叶子节点

第二行输出第1个示例中与叶子相对应的父亲节点

以此类推输出其它示例的结果

输入：

3
AB0C00D00
AB00C00
ABCD0000EF000

输出：

C D 
B A 
B C 
A A 
D F 
C E

代码:

#include <iostream>
#include <string>
#include <queue>

using namespace std;

class biTreeNode {
public:
    char data;
    biTreeNode *lChild, *rChild;

    biTreeNode() : lChild(NULL), rChild(NULL) {}

    ~biTreeNode();
};

class biTree {
    biTreeNode *root;
    string s;
    int pos;

    biTreeNode *create();


    void findF(biTreeNode *t, char ch);

public:
    queue<char> q;

    biTree() : root(NULL) {}

    void create(string a);

    void find() { findF(root, root->data); }
};

void biTree::create(string a) {
    pos = 0;
    s.assign(a);
    root = create();
}

biTreeNode *biTree::create() {
    biTreeNode *t;
    char ch = s[pos++];
    if (ch == '0')
        t = NULL;
    else {
        t = new biTreeNode();
        t->data = ch;
        t->lChild = create();
        t->rChild = create();
    }
    return t;
}


void biTree::findF(biTreeNode *t, char ch) {
    if (t) {
        if (!t->lChild && !t->rChild) {
            cout << t->data << ' ';
            q.push(ch);
        }
        findF(t->lChild, t->data);
        findF(t->rChild, t->data);
    }
}

int main() {
    int t;
    cin >> t;
    while (t--) {
        biTree test;
        string s;
        cin >> s;
        test.create(s);
        test.find();
        cout << endl;
        while (!test.q.empty()) {
            cout << test.q.front() << ' ';
            test.q.pop();
        }
        cout << endl;
    }
    return 0;
}

D. DS树--二叉树高度

题目描述

给出一棵二叉树，求它的高度。二叉树的创建采用前面实验的方法。

注意，二叉树的层数是从1开始

输入

第一行输入一个整数t，表示有t个二叉树

第二行起输入每个二叉树的先序遍历结果，空树用字符‘0’表示，连续输入t行

输出

每行输出一个二叉树的高度

输入：

1
AB0C00D00

输出：

3

代码：

#include <iostream>
#include <string>
using namespace std;
class BiTreeNode {
public:
    char  data;                    //数据域
    BiTreeNode* leftChild, * rightChild;    //左右子树指针
    BiTreeNode() :leftChild(NULL), rightChild(NULL) {}
    ~BiTreeNode() {}
};

class BiTree {
private:
    BiTreeNode* root;    //根结点指针
    string sTree;        //建树字符串
    int pos;            //标识建树字符串的当前字符位置
    BiTreeNode* CreateTree();//建树私有函数
    void PreOrder(BiTreeNode* t);    //先序遍历实现
    void InOrder(BiTreeNode* t);    //中序遍历实现
    void PostOrder(BiTreeNode* t);    //后序遍历实现
    int Leafnum(BiTreeNode* t);
    int depth(BiTreeNode* t);
public:
    BiTree() :root(NULL) {};
    void Create(string vArray);    //建树公有接口，参数是特定的先序遍历字符串
    void PreOrder();            //先序遍历公有接口
    void InOrder();                //中序遍历公有接口
    void PostOrder();            //后序遍历公有接口
    int Leafnum();
    int depth();
};
//二叉树公有接口的实现
void BiTree::Create(string vArray)
{
    pos = 0;
    sTree.assign(vArray);    //把参数保存到内部字符串
    root = CreateTree();    //建树成功后root指向根结点
}
void BiTree::PreOrder()
{
    PreOrder(root);
}
void BiTree::InOrder()
{
    InOrder(root);
}
void BiTree::PostOrder()
{
    PostOrder(root);
}

int BiTree::Leafnum() {
    return Leafnum(root);
}
int BiTree::depth() {
    return depth(root);
}
//请完成上述类内部的私有函数实现
/********** Write your code here! **********/
BiTreeNode* BiTree::CreateTree() {
    BiTreeNode* T = new BiTreeNode;
    char c = sTree[pos++];
    if (c == '0') T = NULL;
    else {
        T->data = c;
        T->leftChild = CreateTree();
        T->rightChild = CreateTree();
    }
    return T;
}

void BiTree::PreOrder(BiTreeNode* t) {
    if (t == NULL) return;
    else {
        cout << t->data;
        PreOrder(t->leftChild);
        PreOrder(t->rightChild);
    }
}
void BiTree::InOrder(BiTreeNode* t) {
    if (t == NULL) return;
    else {
        InOrder(t->leftChild);
        cout << t->data;
        InOrder(t->rightChild);
    }
}

void BiTree::PostOrder(BiTreeNode* t) {
    if (t == NULL) return;
    else {
        PostOrder(t->leftChild);
        PostOrder(t->rightChild);
        cout << t->data;
    }
}
int BiTree::Leafnum(BiTreeNode* t) {
    if (t == NULL) return 0;
    else if ((t->leftChild == NULL) && (t->rightChild == NULL)) return 1;
    else return Leafnum(t->leftChild) + Leafnum(t->rightChild);
}
int BiTree::depth(BiTreeNode* t) {
    if (t == NULL) return 0;
    else  return depth(t->leftChild) > depth(t->rightChild) ? depth(t->leftChild) + 1 : depth(t->rightChild) + 1;
}
/*******************************************/
//主函数
int main()
{
    int t;
    string vArray;
    cin >> t;
    while (t--)
    {
        cin >> vArray;
        BiTree myTree;
        myTree.Create(vArray);
        cout << myTree.depth() << endl;
    }
    return 0;
}

E. DS二叉树--层次遍历

题目描述

层次遍历二叉树，是从根结点开始遍历，按层次次序“自上而下，从左至右”访问树中的各结点。

建树方法采用“先序遍历+空树用0表示”的方法

要求：采用队列对象实现，函数框架如下：

输入

第一行输入一个整数t，表示有t个测试数据

第二行起输入二叉树先序遍历的结果，空树用字符‘0’表示，输入t行

输出

逐行输出每个二叉树的层次遍历结果

输入：

2
AB0C00D00
ABCD00E000FG00H0I00

输出：

ABDC
ABFCGHDEI

代码：

#include <iostream>
#include <string>
#include<queue>
using namespace std;
class BiTreeNode {
public:
    char  data;                    //数据域
    BiTreeNode* leftChild, * rightChild;    //左右子树指针
    BiTreeNode() :leftChild(NULL), rightChild(NULL) {}
    ~BiTreeNode() {}
};

class BiTree {
private:
    BiTreeNode* root;    //根结点指针
    string sTree;        //建树字符串
    int pos;            //标识建树字符串的当前字符位置
    BiTreeNode* CreateTree();//建树私有函数
    void PreOrder(BiTreeNode* t);    //先序遍历实现
    void InOrder(BiTreeNode* t);    //中序遍历实现
    void PostOrder(BiTreeNode* t);    //后序遍历实现
    int Leafnum(BiTreeNode* t);
    int depth(BiTreeNode* t);
    void leaf(BiTreeNode* t);
    void levelOrder(BiTreeNode* t);
public:
    BiTree() :root(NULL) {};
    void Create(string vArray);    //建树公有接口，参数是特定的先序遍历字符串
    void PreOrder();            //先序遍历公有接口
    void InOrder();                //中序遍历公有接口
    void PostOrder();            //后序遍历公有接口
    int Leafnum();
    int depth();
    void leaf();
    void levelOrder();
};
queue<BiTreeNode*> bt;
bool isleaf(BiTreeNode* t) {
    if ((t->leftChild == NULL) && (t->rightChild == NULL)) return true;
    else return false;
}
//二叉树公有接口的实现
void BiTree::Create(string vArray)
{
    pos = 0;
    sTree.assign(vArray);    //把参数保存到内部字符串
    root = CreateTree();    //建树成功后root指向根结点
}
void BiTree::PreOrder()
{
    PreOrder(root);
}
void BiTree::InOrder()
{
    InOrder(root);
}
void BiTree::PostOrder()
{
    PostOrder(root);
}
int BiTree::Leafnum() {
    return Leafnum(root);
}
int BiTree::depth() {
    return depth(root);
}
void BiTree::leaf() {
    leaf(root);
}
void BiTree::levelOrder() {
    levelOrder(root);
}
//请完成上述类内部的私有函数实现
/********** Write your code here! **********/
BiTreeNode* BiTree::CreateTree() {
    BiTreeNode* T = new BiTreeNode;
    char c = sTree[pos++];
    if (c == '0') T = NULL;
    else {
        T->data = c;
        T->leftChild = CreateTree();
        T->rightChild = CreateTree();
    }
    return T;
}

void BiTree::PreOrder(BiTreeNode* t) {
    if (t == NULL) return;
    else {
        cout << t->data;
        PreOrder(t->leftChild);
        PreOrder(t->rightChild);
    }
}
void BiTree::InOrder(BiTreeNode* t) {
    if (t == NULL) return;
    else {
        InOrder(t->leftChild);
        cout << t->data;
        InOrder(t->rightChild);
    }
}

void BiTree::PostOrder(BiTreeNode* t) {
    if (t == NULL) return;
    else {
        PostOrder(t->leftChild);
        PostOrder(t->rightChild);
        cout << t->data;
    }
}

int BiTree::Leafnum(BiTreeNode* t) {
    if (t == NULL) return 0;
    else if ((t->leftChild == NULL) && (t->rightChild == NULL)) return 1;
    else return Leafnum(t->leftChild) + Leafnum(t->rightChild);
}

int BiTree::depth(BiTreeNode* t) {
    if (t == NULL) return 0;
    else  return depth(t->leftChild) > depth(t->rightChild) ? depth(t->leftChild) + 1 : depth(t->rightChild) + 1;
}

void BiTree::leaf(BiTreeNode* t) {
    if (t == NULL) return;
    else if (isleaf(t)) {
        bt.push(t);
        cout << t->data << " ";
    }
    else {
        leaf(t->leftChild);
        leaf(t->rightChild);
    }
}

void BiTree::levelOrder(BiTreeNode* t) {
        queue<BiTreeNode*>tq;
        BiTreeNode* p = t;
        if (p) tq.push(p);
        while (!tq.empty()) {
            cout << tq.front()->data ;
            if (tq.front()->leftChild) tq.push(tq.front()->leftChild);
            if (tq.front()->rightChild) tq.push(tq.front()->rightChild);
            tq.pop();
        }
}

/*******************************************/
//主函数
int main()
{
    int t;
    string vArray;
    cin >> t;
    while (t--)
    {
        cin >> vArray;
        BiTree myTree;
        myTree.Create(vArray);
        myTree.levelOrder();
        cout << endl;
    }
    return 0;
}

F. DS二叉树—二叉树结点的最大距离

题目描述

二叉树两个结点的距离是一个结点经过双亲结点，祖先结点等中间结点到达另一个结点经过的分支数。二叉树结点的最大距离是所有结点间距离的最大值。例如，下图所示二叉树结点最大距离是3，C和D的距离。

二叉树用先序遍历顺序创建，#表示空树。计算二叉树结点最大距离和最大距离的两个结点(假设二叉树中取最大距离的两个结点唯一）。

输入

测试次数T

第2行之后的T行，每行为一棵二叉树先序遍历结果（#表示空树）

输出

对每棵二叉树，输出树的结点最大距离和最大距离的结点，输出格式见样例。

输入：

3
A##
ABC##EF#G###D##
ABEH###F#K###

输出：

0:
5:G D
4:H K

代码：

#include<iostream>
using namespace std;
int* road;
char* Left;
char* Right;
int temp = 0;
class Node {
public:
    char data;
    Node* left;
    Node* right;
    Node() { left = right = NULL; }
    ~Node() { delete left; delete right; }
};
class Tree {
public:
    Node* root;
    int pos;
    string treestr;
    int deep,leftdeep, rightdeep;
    char c, leftc, rightc;
    Tree(string s);
    Node* creat();
    void countdeep(Node *p,int num);
    void countrightdeep(Node *p);
    void countleftdeep(Node *p);
    void pre(Node* p);
};
Tree::Tree(string s) {
    treestr = s;
    pos = leftdeep = rightdeep = deep = 0;
    root = creat();
}
Node* Tree::creat() {
    char ch = treestr[pos++];
    if (ch == '#') return NULL;
    else {
        Node* node=new Node;
        node->data = ch;
        node->left = creat();
        node->right = creat();
        return node;
    }
}
void Tree::countdeep(Node *p,int num) {
    if (p != NULL) {
        num++;
        if (p->left == NULL && p->right == NULL) {
            if (deep < num) {
                deep = num;
                c = p->data;
            }
        }
        countdeep(p->left, num);
        countdeep(p->right, num);
    }
}
void Tree::countleftdeep(Node* p) {
    if (p->left == NULL) {
        leftdeep = 0;
        leftc = p->data;
        return;
    }
    p = p->left;
    countdeep(p, 0);
    leftdeep = deep;
    leftc = c;
}
void Tree::countrightdeep(Node* p) {
    if (p->right == NULL) {
        rightdeep = 0;
        rightc = p->data;
        return;
    }
    p = p->right;
    countdeep(p, 0);
    rightdeep = deep;
    rightc = c;
}
void Tree::pre(Node* p) {
    if (p != NULL) {
        deep = 0; countleftdeep(p);
        deep = 0; countrightdeep(p);
        road[temp]= leftdeep + rightdeep;
        Left[temp] = leftc;
        Right[temp++] = rightc;
        pre(p->left);
        pre(p->right);
    }
}
int main() {
    int t; cin>>t;
    while (t--) {
        road = new int[1000];
        Left = new char[1000];
        Right = new char[1000];
        temp = 0;
        string s; cin >> s;
        Tree tree(s);
        tree.pre(tree.root);
        int max = road[0],index=0;
        for (int i = 0; i < temp; i++) {
            if (road[i] > max) index = i;
        }
        cout << road[index] << ":";
        if (road[index] != 0) cout << Left[index] << " " << Right[index] << endl;
        else cout << endl;
    }
}
要被ddl噶辣
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
问题 E: DS二叉树—二叉树结点的最大距离
m0_52258325的博客
05-08 1577
题目描述 二叉树两个结点的距离是一个结点经过双亲结点，祖先结点等中间结点到达另一个结点经过的分支数。二叉树结点的最大距离是所有结点间距离的最大值。例如，下图所示二叉树结点最大距离是3，C和D的距离。 二叉树用先序遍历顺序创建，#表示空树。计算二叉树结点最大距离和最大距离的两个结点(假设二叉树中取最大距离的两个结点唯一）。 输入 测试次数T 第2行之后的T行，每行为一棵二叉树先序遍历结果（#表示空树） 输出 对每棵二叉树，输出树的结点最大距离和最大距离...
问题 A: DS二叉树--层次遍历
m0_52258325的博客
05-08 692
题目描述 层次遍历二叉树，是从根结点开始遍历，按层次次序“自上而下，从左至右”访问树中的各结点。 建树方法采用“先序遍历+空树用0表示”的方法 要求：采用队列对象实现，函数框架如下： 输入 第一行输入一个整数t，表示有t个测试数据 第二行起输入二叉树先序遍历的结果，空树用字符‘0’表示，输入t行 输出 逐行输出每个二叉树的层次遍历结果 样例输入 2 AB0C00D00 ABCD00E000FG00H0I00 样例输出 ABDC ABFCGHDEI 提示 ...
数据结构二叉树的遍历
qq_48639334的博客
08-02 1225
数据结构二叉树的遍历，包括创建二叉树、先序遍历、中序遍历、后序遍历、层次遍历
DS二叉树—二叉树结点的最大距离
m0_64068846的博客
12-29 1093
二叉树两个结点的距离是一个结点经过双亲结点，祖先结点等中间结点到达另一个结点经过的分支数。二叉树结点的最大距离是所有结点间距离的最大值。例如，下图所示二叉树结点最大距离是3，C和D的距离。找最大距离：先写一个求树高的函数，然后遍历所有结点，找到结点左右子树的树高之和的最大值，即为最大的距离，保存这个最大距离为max和这个结点为maxNode。计算二叉树结点最大距离和最大距离的两个结点(假设二叉树中取最大距离的两个结点唯一）。对每棵二叉树，输出树的结点最大距离和最大距离的结点，输出格式见样例。
二叉树代码
luolvzhou的博客
02-25 560
#include&lt;iostream&gt; using namespace std; typedef struct BiTNode {     char data;     struct BiTNode *lchild, *rchild; }BiTNode, *BiTree; void PreOrderTraverse(BiTree T)//二叉树的先序遍历 {     if (T == N...
DS数据结构
最新发布
m0_63511215的博客
02-21 593
二叉树两个结点的距离是一个结点经过双亲结点，祖先结点等中间结点到达另一个结点经过的分支数。给定一颗二叉树的逻辑结构如下图，（先序遍历的结果，空树用字符‘#’表示，例如AB#C##D##），建立该二叉树的二叉链式存储结构，并输出该二叉树的先序遍历、中序遍历和后序遍历结果。输入图的顶点信息和边信息，完成邻接矩阵的设置，并计算各顶点的入度、出度和度，并输出图中的孤立点（度为0的顶点）每行输出一个要查找的数值在队列的位置和查找次数，数据之间用短划线隔开，如果查找不成功，输出字符串error。孤立点的度信息不输出。
二叉树的遍历实验报告.pdf
11-11
1. 二叉树遍历的概念与目的： 遍历二叉树是为了访问树中的所有节点，按照特定的顺序执行操作，如查找、插入或删除节点。在二叉树的应用中，遍历常用于解决问题，如查找特定属性的节点，或者对所有节点进行统一处理。...
数据结构实验9二叉树遍历的应用.doc
09-25
数据结构实验9二叉树遍历的应用.doc
数据结构实验 二叉树遍历与路径查找
07-18
本实验“数据结构实验：二叉树遍历与路径查找”着重探讨了如何用C/C++语言实现二叉树的遍历和路径查找功能。 首先，我们来理解二叉树的基本概念。二叉树是一种特殊的树形数据结构，每个节点最多有两个子节点，通常...
数据结构实验2.2：二叉树遍历的一些应用.doc
10-29
此外，实验还涉及了三种基本的二叉树遍历方法： - 先序遍历：先访问根节点，再遍历左子树，最后遍历右子树。先序遍历常用于创建二叉树，因为它可以按照输入顺序构建出与原始序列对应的二叉树。 - 中序遍历：先遍历...
实验6 二叉树遍历.doc.zip
02-03
- 实验报告部分可能包括对二叉树遍历的理解、代码实现的分析以及可能遇到的问题和解决方案。 大学生在做这样的作业练习时，不仅能够掌握二叉树的基本概念，还能提升他们的逻辑思维能力和编程技巧。同时，这个实验也...
DS二叉树——二叉树之数组存储
luoyeliufeng的博客
12-18 3630
DS二叉树——二叉树之数组存储 题目描述 二叉树可以采用数组的方法进行存储，把数组中的数据依次自上而下,自左至右存储到二叉树结点中，一般二叉树与完全二叉树对比，比完全二叉树缺少的结点就在数组中用0来表示。，如下图所示 从上图可以看出，右边的是一颗普通的二叉树，当它与左边的完全二叉树对比，发现它比完全二叉树少了第5号结点，所以在数组中用0表示，同样它还少了完全二叉树中的第10、11号结点，所以在数...
DS二叉树——二叉树之父子结点
半濠春水的博客
09-29 981
题目描述 给定一颗二叉树的逻辑结构，（先序遍历的结果，空树用字符‘0’表示，例如AB0C00D00），建立该二叉树的二叉链式存储结构。 编写程序输出该树的所有叶子结点和它们的父亲结点 输入 第一行输入一个整数t，表示有t个二叉树 第二行起，按照题目表示的输入方法，输入每个二叉树的先序遍历，连续输入t行 输出 第一行按先序遍历，输出第1个示例的叶子节点 第二行输出第1个示例中与叶子相对应的父亲节点 以此类推输出其它示例的结果 样例输入 3 AB0C00D00 AB00C00 ABCD0000EF000 样例.
九度OJ 题目1543：无限完全二叉树的层次遍历
zhangzhuom的专栏
11-08 665
时间限制：1 秒 内存限制：128 兆 特殊判题：否 提交：609 解决：101 题目描述： 有一棵无限完全二叉树，他的根节点是1/1,且任意一个节点p/q的左儿子节点和右儿子节点分别是，p/(p+q)和(p+q)/q。如下图： 它的层次遍历结果如下： 1/1, 1/2, 2/1, 1/3, 3/2, 2/3, 3/1,... 有如下两类问题：
求二叉树的节点个数
热门推荐
qq_47142993的博客
08-03 1万+
如果是空树，则结点个数为0，递归结束 否则结点个数为左子树的结点个数+右子树的结点个数+1 【算法描述】 int NodeCount(BiTree T) { if (T == NULL) return 0; // 如果是空树，则结点个数为0，递归结束 else return NodeCount(T->lchild) + NodeCount(T->rchild) + 1; //否则结点个数为左子树的结点个数+右子树的结点个数+1 } 具体代
数据结构与算法 第06部分：二叉树
Win_Xin的博客
03-02 373
1：定义二叉树存储结构 typedef struct Bnode /*定义二叉树存储结构*/ { char data; struct Bnode *lchild,*rchild; }Bnode,*Btree; 2：按先序次序输入二叉树中结点的值（一个字符），创建二叉链表表示的二叉树T //按先序次序输入二叉树中结点的值（一个字符），创建二叉链表表示的二叉树T void Createt...
13、二叉树的层次遍历（先序建树层次遍历）——java数据结构
weixin_47202652的博客
11-09 530
二叉树的层次遍历 编写程序，要求实现 （1）按先序遍历序列建立二叉树的二叉链表； （2）按层次遍历二叉树。 构成二叉链表的结点类代码如下： class BtNode{ char data; BtNode lchild,rchild; } 按加入空树信息的先序遍历序列建立二叉树的二叉链表代码提供如下： //先序遍历序列建立二叉链表 public static BtNode createBiTree() throws IOException{ char c=(char) System.in.
【二叉树】二叉树遍历/根据先序创建二叉树
qq_45601866的博客
06-19 1686
题目描述 编一个程序，读入用户输入的一串先序遍历字符串，根据此字符串建立一个二叉树（以指针方式存储）。例如如下的先序遍历字符串： ABC##DE#G##F###其中“#”表示的是空格，空格字符代表空树。建立起此二叉树以后，再对二叉树进行中序遍历，输出遍历结 输入 输入包括1行字符串，长度不超过100。 输出 可能有多组测试数据，对于每组数据，输出将输入字符串建立二叉树后中序遍历的序列，每个字符后面都有一个空格。每个输出结果占一行。 样例输入 a#b#cdef##### a## 样例输出 a b f
合工大数据结构实验：二叉树遍历与操作
这个实验不仅锻炼了学生的编程技能，还强调了数据结构理论与实践应用的结合，特别是二叉树这一基础数据结构在实际问题中的应用。完成这些任务有助于提高他们的逻辑思维、问题解决能力和代码实现能力。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值