PAT甲级考试的题解和分类

https://download.csdn.net/download/m0_50617544/87783718

https://github.com/ZouJiu1/PAT

PAT甲级 classify

前3道题，一个小时多些，最后一道题，要一个半小时左右，所以前3道题，每道题20min~30min，看题速度仔细些。

大数组要思考的少些

20的题目直接嵌套循环用break，不要想太多，考察双指针较多；

存在输入个数=1的特殊情况；

不想超时加内存，不要因内存而导致耗时变多

用set map存储，尽量用status判断是否重复

1076.  和普通的节点不相同的图不相同，这里的节点可能会重复，同个follower可能存在多层的，deepth first 会存在先访问了左侧的3然后令状态=true，然后右侧节点的3之后的follower就访问不到了，所以最好用width first加status判断是否访问过，是层序遍历，所以不会出现deepth first的情况。Deepth first也可以不过要用set存然后不判断状态，不过最后一个测试点会超时

L=3

              1                                                            

      2             3                                                     

3               6       11                                             

…

尽量不要使用map，set遍历，速度会很慢，直接用大数组，vector<vector<int>>推荐，不推荐vector<set<int>>！ Map或者set的嵌套循环比for嵌套循环更慢，所以尽量用数组存储

多使用status数组来判断状态！！！

数组的index可以用来计算相邻个数！！！

void unionjoin(int a, int c) {     返回值是空要用void，否则会overtime

嵌套for循环考虑提前break的条件，以及for的步长

Vector<int> v的erase是传入指针v.erase(v.begin())，但是set的erase是直接传值，主要是set的值unique，set的运算符重载方式，set<nod> te，根据cnt从小到大进行排序，te.erase({k, cnt});

struct nod {

    int k, cnt;

    bool operator < (const nod &a) const{

        return cnt != a.cnt? cnt < a.cnt : k < a.k;

    }

};

Multi query should clear vector, set, map, maxmax, minmin, status[…] = 0

最短路径的条数，要这样计算sam，或者vector然后recursion遍历

            if(status[y]==0 && dis[y] > dis[x] + d2) {

                dis[y] = dis[x] + d2;

                sam[y] = sam[x];

            } else if(status[y]==0 && dis[y] == dis[x] + d2) {

                sam[y] = sam[x] + sam[y];

            }

Dijkstra用priority_queue或者mat，mat的number of codes line 会少些

并查集要注意是根节点相互connected，而不是子节点和根节点

if(aa > cc) arr[aa] = cc;    //correct

else        arr[cc] = aa;

void unionjoin(int a, int c) {

    int aa = findfather(a);

    int cc = findfather(c);

    // if(aa > cc) arr[aa] = cc;    //correct

    // else arr[cc] = aa;

    if(aa > cc) arr[aa] = cc;    //correct

    else arr[cc] = aa;

    /*

    if(aa > cc) arr[a] = cc;     //wrong

    else arr[c] = aa;

    11 2    unionjoin(11, 2)

    11 --> 2

    11 3    unionjoin(11, 3)

    11 --> 2 <-- 3

    1 3     unionjoin(1 , 3)

    1 <-- 3  and    11 --> 2

    */

}

测试点在题干找

多叉树画图，标记index，判断公式来

0开始  dx~dx+d

1开始   dx – (d-2) ~ dx+1

index     从0开始

      0            0 

    1   2       1  2  3

d=2   x=0   子节点：1 2  2x+1  2x+2

d=3   x=0   子节点：1 2 3  dx+1  dx+2  dx+d

同样可以用子节点的index拿到父节点的index

d=2      x = 2   父节点：(2-1)//2 = 0

d = 3    x = 3   父节点：(3-1)//d = 0

index     从1开始

      1            1 

    2   3       2  3  4

d=2   x=1   子节点：2 3  2x+(2-2):2x  2x+(2-2)+1:2x+1

d=3   x=1   子节点：2 3 4 d*x - (d-2) dx-(d-2)+1 ...  dx+1...   子节点index

同样可以用子节点的index拿到父节点的index

d=2      x = 3   父节点：3+(2-2)//2 = 1

d = 3    x = 3   父节点：3+(d-2)//d = 1

找数组的最小值，可以用另外一个数组记录index，arr[val] = index，这样val最小的地方就是最小值，不用遍历和min_element    PAT甲级 2022年夏季考试 7-2 Least Recently Used Cache

完全d叉树的前序遍历也就是depth_first，所以depth_first就可以gen树或者拿到层序遍历

用草稿纸记下相应的越界条件，像是*-1<0等特殊判断，像是数组的两端

long long输入要使用 scanf(“%lld”)，不能用cin

多叉树示例太复杂可以用简单点的，像三个节点的，方便debug

测试案例要考虑仔细，一次测完不要多个测试案例

草稿纸和相应的内容，多用草稿纸

多项式相乘会相互抵消，草稿纸

.vscode

关闭浏览器QQ等,免打扰模式的

一种方式不行用其他的方式，recursion可能存在多个区间，那就用普通的for循环；

Recursion或者dijikstra

多看几次题目

编号从1~N，要记得加上<=

图端点属性是否相同，存储相应的端点即可

图最深的点，要遍历两次，先拿到相对“最深”，然后再遍历一次，拿到交集不能只考虑第二次遍历的

emplace_back              push_back

Review 202301

考试

2021年秋季考试 7-1 Arrays and Linked Lists【模拟】内存块模拟 PAT甲级 2021年秋季考试 7-1 Arrays and Linked Lists - 知乎

2021年秋季考试 7-2 Stack of Hats【模拟】栈模拟，找最小值和对应值 PAT甲级 2021年秋季考试 7-2 Stack of Hats - 知乎

2021年秋季考试 7-3 Playground Exploration【depth_first_recursion】PAT甲级 2021年秋季考试 7-3 Playground Exploration - 知乎

2021年秋季考试 Sorted Cartesian Tree【二叉树 tree，二叉排序搜索树，堆】求层序 PAT甲级 2021年秋季考试 Sorted Cartesian Tree - 知乎

2022年夏季考试 7-1 What Day is Today【模拟】PAT甲级 2022年夏季考试 7-1 What Day is Today - 知乎

2022年夏季考试 7-2 Least Recently Used Cache【模拟 set 缓存】找到最小值 PAT甲级 2022年夏季考试 7-2 Least Recently Used Cache - 知乎    找数组的最小值，可以用另外一个数组记录index，arr[val] = index，这样val最小的地方就是最小值，不用遍历和min_element  

2022年夏季考试 7-3 DFS Sequence【depth_first_recursion】PAT甲级 2022年夏季考试 7-3 DFS Sequence - 知乎

2022年夏季考试 多叉树遍历 Complete D-Tree 【多叉树，tree】

2022年秋季考试 7-1 Balloon Popping 【模拟】 PAT甲级 2022年秋季考试 7-1 Balloon Popping - 知乎

2022年秋季考试 7-2 The Second Run of Quicksort【quicksort】PAT甲级 2022年秋季考试 7-2 The Second Run of Quicksort - 知乎

2022年秋季考试 7-3 Leader of the Opinion Leaders【模拟】PAT甲级 2022年秋季考试 7-3 Leader of the Opinion Leaders - 知乎

2022年秋季考试 Pseudo-completeness【二叉树tree】PAT甲级 2022年秋季考试 Pseudo-completeness - 知乎    完全满二叉树，完全二叉树等    完全d叉树的前序遍历也就是depth_first，所以depth_first就可以gen树或者拿到层序遍历

2022年冬季考试 A-1 Reduction of Proper Fractions【string模拟】模拟删掉字符 PAT甲级2022年冬季考试 A-1 Reduction of Proper Fractions - 知乎

2022年冬季考试 25 A-2 Luggage Pickup【队列queue】队列模拟的题目 PAT甲级2022年冬季考试 25 A-2 Luggage Pickup - 知乎

2022年冬季考试 25 A-3 Articulation Points【depth_first_recursion】求关键的节点 PAT甲级2022年冬季考试 25 A-3 Articulation Points - 知乎

2022年冬季考试 30 A-4 Check Inorder Traversals【二叉树，前序和后序】前序和后序，check是否能gen树，以及给定中序和前序是否能gen树  PAT甲级2022年冬季考试 30 A-4 Check Inorder Traversals - 知乎

最短的路径  Dijkstra

堆优化要注意：                     pq.pop();                         pq.push({dit[y], y}); !!!!!!!!!!!!!!!!!!!!!!

1003. Emergency (25) [Dijkstra算法]

1018. Public Bike Management (30) 保存所有最短路径， 由于最小带出，和最小带回不能同时用dijkstra算出， 所以用dfs模拟调整经过，回来的时候是不调整的， 所以要在去的时候调整

1163. Dijkstra Sequence (30)    路径都是可选的，x = poi[cnt];  for(int ij = 0; ij < v[x].size(); ij++) {}，实际找路径用的是poi[cnt]，不是queue的值呢

1111. Online Map(30)  题意！！！

1131. Subway Map (30) [dfs深度优先搜索 Dijkstra]  在recursion递归的==这里，要提前return，不然可能出现0:[1]，[1]:0，…-0-1-…的循环情况，递归的变量最好用local变量，不要用全局变量；输出要按照格式%06d

1087. All Roads Lead to Rome (30)  所有最短的路径个数， 保存所有最短路径， 算法会求出所有最短路径  可用Pre保存所有前序节点，

1072. Gas Station (30)     gas站点也要看作节点，计算的时候可以通过这些节点，for要加=号，不然会漏掉某些站点，堆优化更好

1030. Travel Plan (30)    pre保存路径节点

深度优先搜索 depth_firstly_recursion

1021. Deepest Root (25) [图的遍历，DFS，计算连通分量的个数] -

1103. Integer Factorization (30) [深度优先搜索DFS] 递归也是多个嵌套循环，每次循环都存在结束条件

1131. Subway Map (30) [dfs深度优先搜索]  在recursion递归的==这里，要提前return，不然可能出现0:[1]，[1]:0，…-0-1-…的循环情况，递归的变量最好用local变量，不要用全局变量；输出要按照格式%06d

1111. Online Map(30) 求最短路径保存前一个节点

1091 Acute Stroke dfs 先找全块然后判断个数  使用DFS的话会报错，可能是递归的层数太多导致栈出问题了，使用BFS才可以AC   202301

1087. All Roads Lead to Rome (30)  pre保存所有最短路径， 然后可以使用dfs求出路径个数

1034. Head of a Gang (30) [图的遍历，DFS] -

1030. Travel Plan (30)   pre保存路径节点

1018. Public Bike Management (30) 保存所有最短路径， 由于最小带出，和最小带回不能同时用dijkstra算出， 所以用dfs模拟调整经过，回来的时候是不调整的， 所以要在去的时候调整

1115. Counting Nodes in a BST (30)

1106. Lowest Price in Supply Chain (25)  1106. Lowest Price in Supply Chain (25) 记录深度更好，而不是每次计算价格

1094. The Largest Generation (25) [BFS，DFS，树的遍历]

1079. Total Sales of Supply Chain (25) [DFS，BFS，树的遍历]  dfs遍历                                                                                

1053. Path of Equal Weight (30) [树的遍历] dfs 遍历每个路径即可以

1004. Counting Leaves (30) [BFS，DFS，树的层序遍历]

1013. Battle Over Cities (25) [图的遍历，统计连通分量的个数，DFS]    202301    depth_first或者并查集，并查集要注意是    if(aa > cc) arr[aa] = cc;    //correct

    else arr[cc] = aa;

void unionjoin(int a, int c) {

    int aa = findfather(a);

    int cc = findfather(c);

    // if(aa > cc) arr[aa] = cc;    //correct

    // else arr[cc] = aa;

    if(aa > cc) arr[aa] = cc;    //correct

    else arr[cc] = aa;

    /*

    if(aa > cc) arr[a] = cc;     //wrong

    else arr[c] = aa;

    11 2    unionjoin(11, 2)

    11 --> 2

    11 3    unionjoin(11, 3)

    11 --> 2 <-- 3

    1 3     unionjoin(1 , 3)

    1 <-- 3  and    11 --> 2

    */

}

广度优先搜索 width_firstly_recursion

1106. Lowest Price in Supply Chain (25)

1094. The Largest Generation (25) [BFS，DFS，树的遍历]

1079. Total Sales of Supply Chain (25) [DFS，BFS，树的遍历]

1004. Counting Leaves (30) [BFS，DFS，树的层序遍历]

树 Tree

树的遍历和产生key是split 左右branch的条件，然后将根节点入栈，要去找根节点

1053. Path of Equal Weight (30) [树的遍历] -

1167. Cartesian Tree (30) [树的遍历，map映射，STL]   已知是heaporder对inorder排序，然后gen树，要判断在inorder前一个节点的左右，就可以左右依次gen，得到相应的内容；

也可以不用gen树拿到最小值和index直接保存层序遍历，最小堆，最小值就是根节点划开左右branch，使用map自动排序的特点

不能使用数组存储res(10741824, -999)

res[index] = v[pot];

会越界，要使用map存储并自动排序

1162. Postfix Expression (25)  判断左右节点乘积，是正数就用postorder遍历，是负数就用inorder遍历，前后输出括号，可以用string累加，也可以直接输出

1159. Structure of a Binary Tree (30) 用结构体加数组的形式gen树；或者用结构体加链表的形式gen树，然后将节点存到数组里。都可以，最后就是判断了，要注意用cin>>t>>t将多的输入从缓存放出来，不然读到的还是之前的

1151. LCA in a Binary Tree (30) in和pre，不用gen树，判断在根节点的左右就可以

1147. Heaps (30) 直接用层序遍历进行后序遍历，使用2n, 2n+1，n从1开始；判断heap可以直接从2开始，然后n/2就是Parent节点，不用2n, 2n+1更方便

1138. Postorder Traversal (25)  in和pre转post，找到第一个点直接printf然后退出即可

1135. Is It A Red-Black Tree (30)   难题，最后一点每个节点的每条路径都要考虑，直接考虑左右branch的最大黑色节点个数；对多个测试案例全局变量可能要多次重复初始化，最好放在函数main之内！！！多次gentree，要用else if；递归嵌套使用

1130. Infix Expression (25) [二叉树 tree深度优先搜索]

1127. ZigZagging on a Tree (30)   先gen树，要每隔一层倒序，所以是必要的，然后就是遍历，也就是width_firstly_search

1123. Is It a Complete AVL Tree (30)(不考的知识点 AVL)

1119. Pre- and Post-order Traversals (30)  前序或者后续遍历，不用产生树

前序的第二个节点划开，求in输出

后序的倒数第二个节点划开，求in输出

前序或者后序都可以，求层序输出；

1115. Counting Nodes in a BST (30) 在gen树的同时数每层的个数，和最大层数，最后输出即可

1110. Complete Binary Tree (25)  用最大index和节点个数来判断，不要用条件判断，起始1，左：2*n，右：2*n+1，不是满二叉树也可以用这样的方式    202301

1106. Lowest Price in Supply Chain (25) 记录深度更好，而不是每次计算价格

1102. Invert a Binary Tree (25) [树的遍历] vector赋值v2(v1)；仍然可以使用index来进行层序遍历；map层序遍历自动排序，ind保存index的最大值 

1099. Build A Binary Search Tree (30) [⼆叉查找树BST]  不用generate tree， 直接inorder遍历， 和1064对照；层序用index会出错可能越界 > long long最大值，主要是2的100次方太大了，所以这题不能用index!!!，直接保存每层的数值202301  202302

By-liunuo因为是⼆叉搜索树，所以中序遍历这棵树得到的结点顺序应该是给出的数值序列从⼩到⼤的排列顺序，所以 把数值序列排序后，可以在中序遍历的时候直接赋值当前a[root].data～同时可得知树的最⼤层数 maxLevel的值～

Reason: 二叉搜索树，左<根<=右，中序遍历是“左根右”，所以中序遍历一定是从小到大排列的。或者左>=根>右，从大到小排列

1094. The Largest Generation (25) [BFS，DFS，树的遍历]

1090. Highest Price in Supply Chain (25) [树的遍历] dfs遍历

1086. Tree Traversals Again (25) [树的遍历] 看题，push顺序就是前序顺序可以拿到前序遍历，也可以拿到inorder

1079. Total Sales of Supply Chain (25) [DFS，BFS，树的遍历] dfs遍历

1066. Root of AVL Tree (25) [平衡⼆叉树（AVL树）](不考的知识点)

1064. Complete Binary Search Tree (30) [⼆叉查找树BST]  BST树的inorder序列是从小到大排列的，使用index获取levelorder的数值  和1099对照 202301

1057. Stack (30) [树状数组](不考的知识点)

1053. Path of Equal Weight (30) [树的遍历] dfs 遍历每个路径即可以

1043. Is It a Binary Search Tree (25) [⼆叉查找树BST] 可以先gen然后pre对照， 或者根据BST的特点post，看输出的个数

1020. Tree Traversals (25) [⼆叉树的遍历，后序中序转层序]   不用产生树然后遍历， 直接遍历即可

1004. Counting Leaves (30) [BFS，DFS，树的层序遍历]

堆 Heap

1147. Heaps (30)

1155. Heap Paths (30) [深搜回溯，堆]   要使用i/2来遍历根节点，在递归左节点的时候送入栈，右节点可能不是叶子节点左节点也没有才是叶子节点

1167. Cartesian Tree (30) [树的遍历，map映射，STL]   不能使用数组存储res(10741824, -999)

res[index] = v[pot];

会越界，要使用map存储并自动排序

1098. Insertion or Heap Sort (25) [heap sort（堆排序）]

并查集

可以用并查集也可以用深度递归搜索

1107. Social Clusters (30) [并查集]   !!!  将hobby对应到每个人，并查集记录的是人不是hobby    202301

1114. Family Property (25) [并查集]  使用map，用数组存好set和areas，并查集路径化简对应到同一个根节点，202301   并查集或者DFS：使用map，用数组存好set和areas，并查集路径化简对应到同一个根节点，

1118. Birds in Forest (25) [并查集] 202301查集或者DFS DFS，先将鸟看作图节点，遍历看有几个不连通的区块，每个区块就是一颗树，然后将鸟加上区块index，鸟的index相同就是在同一颗树；并查集，先将鸟送到并查集，然后数根节点个数即可，鸟的根节点相同就是在同一棵树

1158. Telefraud Detection (25) [并查集] 202301  要注意no more than以及 more than的区别，一个是“<=”另一个才是“>”

Hash映射

1145. Hashing – Average Search Time (25) [hash映射，hash表，平⽅探测法]  202301

1154. Vertex Coloring (25) [set，hash]    202301，直接判断端点颜色是否相同，不用递归遍历

1134. Vertex Cover (25) [hash散列] 202301   set集合查找比循环比对要好，边只要有一个顶点在set集合就可以，一个O(n)一个是O(n^2)

1092. To Buy or Not to Buy (20) [Hash散列] 202301

1084. Broken Keyboard (20) [Hash散列] 202301，转大写，toupper

1078. Hashing (25) [⼆次⽅探查法]

1041. Be Unique (20) [Hash散列]

1050. String Subtraction (20) [Hash散列]

1048. Find Coins (25) [Hash散列]

拓扑排序

1146. Topological Order (25) [拓扑排序]

关键路径

1146 Topological Order 相关求关键路径.cpp    202301 202302

字符串

1152. Google Recruitment (20) [字符串处理]

1164. Good in C (20) [string字符串处理] 202301 不能存在多的空行，测试案例是--H--EL1LO--，空字符串不放入列表，最后一个字符可能是alpha，要特殊处理，最后一行要输出\n，\n不是空行是nextline，两个\n\n才是空行的

1157. Anniversary (25) [string字符串处理]

回溯剪枝

1103. Integer Factorization (30) [深度优先搜索DFS]

图

1122. Hamiltonian Cycle (25) [图论] 202301

哈密顿图（汉密尔顿图）（英语：Hamiltonian path，或Traceable path）是一个无向图，由文学家哈密顿提出，由指定的起点前往指定的终点，途中经过所有其他节点且只经过一次。 在图论中是指含有 哈密顿回路 的图，闭合的哈密顿路径称作哈密顿回路（Hamiltonian cycle），含有图中所有顶点的路径称作哈密顿路径

1142. Maximal Clique (25) [图论，无向完全图] 202301

1150. Travelling Salesman Problem (25) [图论]

1013. Battle Over Cities (25) [图的遍历，统计连通分量的个数，DFS]  202301

1154. Vertex Coloring (25) [set，hash]                          

1021. Deepest Root (25) [图的遍历，DFS，计算连通分量的个数]   202301  就两次深度优先搜索，先从⼀个结点recursion后保留最⾼⾼度拥有的结点们，然后从这些结点中的其中任意⼀个开始recursion得到最⾼⾼度的结点们，这两个结点集合的并集就是所求

1076. Forwards on Weibo (30) [图的遍历，BFS] 202301，和普通的节点不相同的图不相同，这里的节点可能会重复，同个follower可能存在多层的，deepth first 会存在先访问了左侧的3然后令状态=true，然后右侧节点的3之后的follower就访问不到了，所以最好用width first。Deepth first也可以不过要用set存然后不判断状态，不过最后一个测试点会超时

Widthfirst用set存会内存过大的

L=3

              1

      2             3

3               6       11

…

1126. Eulerian Path (25) [连通图]  202301

1128. N Queens Puzzle (20) [逻辑题]

排序

1101. Quick Sort (25) [快速排序]

1098. Insertion or Heap Sort (25) [heap sort（堆排序）]

1080. Graduate Admission (30) [排序] –

1089. Insert or Merge (25) [two pointers] – 归并排序的 202301

链表

1032. Sharing (25) [链表] –

1133. Splitting A Linked List (25) [链表] –

1165. Block Reversing (25) [链表] 用2dim的数组，然后reverse

1161. Merging Linked Lists (25) [链表]

贪心

1037. Magic Coupon (25) [贪⼼算法] -

1038. Recover the Smallest Number (30) [贪⼼算法] –

运算符重载

1129. Recommendation System (25) [set的应⽤，运算符重载] –

模拟

1153. Decode Registration Card of PAT (25) [模拟，排序，map]

1105. Spiral Matrix (25) [模拟]         202301    双指针方式一个行一个列，用来做递推的

1089. Insert or Merge (25) [two pointers] 202301   要加=号，排序要注意=，sort的第二个参数是后面的一个position，不是所处的position   202302

1065. A+B and C (64bit) (20) [模拟] 202301  会溢出，long long输入要使用 scanf(“%lld”)，不能用cin

1051. Pop Sequence (25) [栈模拟]

1046. Shortest Distance (20) [模拟] 202301  环路总长固定，求得一个总和减去即可

1042. Shuffling Machine (20) [模拟]

1022. Digital Library (30) [map映射，STL的使⽤]

1009. Product of Polynomials (25) [模拟]

1002. A+B for Polynomials (25) [模拟]

双指针

2022年秋季   第一题，避免for循环嵌套带来的长耗时，双指针；作用的数组必须是有序数组，也就是要提前排序，从小到大或者~；能用数组就用数组，尽量不要使用map

1029. Median (25) [two pointers]  可以直接用sort排序，不过题目的意思应该不是这个，所以用归并的思想，使用双指针，对序列进行排序，某个指针指向end，就可以退出while，此时mid的position已经确定了

1085. Perfect Sequence (25) [⼆分，two pointers] 

要用long long，一个指针从前往后，一个从后往前；还是会超时，考虑用 upper_bound >=

upper_bound >=   ，要用clang++编译器

 auto it = lower_bound(v.begin(), v.end(), (long long)v[j] * p, greater<long long>());

加入greater<long long>());，则是<=，或者upper_bound <，此时v从大到小排列

默认lower_bound >=   upper_bound >    v从小到大排列

it – v.begin()拿到index

1105. Spiral Matrix (25) [模拟]

进制

1058. A+B in Hogwarts (20) [进制转

1027. Colors in Mars (20) [进制转

1019. General Palindromic Number (20) [回⽂数]  202301

1015. Reversible Primes (20) [素数]

数学问题

1104. Sum of Number Segments (20) [数学问题]

1008. Elevator (20) [数学问题]  202301   相邻层相同的数字看作再次press button

1156. Sexy Primes (20) [素数]

1125. Chain the Ropes (25) [排序，贪⼼]

STL

1166. Summit (25) [集合set，STL]  202301  for(j = 1; j <= N; j++)

编号从1~N，要记得加上<=

Map

1124. Raffle for Weibo Followers (20) [map映射]

Set

1121. Damn Single (25) [set的应⽤]

1120. Friend Numbers (20) [set的应⽤]

The other

已知前序（先序）与中序输出后序（建树）

已知前序（先序）与中序输出后序：
前序：1, 2, 3, 4, 5, 6（根左右）
中序：3, 2, 4, 1, 6, 5（左根右）
分析：因为前序（根左右）最先出现的总是根结点，所以令root为前序中当前的根结点下标（并且同时把一棵树分为左子树和右子树）。start为当前需要打印的子树在中序中的最左边的下标，end为当前需要打印的子树在中序中最右边的下标。递归打印这棵树的后序，递归出口为start > end。i为root所表示的值在中序中的下标，所以i即是分隔中序中对应root结点的左子树和右子树的下标。
先打印左子树，后打印右子树，最后输出当前根结点pre[root]的值。
输出的后序应该为：3, 4, 2, 6, 5, 1（左右根）

已知后序与中序输出前序（先序）

已知后序与中序输出前序（先序）：
后序：3, 4, 2, 6, 5, 1（左右根）
中序：3, 2, 4, 1, 6, 5（左根右）
分析：因为后序的最后一个总是根结点，令i在中序中找到该根结点，则i把中序分为两部分，左边是左子树，右边是右子树。因为是输出先序（根左右），所以先打印出当前根结点，然后打印左子树，再打印右子树。左子树在后序中的根结点为root – (end – i + 1)，即为当前根结点-(右子树的个数+1)。左子树在中序中的起始点start为start，末尾end点为i – 1.右子树的根结点为当前根结点的前一个结点root – 1，右子树的起始点start为i+1，末尾end点为end。
输出的前序应该为：1, 2, 3, 4, 5, 6（根左右）