剑指offer（1/19）

最新推荐文章于 2023-05-07 22:52:08 发布
最新推荐文章于 2023-05-07 22:52:08 发布
阅读量86 收藏
点赞数
分类专栏： 剑指offer 算法学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44645822/article/details/112802059
版权

二叉树的下一个结点

给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。

/*
public class TreeLinkNode {
    int val;
    TreeLinkNode left = null;
    TreeLinkNode right = null;
    TreeLinkNode next = null;

    TreeLinkNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    public TreeLinkNode GetNext(TreeLinkNode pNode)
    {
        if(pNode == null){
            return null;
        }
        if(pNode.right != null){
            pNode = pNode.right;
            while(pNode.left != null){
                pNode = pNode.left;
            }
            return pNode;
        }
        while(pNode.next != null){
            if(pNode.next.left == pNode){
                return pNode.next;
            }
            pNode = pNode.next;
        }
        return null;
    }
}

class Solution {
public:
    TreeLinkNode* GetNext(TreeLinkNode* node)
    {
        if(node==NULL) return NULL;
        if(node->right!=NULL){    //如果有右子树，则找右子树的最左节点
            node = node->right;
            while(node->left!=NULL) node = node->left;
            return node;
        }
        while(node->next!=NULL){ //没右子树，则找第一个当前节点是父节点左孩子的节点
            if(node->next->left==node) return node->next;
            node = node->next;
        }
        return NULL;   //退到了根节点仍没找到，则返回null
    }
};

对称的二叉树

请实现一个函数，用来判断一棵二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。

public class Solution {
    boolean isSymmetrical(TreeNode pRoot)
    {
        if(pRoot == null) return true;
        return isSame(pRoot.left,pRoot.right);
    }
    boolean isSame(TreeNode r1,TreeNode r2){
        if(r1 == null && r2 == null)
            return true;
        if(r1 == null || r2 == null)
            return false;
        if(r1.val != r2.val)
            return false;
        return isSame(r1.left,r2.right) && isSame(r1.right,r2.left);
    }
}

class Solution {
public:
    bool isSymmetrical(TreeNode* pRoot)
    {
        if(pRoot == NULL)
            return true;
        return isSame(pRoot->left,pRoot->right);
    }
    bool isSame(TreeNode* r1,TreeNode* r2){
        if(r1 == NULL && r2 == NULL) return true;
        if(r1 == NULL || r2 == NULL) return false;
        if(r1->val != r2->val)
            return false;
        return isSame(r1->left,r2->right) && isSame(r1->right,r2->left);
    }
};

之字型打印二叉树

请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。

*/
/**
 * 大家的实现很多都是将每层的数据存进ArrayList中，偶数层时进行reverse操作，
 * 在海量数据时，这样效率太低了。
 * （我有一次面试，算法考的就是之字形打印二叉树，用了reverse，
 * 直接被鄙视了，面试官说海量数据时效率根本就不行。）
 *
 * 下面的实现：不必将每层的数据存进ArrayList中，偶数层时进行reverse操作，直接按打印顺序存入
 * 思路：利用Java中的LinkedList的底层实现是双向链表的特点。
 *     1)可用做队列,实现树的层次遍历
 *     2)可双向遍历,奇数层时从前向后遍历，偶数层时从后向前遍历
 */
public class Solution {
    public ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
    ArrayList<ArrayList<Integer>> ret = new ArrayList<>();
    if (pRoot == null) {
        return ret;
    }
    ArrayList<Integer> list = new ArrayList<>();
    LinkedList<TreeNode> queue = new LinkedList<>();
    queue.addLast(null);//层分隔符
    queue.addLast(pRoot);
    boolean leftToRight = true;
     
    while (queue.size() != 1) {
        TreeNode node = queue.removeFirst();
        if (node == null) {//到达层分隔符
            Iterator<TreeNode> iter = null;
            if (leftToRight) {
                iter = queue.iterator();//从前往后遍历
            } else {
                iter = queue.descendingIterator();//从后往前遍历
            }
            leftToRight = !leftToRight;
            while (iter.hasNext()) {
                TreeNode temp = (TreeNode)iter.next();
                list.add(temp.val);
            }
            ret.add(new ArrayList<Integer>(list));
            list.clear();
            queue.addLast(null);//添加层分隔符
            continue;//一定要continue
        }
        if (node.left != null) {
            queue.addLast(node.left);
        }
        if (node.right != null) {
            queue.addLast(node.right);
        }
    }
     
    return ret;
    }
}
// public class Solution {
//     private ArrayList<ArrayList<Integer>> result = new  ArrayList<ArrayList<Integer>>();
//     public ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
//         if(pRoot == null) return result;
//         ArrayList<TreeNode> parent = new ArrayList<>();
//         parent.add(pRoot);
//         printline(parent, 0);
//         return result;
//     }
     
//     // 树的的结构一般使用的都是递归算来实现的
//     public void printline(ArrayList<TreeNode> nodes, int tim){
//         if(nodes.size() == 0 || nodes == null) return;
//         ArrayList<TreeNode> res = new ArrayList<>();
//         ArrayList<Integer> list = new ArrayList<>();
//         TreeNode temp;
//         for(int i=nodes.size()-1; i>=0; i--){
//             temp = nodes.get(i);
//             list.add(temp.val);
//             if(tim % 2 == 0){
//               if(temp.left != null) res.add(temp.left);
//               if(temp.right != null) res.add(temp.right);    
//             }else{
//                 if(temp.right != null) res.add(temp.right);
//                 if(temp.left != null) res.add(temp.left);
//             }
//         }
//         result.add(list);
//         printline(res, tim+1);
//     }
 
// }

class Solution {
public:
    vector<vector<int> > Print(TreeNode* pRoot) {
        vector<vector<int>> res;
        if(!pRoot)return res;
        queue<TreeNode*> que;    //建立个单向队列，用于存放节点
        bool flag=false;     //判断是否为偶数行,flag=false代表奇数行，flag=true代表偶数行
        que.push(pRoot);
        while(que.size()>0){
            vector<int> vec;    //行容器，用于存入当前行输出的结果
            int len=que.size();
            for(int i=0;i<len;i++){
                TreeNode* tmp=que.front();
                vec.push_back(tmp->val);
                que.pop();
                if(tmp->left)que.push(tmp->left);
                if(tmp->right)que.push(tmp->right);
            }
            if(flag) reverse(vec.begin(),vec.end());  //是偶数行就反转顺序
            flag=!flag;     //改变flag的值
            res.push_back(vec);
        }
        return res;
    }
};

层次遍历

从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。

public class Solution {
    ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer>> result = new ArrayList<>();
        ArrayList<Integer> list = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        TreeNode temp;
        if(pRoot == null){
            return result;
        }
        queue.offer(pRoot);
        int start = 0, end = 1;
        while(!queue.isEmpty()){
            temp = queue.poll();
            list.add(temp.val);
            start++;
            if(temp.left != null){
                queue.offer(temp.left);
            }
            if(temp.right != null){
                queue.offer(temp.right);
            }
            if(start ==end){
                start = 0;
                end = queue.size();
                result.add(list);
                list = new ArrayList<>();
            }
        }
        return result;
    }
    
}

class Solution {
public:
        vector<vector<int> > Print(TreeNode* pRoot) {
            vector<vector<int> > vec;
            if(pRoot == NULL) return vec;
            queue<TreeNode*> q;
            q.push(pRoot);
            while(!q.empty())
            {
                int lo = 0, hi = q.size();
                vector<int> c;
                while(lo++ < hi)
                {
                    TreeNode *t = q.front();
                    q.pop();
                    c.push_back(t->val);
                    if(t->left) q.push(t->left);
                    if(t->right) q.push(t->right);
                }
                vec.push_back(c);
            }
            return vec;
        }
};

序列化二叉树

请实现两个函数，分别用来序列化和反序列化二叉树

二叉树的序列化是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过 某种符号表示空节点（#），以 ！ 表示一个结点值的结束（value!）。

二叉树的反序列化是指：根据某种遍历顺序得到的序列化字符串结果str，重构二叉树。

例如，我们可以把一个只有根节点为1的二叉树序列化为"1,"，然后通过自己的函数来解析回这个二叉树

import java.lang.Integer;
/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    //使用前序遍历来序列化，遇到null就添加#！，遇到数值就添加！
    String Serialize(TreeNode root) {
        if(root==null)
            return "";
        return helpSerialize(root,new StringBuilder()).toString();
  }
    private StringBuilder helpSerialize(TreeNode node,StringBuilder sb){
        if(node==null) 
            return sb;
        sb.append(node.val).append("!");
        if(node.left!=null){
            helpSerialize(node.left,sb);
        }
        else{
            sb.append("#!");
        }
        if(node.right!=null){
            helpSerialize(node.right,sb);
        }
        else{
            sb.append("#!");
        }
        return sb;
    }
     //1!2!4!#!#!5!#!#!3!6!#!#!7!#!#!

    TreeNode Deserialize(String str) {
       if(str==null || str.length()==0){
           return  null;
       }     
        String[] strs=str.split("!");
        return helpDeserialize(strs);
  }
    private int  index=0;  
    //如果遇到了#表示，知道左边结束了，要开始建立右边了，如果再次遇到了#，表示当前整个左边要结束了要开始右子树
    //124##5##36##7##
    //先将1建立为根节点
    //然后建立左子树，2是这个1的左子节点，4是2的左子节点，1左——》2左-》4
    //然后建立4的左子节点的时候，遇到了#退出建立左子节点的递归，然后来到了建立4的右子树节点，又遇到了#号，退出了4的右子树节点递归
    //这样的话，建立4节点的左右子树都退出了，也退出4的递归，到2的右子树建立，然后字符串到5，建立5节点，2的右-》5(左右退出，和4上面的退出是相同得)
    //然后2的右子树递归退出，到1的右子树建立，建立3为1的右子树节点，然后建立3的左子树节点6，然后遇到##，同上面一样，退出6的左子树节点建立，退出6的右子树节点建立
    //到3的右子树节点7，然后7建立左右子树遇到##，也同样退出
    private TreeNode helpDeserialize(String[] str){
        if(str[index].equals("#")){
            index++;
            return null;
        }
        TreeNode root = new TreeNode(Integer.valueOf(str[index]));
        index++;
        root.left=helpDeserialize(str);
        root.right=helpDeserialize(str);
        return root;
    }
}

class Solution {
public:
    //1.将二叉树转化为字符串序列
    //例如：树：10,6,4,14,12,16 
    //序列化后：00！60！40！#！#！#！14！12！#！#！16！#！#！
    vector<int>s;
    void  Serializevector(TreeNode *root)
    {
        if(root==nullptr)//如果根节点为空，直接存入#和！
        {
            s.push_back('#');//#表示空节点
            s.push_back('!');//!表示一个节点存放完毕
            return;
        }
         vector<int>temp;
        //首先将根节点存入容器temp中，value组成的序列为除以10的模，
        int value=root->val;
        while(value!=0)
        {
            temp.push_back(value%10);
       // temp.push_back(value);
            value=value/10;
        }
        for (int i = temp.size() - 1; i >= 0 ; i--)
        {
            s.push_back( temp[i]);
        }
        s.push_back('!');//根节点存完之后输入！表示该节点存放完毕
        Serialize(root->left) ;
        Serialize(root->right);
    }
    char* Serialize(TreeNode *root) {
        Serializevector(root);//分别递归左右节点，
        char*result=new char[s.size()];//构建数的节点大小的空间
        for (int i=0;i<s.size();i++)
        {
            result[i]= (char) s[i];//依次存入到最终结果中
        }
        return result;
    }
    
   //2.反序列化二叉树，将字符串转化成树
    //序列化为：//序列化后：00！60！40！#！#！#！14！12！#！#！16！#！#！
    //反序列化：**str指向'00!'*str从0到‘\0’
    TreeNode* Deserialize(char **str)  
    {
      if(**str=='#')  //如果字符串序列为#！，树某一节点为空
      {
        (*str) += 2;
         return NULL;
      }
       int value=0;
       while (**str!= '!')//若字符串未遍历到字符串末尾，
      {
         value *= 10;
         value += (int)**str;
         (*str)++;
      }
      TreeNode*root =new TreeNode(value);
       //序列化后：'00！60！40！#！#！#！14！12！#！#！16！#！#！\0'
       //当遍历到'\0'时，树的所有节点都遍历完了，返回根节点
      if (**str=='\0')//   
          return root;
      else
        (*str)++;
        root->left=Deserialize(str);//遍历左子树和右子树
        root->right=Deserialize(str);
        return root;
  }
     TreeNode* Deserialize(char *str) {
       return   Deserialize(&str);    
    }
};
科比的缪斯
关注
专栏目录
剑指offer[16、18]
weixin_43433969的博客
05-13 129
面试题16 数值的整数次方 题目： 实现函数double Power(double base, int exponent)，求base的exponent次方。不得使用库函数，同时不需要考虑大数问题。 解法： class Solution { public double myPow(double x, int n) { if(x==0) return 0; double res=1; //Java 代码中 int32 变量 n \in [-2147483
剑指 Offer 12-20
神秘的义勇神驹的博客
08-11 185
剑指 Offer 12. 矩阵中的路径 难度中等140 请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一格开始，每一步可以在矩阵中向左、右、上、下移动一格。如果一条路径经过了矩阵的某一格，那么该路径不能再次进入该格子。例如，在下面的3×4的矩阵中包含一条字符串“bfce”的路径（路径中的字母用加粗标出）。 [["a","b","c","e"], ["s","f","c","s"], ["a","d","e","e"]] 但矩阵中不包含字符串“abf
剑指Offer---2021/7/19
KI的博客
07-19 1万+
剑指Offer---2021/7/19刷题记录
剑指Offer题集（力扣）
qq_42958831的博客
05-07 1万+
力扣题单：https://leetcode.cn/problemset/all/?listId=lcof&page=1
剑指offer所有编程练习总结分析
热门推荐
张彦峰的博客
07-25 168万+
给出剑指offer所有题目描述和对应的解题思路，并且在最有给出对应的代码展示和测试内容 由于牛客剑指Offer题目经过整理和筛选，是面试备考的经典资源之一，因此它的重要性在面试准备过程中是很高的。做这些题目可以帮助面试者熟悉常见的面试题型、巩固基础知识、提升编程能力，为应对面试提供了很好的准备。然而，还需注意不仅仅局限于做题，理解背后的原理和思想同样重要，以便能够在面试时灵活运用和展示自己的能力。
《剑指Offer》题目及代码.zip
06-28
《剑指Offer》 1. 赋值运算函数 2. 单例设计模式 3. 二维数组中查找目标值 4. 替换字符串中的空格 5. 从尾到头打印链表 6. 由前序和中序遍历重建二叉树 7. 用两个栈实现队列 8. 求旋转数组的最小数字 9. ...
剑指offer:17-20
12-22
1. **树的子结构** (第17题) - 在这个问题中，我们需要判断一棵二叉树B是否是另一棵二叉树A的子结构。首先，我们要遍历树A，寻找与树B根节点值相同的节点R。如果找到，我们将以R为根的子树与树B进行比较。比较方法...
剑指Offer-V1.pdf
12-12
《剑指Offer》是一本专注于算法和数据结构的书籍，特别针对面试和编程竞赛中的常见问题进行了深入解析。V1版本仅提供了Java语言的解决方案。书中涵盖了大量编程面试中经常遇到的问题，旨在提升读者在算法设计、实现...
point-to-offer-edition2:剑指offer第二版的java实现
05-11
剑指offer原书第二版的java实现 说明 《剑指offer》，从名字上看虽不是一本系统的算法书，但很多师兄师姐都推荐它，因为很多互联网公司的面试算法题都能这本书上找到思路，链表，二叉树，图，查找，排序，时间空间的...
《剑指offer》Vue面试题 前端
最新发布
12-26
1. Vue是什么 2. Vue和React对比 3. Vue核心特性 4. 为什么要使用Vue？ 5. Vue有哪些生命周期钩子函数？ 6. Vue中的v-if和v-show有什么区别？ 7. Vue如何实现组件间通信？ 8. Vue中的mixins是什么？ 9. Vue中的...
Screen
qq_44645822的博客
02-08 740
Screen 5.1 安装screen 流行的Linux发行版（例如Red Hat Enterprise Linux）通常会自带screen实用程序，如果没有的话，可以从GNU screen的官方网站下载。 [root@TS-DEV ~]# yum install screen [root@TS-DEV ~]# rpm -qa|grep screen screen-4.0.3-4.el5 [root@TS-DEV ~]# 5.2 创建一个新的窗口 安装完成后，直接敲命令screen就可以启动它。但是这样启
Anaconda安装与使用
qq_44645822的博客
02-08 649
Anaconda安装 1.1 下载安装文件 1） 如果想直接下载到本地，在通过ftp上传到远程服务器，请忽略一下操作 2） 如果服务器是联网的，可以直接通过wget命令【centos版本】直接下载服务器，操作如下： 我使用的linux系统为centOS7.6.18-64bits,使用的是wget命令进行的脚本文件下载，命令如下： wget https://repo.anaconda.com/archive/Anaconda3-2019.10-Linux-x86_64.sh 1.2 执行安装 命令：sh A
华为机试 (12/21)
qq_44645822的博客
12-21 480
素数伴侣 题目描述 题目描述 若两个正整数的和为素数，则这两个正整数称之为“素数伴侣”，如2和5、6和13，它们能应用于通信加密。现在密码学会请你设计一个程序，从已有的N（N为偶数）个正整数中挑选出若干对组成“素数伴侣”，挑选方案多种多样，例如有4个正整数：2，5，6，13，如果将5和6分为一组中只能得到一组“素数伴侣”，而将2和5、6和13编组将得到两组“素数伴侣”，能组成“素数伴侣”最多的方案称为“最佳方案”，当然密码学会希望你寻找出“最佳方案”。 输入: 有一个正偶数N（N≤100），表示待挑选的自然
华为机试 (10/4)
qq_44645822的博客
10-04 403
删除链表指定节点 输入一个单向链表和一个节点的值，从单向链表中删除等于该值的节点，删除后如果链表中无节点则返回空指针。 import java.io.*; public class Main { //构建节点 public static class Node { Node next; int val; Node(int val) { this.val = val; next = null;
华为机试 (9/23)
qq_44645822的博客
09-24 383
华为机试9/23公共子串计算尼科彻斯定理一二维数组操作统计大写字母个数字符串运用-密码截取一求连续最大的bit数 公共子串计算 计算两个字符串的最大公共字串的长度，字符不区分大小写 最长公共子串和最长公共子序列 例：str1=“123ABCD456” str2 = “ABE12345D” 最长公共子串是：123 最长公共子序列是：12345 这两个都可以用动态规划，只是状态转移方程有点区别 最长公共子序列是： dp[i][j] – 表示子串str1[0…i]和子串str[0…j]的最长公共子序列 当str
华为机试 (9/29)
qq_44645822的博客
09-29 278
简单密码破解 他是这么变换的，大家都知道手机上的字母： 1–1， abc–2, def–3, ghi–4, jkl–5, mno–6, pqrs–7, tuv–8 wxyz–9, 0–0,就这么简单，渊子把密码中出现的小写字母都变成对应的数字，数字和其他的符号都不做变换， 声明：密码中没有空格，而密码中出现的大写字母则变成小写之后往后移一位，如：X，先变成小写，再往后移一位，不就是y了嘛，简单吧。记住，z往后移是a哦。 示例 输入 YUANzhi1987 输出 zvbo9441987 // Java imp
华为机试 (10/31)
qq_44645822的博客
10-31 234
学英语 Jessi初学英语，为了快速读出一串数字，编写程序将数字转换成英文： 如22：twenty two，123：one hundred and twenty three。 说明： 数字为正整数，长度不超过九位，不考虑小数，转化结果为英文小写； 输出格式为twenty two； 非法数据请返回“error”； 关键字提示：and，billion，million，thousand，hundred。 本题含有多组输入数据。 import java.util.*; import java.io.*;
华为机试 (10/21)
qq_44645822的博客
10-21 231
删除字符串中出现次数最少的字符 实现删除字符串中出现次数最少的字符，若多个字符出现次数一样，则都删除。输出删除这些单词后的字符串，字符串中其它字符保持原来的顺序。 注意每个输入文件有多组输入，即多个字符串用回车隔开 import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.LinkedHashMap; public class Main {
华为机试 (11/22)
qq_44645822的博客
11-22 219
函数编写 编写一个函数，传入一个int型数组，返回该数组能否分成两组，使得两组中各元素加起来的和相等，并且，所有5的倍数必须在其中一个组中，所有3的倍数在另一个组中（不包括5的倍数），能满足以上条件，返回true；不满足时返回false。 import java.io.BufferedReader; import java.io.InputStreamReader; import java.util.ArrayList; import java.util.Arrays; import java.util.L
Java版剑指Offer：编程题解
"这是《剑指Offer》一书的Java版代码实现，由GitHub用户Cyc2018贡献，仅供学习交流，禁止商业用途。书中涵盖了许多经典的算法和数据结构问题，适合准备面试和提升编程能力。" 这篇文章是关于《剑指Offer》一书中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值