一、递归实现
import java.util.*;
/*
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}*/
public class TreeToSequence {
public int[][] convert(TreeNode root) {
// write code here
//函数返回值是一个二维数组,此二维数组储存了三种遍历方式的遍历结果
//首先创建三个list结构用来存储遍历出的树型结构
List<Integer> preorderList = new ArrayList<Integer>();
List<Integer> inorderList = new ArrayList<Integer>();
List<Integer> postorderList = new ArrayList<Integer>();
//调用遍历函数
transPreorder(root, preorderList);
transInorder(root, inorderList);
transPostorder(root, postorderList);
//创建二维数组
int length = preorderList.size();
int[][] result = new int[3][length];
//取出遍历结果
for(int i = 0; i < length; i++) {
result[0][i] = preorderList.get(i);
}
for(int i = 0; i < length; i++) {
result[1][i] = inorderList.get(i);
}
for(int i = 0; i < length; i++) {
result[2][i] = postorderList.get(i);
}
return result;
}
//先序遍历
public void transPreorder(TreeNode node, List<Integer> list){
if(node==null){
return;
}
list.add(node.val);
transPreorder(node.left,list);
transPreorder(node.right,list);
}
//中序遍历
public void transInorder(TreeNode node, List<Integer> list){
if(node==null){
return;
}
transInorder(node.left,list);
list.add(node.val);
transInorder(node.right,list);
}
//后序遍历
public void transPostorder(TreeNode node, List<Integer> list){
if(node==null){
return;
}
transPostorder(node.left,list);
transPostorder(node.right,list);
list.add(node.val);
}
}
二、非递归实现
import java.util.*;
/*
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}*/
public class TreeToSequence {
public int[][] convert(TreeNode root) {
// write code here
List<Integer> pre = new ArrayList<Integer>();
List<Integer> in = new ArrayList<Integer>();
List<Integer> post = new ArrayList<Integer>();
preOrder(root, pre);
inOrder(root, in);
postOrder(root, post);
int[][] res = new int[3][pre.size()];
for(int i = 0; i < pre.size(); i++){
res[0][i] = pre.get(i);
res[1][i] = in.get(i);
res[2][i] = post.get(i);
}
return res;
}
//先序遍历
public void preOrder(TreeNode root,List<Integer> list){
if(root == null)
return;
//创建一个栈结构,并将根节点入栈
Stack<TreeNode> stack = new Stack<TreeNode>();
stack.push(root);
//当栈不为空时,弹出栈顶元素并记录,如果该元素的右子树不为空,那么将他的右子树入栈,继续,如果他的左子树不为空,入栈
while(!stack.isEmpty()){
TreeNode cur = stack.pop();
list.add(cur.val);
if(cur.right!=null)
stack.push(cur.right);
if(cur.left != null)
stack.push(cur.left);
}
}
//中序遍历
public void inOrder(TreeNode root,List<Integer> list){
if(root == null)
return;
//创建一个栈结构,将根节点作为当前结点
Stack<TreeNode> stack = new Stack<TreeNode>();
TreeNode cur = root;
//当栈不为空,并且当前结点不为空时
while(!stack.isEmpty() || cur != null){
//如果当前结点不为空,则将该节点入栈并且将指针移向左子树
if(cur != null){
stack.push(cur);
cur = cur.left;
}else{
//如果为空则弹出栈顶元素,并且将指针移向出栈结点的右子树
cur = stack.pop();
list.add(cur.val);
cur = cur.right;
}
}
}
//后序遍历
public void postOrder(TreeNode root,List<Integer> list){
if(root == null)
return;
//创建一个栈结构,将根节点作为当前结点
Stack<TreeNode> stack = new Stack<TreeNode>();
//创建一个栈顶结点和一个标记结点
TreeNode h = root, c = null;
stack.push(root);
while(!stack.isEmpty()){
c = stack.peek();
//如果标记结点的左子树和右子树都不为空,并且标记结点的左子树和栈顶结点不同,说明标记结点的左子树和右子树都没有处理过
if(c.left != null && (c.left != h && c.right != h)){
stack.push(c.left);
c = c.left;
}else if(c.right != null && c.right != h){ //如果c的右子树不等于栈顶结点,说明右子树没有处理过
stack.push(c.right);
c = c.right;
}else{ //如果都处理了,则弹出栈顶元素并且将当前标记的节点置为栈顶元素。
h = c;
TreeNode tmp = stack.pop();
list.add(tmp.val);
}
}
}
}