Java基础 - 二叉树的遍历之深度优先遍历（非递归遍历）

package com.yc.test;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.List;

import com.yc.tree.ThreeLinkBinTree;
import com.yc.tree.ThreeLinkBinTree.Node;

/**
*
* @author wb
*下面以三叉链表结构的二叉树为例实现这三种遍历：
*/
public class DFS {
@SuppressWarnings({ "rawtypes", "unused", "unchecked" })
public static void main(String[] args) {
ThreeLinkBinTree<String> tree = new ThreeLinkBinTree<String>("A");
Node n2_l = tree.addAndReturn(tree.root(), "+", true);
Node n2_r = tree.addAndReturn(tree.root(), "B", false);

Node n3_n2_l = tree.addAndReturn(n2_l, "*", true);
Node n3_n2_r = tree.addAndReturn(n2_l, "D", false);

Node n4_n3_n2_l = tree.addAndReturn(n3_n2_l, "/", true);
Node n4_n3_n2_r = tree.addAndReturn(n3_n2_l, "%", false);

Node n5_n4_n3_n2_l = tree.addAndReturn(n4_n3_n2_r, "E", true);
Node n5_n4_n3_n2_r = tree.addAndReturn(n4_n3_n2_r, "F", false);

/**
* 此时二叉树的情况为：
* 						   A
* 					         │ │
* 					     + ←┘ └→ B
* 					   │ │
* 				       * ←┘ └→ D
* 				     │ │
* 				 / ←┘ └→ %
* 					   │ │
* 				       E ←┘ └→ F
*
*/

System.out.println( "非递归先序遍历结果:" + cStackDLR(tree));

System.out.println( "非递归先序遍历结果:" + cStackLDR(tree));

System.out.println( "非递归后序遍历结果:" + cStackLRD(tree));

}

//非递归方式前序遍历
public static List<Node> cStackDLR(ThreeLinkBinTree<String> tree){
return stackDLR(tree.root());
}
private static List<Node> stackDLR(Node node) {
//用于返回的
List<Node> nodes = new ArrayList<Node>();
//用于操作的（在前面的几章中讲到Deque继承了 Queue和Stack俩个接口或者类，所以它具有队列和栈的特性）
Deque<Node> deque = new ArrayDeque<Node>();

deque.push(node);

mainDealForDFS(deque, nodes);

return nodes;
}

//非递归方式中序遍历
public static List<Node> cStackLDR(ThreeLinkBinTree<String> tree){
return stackLDR(tree.root());
}
private static List<Node> stackLDR(Node node) {
//用于返回的
List<Node> nodes = new ArrayList<Node>();
//用于操作的（在前面的几章中讲到Deque继承了 Queue和Stack俩个接口或者类，所以它具有队列和栈的特性）
Deque<Node> deque = new ArrayDeque<Node>();

Node rootLeftChild = node.getLeft();
Node rootRightChild = node.getRight();

deque.push(rootLeftChild);
mainDealForDFS(deque, nodes);

nodes.add(node);

deque.push(rootRightChild);
mainDealForDFS(deque, nodes);

return nodes;
}

//非递归方式后序遍历
public static List<Node> cStackLRD(ThreeLinkBinTree
4000
<String> tree){
return stackLRD(tree.root());
}
private static List<Node> stackLRD(Node node) {
//用于返回的
List<Node> nodes = new ArrayList<Node>();
//用于操作的（在前面的几章中讲到Deque继承了 Queue和Stack俩个接口或者类，所以它具有队列和栈的特性）
Deque<Node> deque = new ArrayDeque<Node>();

Node rootLeftChild = node.getLeft();
Node rootRightChild = node.getRight();

deque.push(rootLeftChild);
mainDealForDFS(deque, nodes);

deque.push(rootRightChild);
mainDealForDFS(deque, nodes);

nodes.add(node);

return nodes;
}
private static void mainDealForDFS(Deque<Node> deque, List<Node> nodes){
while(!deque.isEmpty()){
//移除栈顶节点并添加到nodes里
Node tempN = deque.pop();
nodes.add( tempN);

if(tempN != null){
if(tempN.getRight() != null){
deque.push( tempN.getRight());
}
if(tempN.getLeft() != null){

deque.push( tempN.getLeft());
}
}
}
}
}

非递归先序遍历结果:[A, +, *, /, %, E, F, D, B]
非递归先序遍历结果:[+, *, /, %, E, F, D, A, B]
非递归后序遍历结果:[+, *, /, %, E, F, D, B, A]