在牛客网刷到了二叉树的遍历，二叉树的遍历分为前序遍历，前序遍历也有先序遍历之称，还有中序遍历，以及后序遍历，这么多种遍历，遍历的方式不一样而已，前序遍历是先遍历根然后左节点然后是右节点，就是根左右，中序遍历的话是左根右，后序遍历是左右根，
1种：一般遍历采取递归方式，比如根左右，在调用左节点一直递归直到找到左边结束，到某个节点分叉口时再继续遍历邻节点也是同样方式一直递归，直到所有节点递归完，
2种：除了递归以外也可以通过栈（先进后出，后进的先出）方式遍历树，先把树根节点存储到栈里，然后开始取出树根存储到集合里，继续往栈里存放先放右节点，再放左节点，这样继续循环取就先取左边的数据了。
准备工作，我们先来定义二叉树的节点TreeNode
public class TwoTreeBeforeIterable {
public static class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
}1.前序遍历
咱们先实现个用栈思想来进行前序遍历操作
// 利用栈思想，先进后出
public static int[] preorderTraversal1(TreeNode root) {
LinkedList<Integer> list = new LinkedList<>();
if (root == null) {
return new int[0];
}
// 先把树节点存放在栈种
ArrayDeque<TreeNode> que = new ArrayDeque<>();
que.push(root);
while (!que.isEmpty()) {
// 取出树节点
TreeNode node = que.pop();
// 存储节点
list.add(node.val);
//根左右，由于栈是先进后出，所以要让左节点后入栈，这样才能先弹出来
if (node.right != null) {
// 先往栈里存放右节点
que.push(node.right);
}
if (node.left != null) {
// 再往栈里存放左节点
que.push(node.left);
}
}
return list.stream().mapToInt(Integer::intValue).toArray();
}5
4 6
1 2
测试：
public static void main(String[] args) {
// 生成树结构开始
TreeNode treeNode = new TreeNode(5);
TreeNode treeLeftNode = new TreeNode(4);
TreeNode treeRightNode = new TreeNode(6);
TreeNode treeLeftLeftNode = new TreeNode(1);
TreeNode treeRightRightNode = new TreeNode(2);
treeNode.left = treeLeftNode;
treeNode.right = treeRightNode;
treeLeftNode.left = treeLeftLeftNode;
treeLeftNode.right = treeRightRightNode;
treeRightNode.right = null;
treeRightNode.left = null;
// 生成树结构结束
int[] s = TwoTreeBeforeIterable.preorderTraversal1(treeNode);
System.out.println(Arrays.toString(s));
}结果：
[5, 4, 1, 2, 6]
递归实现下先序遍历，递归这种方式也叫深度优先遍历，
深度优先遍历先找到当前节点，然后沿着某一节点一直走到底，再通过节点返回走下一节点邻节点，
根左右，所以再存list时先存储root.val，然后再递归左边，左边深度遍历完毕，再递归节点右部，直到全部遍历完毕
public static int[] preorderTraversal2(TreeNode root) {
List<Integer> list = new ArrayList<>();
dfs(list, root);
return list.stream().mapToInt(Integer::intValue).toArray();
}public static void dfs(List<Integer> list, TreeNode root) {
if (root != null) {
list.add(root.val);
dfs(list, root.left);
dfs(list, root.right);
}
}用刚才的示例测试递归方式的，结果是一样的
中序遍历
其实按照递归方式，我们很容易的就能实现二叉树的中序遍历，在递归时，先递归左部，再存储到list值，再递归右部即可。
// 二叉树中序遍历--------------------------------------------------------开始
// 左根右
public static int[] preorderTraversal3Mid(TreeNode root) {
List<Integer> list = new ArrayList<>();
dfsMid(list, root);
return list.stream().mapToInt(Integer::intValue).toArray();
}
public static void dfsMid(List<Integer> list, TreeNode root) {
if (root != null) {
dfsMid(list, root.left);
list.add(root.val);
dfsMid(list, root.right);
}
}
// 二叉树中序遍历--------------------------------------------------------结束5
4 6
1 2
结果：[1, 4, 2, 5, 6]
后序遍历
后序遍历是左右根，前序遍历和中序遍历，你都知道了，那后序遍历就不用多说了
// 二叉树后序遍历--------------------------------------------------------开始
// 左右根遍历
public static int[] preorderTraversal3Back(TreeNode root) {
ArrayList<Integer> que = new ArrayList<>();
dfsBack(que, root);
return que.stream().mapToInt(Integer::intValue).toArray();
}
public static void dfsBack(ArrayList<Integer> que, TreeNode root) {
if (root != null) {
dfsBack(que, root.left);
dfsBack(que, root.right);
que.add(root.val);
}
}
/*
*
*
* 1
* 2 3
* 4 5 6 7
* 后序递归遍历分析：
* 代码逻辑是先找左边递归
* 1.这样进来就先找到1的left，再次进入递归得到left2，再次进入递归得到left4，再此进入左节点为空，得到右节点为空
* 此时把4存储起来que.add(root.val);
* 2.4的上一个节点2递归到右边找到5，找到5的节点的左右节点，发现没有把5存储起来que.add(root.val);
* 3.5的上一个节点2(左右都递归完毕)递归完毕，把2存储起来que.add(root.val);
* 4.root就变为1节点，root此时的左边节点全部找到，开始处理右部节点3，找3的左部节点为6，再找6的左节点发现没有，递归结束，再找6的右节点也没有
* 开始存储6 que.add(root.val);
* 5.此时root节点变为3，找3的右节点为7，找7的左节点为空，找7的右节点为空，此时存储7que.add(root.val);
* 6.此时3的左右节点全部遍历完毕，直接存储3 que.add(root.val);
* 7.此时1的左右节点全部遍历完毕，直接存储1 que.add(root.val);
* 最终按照左右根方式输出为：[4, 5, 2, 6, 7, 3, 1]
* **/
// 二叉树后序遍历--------------------------------------------------------结束
测试一下
1
2 3
4 5 6 7
TreeNode treeNode = new TreeNode(1);
TreeNode treeLeftNode = new TreeNode(2);
TreeNode treeRightNode = new TreeNode(3);
treeNode.left = treeLeftNode;
treeNode.right = treeRightNode;
TreeNode treeLeftLeftNode = new TreeNode(4);
TreeNode treeLeftRightNode = new TreeNode(5);
treeLeftNode.left = treeLeftLeftNode;
treeLeftNode.right = treeLeftRightNode;
TreeNode treerightLeftNode = new TreeNode(6);
TreeNode treeRightRightNode = new TreeNode(7);
treeRightNode.left = treerightLeftNode;
treeRightNode.right = treeRightRightNode;
int[] s = TwoTreeBeforeIterable.preorderTraversal3Back(treeNode);
System.out.println(Arrays.toString(s));结果：[4, 5, 2, 6, 7, 3, 1]
时间复杂度空间复杂度都为O(n)
![[附源码]Node.js计算机毕业设计高校运动会管理系统Express](https://img-blog.csdnimg.cn/3b46ddac98c44f568ff9ab8bb4a5dc6e.png)
