// 递归先序遍历
public static void PreOrderTraverse(BitNode root) {
if (root != null) {
visitTNode(root);
PreOrderTraverse(root.lchild);
PreOrderTraverse(root.rchild);
}
}
// 递归中序遍历
public static void InOrderTraverse(BitNode root) {
if (root != null) {
InOrderTraverse(root.lchild);
visitTNode(root);
InOrderTraverse(root.rchild);
}
}
// 递归后序遍历
public static void PostOrderTraverse(BitNode root) {
if (root != null) {
PostOrderTraverse(root.lchild);
PostOrderTraverse(root.rchild);
visitTNode(root);
}
}
// 非递归先序遍历
public static void preorderTraverse(BitNode root) {
Stack s = new Stack();
s.push(root);
while (!s.isEmpty()) {
BitNode bn = (BitNode) s.pop();
visitTNode(bn);
if (bn.rchild != null)
s.push(bn.rchild);
if (bn.lchild != null)
s.push(bn.lchild);
}
}
// 非递归中序遍历
public static void inorderTraverse(BitNode root) {
Stack s = new Stack();
BitNode p = root;
while (p != null || !s.isEmpty()) {
if (p != null) {
s.push(p);
p = p.lchild;
} else {
p = (BitNode) s.pop();
visitTNode(p);
p = p.rchild;
}
}
}
// 非递归后序遍历1
public static void postorderTraverse(BitNode root) {
Stack s = new Stack();
BitNode p = root;
// pre标记最近出栈的节点,用于判断是否是p节点的右孩子,如果是的话,就可以访问p节点
BitNode pre = p;
// flag标记是出栈还是继续将左孩子进栈
boolean flag = true;
while (p != null || !s.isEmpty()) {
if (p != null && flag) {
s.push(p);
p = p.lchild;
} else {
if (s.isEmpty())
return;
p = (BitNode) s.peek();
if (p.rchild != null && p.rchild != pre) {
p = p.rchild;
flag = true;
} else {
p = (BitNode) s.pop();
visitTNode(p);
flag = false;
pre = p;
}
}
}
}
// 非递归后序遍历2
public static void postorderTraverse2(BitNode root) {
Stack s = new Stack();
BitNode p = root;
// pre标记最近出栈的节点,用于判断是否是p节点的右孩子,如果是的话,就可以访问p节点
BitNode pre = p;
while (p != null || !s.isEmpty()) {
if (p != null) {
s.push(p);
p = p.lchild;
} else {
if (s.isEmpty())
return;
p = (BitNode) s.peek();
if (p.rchild != null && p.rchild != pre) {
p = p.rchild;
} else {
p = (BitNode) s.pop();
visitTNode(p);
pre = p;
p = null;
}
}
}
}
// 层级遍历
public static void levelTraverse(BitNode root) {
Queue<BitNode> queue = new LinkedList<BitNode>();
queue.offer(root);// 从根节点入队列
while (!queue.isEmpty()) {// 在队列为空前反复迭代
BitNode bitNode = queue.poll();// 取出队列首节点
visitTNode(bitNode);
if (bitNode.lchild != null)
queue.offer(bitNode.lchild);// 左孩子入列
if (bitNode.rchild != null)
queue.offer(bitNode.rchild);// 右孩子入列
}
}
//测试
public static void main(String[] args) {
BitNode root = new BitNode();
int[] a = { 8,9,6,7,5,3,0};
root = createBiTree2(root, a, counter);
System.out.println("-----递归先序遍历-----");
PreOrderTraverse(root);
System.out.println("\n-----非递归先序遍历-----");
preorderTraverse(root);
System.out.println("\n\n-----递归中序遍历-----");
InOrderTraverse(root);
System.out.println("\n-----非递归中序遍历-----");
inorderTraverse(root);
System.out.println("\n\n-----递归后序遍历-----");
PostOrderTraverse(root);
System.out.println("\n-----非递归后序遍历1-----");
postorderTraverse(root);
System.out.println("\n-----非递归后序遍历2-----");
postorderTraverse2(root);
System.out.println("\n\n-----层序遍历-----");
levelTraverse(root);
}
public static void PreOrderTraverse(BitNode root) {
if (root != null) {
visitTNode(root);
PreOrderTraverse(root.lchild);
PreOrderTraverse(root.rchild);
}
}
// 递归中序遍历
public static void InOrderTraverse(BitNode root) {
if (root != null) {
InOrderTraverse(root.lchild);
visitTNode(root);
InOrderTraverse(root.rchild);
}
}
// 递归后序遍历
public static void PostOrderTraverse(BitNode root) {
if (root != null) {
PostOrderTraverse(root.lchild);
PostOrderTraverse(root.rchild);
visitTNode(root);
}
}
// 非递归先序遍历
public static void preorderTraverse(BitNode root) {
Stack s = new Stack();
s.push(root);
while (!s.isEmpty()) {
BitNode bn = (BitNode) s.pop();
visitTNode(bn);
if (bn.rchild != null)
s.push(bn.rchild);
if (bn.lchild != null)
s.push(bn.lchild);
}
}
// 非递归中序遍历
public static void inorderTraverse(BitNode root) {
Stack s = new Stack();
BitNode p = root;
while (p != null || !s.isEmpty()) {
if (p != null) {
s.push(p);
p = p.lchild;
} else {
p = (BitNode) s.pop();
visitTNode(p);
p = p.rchild;
}
}
}
// 非递归后序遍历1
public static void postorderTraverse(BitNode root) {
Stack s = new Stack();
BitNode p = root;
// pre标记最近出栈的节点,用于判断是否是p节点的右孩子,如果是的话,就可以访问p节点
BitNode pre = p;
// flag标记是出栈还是继续将左孩子进栈
boolean flag = true;
while (p != null || !s.isEmpty()) {
if (p != null && flag) {
s.push(p);
p = p.lchild;
} else {
if (s.isEmpty())
return;
p = (BitNode) s.peek();
if (p.rchild != null && p.rchild != pre) {
p = p.rchild;
flag = true;
} else {
p = (BitNode) s.pop();
visitTNode(p);
flag = false;
pre = p;
}
}
}
}
// 非递归后序遍历2
public static void postorderTraverse2(BitNode root) {
Stack s = new Stack();
BitNode p = root;
// pre标记最近出栈的节点,用于判断是否是p节点的右孩子,如果是的话,就可以访问p节点
BitNode pre = p;
while (p != null || !s.isEmpty()) {
if (p != null) {
s.push(p);
p = p.lchild;
} else {
if (s.isEmpty())
return;
p = (BitNode) s.peek();
if (p.rchild != null && p.rchild != pre) {
p = p.rchild;
} else {
p = (BitNode) s.pop();
visitTNode(p);
pre = p;
p = null;
}
}
}
}
// 层级遍历
public static void levelTraverse(BitNode root) {
Queue<BitNode> queue = new LinkedList<BitNode>();
queue.offer(root);// 从根节点入队列
while (!queue.isEmpty()) {// 在队列为空前反复迭代
BitNode bitNode = queue.poll();// 取出队列首节点
visitTNode(bitNode);
if (bitNode.lchild != null)
queue.offer(bitNode.lchild);// 左孩子入列
if (bitNode.rchild != null)
queue.offer(bitNode.rchild);// 右孩子入列
}
}
//测试
public static void main(String[] args) {
BitNode root = new BitNode();
int[] a = { 8,9,6,7,5,3,0};
root = createBiTree2(root, a, counter);
System.out.println("-----递归先序遍历-----");
PreOrderTraverse(root);
System.out.println("\n-----非递归先序遍历-----");
preorderTraverse(root);
System.out.println("\n\n-----递归中序遍历-----");
InOrderTraverse(root);
System.out.println("\n-----非递归中序遍历-----");
inorderTraverse(root);
System.out.println("\n\n-----递归后序遍历-----");
PostOrderTraverse(root);
System.out.println("\n-----非递归后序遍历1-----");
postorderTraverse(root);
System.out.println("\n-----非递归后序遍历2-----");
postorderTraverse2(root);
System.out.println("\n\n-----层序遍历-----");
levelTraverse(root);
}