java树的非递归遍历_java 树的遍历(递归与非递归)

package wangChaoPA实习工作练习.com.leetcode;

import java.util.ArrayList;

import java.util.Stack;

class TreeNode

{

TreeNode left;

TreeNode right;

int val;

TreeNode(int x)

{

val = x;

}

}

public class TreeTrivel

{

// 测试

public static void main(String[] args)

{

TreeTrivel aa = new TreeTrivel();

TreeNode treeNode1 = new TreeNode(1);

TreeNode treeNode2 = new TreeNode(2);

TreeNode treeNode3 = new TreeNode(3);

TreeNode treeNode4 = new TreeNode(4);

TreeNode treeNode5 = new TreeNode(5);

TreeNode treeNode6 = new TreeNode(6);

TreeNode treeNode7 = new TreeNode(7);

treeNode1.left = treeNode2;

treeNode1.right = treeNode3;

treeNode2.left = treeNode4;

treeNode2.right = treeNode5;

treeNode3.left = treeNode6;

treeNode3.right = treeNode7;

/*

* ArrayList postorder = aa.postorderTraversal(treeNode1); for

* (Integer temp : postorder) { System.out.print(temp + " "); }

* System.out.println();

*/

/*

* ArrayList preorder = aa.preorderTraversal(treeNode1); for

* (Integer temp : preorder) { System.out.print(temp + " "); }

* System.out.println();

*/

/*

* ArrayList inorder = aa.inorderTraversal(treeNode1); for

* (Integer temp : inorder) { System.out.print(temp + " "); }

* System.out.println();

*/

/*

* ArrayList inorder = aa.inorder(treeNode1); for (Integer temp

* : inorder) { System.out.print(temp + " "); } System.out.println();

*/

ArrayList postorder = aa.postorder(treeNode1);

for (Integer temp : postorder)

{

System.out.print(temp + " ");

}

System.out.println();

}

ArrayList res = new ArrayList();

/*

* 递归中序遍历

*/

public ArrayList inorder(TreeNode root)

{

if (root == null)

{

return this.res;

}

inorder1(root);

return this.res;

}

private void inorder1(TreeNode root)

{

if (root == null)

{

return;

}

inorder1(root.left);

this.res.add(root.val);

inorder1(root.right);

}

/*

* 非递归中序遍历 最重要的是判断结点p有没有作结点,若有则p.left进栈,并使p.left=null,否则将p.val保存到链表中,并判断p.

* right是否为null 若不为null则把p.right进栈

*/

public ArrayList inorderTraversal(TreeNode root)

{

ArrayList res = new ArrayList();

if (root == null)

{

return res;

}

Stack stack = new Stack();

stack.push(root);

while (!stack.empty())

{

TreeNode temp = stack.peek();

if (temp.left == null)

{

TreeNode p = stack.pop();

res.add(p.val);

if (p.right != null)

{

stack.push(temp.right);

}

}

else

{

stack.push(temp.left);

temp.left = null;

}

}

return res;

}

/*

* 递归后序遍历

*/

public ArrayList postorder(TreeNode root)

{

if (root == null)

{

return this.res;

}

postorder1(root);

return this.res;

}

private void postorder1(TreeNode root)

{

if (root == null)

{

return;

}

postorder1(root.left);

postorder1(root.right);

this.res.add(root.val);

}

/*

* 非递归后序遍历 思路:要保证根结点在其左孩子和右孩子访问之后才能访问,因此对于任一结点p,先将其入栈.

* 如果p不存在左孩子和右孩子,则可直接访问;否则将p的右孩子和左孩子依次入栈然后把p的左右孩子结点赋值null,这样就保证了每次取栈顶的元素的时候

* 左孩子在右孩子前面被访问, 左孩子和右孩子都在根结点前面被访问

*/

public ArrayList postorderTraversal(TreeNode root)

{

ArrayList res = new ArrayList();

if (root == null)

{

return res;

}

Stack stack = new Stack();

stack.push(root);

while (!stack.isEmpty())

{

TreeNode temp = stack.peek();

if (temp.left == null && temp.right == null)

{

TreeNode pop = stack.pop();

res.add(pop.val);

}

else

{

if (temp.right != null)

{

stack.push(temp.right);

temp.right = null;

}

if (temp.left != null)

{

stack.push(temp.left);

temp.left = null;

}

}

}

return res;

}

/*

* 递归前序遍历

*/

public ArrayList preorder(TreeNode root)

{

if (root == null)

{

return this.res;

}

preorder1(root);

return this.res;

}

private void preorder1(TreeNode root)

{

if (root == null)

{

return;

}

this.res.add(root.val);

preorder1(root.left);

preorder1(root.right);

}

// 非递归前序遍历

/*

* p.val直接保存到链表中,然后判断p.right是否为null若不为null则将p.right进栈 然后判断

* p.left是否为null若不为null则将p.left进栈

*/

public ArrayList preorderTraversal(TreeNode root)

{

ArrayList res = new ArrayList();

if (root == null)

{

return res;

}

Stack stack = new Stack();

stack.push(root);

while (!stack.empty())

{

TreeNode temp = stack.pop();

res.add(temp.val);

if (temp.right != null)

{

stack.push(temp.right);

}

if (temp.left != null)

{

stack.push(temp.left);

}

}

return res;

}

}