目录
145、二叉树的后序遍历 - 力扣
思路:后序遍历:左右根。非递归写法,先判断左树,然后判断右树,若右树不为空且之前没有被处理过,最后把根节点压入栈中。
class Solution {
public List<Integer> postorderTraversal(TreeNode root) {
List<Integer> ret = new ArrayList<>();
if (root == null){
return ret;
}
TreeNode cur = root;
// 上一个完全处理过的节点(左右根都处理完毕的节点)
TreeNode prev = null;
Deque<TreeNode> stack = new ArrayDeque<>();
while (cur != null || (!stack.isEmpty())){
// 先一路向左走到根儿
while (cur != null){
stack.push(cur);
cur = cur.left;
}
// 此时左树为空,cur取栈顶元素,第二次访问
cur = stack.pop();
// 判断右树是否为空或者被我们访问过
if (cur.right == null || prev == cur.right) {
ret.add(cur.val);
// 当前节点cur就是最后处理的根节点,更新prev引用,变为cur
prev = cur;
cur = null;
}else {
// 此时右树不为空且没有处理过,就需要把根节点再压入栈中,继续处理右子树
stack.push(cur);
cur = cur.right;
}
}
return ret;
}
}
94、二叉树的中序遍历 - 力扣
思路:先遍历左树,一直向左走到底,最后一个值存放在栈中,然后出栈,访问根节点,最后遍历访问右子树。
class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> ret = new ArrayList<>();
if (root == null) {
return ret;
}
//走到当前节点
TreeNode cur = root;
Deque<TreeNode> stack = new ArrayDeque<>();
// 当前树不为空 或者 当前栈不为空,一直向左走到根
while (cur != null || !stack.isEmpty()) {
while (cur != null) {
//当前树不为空,直接将当前节点入栈
stack.push(cur);
cur = cur.left;
}
//此时cur为空,说明走到了null,此时栈顶就存放了左树为空的节点,将该节点出栈
cur = stack.pop();
ret.add(cur.val);
//继续访问右子树
cur = cur.right;
}
return ret;
}
}
572、另一棵树的子树 - 力扣
思路:p和q是两颗相同的树 || p包含q || q包含p,满族任意一个条件就可以证明一棵树是另一颗的子树。
class Solution {
// 传入两颗树root和subRoot,就能判断出subRoot是否是root的子树
public boolean isSubtree(TreeNode root, TreeNode subRoot) {
//边界
if (root == null && subRoot == null){
return true;
}
if (root == null || subRoot == null){
return false;
}
// root和subRoot相同 || 左树包含 || 右树包含
return isSameTree(root, subRoot) || isSubtree(root.left,subRoot) || isSubtree(root.right,subRoot);
}
public boolean isSameTree(TreeNode p, TreeNode q) {
if (p == null && q == null){
return true;
}
if (p == null || q == null){
return false;
}
return p.val == q.val &&
isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
}
}
236、二叉树的最近公共祖先 - 力扣
思路:先找p和q的所有祖先,p和q一定不在同一子树中,从节点开始遍历,能同时将p和q这两个节点找到就是他俩的祖先。p和q可能出现的位置:左右子树,左子树和根,右子树和根。
class Solution {
// 最近公共祖先
private TreeNode lca;
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
// 找到p和q的所有祖先
findNode(root,p,q);
return lca;
}
/**
* 以当前root为根节点的二叉树能否找到节点p或q
* @param root
* @param p
* @param q
*/
private boolean findNode(TreeNode root, TreeNode p, TreeNode q) {
//边界
if (root == null) {
return false;
}
//用整型变量来记录是否找到节点
//先在左子树中寻找p和q
//若left==1 =》 在左子树至少找到了一个节点p或者q
int left = findNode(root.left,p,q) ? 1 : 0;
//再在右子树中寻找p和q
//若right==1 =》 在右子树至少找到了一个节点p或者q
int right = findNode(root.right,p,q) ? 1 : 0;
//最后在根节点中寻找p和q
//若mid==1 => 根节点就是p或者q
int mid = (root == p || root == q) ? 1 : 0;
if (left + mid + right == 2) {
//说明一定把p和q都找到了,且p和q不在一棵子树中
lca = root;
}
//此时返回是boolean类型
//返回true,说明找到p或者q或者p q都找到
//返回false,说明没找到 p q
return (left + mid + right) > 0;
}
}
JZ36、二叉搜索树与双向链表 - 牛客
思路:因为要得到一个排序的双向链表,将BST进行中序遍历;原地操作,left左子树就相当于前驱节点,right右子树就相当于后继节点。
public class Solution {
//传入一颗以root为根的BST就能转换为双向链表,返回链表的头节点
public TreeNode Convert(TreeNode pRootOfTree) {
//边界
if(pRootOfTree == null) {
return null;
}
//对树进行中序遍历
//此时的遍历 => 转换操作 => 先将左子树转换为双向链表
//通过子函数就转了Conver(root.left);
//此时leftHead就是左链表的头节点
TreeNode leftHead = Convert(pRootOfTree.left);
//继续处理根节点
//左子树的尾节点 root.prev(left) = lifeTail
//找到左链表的尾节点
TreeNode leftTail = leftHead;
//此时要判空
while (leftTail != null && leftTail.right != null) {
leftTail = leftTail.right;
}
//此时leftTail就处于左侧链表的尾节点
if (leftTail != null) {
pRootOfTree.left = leftTail;
leftTail.right = pRootOfTree;
}
//再递归处理右子树,转换右子树为链表,返回右侧链表的头节点
TreeNode rightHead = Convert(pRootOfTree.right);
//在和根节点拼接
if (rightHead != null) {
pRootOfTree.right = rightHead;
rightHead.left = pRootOfTree;
}
//返回整个大链表的根节点
//左树不为空返回左侧头节点
//否则返回根节点
return leftHead == null ? pRootOfTree : leftHead;
}
}
本小节完^_^