【Java版本】剑指offer所有面试题(完整版题解2)

已于 2022-04-28 14:29:11 修改
阅读量517 收藏 1
点赞数
分类专栏： 算法 数据结构 java 文章标签： 算法 数据结构 java
于 2022-04-24 16:46:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43167873/article/details/124386532
版权
java 同时被 3 个专栏收录
90 篇文章 30 订阅
订阅专栏
算法
33 篇文章 1 订阅
订阅专栏
数据结构
29 篇文章 3 订阅
订阅专栏

剑指offer 11-20题

文章目录

第十一题-斐波契那数列

image-20220412082937474

public class Test09 {
    public static int F(int n){
        if(n <= 0) return 0;
        if(n == 1 || n ==2) return 1;
        int[] dp = new int[n+1];
        dp[1] = 1;
        dp[2] = 1;
        for(int i =3;i<=n;i++){
            dp[i] = dp[i-1]+dp[i-2];
        }
        return dp[n];
    }

    public static void main(String[] args) {
        System.out.println(F(0));
        System.out.println(F(1));
        System.out.println(F(2));
        System.out.println(F(3));
        System.out.println(F(4));
        System.out.println(F(5));
        System.out.println(F(6));
        System.out.println(F(7));

    }
}

第十二题-矩阵中的路径

image-20220422084716094

import java.lang.reflect.Array;
import java.util.Arrays;

public class Test12_1 {
    /**
     *
     * @param matrix 输入的矩阵
     * @param row 行
     * @param col 列
     * @param str 要搜索的字符
     * @return
     */
    public static  boolean hasPath(char[] matrix,int row,int col,char[] str){
        if (matrix == null || matrix.length != row*col ||str == null || str.length == 0) return  false;

        boolean[] visited = new boolean[row*col];
        Arrays.fill(visited,false);

        //结果记录
        int[] pathLength = {0};
        //以每一个点为起点进行搜索
        for (int i = 0; i< row;i++){
            for (int j = 0; j<col;j++){
                if (hasPathCore(matrix,row,col,str,visited,i,j,pathLength)){
                    return true;
                }
            }
        }
        return false;
    }

    /**
     *
     * @param matrix 输入的矩阵
     * @param rows 行
     * @param cols 列
     * @param str 要寻找的字符
     * @param visited 是否遍历过
     * @param currow 当前处理的行号
     * @param curcol 当前处理的行号
     * @param pathLength 已处理的str中字符的个数
     * @return
     */
    public static boolean hasPathCore(char[] matrix, int rows, int cols, char[] str, boolean[] visited,
                                      int currow, int curcol, int[] pathLength){
        if (pathLength[0] == str.length) return true;
        boolean haspath = false;
        //当前行大于0且小于总行数，当前列大于0且小于总列数，当前字符 == 要处理的字符 没有遍历过当前字符
        if (currow >= 0 && currow<rows && curcol >=0 && curcol < cols && matrix[currow*cols+curcol]  == str[pathLength[0]] && !visited[currow*cols+curcol]){
            visited[currow * cols + curcol] = true;
            pathLength[0]++;

            //回溯
            haspath = hasPathCore(matrix,rows,cols,str,visited,currow,curcol+1,pathLength) ||
                    hasPathCore(matrix,rows,cols,str,visited,currow+1,curcol,pathLength) ||
                    hasPathCore(matrix,rows,cols,str,visited,currow,curcol-1,pathLength) ||
                    hasPathCore(matrix,rows,cols,str,visited,currow-1,curcol,pathLength);
            if (!haspath){
                pathLength[0] --;
                visited[currow*cols+curcol] = false;
            }
        }
        return haspath;
    }

    public static void main(String[] args) {
        //ABCE  //ABCCED
        //SFCS
        //ADEE
        System.out.println(hasPath("ABCESFCSADEE".toCharArray(), 3, 4,
                "ABCCED".toCharArray()) );// true
    }
}

第十三题-机器人的运动范围

image-20220422092712410

import java.lang.reflect.Array;
import java.util.Arrays;

public class Test13_1 {
    /**
     *
     * @param threshold 约束值
     * @param rows 行数
     * @param cols 列数
     * @return
     */
    public static int movingCount(int threshold, int rows, int cols){
        if(threshold< 0 ||rows < 1 ||cols < 1) return  0;
        //变量初始化
        boolean[] visited = new boolean[rows*cols];
        Arrays.fill(visited,false);
        return movingCountCore(threshold,rows,cols,0,0,visited);

    }

    /**
     *
     * @param threshold
     * @param rows
     * @param cols
     * @param currow 当前行
     * @param curcol 当前列
     * @param visited 是否被访问过
     * @return
     */
    public static int movingCountCore(int threshold, int rows, int cols,
                                      int currow, int curcol, boolean[] visited){
        int count = 0;
        if (check(threshold,rows,cols,currow,curcol,visited)){
            visited[currow*cols+curcol] = true;
            count = 1+movingCountCore(threshold,rows,cols,currow+1,curcol,visited) +
                    movingCountCore(threshold,rows,cols,currow,curcol+1,visited) +
                    movingCountCore(threshold,rows,cols,currow-1,curcol,visited) +
                    movingCountCore(threshold,rows,cols,currow,curcol-1,visited);
        }
        return count;
    }

    /**
     * 断机器人能否进入坐标为(row, col)的方格
     *
     * @param threshold 约束值
     * @param rows      方格的行数
     * @param cols      方格的列数
     * @param currow    当前处理的行号
     * @param curcol    当前处理的列号
     * @param visited   访问标记数组
     * @return 是否可以进入，true是，false否
     */
    public static boolean check(int threshold, int rows, int cols,
                                int currow, int curcol, boolean[] visited){
        return curcol >= 0 && curcol < cols && currow >= 0 && currow < rows && !visited[currow*cols+curcol]
                &&(getDigitSum(curcol) + getDigitSum(currow) <= threshold);
    }

    /**
     * 一个数字的数位之和
     * @param number 数字
     * @return 数字的数位之和
     */
    private static int getDigitSum(int number) {
        int result = 0;
        while (number > 0) {
            result += (number % 10);
            number /= 10;
        }

        return result;
    }

    public static void main(String[] args) {
        System.out.println(movingCount(5, 10, 10) );
        System.out.println(movingCount(15, 20, 20) );
    }
}

第十四题-剪绳子

image-20220422094805048

import  java.util.*;
public class Test14_1 {
    public static int maxProductAfterCutting_1(int length){
        if (length == 3) return 3;
        if (length == 2) return 1;
        if (length < 2) return 0;

        int[] dp = new int[length+1];
        dp[0] = 0;
        dp[1] = 1;
        dp[2] = 2;
        dp[3] = 3;

        int max = 0;
        for (int i = 4;i<=length;i++){
            max = 0;
            for(int j = 1; j<= i/2;j++){
                int temp = dp[j] * dp[i-j];
                if (temp > max) max = temp;
                dp[i] = max;
            }
        }
        max = dp[length];
        return max;

    }

    public static int maxProductAfterCutting_2(int length){
        if (length == 3) return 3;
        if (length == 2) return 2;
        if (length < 2) return 0;

        //尽可能的剪长度为3的长度
        int timeof3 = length /3;
        if (length - timeof3*3 == 1)   timeof3 -= 1;
        int timeof2 = (length-timeof3*3)/2;
        return (int)Math.pow(3,timeof3) * (int)Math.pow(2,timeof2);
    }

    public static void main(String[] args) {
        System.out.println(maxProductAfterCutting_1(5));
        System.out.println(maxProductAfterCutting_2(5));
    }
}

第十五题：二进制中1的个数

image-20220412083734045

public class Test10 {
    public static int numberofone(int n){
        int res =0;
        while(n!=0){
            res += (n&1);
            n >>>= 1;
        }
        return  res;
    }
    public static  int numberofone1(int n){
        int res = 0;
        while(n!=0){
            res ++;
            n = (n-1)&n;
        }
        return res;
    }

    public static void main(String[] args) {
        System.out.println(numberofone(0B00000000_00000000_00000000_00000000)); // 0
        System.out.println(numberofone(0B00000000_00000000_00000000_00000001)); // 1
        System.out.println(numberofone(0B11111111_11111111_11111111_11111111)); // -1
        System.out.println(0B01111111_11111111_11111111_11111111 == Integer.MAX_VALUE);
        System.out.println(numberofone(0B01111111_11111111_11111111_11111111)); // Integer.MAX_VALUE
        System.out.println(0B10000000_00000000_00000000_00000000 == Integer.MIN_VALUE);
        System.out.println(numberofone(0B10000000_00000000_00000000_00000000)); // Integer.MIN_VALUE

        System.out.println("");
        System.out.println(numberofone1(0B00000000_00000000_00000000_00000000)); // 0
        System.out.println(numberofone1(0B00000000_00000000_00000000_00000001)); // 1
        System.out.println(numberofone1(0B11111111_11111111_11111111_11111111)); // -1
        System.out.println(numberofone1(0B01111111_11111111_11111111_11111111)); // Integer.MAX_VALUE
        System.out.println(numberofone1(0B10000000_00000000_00000000_00000000)); // Integer.MIN_VALU
    }

}

第十六题-数值的整数次方

image-20220412091448388

public class Test11 {
    public static double power(double base,int e){
        if(base == 0 && e== 0) throw new RuntimeException("invalid");
        //指数为0
        if(e == 0) return 1;
        //指数为1
        if(e == 1) return base;
        //求指数的绝对值
        int exp = e;
        if(exp < 0){
            exp = -exp;
        }
        double res = powerWithUnsigned(base,exp);
        if(e < 0){
            res = 1/res;
        }
        return res;

    }
    public static double powerWithUnsigned(double base,int e){
        if(e == 0) return 1;
        if(e == 1) return base;
        double res = powerWithUnsigned(base,e>>1);
        res = res*res;
        if(e % 2 !=0) //如果是奇数还需要在×一个base
            res *= base;
        return  res;
    }
    public static void main(String[] args) {

        System.out.println(power(2, -4));
        System.out.println(power(2, 4));
        System.out.println(power(2, 0));
        System.out.println(power(0.0000000000000000000001, -1));
        System.out.println(power(0.0000000000000000000001, 1));
        System.out.println(power(0.0000000000000000000001, 0));
        System.out.println(power(0.0000000000000000000000, 0));
    }
}

第十七题-打印1到最大的n位数

image-20220412093040137

import java.util.Arrays;

public class Test12 {

    //打印1到最大的n位数的主方法
    public static void printToMaxOfDigits(int n){
        if(n <= 0){
            System.out.println("invalid");
            return;
        }
        char number[] = new char[n];
        Arrays.fill(number,'0');//数组全部填充为0
        for (int i = 0; i < 10; ++i) {
            number[0] = (char) (i + '0');//首位数字
            printToMaxOfNDigitsRecursively(number, n, 0);
        }
    }
    //利用递归实现1到最大的n位数的全排列
    public static void printToMaxOfNDigitsRecursively(char[] number, int n, int index) {
        if(index == n - 1){//到了最后一位，当前首位数字的全排列结束
            printNumber(number);//打印
            return;
        }
        for (int i = 0; i < 10; ++i) {
            number[index + 1] = (char) (i + '0');//进行全排列
            printToMaxOfNDigitsRecursively(number, n, index + 1);
        }
    }

    //输出
    private  static void printNumber(char[] number) {
        boolean falg = true;
        int nLength = number.length;
        for (int i = 0; i < nLength; ++i) {
            if(falg && number[i]!='0'){//防止首位为0
                falg = false;
            }
            if(!falg){
                System.out.print(number[i]);
            }
        }
        System.out.println();
    }

    public static void main(String[] args) {
        printToMaxOfDigits(2);
    }
}

第十八题-在O(1)时间删除链表节点

image-20220412102017606

public class Test13 {
    public static ListNode deleteNode(ListNode head,ListNode delNode){
        if(head == null || delNode == null) return head;
        if(head == delNode) return head.next;
        if(delNode.next == null){
            ListNode temp = head;
            while(temp.next != delNode){
                temp = temp.next;
            }
            temp.next = null;
        }else{
            delNode.val = delNode.next.val;//把后一个节点值传给待删除节点
            delNode.next = delNode.next.next; //把后一个节点删除
        }
        return head;
    }

    public static void print(ListNode head){
        ListNode temp = head;
        while(temp!=null) {
            System.out.print(temp.val + " ");
            temp = temp.next;
        }
        System.out.println();
    }
    public static void main(String[] args) {


        ListNode head = new ListNode();
        head.val = 1;

        head.next = new ListNode();
        head.next.val = 2;

        head.next.next = new ListNode();
        head.next.next.val = 3;

        head.next.next.next = new ListNode();
        head.next.next.next.val = 4;

        ListNode middle = head.next.next.next.next = new ListNode();
        head.next.next.next.next.val = 5;

        head.next.next.next.next.next = new ListNode();
        head.next.next.next.next.next.val = 6;

        ListNode last =  head.next.next.next.next.next.next = new ListNode();
        head.next.next.next.next.next.next.val = 7;
        

        head = deleteNode(head, null); // 删除的结点为空
        print(head);
        ListNode node = new ListNode();
        node.val = 12;

        head = deleteNode(head, head); // 删除头结点
        print(head);
        head = deleteNode(head, last); // 删除尾结点
        print(head);
        head = deleteNode(head, middle); // 删除中间结点
        print(head);

        head = deleteNode(head, node); // 删除的结点不在链表中
        print(head);
    }

}

第十九题-正则表达式匹配

image-20220422103050128

public class Test19_1 {
    public static boolean match(String input,String pattern){
        if (input == null || pattern == null) {
            return false;
        }

        return matchCore(input, 0, pattern, 0);
    }
    public static boolean matchCore(String string,int i, String pattern,int p){
        if ( i >= string.length() && p >= pattern.length()) return true;

        if (i != string.length() && p >= pattern.length()) return false;

        //p的下一位置的字符为*
        if (p + 1 < pattern.length() && pattern.charAt(p + 1) == '*') {
            // 匹配串已经结束
            if (i >= string.length()) return matchCore(string,i,pattern,p+2);
            else {
                //匹配串没有结束
                if (pattern.charAt(p) == string.charAt(i) || pattern.charAt(p) == '.') {
                    // 匹配串向后移动一个位置，模式串向后移动两个位置,把p看作出现一次
                    return matchCore(string,i+1,pattern,p+2) ||
                            //匹配串向后移动一个位置，模式串不移动，把p看作多次出现
                            matchCore(string,i+1,pattern,p) ||
                            //匹配串不移动，模式串向后移动两个位置 ，把p看做一次都不出现
                            matchCore(string,i,pattern,p+2);
                }else
                    //如果当前字符和匹配的字符不想等，那么匹配向后移位2个，继续匹配
                    return matchCore(string, i, pattern, p+2);
            }
        }
        // 匹配串已经结束，模式串还没有结束，前面判断了模式串没有结束
        if (i >= string.length()) {
            return false;
        }else {
            //匹配串还未结束，如果当前位置的字符和匹配字符相等，则后一继续匹配
            if (string.charAt(i) == pattern.charAt(p) || pattern.charAt(p) == '.')
                return matchCore(string, i+1, pattern, p+1);
        }
        return false;
    }

    public static void main(String[] args) {
//        System.out.println(match("", "") + "[" + true + "]");
//        System.out.println(match("", ".*") + "[" + false + "]");
//        System.out.println(match("", ".") + "[" + false + "]");
//        System.out.println(match("", "c*") + "[" + true + "]");
//        System.out.println();

        System.out.println(match("aaa", "aab*a"));


    }
}

第二十题-表示数值的字符串

image-20220423091213898

public class Test20_1 {
    public static boolean isNumeric(String string) {
        if (string == null || string.length() < 1) return false;
        int index = 0;
        //先判断整数
        if (string.charAt(index) == '+' || string.charAt(index) == '-') {
            index++;
        }
        //已经到达字符串的末尾
        if (index >= string.length()) return false;

        //判断标准
        boolean numeric = true;
        //找到数字部分的下一个位置
        index = scanDigits(string, index);

        //如果没有到达末尾
        if (index < string.length()) {
            //如果是小数点
            if (string.charAt(index) == '.') {
                index++;
                index = scanDigits(string, index);
                //如果已经达到了字符的末尾
                if (index >= string.length()) numeric = true;
                //如果还没有到达，判断是否为指数
                else if (index < string.length() && (string.charAt(index) == 'e' || string.charAt(index) == 'E'))
                    //判断指数是否合法
                    numeric = isExponential(string,index);
                //不是返回false
                else numeric = false;
            }return numeric;
        }
        else return true;
    }

    //扫描字符串中数字部分
    public static int scanDigits(String string, int index) {
        while (index < string.length() && string.charAt(index) >= '0' && string.charAt(index) <= '9')
            index++;
        return index;
    }

    /**
     * 判断指数部分是否合法
     * @param string
     * @param index
     * @return
     */
    public static boolean isExponential(String string, int index) {
        if (index >= string.length() || (string.charAt(index) != 'e' && string.charAt(index) != 'E')) {
            return false;
        }
        index ++;
        if (index >= string.length()) return  false;

        if (string.charAt(index) == '+' ||string.charAt(index) == '-'){
            index ++;
        }
        if (index >= string.length()) return false;

        index = scanDigits(string,index);

        return index >= string.length();
    }

    public static void main(String[] args) {
        System.out.println(isNumeric("100") + "[" + true + "]");
        System.out.println(isNumeric("123.45e+6") + "[" + true + "]");
        System.out.println(isNumeric("+500") + "[" + true + "]");
        System.out.println(isNumeric("5e2") + "[" + true + "]");
        System.out.println(isNumeric("1.79769313486232E+308") + "[" + true + "]");
        System.out.println(isNumeric("12e") + "[" + false + "]");
        System.out.println(isNumeric("1a3.14") + "[" + false + "]");
        System.out.println(isNumeric("1+23") + "[" + false + "]");
        System.out.println();
    }
}
小七rrrrr
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java架构师的升级之路，剑指Java面试百度云
m0_60707263的博客
09-03 128
其实高级开发和资深架构在需要掌握的技能方面，并没太大的差别，具体而言，能帮助实现性能优化的分布式组件和数据库组件（或者叫中间件）也就这么多，linux下的操作命令也就这么些，一些系统管理的工具，比如Maven，Jenkins，ant等的用法也不难。但和高级开发相比，资深架构的差别在于如下几点。 ①. 资深架构解决的问题种类和数量要比高级开发多很多，所谓神枪手得靠子弹喂出来，有些问题，比如针对Kafka消息中间件的问题，资深架构一看日志就知道该怎么改，或者一看log4j错误信息就知道和其它哪些类有冲突了，又.
Java多态实现原理解析，你不懂还不学？
m0_56530263的博客
04-09 367
一、概述 本文主要来分析JMM内存模型，英文名JAVA Memory Model，它是与计算机硬件有关的一个概念。为了保证共享内存的正确性（可见性、有序性、原子性），内存模型定义了共享内存系统中多线程程序读写操作行为的规范。 一、 前些年，互联网行业里对架构师这个岗位的标准还不是很清晰。所以，很多架构师的工作往往就是一些技术被公司认可的资深工程师负责。 彼时，正巧我也是这类人员之一，故也得到了一个从零开始架设一套广告投放平台的机会。 我很喜欢钻研技术，对这种机会自然很看重。 那时候，架构并无如今这么复杂，一
《剑指offer》面试题答案汇总（Java版）
The night of summer
01-07 5045
面试题2：实现Singleton模式 （1）饿汉模式 public class Singleton{ private static Singleton instance = new Singleton(); privateSingleton(){} public static Singleton getInstance(){ return instance; }
剑指offer第二版(150M超清分享PDF+源码) 存在百度云(喜欢就点个赞评论一下)
不二的博客
02-28 8187
链接:https://pan.baidu.com/s/1b6ZxVIBvjPfKifToh_h26Q 密码:6t76 https://github.com/zhedahht/ChineseCodingInterviewAppendix（代码） 如需要更多iOS书籍留言！！！ 剑指offer 第二版 包含 PDF和源码 各大公司的算法面试题，存在百度云...
《剑指Java面试-Offer直通车》--计算机网络
lucky_jiexia的博客
04-11 7502
计算机网络 网络基础知识讲解 OSI七层
剑指offer面试题python题解（做题记录）.zip
最新发布
11-14
python面试题、知识点，用于程序员应聘学习参考，提供代码+题型等资料 python面试题、知识点，用于程序员应聘学习参考，提供代码+题型等资料 python面试题、知识点，用于程序员应聘学习参考，提供代码+题型等资料 ...
leetcode2-code_interview:LeetCodeLintCode题解，剑指offer题目，互联网公司面试，BAT外企等面试题
06-29
是剑指offer 是面试中遇到的有意思的题目总结，比如说BAT，intel，NVIDIA等公司面试的题目记录 包含了对传统排序算法的改进和应用总结 Leetcode Python / C++ 11 Solutions LeetCode Questions and Some of LintCode...
java笔试题算法-coding-note:刷题笔记：LeetCode和剑指Offer等
06-03
java笔试题算法 coding-note 刷题笔记：Leetcode和剑指Offer等 语言： C++（为主） Python ​ 项目 ...含剑指Offer题解、Leetcode题解、算法等内容 : 含算法与数据结构、C++/ JAVA /Python面试经验等
leetcode题库-Interview-Notes:C++技术面试知识笔记—剑指offer题解C++版、Leetcode题解C++版、数据结
06-29
leetcode题库  算法  操作系统  计算机网络  面向对象  嵌入式  数据库  工具  编码实践 :pencil: 数据结构与算法 :laptop: 操作系统 :cloud: 计算机网络 :artist_palette: ...LaTeX公式支持：
算法：“面试算法练习级攻略”-“ LeetCode题解”-“剑指优惠题解”
01-31
算法练级计划以面试算法过渡为线索，总结归纳面试涉及的算法知识点，整理LeetCode以及“剑指要约”出现的面试转换，在大量的LeetCode过渡中梳理一个刷题脉络，让大家能够在有限的频率，通过面试算法回归的练习，提高...
303-java-offter:「剑指Java面试-Offer直通车」学习原始码及笔记
03-23
2-1网络基础知识讲解 2-2 TCP的三次握手_1 2-3 TCP的三次握手_2 2-4 TCP的四次挥手 2-5 TCP和UDP的区别 2-6 TCP的滑窗试看 2-7 HTTP相关 2-8 HTTP相关_2 2-9 HTTP和HTTPS的区别 2-10插座相关 2-11网络知识总结 2-12彩蛋之走进面试官的世界 3-1数据库架构 3-2优化您的索引-使用二叉查找树 3-3优化你的索引-运用B树 3-4优化你的索引-运用B +树 3-5优化您的索引-使用哈希和位图 3-6密集索引和稀疏索引的区别 3-7索引额外的问题之如何调优Sql 3-8索引额外问题之最左匹配原则的成因 3-9索引额外问题之索引是建立越多越好吗 3-10锁模块之MyISAM与InooDB关于锁方面的区别 3-11锁模块之MyISAM与InooDB关于锁方面的区别_2 3-12锁模块之数据库事务的四大特性 3-13锁
剑指offer面试题3(java)
04-23
剑指offer面试题3(java)
剑指Offer第二版PDF+源码
林夕07
04-23 1万+
《剑指Offer》 百度网盘自己下载食用。 链接：https://pan.baidu.com/s/17ycDxG_wF1AEnhWA_tsKGA 提取码：3cfp
1.《剑指Java面试-Offer直通车》--计算机网络
weixin_35821291的博客
01-12 525
一、网络基础知识讲解 OSI开放式互联参考模型 第1层 物理层 首先解决两台物理机之间的通信需求，具体就是机器A往机器B发送比特流，机器B能收到比特流。 主要作用是传输比特流（0101二进制数据），将比特流转化为电流强弱传输，到达目的后再转化为比特流，即常说的数模转化和模数转换。这层数据叫做比特。网卡工作在这层。 第2层 数据链路层 【封装成帧、透明传输、差错检测】 封装成帧：在数据前后添加首部和尾部，使用帧定界符。（SOH、EOT），数据部分小等于MTU 透明传输：为了.
Java算法：牛客网Java版剑指Offer全套算法面试题目整理及电子档，Java算法与数据结构面试题，面试刷题、背题必备！牛客网剑指offer
qq_43265673的博客
03-25 698
剑指offer（java版） 牛客网Java版剑指Offer全套题目67道 资源来源于网络 下载地址：牛客网Java版剑指Offer全套算法面试题目整理 牛客网Java版剑指Offer全套算法面试题目电子档，面试刷题、背题必备！需要参加面试的人赶紧下载！如果不想花费积分请与我私信，也可以阅读这篇文章。 第1题. 二维数组中的查找... 2 第2题. 替换空格... ...
2.《剑指Java面试-Offer直通车》--数据库
weixin_35821291的博客
01-15 622
如何设计一个关系型数据库？ 数据库最主要的功能是存储数据，因此有一个存储模块存储数据。存储模块类似OS文件系统，将数据持久化存入磁盘中，如存入机械硬盘、SSD固态硬盘、亦或者是它们的磁盘阵列矩阵中。 但是只有存储是不行的，还需要组织并且用到这些数据，因此需要有程序的实例，用逻辑结构来映射出物理结构，并且在程序中提供获取和管理数据的方式，以及提供必要的问题追踪机制。 细分程序模块： 1）数据逻辑关系转换成物理存储关系的存储管理模块：首先对数据的格式和文件的分隔进行统一的管理，即把物理数据通过逻辑..
并发编程挑战：死锁与上下文切换
weixin_45493817的博客
12-03 235
引言 上下文切换（有时也称做进程切换或任务切换）是指 CPU 从一个进程或线程切换到另一个进程或线程。上下文切换会影响多线程执行速度。死锁是指多个进程或线程循环等待它方占有的资源而无限期地僵持下去的局面。 1、上下文切换 上下文定义 cpu发生进程或者线程切换时，所依赖的数据集合，比如一个函数有外部变量，函数运行时，必须获取外部变量，这些变量值的集合就是上下文。 引发问题 对于...
java剑指offer
qq_41974391的博客
06-08 235
https://www.cnblogs.com/ioio2/articles/9158053.html
剑指Offer（java答案）
热门推荐
壮少Bryant的博客
04-12 2万+
剑指Offer（java答案）剑指Offerjava答案 5从尾到头打印链表 6重建二叉树 33把数组排成最小的数 34丑数 35第一个只出现一次的字符 36数组中的逆序对 37两个链表的第一个公共交点 38数字在排序数组中出现的次数 39二叉树的深度 扩展题判断二叉树平衡 40-数组只指出现一次的数字 异或去重 11-1000放在含有1001个元素的数组中只有唯一的一个元素值重复其它均只出现一次每
写一个leetcode第1515题的java版本的题解
03-05
树的重心是指树上的一个节点，如果将该节点删除后，剩余各个连通分量的节点数最大值最小，那么这个节点就是树的重心。 我们可以使用两次 DFS 来解决这个问题。第一次 DFS 用来求出树的重心，第二次 DFS 用来计算...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小七rrrrr

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值