先序遍历非递归
//https://leetcode-cn.com/problems/binary-tree-preorder-traversal/
public List<Integer> preorderTraversal(TreeNode root) {
if(root==null){
return new ArrayList<>();
}
List<Integer> list=new ArrayList<>();
Stack<TreeNode> stack=new Stack<>();
stack.push(root);
//头左右
while (!stack.isEmpty()){
TreeNode treeNode = stack.pop();
list.add(treeNode.val);
//先压右,栈是后进后出的,左边遍历比右快
if(treeNode.right!=null){
stack.push(treeNode.right);
}
if(treeNode.left!=null){
stack.push(treeNode.left);
}
}
return list;
}
中序遍历非递归
//https://leetcode-cn.com/problems/binary-tree-inorder-traversal/
List<Integer> list=new ArrayList<>();
Stack<TreeNode> stack=new Stack<>();
while (root!=null||!stack.isEmpty()){
//一直找左边
if(root!=null){
stack.push(root);
root=root.left;
}else{
//左边没有找右边
TreeNode node=stack.pop();
list.add(node.val);
root=node.right;
}
}
return list;
后序遍历非递归
//https://leetcode-cn.com/problems/binary-tree-postorder-traversal/
public List<Integer> postorderTraversal(TreeNode root) {
if(root==null){
return new ArrayList<>();
}
ArrayList<Integer> list=new ArrayList<>();
Stack<TreeNode> stack=new Stack<>();
//反转栈
Stack<TreeNode> stack1=new Stack<>();
stack.push(root);
//头右左
while (!stack.isEmpty()){
TreeNode treeNode=stack.pop();
stack1.push(treeNode);
if(treeNode.left!=null){
stack.push(treeNode.left);
}
if(treeNode.right!=null){
stack.push(treeNode.right);
}
}
System.out.println(stack);
//左右头
while (!stack1.isEmpty()){
list.add(stack1.pop().val);
}
return list;
}
树的路径总和I
//https://leetcode-cn.com/problems/path-sum/submissions/
class Solution {
boolean flag=false;
public boolean hasPathSum(TreeNode root, int targetSum) {
hasPathSum(root,targetSum,0);
return flag;
}
public void hasPathSum(TreeNode root,int targetSum,int cur){
if(root!=null){
int num=root.val+cur;
if(root.left==null&&root.right==null&&num==targetSum){
flag=true;
}
hasPathSum(root.left,targetSum,num);
hasPathSum(root.right,targetSum,num);
}
}
}
求和路径
//https://leetcode-cn.com/problems/paths-with-sum-lcci/
class Solution {
int count=0;
public int pathSum(TreeNode root, int sum) {
if(root!=null){
pathSum(root,sum,0);
pathSum(root.left,sum);
pathSum(root.right,sum);
}
return this.count;
}
public void pathSum(TreeNode root,int sum,int cur){
if(root!=null){
int num=cur+root.val;
System.out.println(num);
if(num==sum){
System.out.println(1);
this.count++;
}
pathSum(root.left,sum,num);
pathSum(root.right,sum,num);
}
}
}
二叉树的深度
//https://leetcode-cn.com/problems/er-cha-shu-de-shen-du-lcof/
class Solution {
public int maxDepth(TreeNode root) {
if(root!=null){
return Math.max(maxDepth(root.left),maxDepth(root.right))+1;
}
return 0;
}
}
判断树是否平衡
class Solution {
boolean flag=true;
public boolean isBalanced(TreeNode root) {
//注意剪枝条件
if(root!=null&&flag==true){
int left=height(root.left);
int right=height(root.right);
if(Math.abs(left-right)>1){
flag=false;
}
isBalanced(root.left);
isBalanced(root.right);
}
return flag;
}
public int height(TreeNode node){
if(node!=null){
int left=height(node.left);
int right=height(node.right);
return Math.max(left,right)+1;
}
return 0;
}
}
平衡二叉树第k大结点
//https://leetcode-cn.com/problems/er-cha-sou-suo-shu-de-di-kda-jie-dian-lcof/
class Solution {
List<Integer> list=new ArrayList();
public int kthLargest(TreeNode root, int k) {
order(root);
return list.get(list.size()-k);
}
public void order(TreeNode root){
if(root!=null){
order(root.left);
list.add(root.val);
order(root.right);
}
}
}
二叉树的剪枝
//https://leetcode-cn.com/problems/binary-tree-pruning/comments/
class Solution {
public TreeNode pruneTree(TreeNode root) {
if(root!=null){
TreeNode left=pruneTree(root.left);
TreeNode right=pruneTree(root.right);
root.left=left;
root.right=right;
if((left==null)&&(right==null)&&root.val==0){
return null;
}
return root;
}
return null;
}
}
二叉树搜索树的公共祖先
//https://leetcode-cn.com/problems/er-cha-sou-suo-shu-de-zui-jin-gong-gong-zu-xian-lcof/
//利用二叉树搜索树的有序性
class Solution {
TreeNode node=null;
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
dfs(root,p,q);
return node;
}
//注意p,q大小不知道谁大谁小都需要讨论好
void dfs(TreeNode root, TreeNode p, TreeNode q){
if(root!=null&&node==null){
if(root.val>=p.val&&root.val<=q.val&&node==null){
node=root;
}
else if(root.val>=q.val&&root.val<=p.val&&node==null){
node=root;
}
dfs(root.left,p,q);
dfs(root.right,p,q);
}
}
}
二叉树的祖先问题
//https://leetcode-cn.com/problems/er-cha-shu-de-zui-jin-gong-gong-zu-xian-lcof/submissions/
class Solution {
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
if(root!=null){
TreeNode left=lowestCommonAncestor(root.left, p, q);
TreeNode right=lowestCommonAncestor(root.right,p,q);
if(root==p||root==q){
return root;
}
if(left!=null&&right!=null){
return root;
}
if(right!=null&&left==null){
return right;
}
if(left!=null&&right==null){
return left;
}
if(left==null&&right==null){
return null;
}
}
return null;
}
}
具有所有最深节点的最小子树
class Solution {
public TreeNode subtreeWithAllDeepest(TreeNode root) {
List<TreeNode> treeNode=getTreeNode(root);
System.out.println(treeNode);
return dfs(root,treeNode);
}
//获取深度最深的结点的集合
private List<TreeNode> getTreeNode(TreeNode root) {
Queue<TreeNode> queue=new LinkedList<>();
queue.offer(root);
HashMap<TreeNode,Integer> map=new HashMap<>();
List<TreeNode> list=new ArrayList<>();
int max=Integer.MIN_VALUE;
map.put(root,1);
while (!queue.isEmpty()){
int size = queue.size();
for (int i=0;i<size;i++){
TreeNode node = queue.poll();
int height = map.get(node);
max=Math.max(height,max);
if(node.left!=null){
map.put(node.left,height+1);
queue.offer(node.left);
}
if(node.right!=null){
map.put(node.right,height+1);
queue.offer(node.right);
}
}
}
for(TreeNode treeNode:map.keySet()){
if(map.get(treeNode)==max){
list.add(treeNode);
}
}
return list;
}
//获取最深结点的共同祖先的模板,后序遍历
public TreeNode dfs(TreeNode root,List<TreeNode> list){
if(root!=null){
TreeNode left=dfs(root.left,list);
TreeNode right=dfs(root.right,list);
if(list.contains(root)){
return root;
}
if(left==null&&right==null){
return null;
}
if(left!=null&&right==null){
return left;
}
if(left==null&&right!=null){
return right;
}
if(left!=null&&right!=null){
return root;
}
}
return null;
}
}
二叉树最大宽度(算空值)
//https://leetcode-cn.com/problems/maximum-width-of-binary-tree/submissions/
class Solution {
public int widthOfBinaryTree(TreeNode root) {
if(root==null){
return 0;
}
Deque<TreeNode> queue=new LinkedList<>();
queue.add(root);
HashMap<TreeNode,Integer> map=new HashMap<>();
map.put(root,1);
int max=Integer.MIN_VALUE;
while (!queue.isEmpty()){
int size=queue.size();
int left=map.get(queue.getFirst());
int right=map.get(queue.getLast());
max=Math.max(max,right-left+1);
for (int i=0;i<size;i++){
TreeNode treeNode = queue.pollFirst();
Integer pos = map.get(treeNode);
//利用满二叉树的思想
if(treeNode.left!=null){
queue.offerLast(treeNode.left);
map.put(treeNode.left,2*pos);
}
if(treeNode.right!=null){
queue.offerLast(treeNode.right);
map.put(treeNode.right,2*pos+1);
}
}
}
return max;
}
}