数据结构与算法——二叉树
文章目录
- 前言
- 一、二叉树的四种遍历
-
- 1.先序遍历
- 2.中序遍历
- 3.后序遍历
- 4. 层序遍历
- 二、二叉树的高度及特殊二叉树判断
-
- 1. 二叉树的高度
- 2.判断一棵二叉树是否为平衡二叉树
- 3.判断一棵二叉树是否为完全二叉树
- 总结
前言
二叉树是一种重要的数据存储结构，与二叉树相关的算法也有很多，本文简单介绍二叉树的先序遍历、中序遍历、后序遍历、层序遍历，四种遍历方式的递归及非递归解法；求解二叉树的高度；判断一棵二叉树是否为平衡二叉树 、完全二叉树 。本文涉及的二叉树定义为：
public class TreeNode {
//二叉树根结点的值
int val;
//左子树
TreeNode left;
//右子树
TreeNode right;
TreeNode() {}
TreeNode(int val) { this.val = val; }
TreeNode(int val, TreeNode left, TreeNode right) {
this.val = val;
this.left = left;
this.right = right;
}
}
一、二叉树的四种遍历
1.先序遍历
先序遍历也称前序遍历，遍历顺序为 根结点 -> 左子树 -> 右子树 简称 根左右
根据先序遍历的特点，先访问根结点然后访问根结点的左子树，访问左子树时左子树成为新的根结点继续重复先序遍历的过程，因此该二叉树的前序遍历顺序为 4 -> 2 -> 1 -> 3 -> 7 -> 6 ->9
递归解法
class Solution {
//list集合存储二叉树遍历先序遍历结点的值
List <Integer> list = new ArrayList<>();
public List<Integer> preorderTraversal(TreeNode root) {
if(root == null) return list;
//先访问结点，并将结点的值加入list集合
list.add(root.val);
//遍历根结点的左子树
preorderTraversal(root.left);
//遍历根结点的右子树
preorderTraversal(root.right);
return list;
}
}
非递归解法
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
//list集合存储二叉树遍历先序遍历结点的值
List<Integer> list = new ArrayList<Integer>();
if (root == null) {
return list;
}
//创建栈存储结点
Stack<TreeNode> stack = new Stack<TreeNode>();
TreeNode curNode = root;
// curNode 指向正在访问的结点
while(!stack.isEmpty() || curNode !=null) {
if (curNode != null) {
//遍历访问 压栈
list.add(curNode.val);
stack.push(curNode);
//遍历左子树
curNode = curNode.left;
}else {
//左子树为空 栈顶结点出栈访问右子树
curNode = stack.pop();
curNode =curNode.right;
}
}
return list;
}
}
2.中序遍历
中序遍历，遍历顺序为 左子树 -> 根结点 -> 右子树 简称 左根右
根据中序遍历的特点，一直遍历二叉树根结点的左子树，待左子树为空，再返回访问根结点，最后遍历访问右子树，因此该二叉树的中序遍历顺序为 1 -> 2 -> 3 ->4 ->6 ->7 ->9
递归解法
class Solution {
//list集合存储二叉树中序遍历结点的值
List<Integer> list = new ArrayList<>();
public List<Integer> inorderTraversal(TreeNode root) {
if(root == null) return list;
//先一直遍历左子树
inorderTraversal(root.left);
//访问结点，并将结点的值加入list集合
list.add(root.val);
//遍历右子树
inorderTraversal(root.right);
return list;
}
}
非递归解法
class Solution {
//list集合存储二叉树中序遍历结点的值
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> list = new ArrayList<Integer>();
if (root == null) {
return list;
}
//创建栈存储结点
Stack< TreeNode> stack = new Stack<TreeNode>();
TreeNode curNode =root;
//临时结点指向正在访问的结点
while(!stack.isEmpty() || curNode != null ) {
if(curNode != null) {
//一直向左子树遍历压栈
stack.push(curNode);
curNode = curNode.left;
}else {
//左子树为空 栈顶结点出栈访问 随后curNode指向右节点
curNode = stack.pop();
list.add(curNode.val);
curNode = curNode.right;
}
}
return list;
}
}
3.后序遍历
后序遍历，遍历顺序为 左子树 -> 右子树 -> 根结点 简称 左右根
根据后序遍历的特点，一直遍历二叉树根结点的左子树，左子树为空时再去遍历访问右子树，待右子树也为空时，才醉后遍历访问根结点，该二叉树后序遍历结果为 1 -> 3 -> 2 -> 6 -> 9 ->7 -> 4
递归解法
class Solution {
//list集合存储二叉树后序遍历结点的值
List <Integer> list = new ArrayList<>();
public List<Integer> postorderTraversal(TreeNode root) {
if(root == null) return list;
//遍历左子树
postorderTraversal(root.left);
//遍历右子树
postorderTraversal(root.right);
// 访问结点，并将结点的值加入list集合
list.add(root.val);
return list;
}
}
非递归解法
class Solution {
public List<Integer> postorderTraversal(TreeNode root) {
//list集合存储二叉树后序遍历结点的值
List <Integer> list = new ArrayList<>();
//创建栈存储结点
Stack<TreeNode> stack = new Stack();
//临时结点 cur 指向当前访问结点
TreeNode cur = root;
//临时结点 pre 指向上一次访问的结点
TreeNode pre = null;
while(!stack.isEmpty() || cur != null){
while(cur != null){
stack.push(cur);
cur = cur.left;
}
//cur 指向栈顶结点 但不出栈 此时cur 的左子树为空
cur = stack.peek();
if(cur.right == null || cur.right == pre){
//如果cur 的右子树也为空 或者 cur的右子树已经访问过了，
//则栈顶结点真正出栈 pre指向栈顶结点也就是要访问的结点进行记录
//最后cur所指向的栈顶结点已经访问过了，cur置为空
pre = stack.pop();
list.add(pre.val);
cur = null;
}else{
//右节点不为空 且右子树没访问过，cur就遍历右子树
cur = cur.right;
}
}
return list;
}
}
pre指向上一次访问结点的作用： 由于后序遍历是 左右根 只有遍历了根结点才知晓左子树，左子树为空时，再遍历根结点然后访问右子树。只有左右子树都为空或者已经访问过，才访问根结点。所以根结点遍历了两次，且根结点右子树为空或者已经访问过，才访问根结点。
4. 层序遍历
层序遍历，遍历顺序为一层层进行遍历，层序遍历比较符合我们平时直观上的遍历。
根据层序遍历的特点，该二叉树层序遍历的结果为 4 -> 2 -> 7 ->1 -> 3 ->6 ->9 ，根据层序遍历的先后顺序我们可以观察到，每次访问一个结点就要记录这个结点的左右子树，待本层访问结束就会按照记录的先后顺序继续访问下一层，符合队列的先进先出特点，因此我们用队列进行辅助遍历。
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
//记录二叉树某一层结点个数，从根结点 1 开始
int levelSize = 1;
List<List<Integer>> res = new ArrayList<List<Integer>>();
if(root == null) return res;
//list集合存储每一层的结点的值
List<Integer> list = new ArrayList<Integer>();
//创建队列 存储结点
Queue<TreeNode> queue =new LinkedList<>();
//根结点入队
queue.offer(root);
//层序遍历
while(!queue.isEmpty()) {
//队头结点出队
TreeNode node = queue.poll();
//本层结点数 -1
levelSize--;
list.add(node.val);
if(node.left != null) {
queue.offer(node.left);
}
if(node.right != null) {
queue.offer(node.right);
}
//每一层访问结束 数的高度 + 1 levelSize等于下一层的结点个数
if(levelSize == 0) {
res.add(list);
levelSize = queue.size();
list = new ArrayList<Integer>();
}
}
return res;
}
}
二叉树前序、中序、后序、层序遍历 时间复杂度为 O（n） ， n为二叉树结点个数。
空间复杂度如果单是遍历，前、中、后序遍历都是O（h）, h为二叉树高度，但是用list集合存储遍历结果 所以空间复杂度为O（n）， n为二叉树结点个数，层序遍历空间复杂度为O（n) 。
二、二叉树的高度及特殊二叉树判断
1. 二叉树的高度
求解二叉树的高度，即为求根结点的高度，方法分为递归与非递归两种
递归解法
public int height(TreeNode root) {
if(root == null)
return 0;
return 1 + Math.max(height(root.left), height(root.right));
}
非递归解法
public int height(TreeNode root) {
if(root == null)
return 0;
//记录二叉树的高度
int height = 0;
//记录二叉树某一层结点个数，从根结点 1 开始
int levelSize = 1;
Queue<TreeNode> queue = new LinkedList<>();
//根结点入队
queue.offer(root);
//层序遍历
while(!queue.isEmpty()) {
TreeNode node = queue.poll();
levelSize--;
if(node.left != null) {
queue.offer(node.left);
}
if(node.right != null) {
queue.offer(node.right);
}
//每一层访问结束 数的高度 + 1 levelSize等于下一层的结点个数
if(levelSize == 0) {
height++;
levelSize = queue.size();
}
}
return height;
}
时间复杂度：O(n) 空间复杂度：O(n) n为二叉树结点个数
2.判断一棵二叉树是否为平衡二叉树
平衡二叉树 ： 二叉树中每个节点 的左右两个子树的高度差的绝对值不超过 1
采用类似后序遍历的递归方式，对于当前遍历到的节点，先递归地判断其左右子树是否平衡，再判断当前结点的根结点是否平衡。如果一棵子树是平衡的，则返回其高度（高度一定是非负整数），否则返回 -1。如果存在一棵子树不平衡，则整个二叉树一定不平衡。
class Solution {
public boolean isBalanced(TreeNode root) {
return height(root) >=0 ;
}
public int height(TreeNode node){
if(node == null)
return 0;
//遍历左子树，遍历右子树
int l = height(node.left), r = height(node.right);
//如果此结点的子树是平衡的，返回此结点的高度 左右子树最大高度 + 1
if(l >= 0 && r >=0 && Math.abs(l-r) <= 1 ){
return Math.max(l,r) + 1;
}else{
return -1;
}
}
}
时间复杂度：O(n) 空间复杂度：O(n) n为二叉树结点个数
3.判断一棵二叉树是否为完全二叉树
完全二叉树：
public boolean isComplete(TreeNode root) {
if(root == null)
return false;
boolean leaf = false;
Queue<TreeNode> queue = new LinkedList<>();
//根结点入队
queue.offer(root);
//层序遍历
while(!queue.isEmpty()) {
TreeNode node = queue.poll();
//此节点应该是叶子结点，但是实际如果不是叶子结点 ，leaf为true 说明这个二叉树不是完全二叉树
if(leaf && (node.left != null || node.right !=null)) {
return false;
}
if (node.left != null) {
queue.offer(node.left);
}else if(node.right == null) {
//左结点为空，右结点不为空 二叉树一定不是完全二叉树
return false;
}
if (node.right != null) {
queue.offer(node.right);
}else {
//左结点为空或者左结点不为空 && 右结点一定为空 若是完全二叉树，此结点应该为叶子结点
leaf = true;
}
}
return true;
}
时间复杂度：O(n) 空间复杂度：O(n) n为二叉树结点个数
总结
1. 二叉树的前序、中序、后序遍历的非递归解法，观察发现其实是一个模板，根据这个模板结合三种遍历各自特有的性质，就可以写出三种遍历的非递归代码。
if(root == null)
return;
//临时结点cur指向当前访问的结点
TreeNode curNode = root;
//后序遍历需要再加一个临时结点指向上一次遍历的结点
while(栈非空 || curNode != null)
{
if(curNode != null){
}else{
}
}
2. 而特殊二叉树的判断和求二叉树高度，则需要进行层序遍历，在层序遍历的基础之上加上各自特殊性质的逻辑判断即可完全求解。