二叉树的遍历

先序遍历

先序遍历方式：根——>左子树——>右子树
根据上图先序遍历结果为：1 2 4 3 5 6

1. 利用递归

	private void preOrderTraverse(Node root) {
		if (root != null) {
			System.out.print(root.getData() + " ");
			this.preOrderTraverse(root.getLeft());
			this.preOrderTraverse(root.getRight());
		}

	}

2. 不利用递归进行遍历
   利用栈的“后进先出”的特性

	private void preOrderByStack(Node root) {
		if (root == null)
			return;
		//利用栈存储节点
		Deque<Node> stack = new LinkedList<Node>();
		Node current = root;

		while (!stack.isEmpty() || current != null) {
			//边打印，边入栈将
			while (current != null) {
				System.out.print(current.getData() + " ");
				stack.push(current);
				current = current.getLeft();
			}
			//如果左子树已经遍历完，将最后一个节点弹出，进行右子树的遍历
			if (!stack.isEmpty()) {
				Node temp = stack.pop();
				current = temp.getRight();
			}
		}
		System.out.println();
	}

中序遍历

中序遍历方式：左子树——>根——>右子树
中序遍历结果：2 4 1 5 3 6

1. 利用递归

	private void preOrderTraverse(Node root) {
		if (root != null) {
			System.out.print(root.getData() + " ");
			this.preOrderTraverse(root.getLeft());
			this.preOrderTraverse(root.getRight());
		}

	}

2. 不利用递归进行遍历
   利用栈的“后进先出”的特性

	private void inOrderByStack(Node root) {
		Deque<Node> stack = new LinkedList<>();
		Node current = root;
		while (current != null || !stack.isEmpty()) {
			while (current != null) {
				stack.push(current);
				current = current.getLeft();
			}

			if (!stack.isEmpty()) {
				current = stack.pop();
				System.out.print(current.getData() + " ");
				current = current.getRight();
			}

		}
		System.out.println();

	}

后序遍历

后序遍历方式：左子树——>右子树——>根
后序遍历结果：4 2 5 6 3 1

1. 利用递归

	public void postOrderTraverse(Node node) {
		if (node != null) {
			postOrderTraverse(node.getLeft());
			postOrderTraverse(node.getRight());
			System.out.print(node.getData() + " ");
		}

	}

2. 不利用递归进行遍历
   利用栈的“后进先出”的特性

	private void postOrderByStack(Node root) {
		if (root == null) {
			return;
		}
		Deque<Node> stack = new LinkedList<Node>();
		Node current = root;
		Node lastCurrent = null;
		
		while (current != null || !stack.isEmpty()) {
			while (current != null) {
				stack.push(current);
				current = current.getLeft();
			}

			Node temp = stack.pop();
			//如果该节点的右子树为空或右子树已经遍历过了，则输出该节点
			if (temp.getRight() == null || temp.getRight() == lastCurrent) {
				System.out.print(temp.getData() + " ");
				lastCurrent = temp;
			} else {
			//如果该节点的右子树未遍历，则该节点接着入栈，
			//并将current指向该节点下一个右节点（为了将该右节点
			//的左子树添加入栈并遍历）
				stack.push(temp);
				current = temp.getRight();

			}

		}
		System.out.println();
	}

层次遍历

层次遍历结果：1 2 3 4 5 6

	//利用队列的“先进先出”特性
	private void levelOrderByStack(Node root) {
		if (root == null) {
			return;
		}
		Queue<Node> queue = new LinkedList<Node>();
		queue.add(root);
		while (queue.size() != 0) {
			int len = queue.size();
			for (int i = 0; i < len; i++) {
				Node temp = queue.poll();
				System.out.print(temp.getData() + " ");
				if (temp.getLeft() != null) {
					queue.add(temp.getLeft());
				}
				if (temp.getRight() != null) {
					queue.add(temp.getRight());
				}
			}
		}
		System.out.println();

	}