文章目录
前序遍历
访问顺序：根节点，前序遍历左子树，前序遍历右子树
二叉树的前序遍历
- 二叉树前序递归实现
public void preorderTraversal(TreeNode root){
//访问根节点
System.out.println(root.val);
//前序遍历左子树
preorderTraversal(root.left);
//后序遍历右子树
preorderTraversal(root.right);
}
- 二叉树前序迭代法遍历
利用栈实现，将node指向根节点
循环执行下面操作，如果node!=null,对node经行访问，然后将node的右子树入栈，将node指向node的左子树，如果node 为空，如果栈为空，结束遍历，如果栈不为空，弹出栈顶的元素。
//只有右子树要入栈
public List<Integer> preorderTraversal(TreeNode node) {
List<Integer> list = new LinkedList<Integer>();
Stack<TreeNode> rights = new Stack<TreeNode>();
while(node != null) {
list.add(node.val); //访问根节点
if (node.right != null) {
rights.push(node.right);
}
node = node.left; //访问左子树
if (node == null && !rights.isEmpty()) {
node = rights.pop(); //访问右子树
}
}
return list;
}
多叉树的前序遍历
题目 : 多叉树的前序遍历
- 多叉树的前序递归实现，和二叉树的原理一样，先访问根节点，然后分别前序遍历各个子树节点
private List<Integer> list=new ArrayList();
public List<Integer> preorder(Node root) {
if(root==null)
return list;
list.add(root.val);
for(Node node:root.children){
preorder(node);
}
return list;
}
- 迭代法遍历N叉树,和二叉树的前序遍历迭代法原理一样，应为前序遍历访问顺序是root,left,right，而栈是FILO,所以子树的入栈顺序从，最右边，往左边入栈。
public List<Integer> preorder(Node root) {
List<Integer> list = new ArrayList<>();
if (root == null) return list;
Stack<Node> stack = new Stack<>();
stack.add(root);
while (!stack.empty()) {
root = stack.pop();
list.add(root.val);
for (int i = root.children.size() - 1; i >= 0; i--)
stack.add(root.children.get(i));
}
return list;
}
中序遍历
访问顺序，是先中序访问左子树，然后根节点，然后中序访问右子树。
二叉搜索树的中序遍历是升序或者降序
二叉树的中序遍历
- 二叉树的前序遍历递归实现
public List<Integer> inorderTraversal(TreeNode root) {
if(root==null)
return list;
inorderTraversal(root.left);
list.add(root.val);
inorderTraversal(root.right);
return list;
}
- 迭代发实现二叉树的中序遍历，用node指向root,循环执行一下操作
如果node不为空，将node入栈，然后node=node的左子树，
如果node为空，结束遍历，如果栈不为空，弹出栈顶元素，并且让node指向他，对node经行访问，然后node指向node右子树，继续循环
public List<Integer> inorderTraversal12(TreeNode root) {
List<Integer> list=new ArrayList<>();
if(root==null)
return list;
Stack<TreeNode> stack=new Stack<>();
TreeNode node=root;
while (true){
while(node!=null){
stack.push(node);
node=node.left;
}
if(stack.isEmpty())
return list;
node = stack.pop();
list.add(node.val);
node=node.right;
}
}
后序遍历
二叉树的后序遍历方法
遍历顺序，先后序遍历二叉树的左子树，后序遍历二叉树的右子树，根节点
- 二叉树的后序遍历递归实现
List<Integer> list=new ArrayList<>();
public List<Integer> postorderTraversal(TreeNode root){
if(root==null)
return list;
postorderTraversal(root.left);
postorderTraversal(root.right);
list.add(root.val);
return list;
}
- 二叉树的后序遍历迭代实现，将root入栈，执行一下循环
用node指向栈顶元素，如果栈顶元素是叶子节点，或者之前访问的节点是node节点的子节点，将栈顶元素出栈，并访问它，否则判断node的右子树是否为空，不为空，将node的右子树入栈，同理，将左子树入栈
List<Integer> list=new ArrayList<>();
//判单是否是不是叶子节点
private boolean isLeaf(TreeNode node){
if(node.left==null && node.right==null)
return true;
return false;
}
//判断child节点是不是nodede 叶子节点
private boolean isChildren(TreeNode node,TreeNode child){
if(node.left==child ||node.right==child)
return true;
return false;
}
public List<Integer> postorderTraversal(TreeNode root) {
if(root==null)
return list;
Stack<TreeNode> stack=new Stack<>();
stack.push(root);
TreeNode temp=root; //记录入栈的元素
while(!stack.isEmpty()){
TreeNode node = stack.peek();
//判断栈顶元素是不是叶子节点，或者刚刚访问的节点是不是node的孩子节点
if(isLeaf(node)|| isChildren(node,temp)){
temp=stack.pop();
list.add(temp.val);
//出栈元素
}else{
//左右子树入栈
if(node.right!=null)
stack.push(node.right);
if(node.left!=null)
stack.push(node.left);
}
}
return list;
}
在前，中，后序的迭代遍历中，前序最为简单了，访问顺序为 根 --> 左–>右 因为碰到根节点，最先访问了，而在后序遍历中根节点却是最后访问了，后序遍历的顺序为 左–> 右–>根，如果将访问的顺序的倒置过来也就是 根–>右–<左 ，也就和前序遍历差不多了，最后在将访问顺序倒置一下即可。
实现方法：
public List<Integer> postorderTraversal(TreeNode root) {
LinkedList<Integer> result = new LinkedList<>();
Deque<TreeNode> stack = new ArrayDeque<>();
TreeNode p = root;
while(!stack.isEmpty() || p != null) {
if(p != null) {
stack.push(p);
result.addFirst(p.val); // Reverse the process of preorder
p = p.right; // Reverse the process of preorder
} else {
TreeNode node = stack.pop();
p = node.left; // Reverse the process of preorder
}
}
return result;
}
多叉树的后序遍历题目
- 递归实现
List<Integer> list=new ArrayList<>();
public List<Integer> postorder(Node root) {
if(root==null)return list;
for (Node child : root.children) {
postorder(child);
}
list.add(root.val);
return list;
}
- 迭代法实现遍历
public List<Integer> postorder(Node root) {
List<Integer> list=new ArrayList<>(); //用链表替换比较合适
if(root==null)
return list;
Stack<Node> stack=new Stack<>();
stack.push(root);
while(!stack.empty()){
root=stack.pop();
list.add(0,root.val);
for (Node child : root.children) {
stack.push(child);
}
}
return list;
}
二叉树的层次遍历
访问顺序，从根节点一层一层向下访问
实现思路，使用队列
1 将根节点入队列
2 循环执行一下操作，直到队列为空
- 将对头节点A出队，经行访问
- 将A的左子节点入队
- 将A的右子节点入队
public void levelOrder(Visitor<E> visitor){
if(root==null||visitor==null)
return;
Queue<Node<E>> queue=new LinkedList<>();
queue.offer(root);
while(!queue.isEmpty()){
Node<E> poll = queue.poll();
if(visitor.visit(poll.element))
return;
if(poll.left!=null)
queue.offer(poll.left);
if(poll.right!=null)
queue.offer(poll.right);
}
}