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<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]