二叉树的遍历java实现

package com.main;

public interface ICollectionInterface<T> {
final int INITIAL_SIZE = 32;
public boolean isEmpty();
public boolean add(T node);
public T pop();
}

package com.main;

import java.util.ArrayList;

public class TreeStack<T> implements ICollectionInterface<T> {
private ArrayList<T> mDatas = null;

public TreeStack(int initialCapacity) {
mDatas = initialDatas(initialCapacity);
}

public TreeStack() {
mDatas = initialDatas(INITIAL_SIZE);
}

private ArrayList<T> initialDatas(int initialCapacity) {
return new ArrayList<T>(initialCapacity);
}

public boolean add(T node) {
return mDatas.add(node);
}

public boolean isEmpty() {
return mDatas.isEmpty();
}

public T pop() {
T node = null;
if (!isEmpty()) {
int index = mDatas.size() - 1;
node = mDatas.get(index);
mDatas.remove(index);
}
return node;
}
}

package com.main;

import java.util.ArrayList;

public class TreeQueue<T> implements ICollectionInterface<T> {
private ArrayList<T> mDatas = null;

public TreeQueue(int initialCapacity) {
// TODO Auto-generated constructor stub
mDatas = initialDatas(initialCapacity);
}

public TreeQueue() {
// TODO Auto-generated constructor stub
mDatas = initialDatas(INITIAL_SIZE);
}

private ArrayList<T> initialDatas(int initialCapacity) {
return new ArrayList<T>(initialCapacity);
}

@Override
public boolean isEmpty() {
// TODO Auto-generated method stub
return mDatas.isEmpty();
}

@Override
public boolean add(T node) {
// TODO Auto-generated method stub
return mDatas.add(node);
}

@Override
public T pop() {
// TODO Auto-generated method stub
T node = null;
if (!isEmpty()) {
int index = 0;
node = mDatas.get(index);
mDatas.remove(index);
}
return node;
}

}

package com.main;

public class TreeNode {
public int value = -1;
public TreeNode left = null;
public TreeNode right = null;
public int tag = 0;
}

package com.main;

import java.util.ArrayList;

public class TreeMain {

private static final int MAX_NUM = 20;

private static void initArrayList(ArrayList<Integer> datas, int size) {
int i = 0;

for (i = 0; i < size; ++i) {
datas.add(i);
}
}

public static void pre_order(TreeNode root) {
TreeStack<TreeNode> mStack = new TreeStack<TreeNode>();
TreeNode node = null;
mStack.add(root);
node = root;

while (!mStack.isEmpty()) {
while (node.left != null) {
if (node.value != -1) {
System.out.println("node:" + String.valueOf(node.value));
}
mStack.add(node.left);
node = node.left;
}

while (!mStack.isEmpty()) {
node = mStack.pop();
if (node.right != null) {
mStack.add(node.right);
node = node.right;
break;
}
}
}
}

public static void in_order(TreeNode root) {
TreeStack<TreeNode> mStack = new TreeStack<>();
TreeNode node = null;
mStack.add(root);

node = root;
while (!mStack.isEmpty()) {
while (node.left != null) {
mStack.add(node.left);
node = node.left;
}

while (!mStack.isEmpty()) {
node = mStack.pop();
if (node.value != -1) {
System.out.println("node:" + String.valueOf(node.value));
}
if (node.right != null) {
mStack.add(node.right);
node = node.right;
break;
}
}
}
}

public static void back_order(TreeNode root) {
TreeStack<TreeNode> mStack = new TreeStack<>();
TreeNode node = null;
mStack.add(root);

node = root;
while (!mStack.isEmpty()) {
if (node.tag != 1) {
node.tag |= 1 << 0;
while (node.left != null) {
mStack.add(node.left);
node = node.left;
node.tag |= 1 << 0;
}
}

if ((node.tag >> 1) != 1) {
node.tag |= 1 << 1;
if (node.right != null) {
mStack.add(node.right);
node = node.right;
}
}

while (!mStack.isEmpty()) {
node = mStack.pop();
if (node.value != -1) {
if (node.right == null || node.tag == 3) {
System.out.println("node:" + String.valueOf(node.value));
continue;
}

mStack.add(node);
break;
}
}
}
}

public static void print_order(TreeNode root) {
TreeQueue<TreeNode> mQueue = new TreeQueue<>();
// ArrayList<TreeNode> mQueue = new ArrayList<>();
TreeNode node = null;
mQueue.add(root);
while (!mQueue.isEmpty()) {
node = mQueue.pop();
if (node.value != -1) {
System.out.println("node:" + String.valueOf(node.value));
if (node.left != null) {
mQueue.add(node.left);
}

if (node.right != null) {
mQueue.add(node.right);
}
}
}
}

public static TreeNode buildTree() {
TreeNode root = null;
ArrayList<Integer> mDatas = new ArrayList<Integer>();
ArrayList<TreeNode> mQueue = new ArrayList<TreeNode>();

initArrayList(mDatas, MAX_NUM);

TreeNode node = null;
root = new TreeNode();

mQueue.add(root);
while (!mDatas.isEmpty() && !mQueue.isEmpty()) {
node = mQueue.get(0);
mQueue.remove(0);

if (node != null) {
node.value = mDatas.get(0);
mDatas.remove(0);
node.left = new TreeNode();
node.right = new TreeNode();

mQueue.add(node.left);
mQueue.add(node.right);
}
}

return root;
}

public static void main(String[] args) {
// TODO Auto-generated method stub
TreeNode root = buildTree();
print_order(root);
System.out.println("--------------------------------");
pre_order(root);
System.out.println("--------------------------------");
in_order(root);
System.out.println("--------------------------------");
back_order(root);
// System.out.println("hello world");
}

}