多叉树后序转前序++

最新推荐文章于 2021-01-14 07:47:05 发布
最新推荐文章于 2021-01-14 07:47:05 发布
阅读量1k 收藏
点赞数
分类专栏： 面试题 C/C++ 文章标签： list struct fp null file
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wzb56_earl/article/details/7993435
版权

多叉树前序转后序

返回比赛首页

给定一颗多叉树，


该多叉树可以用一个后序遍历的字符串表示为4(0),5(0),1(2),6(0),2(1),7(0),8(0),9(0),10(0),3(4),0(3)

其中括号内的数字表示该节点的子节点数，比如0(3)表示节点0有3个子节点，而节点按照后序遍历的顺序排列。

给定一个类似的多叉树后序遍历的字符串，试写出一个程序输出其对应前序遍历的字符串。

如上述多叉树的前序遍历字符串为0,1,4,5,2,6,3,7,8,9,10

注意，在输出中不包含节点的子节点数。注意子节点是有顺序的，在输出中应保证子节点的顺序和后序遍历一致，比如在上例中，输出0,1,5,4,2,6,3,7,8,9,10是错误的。


输入：

输入多行数据，直到结束。每行数据包含一个多叉树的后序遍历的字符串。


输出：

对于每行输入数据，通过stdout，输出一行该多叉树的前序遍历的字符串


样例输入：

4(0),5(0),1(2),6(0),2(1),7(0),8(0),9(0),10(0),3(4),0(3)

1(0),3(0),4(0),2(2),0(2)

4(0),5(0),2(2),3(0),1(2),0(1)


样例输出：

0,1,4,5,2,6,3,7,8,9,10

0,1,2,3,4

0,1,2,4,5,3


解决方案：

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

#define MAX 100
typedef struct node {
    int num;
    int size;
    struct node * children[MAX];
} node_t;

node_t * list[100000];


 void preOrderTree( node_t *root) {
    int i;

    if(root) {
        printf("%d,", root->num);
        for(i = 0; i < root->size; ++i) {
            preOrderTree(root->children[i]);
        }
    }
 }

 void destroyTree(node_t *root) {
    int i;

    if(root) {
        for(i = 0; i < root->size; ++i) {
            destroyTree(root->children[i]);
        }
        free(root);
    }
}

int main(int argc, char *argv[])
{
    int i;

    int num;
    int size;
    int count = 0;

    FILE *fp = fopen("sysFileUrl", "r");
    if(NULL != fp) {
            while(fscanf(fp, "%d(%d),", &num, &size) != EOF) {
                node_t *p = malloc(sizeof(node_t));
                if(NULL != p) {
                    p->num = num;
                    p->size = size;

                    if(size == 0 ) {
                        list[count++] = p;
                    }else {
                        for(i = size - 1; i >= 0; --i) {
                            p->children[i] = list[--count];
                        }

                        if(num != 0) {
                            list[count++] = p;
                        }
                    }

                    if(num == 0) {
                        preOrderTree(p);
                        printf("\n");
                        destroyTree(p);
                    }
                }
            }

        fclose(fp);
    }

    return 0;
}


1.改进方案：
//树节点中的孩子数组，采用动态数组，可以节省空间；
//此外，当某个节点度数（孩子节点个数）极端多的情况，
//将会避免更多空间的浪费，同时也能保证算法的可行性；

//list中元素最多时，不超过最大度数的的2倍

代码如下：

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

//树中的节点的最大度数
#define MAX 100

//树节点中的孩子数组，采用动态数组，可以节省空间；
//此外，当某个节点度数（孩子节点个数）极端多的情况，
//将会避免更多空间的浪费，同时也能保证算法的可行性；
typedef struct node {
    int num;
    int size;
//struct node * children[MAX];
    struct node *children[0];
} node_t;

//list中元素最多时，不超过最大度数的的2倍；
node_t *list[MAX*2];


 void preOrderTree( node_t *root) {
    int i;
    if(root) {
        printf("%d,", root->num);
        for(i = 0; i < root->size; ++i) {
            preOrderTree(root->children[i]);
        }
    }
 }

 void destroyTree(node_t *root) {
    int i;

    if(root) {
        for(i=0; i < root->size; ++i) {
            destroyTree(root->children[i]);
        }
        free(root);
    }
}

int main(int argc, char *argv[])
{
    int i;

    int num;
    int size;
    int count = 0;
    printf("\\n = %d \n", '\n');
    printf("\\r = %d \n", '\r');

    FILE *fp = fopen("sysFileUrl", "r");
    if(NULL != fp) {
            while(fscanf(fp, "%d(%d),", &num, &size) != EOF) {
                node_t *p = (node_t *) malloc(sizeof(node_t) + size * sizeof(node_t *));
                int tag = 0;
                int ch = fgetc(fp);
                if( ch == '\n' || ch == '\r' || ch == EOF ) {
                    printf("ch = %d \n", ch);
                    ungetc(ch, fp);
                    tag = 1
                }
                if(NULL != p) {
                    p->num = num;
                    p->size = size;

                    if(size == 0 ) {
                        list[count++] = p;
                    }else {
                        for(i = size - 1; i >= 0; --i) {
                            p->children[i] = list[--count];
                        }

                        if(num != 0) {
                            list[count++] = p;
                        }
                    }

                    if(num == 0) {
                        preOrderTree(p);
                        printf("\n");
                        destroyTree(p);
                    }
                }
            }

        fclose(fp);
    }

    return 0;
}



改进方案2:  避免通过测试节点值为0，作为根节点的标志。 
#include <stdio.h>
#include <stdlib.h>

//树中的节点的最大度数
#define MAX 100

//树节点中的孩子数组，采用动态数组，可以节省空间；
//此外，当某个节点度数（孩子节点个数）极端多的情况，
//将会避免更多空间的浪费，同时也能保证算法的可行性；
typedef struct node {
    int num;
    int size;
//struct node * children[MAX];
    struct node *children[0];
} node_t;

//list中元素最多时，不超过最大度数的的2倍；
node_t *list[MAX*2];


 void preOrderTree( node_t *root) {
    int i;
    if(root) {
        printf("%d,", root->num);
        for(i = 0; i < root->size; ++i) {
            preOrderTree(root->children[i]);
        }
    }
 }

 void destroyTree(node_t *root) {
    int i;

    if(root) {
        for(i=0; i < root->size; ++i) {
            destroyTree(root->children[i]);
        }
        free(root);
    }
}

//获取换行标志
int getTag(FILE *fp) {
    int tag = 0;

    int ch = fgetc(fp);
    if( ch == '\n' || ch == '\r' /*|| ch == EOF */) {
      //  printf("ch = %d \n", ch);
        tag = 1;
    }
    ungetc(ch, fp);

    return tag;
}


int main(int argc, char *argv[])
{
    int i;

    int num;
    int size;
    int count = 0;
    int tag;   // 换行标志，以示，一棵树到达root；

    FILE *fp = fopen("sysFileUrl", "r");
    if(NULL != fp) {
            while(fscanf(fp, "%d(%d),", &num, &size) != EOF) {
                node_t *p = (node_t *) malloc(sizeof(node_t) + size * sizeof(node_t *));
                tag = getTag(fp);

                if(NULL != p) {
                    p->num = num;
                    p->size = size;

                    //叶子节点
                    if(size == 0 ) {
                        list[count++] = p;
                    }else {
                        for(i = size - 1; i >= 0; --i) {
                            p->children[i] = list[--count];
                        }
                        //非根节点也非叶子节点
                        if(!tag) {
                            list[count++] = p;
                        }
                    }

                    //根节点
                    if(tag) {
                        preOrderTree(p);
                        printf("\n");
                        destroyTree(p);
                    }
                }
            }

        fclose(fp);
    }

    return 0;
}



2.将句子中单词逆序，如 “Hello world" 变为”world Hello"
思路：首先将句子逆序，然后将每个逆序的单词进行逆序。

代码实现： 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void swap(char *p, char *q);
void reverseStringWord(char *str);


int main(int argc, char *argv[])
{
        char str[] = "Hello world. ";
        reverseStringWord(str);
        printf(str);
        printf("\n");


        return 0;
}

void swap(char *p, char *q) {
        char temp = *p;
        *p = *q;
        *q = temp;
}

void reverseStringWord(char *str) {
        char *p;
        char *q;
        char *r;
        int length;

        if(str) {
                length = strlen(str);
                p = str;
                q = str + length - 1;

                //实现句子逆序
                while(p < q) {
                        swap(p++, q--);
                }

                //实现句子中的每个单词逆序
                p = str;
                while(*p) {
                        //跳过单词前的空格
                        while(*p && *p == ' ') ++p; // p指向word的开始字符
                        //if(*p == '\0') break;

                        //找到单词的结尾字符
                        q = p;
                        while(*q && *q != ' ')  ++q; //q指向word的结尾字符的下一个字符
                        r = q - 1;  // r 指向word的结尾字符

                        //实现单词逆序
                        while(p < r) {
                                swap(p++, r--);
                        }

                        p = q;
                }
        }

}



wzb56
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
中序后序转先序
E_Water_的博客
06-09 233
#include<iostream> #include<algorithm> #include<vector> using namespace std; typedef int ElementType; int post[30], in[30]; void Traversal(int postL, int postR, int inL, int inR, int N); int main() { int N, i; cin >> N; for (i =
多叉树的前序遍历_基于顺序存储实现的多叉树（3）：前序遍历
weixin_33248912的博客
12-24 753
类型定义在多叉树中，前序遍历迭代器有只读、读写、只读反转、读写反转4种，在mtree容器中的定义如下：1 typedefpre_iterator_implpre_iterator;2typedefpre_iterator_implreverse_pre_iterator;3typedefpre_iterator_implconst_pre_iterator;4typedefp...
多叉树前序转后序
lslxdx的专栏
09-18 1182
给定一颗多叉树， 该多叉树可以用一个后序遍历的字符串表示为4(0),5(0),1(2),6(0),2(1),7(0),8(0),9(0),10(0),3(4),0(3) 其中括号内的数字表示该节点的子节点数，比如0(3)表示节点0有3个子节点，而节点按照后序遍历的顺序排列。 给定一个类似的多叉树后序遍历的字符串，试写出一个程序输出其对应前序遍历的字符串。 如上述多叉
英伟达(NVIDIA)在线编程挑战赛--多叉树后序转先序
Stay hungry, stay foolish !
09-19 2446
昨晚在1问1答平台上做了 英伟达(NVIDIA)在线编程挑战赛 的第二轮题目：给出一个多叉树的后序遍历，写出先序遍历。 昨天做题的时候一直纠结怎么把字符串中的数字取出来，想用strtok()来把字符串分开，由于自己不熟悉这个函数，试了几次还是没把数字读出来；最后直接拿指针指向字符串，如果指向的是数字，就保存起来。但这种方式读多位数时比较麻烦，比如样式输入里的第一个里面有个
前序中序转后序，后序中序转前序，前序后序转中序
weixin_43842155的博客
06-06 1112
将前序序列存入pre数组，中序序列存入in数组，后序序列存入post数组，则： 前序中序—>后序 #include <cstdio> using namespace std; int pre[] = {1, 2, 3, 4, 5, 6}; int in[] = {3, 2, 4, 1, 6, 5}; void post(int root, int start, int end) { if(start > end) return ; int i = start;
智能指针创建多叉树
huyanjie0327的专栏
11-04 413
参考：http://thispointer.com/shared_ptr-binary-trees-and-the-problem-of-cyclic-references/ #include #include #include using namespace std; class Node : public enable_shared_from_this { public: typ
多叉树的前序遍历_多叉树的递归遍历和堆栈遍历【多叉树的前序遍历及后续遍历】 | 学步园...
weixin_42347486的博客
01-14 257
//多叉树递归遍历//假设树节点定义为:struct Node{Node *pPNode;list childs;};//前序遍历(正序遍历):void EnumNode(Node *pNode){do_something(pNode);list::iterator iter; //正向遍历器for(iter=pNode->childs.begin();iter!=pNode->chi...
多叉树的 前序、后序、层序遍历，非递归
Tlwhisper的博客
07-15 746
1、描述 590给定一个 N 叉树，返回其节点值的后序遍历。 2、关键字 N叉树，后序遍历 3、思路 前序遍历，stack, 思考前序遍历是：根左右，后序遍历是：左右根 如果把后序遍历根节点和孩子节点倒过来，就是和前序遍历类型一样了。而前序遍历是：左右， 后序遍历是右左，所以在处理孩纸节点时候，用stack暂存当前节点的孩子节点，输出逆置答案时，把stack弹出就好了， 4、notes 1、前序遍历就是队列，层序遍历也是队列，后序遍历就是用栈暂存逆序，最后结果序列再逆置一下 2、层序遍历是取第一个元素，把
多叉树的后序非递归遍历
01-08
多叉树的建立以及后序非递归遍历，希望对学习数据结构的同学有所帮助，也对树一部分有更深的了解。
Java实现多叉树查找
12-22
1 package tree; 　2 　3 import java.util.List; 　4 import java.util.ArrayList; 　5 import java.io.Serializable; 　6 　7 public class TreeNode implements Serializable { 　8 private int parentId...
java多叉树的实现和遍历输出
11-02
java多叉树的实现：节点集合生成多叉树，单个节点添加到多叉树，深度遍历，广度遍历
自己用C语言实现的拓扑多叉树
09-06
多叉树的构建，包含测试代码
c++ 多叉树
01-27
c++实现的多叉树，文件里面有文档，操作说明。代码有注释，基本按照编码规范来的。 c++实现的多叉树，文件里面有文档，操作说明。代码有注释，基本按照编码规范来的。
NVDIA（英伟达)一道笔试笔试编程题
wzb56的资料库
04-18 7198
NVDIA（英伟达)一道笔试笔试编程题 Given an integer number N(n = m^2 - 1),  print sequence 0, 1, 2, 3, ..., n，in below form.  You can only use printf(C) or cout(C++).  For example, given n = 24(5^2 - 1), the pro
题目：求两个方阵A，B的乘积
wzb56的资料库
10-15 4346
题目：求两个方阵A，B的乘积方阵product； 分析 product[i,j] 是A的第i行的元素与B的第j列的元素 逐个乘积作和。 即： 。 代码实现： #include #include int *multiplyMatrixs(int *a, int *b, int *p, int n); void printMatrixArray(in
题目：给一个排序好的整数数组A，请写一个函数，输入是数组A和一个整数x，返回数组A中值小于x的最大元素的索引值
wzb56的资料库
10-15 4129
题目：给一个排序好的整数数组A（升序）， 请写一个函数，输入是数组A和一个整数key，返回数组A中值小于key的最大元素的索引值。 分析：因为有序，故可以使用折半查找的思想，但是需要变通实现。 实现如下： #include int modifiedBinarySearch(int list[], int len, int key); int main(int argc
2012年奇虎360校园招聘实习生笔试编程题
wzb56的资料库
04-14 3272
2012年奇虎360校园招聘实习生笔试编程题 1.  自己实现库函数 int atoi(const char* str);        注意两点：(1). 字符串中，符号位的处理。                         (2).字符串中，出现非数字字符。 (3). 进制考虑（如八进制只以0开头，十六进制以0x或者0X开头）       实现原理： 霍纳规则(Horno
统计一个整数n的二进制表示中1的个数的几种解法
wzb56的资料库
10-29 2485
统计一个整数n的二进制表示中1的个数； 分析：此题有多种解法. 1. 除2取余法：求一个整数的二进制的表示是，用的方法是除2取余。对于本题，只是统计一下余数为1的个数而已。 2. 位模式法+移位：1的变种，用移位代除2，该方法更高效。用位模式，与1相与，取得一位。 3. 模式位法： n = n& (n -1);  考虑 n 与 n -1的二进制表示，两者相&, n-1总能将n的最低位的1，
帮我设计一个高效的多叉树的后序遍历算法
最新发布
02-20
很高兴为你提供帮助。这是一个有效的多叉树后序遍历算法： 1. 访问根结点。 2. 访问根结点的每个子节点，按照从左到右的顺序访问。 3. 对每个子节点，重复步骤 1 和 2，直到所有的节点都被访问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值