1102. Invert a Binary Tree (25)

最新推荐文章于 2022-03-30 22:47:47 发布

原创最新推荐文章于 2022-03-30 22:47:47 发布 · 304 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#PAT #树的存储

PAT 专栏收录该内容

33 篇文章

订阅专栏

本文提供了一种使用C++实现的PAT-A 1102题目解决方案，采用一种特殊的二叉树节点结构来实现后序遍历、层次遍历和中序遍历，并对二叉树进行了反转。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目描述：https://www.patest.cn/contests/pat-a-practise/1102

提交情况：

这里写图片描述

代码：

#include <iostream>
#include <vector>
#include <string.h>
using namespace std;
#define N 11
typedef struct Node 
{
    int leftChild;
    int rightChild;
}Node;
Node node[N];
int n,root[N];
vector<int> number;
int queue[N],rear,front;
int charToNum( char c )  //输入的是字符，因此需要把字符转化成数字 
{
    if( c == '-' )
        return -1;
    else
        return c-'0';
}
void postOrder( int root )  //后序遍历，并把该二叉树反转 
{
    if( root != -1 )
    {
        postOrder(node[root].leftChild);
        postOrder(node[root].rightChild);
        swap(node[root].leftChild,node[root].rightChild);
    }
}
void BFS( int root ) //层次遍历 
{
    queue[++rear] = root;
    while( front != rear )
    {
        int key = queue[++front];
        if( node[key].leftChild != -1 )
        {
            queue[++rear] = node[key].leftChild;
        }
        if( node[key].rightChild != -1)
        {
            queue[++rear] = node[key].rightChild;
        }
    }
}
void inOrder( int root )
{
    if( root != -1 )
    {
        inOrder(node[root].leftChild);
        queue[++rear] = root;
        inOrder(node[root].rightChild);
    }
}
void swap( int &left,int &right)
{
    int temp;
    temp = left;
    left = right;
    right = temp;
}
void printArray( int queue[],int rear )
{
    for( int i=0;i<=rear;++i )
    {
        if( i == rear )
            cout<<queue[i]<<endl;
        else
            cout<<queue[i]<<" ";    
    }
}
int main()
{
    cin>>n;
    int Root;
    memset(root,-1,sizeof(root));
    for( int i=0;i<n;++i )
    {
        char left,right;
        cin>>left>>right;
        node[i].leftChild = charToNum(left);
        node[i].rightChild = charToNum(right);
        if( charToNum(left) != -1 )
            root[charToNum(left)] = i;
        if( charToNum(right) != -1 )
            root[charToNum(right)] = i;
    }
    for( int i=0;i<n;++i )
    {
        if( root[i] == -1 )
        {
            Root = i;
            break;
        }       
    }
    postOrder(Root);  //后序遍历，并把二叉树反转
    front = rear = -1; //层次遍历前的初始化 
    BFS(Root);        //层次遍历 
    printArray( queue,rear );
    front = rear = -1;  //中序遍历前的初始化 
    inOrder(Root);
    printArray( queue,rear );
    return 0;
}

本题不难，但是必须得转换思想。以前的结构体如下所示：

typedef struct BTree
{
    int data;  //存储节点信息 
    struct BTree *leftChild;  //存储左孩子的地址 
    struct BTree *rightChild;   //存储右孩子的地址 
}BTree;

而现在的结构体为：

typedef struct Node 
{
    int leftChild;   //存储左孩子的下标 
    int rightChild; //存储右孩子的下标 
}Node;

节点本身的信息存储到了Node的数组的下标中了，而数组又支持随机访问的特性。这是解答本题的关键。这道题还是挺不错的，尤其是这种存储结构，以前在树上看到过类似的存储结构，但是一直没有在题中遇到过，现在好像有点明白 程序 = 数据结构 + 算法 了，一个程序必须解决数据的存储的问题（这是数据结构解决的问题），然后才能这些数据施加某些算法进行处理。