剑指offer 二叉树专题 刷题记录(1)

简介: 剑指offer 二叉树专题 刷题记录(1)

4、重建二叉树


image.png


/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        TreeNode root=reConstructBinaryTree(pre,0,pre.length-1,in,0,in.length-1);
        return root;
    }
    public TreeNode reConstructBinaryTree(int[] pre,int preStart,int preEnd,int[] in,int inStart,int inEnd){
        if(preStart>preEnd||inStart>inEnd){
            return null;
        }
        TreeNode root=new TreeNode(pre[preStart]);
        for(int i=inStart;i<=inEnd;i++){
            if(pre[preStart]==in[i]){
                root.left=reConstructBinaryTree(pre,preStart+1,preStart+i-inStart,in,inStart,i-1);
                root.right=reConstructBinaryTree(pre,preStart+i-inStart+1,preEnd,in,i+1,inEnd);
                break;
            }
        }
        return root;
    }
}


17、数的子结构

两次递归


public class Solution {
    public static boolean HasSubtree(TreeNode root1, TreeNode root2) {
    boolean result = false;
    //当Tree1和Tree2都不为零的时候,才进行比较。否则直接返回false
    if (root2 != null && root1 != null) {
      //如果找到了对应Tree2的根节点的点
      if(root1.val == root2.val){
        //以这个根节点为为起点判断是否包含Tree2
        result = doesTree1HaveTree2(root1,root2);
      }
      //如果找不到,那么就再去root的左儿子当作起点,去判断时候包含Tree2
      if (!result) {
        result = HasSubtree(root1.left,root2);
      }
      //如果还找不到,那么就再去root的右儿子当作起点,去判断时候包含Tree2
      if (!result) {
        result = HasSubtree(root1.right,root2);
         }
      }
        //返回结果
    return result;
  }
  public static boolean doesTree1HaveTree2(TreeNode node1, TreeNode node2) {
    //如果Tree2已经遍历完了都能对应的上,返回true
    if (node2 == null) {
      return true;
    }
    //如果Tree2还没有遍历完,Tree1却遍历完了。返回false
    if (node1 == null) {
      return false;
    }
    //如果其中有一个点没有对应上,返回false
      if (node1.val != node2.val) { 
        return false;
    }
      //如果根节点对应的上,那么就分别去子节点里面匹配
      return doesTree1HaveTree2(node1.left,node2.left) && doesTree1HaveTree2(node1.right,node2.right);
    }
}


18、二叉树的镜像


##采用递归思想##


1.先处理根节点。若根节点为空,或为单个节点,则直接返回。否则交换左右节点


2.处理根节点的左子树


3.处理根节点的右子树


import java.util.*;
public class Solution {
    public TreeNode Mirror (TreeNode pRoot) {
        if(pRoot==null)
            return pRoot;
        if(pRoot.left==null && pRoot.right==null)
            return pRoot;
        //处理根节点,交换左右节点
        TreeNode temp=pRoot.left;
        pRoot.left=pRoot.right;
        pRoot.right=temp;
        //处理左子树
        Mirror(pRoot.left);
        //处理右子树
        Mirror(pRoot.right);
        return pRoot;
    }
}


22、从上往下打印二叉树

层序遍历,用栈


import java.util.ArrayList;
import java.util.Queue;
import java.util.LinkedList;
/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;
    public TreeNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
        ArrayList<Integer> list=new ArrayList<Integer>();
        Queue<TreeNode> queue=new LinkedList<TreeNode>();
        if(root==null)
        {
            return list;
        }
        queue.add(root);
        while(!queue.isEmpty()){
            TreeNode temp=queue.poll();
            list.add(temp.val);
            if(temp.left!=null){
                queue.add(temp.left);
            }
            if(temp.right!=null){
                queue.add(temp.right);
            }
        }
        return list;
    }
}
目录
相关文章
|
7月前
【一刷《剑指Offer》】面试题 23:从上往下打印二叉树
【一刷《剑指Offer》】面试题 23:从上往下打印二叉树
|
7月前
【一刷《剑指Offer》】面试题 15:链表中倒数第 k 个结点
【一刷《剑指Offer》】面试题 15:链表中倒数第 k 个结点
|
7月前
|
存储 算法
六六力扣刷题链表之合并两个有序链表
六六力扣刷题链表之合并两个有序链表
51 0
|
7月前
|
机器学习/深度学习 算法
六六力扣刷题双指针之删除链表的倒数第N个节点
六六力扣刷题双指针之删除链表的倒数第N个节点
70 0
|
7月前
|
存储 算法
六六力扣刷题链表之链表相交
六六力扣刷题链表之链表相交
53 0
|
算法 Cloud Native
【刷题日记】429. N 叉树的层序遍历
本次刷题日记的第 27 篇,力扣题为:429. N 叉树的层序遍历 ,中等
|
Cloud Native
【刷题日记】589. N 叉树的前序遍历
本次刷题日记的第 4 篇,力扣题为:589. N 叉树的前序遍历 ,简单
|
Cloud Native
【刷题日记】590. N 叉树的后序遍历
本次刷题日记的第 5 篇,力扣题为:【刷题日记】590. N 叉树的后序遍历 ,简单
|
算法
刷题算法:快慢指针法
快慢指针法指的就是操作数组、链表及字符串等使用两个起点相同但前进步数不同的指针。相对于利用多次循环解决问题,快慢指针法的时间复杂度较低,执行效率高。对于快慢指针法根据题目可供调整的无非就为两点: 起点 前进步数 快慢指针法起点位置的选择通常是采取一个 if else 语句进行判断,而在未达到正确起点位置时,两个指针的前进步数将保持一致。而实现快慢指针前进步数不一致移动的方法通常是采取一个 for 循环进行移动指针,注意越界问题。此处 for 循环迭代有两种方案: 既可以设置快慢指针的步数一致,再在 i
119 0
剑指offer 二叉树专题 刷题记录(2)
剑指offer 二叉树专题 刷题记录(2)
116 0
剑指offer 二叉树专题 刷题记录(2)