算法 | 第5章 位操作相关《程序员面试金典》

最新推荐文章于 2022-10-09 12:44:28 发布
最新推荐文章于 2022-10-09 12:44:28 发布
阅读量262 收藏 1
点赞数 1
分类专栏： 学习笔记 # 数据结构与算法学习笔记 文章标签： 面试 算法 java 位运算 二进制
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dlhjw1412/article/details/120811308
版权

第5章 位操作相关《程序员面试金典》

前言

本系列笔记主要记录笔者刷《程序员面试金典》算法的一些想法与经验总结，按专题分类，主要由两部分构成：经验值点和经典题目。其中重点放在经典题目上；

0. *经验总结

0.1 程序员面试金典 P94

  • 位操作是优化代码的一种技巧；

  • 一些操作技巧：（1s和0s表示一串1和0）

    • 乘2：左移1位；
    • 异或^：同0异1；
    • 某数与111100做与&运算：将某数最后2位清零；
    异或与或
    x ^ 0s = sx & 0s = 0x | 0s = x
    x ^ 1s = ~xx & 1s = xx | 1s = 1s
    x ^ x = 0x & x = xx | x = x
    • 根据正数求复数：所有取反加1，符号位变为1；
    • 逻辑右移与算数右移：对于数 1 0110101（-75）；
      • **逻辑右移 >>> **：移位后 0 1011010（90），最终得到0；
      • **算数右移>> **：移位后 1 1011010（-38），最终得到-1；

0.2 Java中的位运算相关代码

1. 算数移位

算数左移乘2补0；算数右移除2，正数补0复数补1；持续算移得-1或0；

int repeatedAritmeticShift(int x, int count){
	for(int i = 0; i < count; i++){
		x >>= 1;  //算数右移1位
	}
	return x;
}

2. 逻辑移位

逻辑左移乘2补0；逻辑右移除2补0；持续逻移得0；

int repeatedLogicalShift(int x, int count){
	for(int i = 0; i < count; i++){
		x >>>= 1;  //逻辑右移1位
	}
	return x;
}

3. 获取数位

将1算数左移i位得0001000（假设i为3），接着与num做位与&运算，将除i位外的位清零，保留i位。检查结果为1（或0），则num第i位为1（或0）；

boolean getBit(int num, int i){
	return ((num & (1 << i)) != 0);
}

4. 设置数位

将1算数左移i位得0001000（假设为3），接着与num做位或|运算，将i位设置为1；

int setBit(int num, int i){
	return num | (1 << i);
}

5. 清零数位

清零第i位：

将1算数左移i位后取反得1110111（假设i为3），接着与num做位与&运算，将i位清零，其余位不变；

int clearBit(int num, int i){
	int mask = ~(1 << i);
	return num & mask;
}

清零最高位到第i位（包括最高和第i位）：

将1算数左移i位得0001000（假设i为3），减1得0000111，接着与num做位与&运算，保留后i位；

int clearBitMSBthroughI(int num, int i){
	int mask = (1 << i) - 1;
	return num & mask;
}

清零第i位到第0位（包括第i位和第0位）：

将全1构成的数 1111111 算数左移i位得 1111000，接着与num做位与&运算保留前面；

int clearBitsIthrough0(int num, int i){
	int mask = (-1 << (i+1));
	return num & mask;
}

6. 更新数位

将第i位设置为v：先将1算数左移i位取反得1110111（假设i为3），与num做位与&运算将i位清零，得结果1。将待写入值v左移i位得结果2：0001000（或0000000）。结果1与结果二做位或|运算即可；

int updateBit(int num, int i, boolean bitIs1){
	int value = bitIs1 ? 1 : 0;
	int mask = ~(1 << i);
	return (num & mask) | (value << i);
}

0.3 Java判断double是否为整数的方法

Math.abs(num - (int)num) < 0.000001

0.4 Java进制转换API

  • Integer类的静态方法：
  • static String toBinaryString(int i)：返回数字i的二进制数字符串；
  • static String toOctalString(int i)：返回数字i的八进制数字符串；
  • static String toHexString(int i)：返回数字i的十六进制数字符串；
  • static int parseInt(String s)： 将字符串参数s解析为带符号的十进制整数；
  • static int parseInt(String s, int radix)： 将整数字符串s（radix用来指明s是几进制）转换成10进制的整数；

0.5 Math类常用API

  • static double abs(double a)：返回double值的绝对值；
  • static double ceil(double a)：向上取整，返回大于等于参数的最小的整数；
  • static double floor(double a)：向下取整，返回小于等于参数最大的整数；
  • static long round(double a)：返回最接近参数的long；(相当于四舍五入方法)
  • static int max(int a, int b) ：返回a与b中较大值；
  • static int min(int a, int b)：返回a与b中较小值；
  • static double log10(double a)：返回 double值的基数10对数；
  • static double pow(double a, doubl b) ：a^b；
  • static double sqrt(double a) ：返回 double值的正确舍入正平方根；

0.6 位操作技巧（重要）

普通写法位运算含义
n == 1in & 1判断n是否为1
n = n & (n-1)将最低位的1清零
n == Math.pow(2, x)(n & (n-1)) == 0判断n是否为2的x次方

0.7 Java运算优先级

Java运算优先级

0.8 Java中常用基本类型的取值范围

常用类型多少字节范围
byte1*8=8 bit-28 ~ 27 (-128 ~ 127)
short2*8=16 bit-216 ~ 215 (-32768 ~ 32767)
int4*8=32 bit-232 ~ 231 (-2147483648 ~ 2147483647)
long8*8=64 bit-264 ~ 263 (-18446744073709551616 ~ 18446744073709551615)
float4*8=32 bit-232 ~ 231 (-2147483648 ~ 2147483647)
double8*8=64 bit-264 ~ 263 (-18446744073709551616 ~ 18446744073709551615)
char2*8=16 bit
boolean8 bittrue / false

0.9 特殊二进制

在一些方法中利用特殊二进制有妙招（如：7.配对交换）；

十六进制二进制说明
0xaaaaaaaa10101010101010101010101010101010偶数位为1，奇数位为0
0x555555551010101010101010101010101010101偶数位为0，奇数位为1
0x333333331100110011001100110011001100111和0每隔两位交替出现
0xcccccccc110011001100110011001100110011000和1每隔两位交替出现
0x0f0f0f0f000011110000111100001111000011111和0每隔四位交替出现
0xf0f0f0f0111100001111000011110000111100000和1每隔四位交替出现

1. 插入 [easy]

插入

1.1 考虑点

  • 解决多位操作的问题时，需要进行测试，否则很容易犯下差一位的错误；

1.2 解法

1.2.1 位运算（优）

public int insertBits(int N, int M, int i, int j) {
    int mask = ~(((int)Math.pow(2, j-i+1)-1)<<i);
    int m = M<<i;
    int result = (N & mask);
    return result | m;
}
  • 执行时间：100.00%；内存消耗：95.99%；

2. 二进制数转字符串 [medium]

二进制数转字符串

2.1 考虑点

  • 注意准备好测试用例；

2.2 解法

2.2.1 count计数法

public String printBin(double num) {
    int count = 0;
    boolean isFind = false;
    while(count <= 30 && !isFind){
        num*=2;
        count++;
        if(Math.abs(num - (int)num) < 0.000001){
            isFind = true;
        }
    }
    if(isFind){
        StringBuilder sb = new StringBuilder();
        sb.append("0."); //这里注意不要写成 sb.append(0.)
        int n = (int)num;
        while(n != 0){
            n/=2;
            count--;
        }
        for(int i = 0; i < count; i++){
            sb.append(0);
        }
        sb.append( Integer.toBinaryString( (int)num) );
        return sb.toString();
    } else {
        return "ERROR";
    }
}
  • 执行时间：100.00%；内存消耗：45.18%；
  • 统计需要乘多少个2才变成整数，减去转成二进制后的位数，得有效位0的数量；

2.2.2 折半比较法（优）

public String printBin(double num) {
    String str = "0.";
    double i = 0.5;
    while(str.length() < 32){
        if(num-i >= 0){
            str += "1";
            num = num - i;
        }else{
            str += "0";
        }
        if(num == 0){
            return str;
        }
        i /= 2;
    }
    return "ERROR";
}
  • 执行时间：100.00%；内存消耗：97.48%；
  • num逐个减去 2-1、2-2、2-3……减法成功则为添1，否则添0；

3. 翻转数位 [easy]

翻转数位

3.1 考虑点

  • 注意num为负数的情况，num=-1时，其二进制数为32个1；

3.2 解法

3.2.1 逐个遍历法

public int reverseBits(int num) {
    //注意num为-1的情况
    if(num == -1){
        return 32;
    }
    String binaryString = Integer.toBinaryString(num);
    int a = 0;
    int b = 0;
    int max = 0;
    int count = 0;
    for(int i = 0; i < binaryString.length(); i++){
        if(binaryString.charAt(i) == '0'){
            a = b;
            b = count;
            count = 0;
            if(a+b > max){
                max = a+b;
            }
        } else {
            count++;
        }
    }   
    //最后一位不为0时，count的数出不来；
    if(count != 0){
        max = Math.max(b+count, max);
    }
    return max+1;
}
  • 执行时间：100.00%；内存消耗：61.13%；
  • 时间复杂度：O(n)，n为整数的位数；注意需要跟面试官说明n的含义，不然有可能会有歧义；
  • 空间复杂度：O(1)；
  • 需要注意最后一位不为0的情况与num为负数的情况；

3.2.2 滑动窗口法（优）

public int reverseBits(int num) {
    int max = 0;
    int count = 0;
    boolean flag = false;
    int start = 0;
    for (int i = 31; i >= 0; i--) {
        int i1 = (num >> i) & 1;
        if (i1 == 1) {
            count++;
            max = Math.max(max, count);
        } else {
            if (!flag) {
                count++;
                flag = true;
                start = i;
                max = Math.max(max, count);
            } else {
                count = 0;
                i = start;
                flag = false;
            }
        }
    }
    return max;
}
  • 执行时间：100.00%；内存消耗：99.05%；

4. 下一个数 [medium]

下一个数

4.1 考虑点

  • 注意特殊值，两个边界范围；
  • 注意移位方向；

4.2 解法

4.2.1 位运算法（优）

public int[] findClosedNumbers(int num) {
    if(num == 1){
        return new int[]{2,-1};
    }
    if(num == 2147483647){  //注意特殊值
        return new int[]{-1,-1};
    }
    //较大：从右往左遍历，找到遇到1后的一个0（期间统计1的个数count1），交换0和1。
    //如果n不为1，需要把其余1后移；如果n为1，不做处理；
    boolean isFound0 = false;
    int count1 = 0;
    int i = 0;
    while(!isFound0){
        if(count1 != 0 && ((num >> i) & 1) == 0){ //注意加括号，不然优先级不够
            isFound0 = true;
        }
        if(((num >> i) & 1) == 1){
            count1++;
        }
        i++;
    }
    int moreNum = 0;
    if(count1 == 1){
        moreNum = num >> (i-1);
        moreNum++;
        moreNum = moreNum << (i-1);
    } else {
        moreNum = num >> i-1;
        moreNum++;
        moreNum = moreNum << (i-count1);
        for(int k = 0; k < count1-1; k++){
            moreNum = moreNum << 1;
            moreNum++;
        }
    }
    //较小：从右往左遍历，找到第一个1（统计期间0的个数count0）。
    //如果m不为0，则该1退一位；反之，遍历到有0后的第一个1，该1退位，后面1补上接着；
    boolean isFound1 = false;
    int count0 = 0;
    int j = 0;
    while(!isFound1){
        if(((num >> j) & 1) == 1){
            isFound1 = true;
        } else {
            count0++;
        }
        j++;
    }
    int lessNum = 0;
    if(count0 == 0){
        isFound0 = false;
        isFound1 = false;
        count1 = 1;
        while(!isFound0){
            if(((num >> j) & 1) == 0){
                isFound0 = true;
            } else {
                count1++;
            }
            j++;
        }
        while(!isFound1){
            if(((num >> j) & 1) == 1){
                count1++;
                isFound1 = true;
            }
            j++;
        }
        lessNum = num >> j;
        lessNum = lessNum << 1;
        for(int k = 0; k < count1; k++){
            lessNum = lessNum << 1;
            lessNum++;
            j--;
        }
        lessNum = lessNum << (j-1);
    } else {
        lessNum = num >> j; //注意方向
        lessNum = lessNum << 2;
        lessNum++;
        lessNum = lessNum << (j-2);
    }
    return new int[]{moreNum, lessNum};
}
  • 执行时间：100.00%；内存消耗：89.61%；

4.2.2 暴力穷举法

public int[] findClosedNumbers(int num) {
    if(num == 1){
        return new int[]{2,-1};
    }
    if(num == 2147483647){  //注意特殊值
        return new int[]{-1,-1};
    }
    int up = num + 1;//向上枚举
    int down = num - 1;//向下枚举
    int count = findOneCount(num);//num的1的个数
    while (findOneCount(up) != count) {
        up++;
        if (up < 0) {//越界了那就是找不到，设置为-1
            up = -1;
            break;
        }
    }
    while (findOneCount(down) != count) {
        down--;
        if (down < 0) {//变为负数了那就是找不到了，设置为-1
            down = -1;
            break;
        }
    }
    return new int[]{up, down};
}
//求数的二进制1的个数
private static int findOneCount(int num) {
    int count = 0;
    while (num != 0) {
        num &= num - 1;
        count++;
    }
    return count;
}
  • 执行时间：100.00%；内存消耗：55.20%；

4.2.3 看不懂啥方法

public int[] findClosedNumbers(int num) {
    int mx = nextOne(num), mi = ~nextOne(~num);
    return new int[]{mx > 0 ? mx : -1, mi > 0 ? mi : -1};
}
public int nextOne(int x){
    long lowbit = x & (-x);
    long toZero = x + lowbit;
    return (int)((x & ~toZero) / lowbit >> 1 | toZero);
}
  • 执行时间：100.00%；内存消耗：45.16%；
  • 如果1的个数不同直接往低位加，这里要求相同，所以只能把最右边的连续1左移，然后保留连续1区间的最左一个，剩下的（连续长度-1）个的搬到全局最右边，步骤：
    • 1.先求出二进制最右边的1得到 lowbit = x & (-x)；
    • 2.求出最左1也就是消去连续1得到连续0 toZero = x + lowbit；
    • 3.把（最右连续1长度-1）个1搬到全局最优 (x & ~toZero) / lowbit >> 1；
    • ps: ~toZero 与 x 进行并得到最右连续1部分 /lowbit 后把1搬到右边 这里因为相加进位，所以要右移去掉一个1

6. 整数转换（汉明距离） [easy]

整数转换

6.1 考虑点

  • 将最低位清零的写法n = n & (n-1)；

6.2 解法

6.2.1 异或遍历法（优）

//第一种写法
public int convertInteger(int A, int B) {
    int C = A ^ B;
    int count = 0;
    for(int i = 0; i < 32; i++){
        if(((C >> i) & 1) == 1){
            count++;
        }
    }
    return count;
}
//第二种写法
public int convertInteger(int A, int B) {
    int count = 0;
    for(int C = A ^ B; C != 0; C = C >>> 1){
        count += C & 1;
    }
    return count;
}
//第三种写法（优）
public int convertInteger(int A, int B) {
    int count = 0;
    for(int C = A ^ B; C != 0; C = C & (C-1)){
        count++;
    }
    return count;
}
  • 执行时间：100.00%；内存消耗：12.36%；
  • 先做异或操作，再遍历每一位统计1的个数；
  • 第三种写法的c = c & (c-1)是清除最低位1；

7. 配对交换 [easy]

配对交换

7.1 考虑点

  • 可以询问面试官需要处理的数据位数；

7.2 解法

7.2.1 隔位操作法

public int exchangeBits(int num) {
    int moreNum = num << 1;
    int lessNum = num >> 1;
    int result = lessNum;
    for(int i = 1; i < 31; i+=2){
        if(((moreNum >> i) & 1) != ((lessNum >> i) & 1)){
            result = change(result, i);
        }
    }
    return result;
}

public int change(int lessNum, int i){
    int mask = ~(1 << i);
    // i位清零
    int result = lessNum & mask;
    if(result != lessNum){
        return result;
    } else {
        return (result | (1 << i));
    }	
}
  • 执行时间：100.00%；内存消耗：63.11%；

7.2.2 特殊二进制法（优）

public int exchangeBits(int num) {
    //奇数
    int odd = num & 0x55555555;
    //偶数
    int even = num & 0xaaaaaaaa;
    odd = odd << 1;
    even = even >>> 1;
    return odd | even;
}
//简短写法
public int exchangeBits(int num) {
    return ((num&0x55555555) << 1) | ((num&0xaaaaaaaa) >>> 1);
}
  • 执行时间：100.00%；内存消耗：48.19%；
  • 分别取出奇数位和偶数位，移动后做或运算；
  • 0x55555555 = 0b0101_0101_0101_0101_0101_0101_0101_0101
  • 0xaaaaaaaa = 0b1010_1010_1010_1010_1010_1010_1010_1010
  • 用这两个数做与运算，把奇数位和偶数位取出来。然后位左移奇数位，右移偶数位。再把奇数位和偶数位做或运算；
  • 这里运用逻辑右移而不是算数右移是因为我们希望符号位被0填充；
  • 上述代码实现的是32位整数，处理64位整数需要修改掩码；

8. 绘制直线 [medium]

在这里插入图片描述

题目理解：
题目解析

8.1 考虑点

  • 一个简单的做法是：用for循环迭代，从x1到x2，一路设定每个像素，但这样做太没劲，效率不高；
  • 处理这个问题需要十分细心，其中有很多陷阱和特殊情况；比如需要考虑x1到x2出于同一个字节的情况；

8.2 解法

8.2.1 逐组分析法

public int[] drawLine(int length, int w, int x1, int x2, int y) {
    int higth = length*32/w; //屏幕高度
    int intNum = w/32; //一行有多少个int
    int[] result = new int[length];
    int index = 0;

    //前面第0 ~ y-1行为0，y*intNum个0
    //第y行输出数字，intNum个数字
    //后面第y+1 ~ hight-1行开始为0，(hight-y-1)*intNum个0
    
    //对于数组，前面至下标(x1+y*w)/32-1为0；从下标(x2+y*w)/32+1开始到结尾为0；中间为数
    //第一个数，下标为i
    int i = (x1+y*w)/32;
    int min = Math.min( ((x1 / 32 + 1) * 32 - x1), (x2-x1+1));
    for (int j = 0; j < min; j++) {
        result[i] = result[i] << 1;
        result[i]++;
    }
    if(min == x2-x1+1){
        result[i] = result[i] << (32-x2-1);
    }
    i++;
    //中间-1的个数numOne
    int numOne = 0;
    if(x2/32 != x1/32){
        numOne = x2/32 - x1/32 -1;
    }
    if(numOne != 0){
        for(int j = i; j < numOne + i; j++){
            result[j] = -1;
        }
    }
    //最后一个数，下标为i+numOne
    i = i + numOne;
    if(i < length && (x2-x1)/32 > 0){
        for (int j = 0; j < (x2 - (x2 / 32) * 32 + 1); j++) {
            result[i] = result[i] << 1;
            result[i]++;
        }
        result[i] = result[i] << (32 - x2 + (x2/32)*32 -1);
        if( (x2 - (x2/32)*32 + 1) == 32){
            result[i] = -1;
        }
    }
    return result;
}
  • 执行时间：100.00%；内存消耗：67.24%；
  • 需要注意大量细节，包括中间-1的个数numOne，以及考虑最后一个数可以跟以一个重合的情况(x2-x1)/32 > 0；
  • 过于复杂，思路相同的不同实现方法如下；

8.2.2 位运算（优）

public int[] drawLine(int length, int w, int x1, int x2, int y) {  
    int[] ans=new int[length];
    int low=(y*w+x1)/32;
    int high=(y*w+x2)/32;
    for(int i=low;i<=high;i++){
        ans[i]=-1;
    }
    ans[low]=ans[low]>>>x1%32;
    ans[high]=ans[high]&Integer.MIN_VALUE>> x2 % 32;
    return ans;
}
  • 执行时间：100.00%；内存消耗：51.73%；

最后

新人制作，如有错误，欢迎指出，感激不尽！
欢迎关注公众号，会分享一些更日常的东西！
如需转载，请标注出处！
多氯环己烷
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
程序员面试金典(第五版)-高清扫描PDF
11-06
本书是原谷歌资深面试官的经验之作，全面而详尽地介绍了程序员应当如何应对面试，才能在面试中脱颖而出。为读者呈现了出自微软、苹果、谷歌等多家知名公司的150 道编程面试题，并针对每一道面试题目，分别给出了详细...
程序员面试金典-第五版
04-14
第8～9 章从数据结构、概念与算法、知识类问题和附加面试题4 个方面，为读者呈现了出自微软、苹果、谷歌等多家知名公司的150 道编程面试题，并针对每一道面试题目，分别给出了详细的解决方案。 本书适合程序开发和...
程序员面试金典——奇偶位交换__（位运算）
sinat_24048051的博客
05-30 396
题目描述 请编写程序交换一个数的二进制的奇数位和偶数位。（使用越少的指令越好） 给定一个int x，请返回交换后的数int。 测试样例： 10 返回：5 思路： //提取一个数的奇数位：x&0x55555555;奇数位全置1，偶数位全置0 //提取一个数的偶数位：x&0xAAAAAAAA;奇数位全置0，偶数位全置1 //互换位置：提取奇偶位后移动一下，
程序员面试金典——整数转化__（位运算）
sinat_24048051的博客
05-29 272
题目描述 编写一个函数，确定需要改变几个位，才能将整数A转变成整数B。 给定两个整数int A，int B。请返回需要改变的数位个数。 测试样例： 10,5 返回：4 思路：改变几位就是算它们之间不同的位的个数。用异或（相同位为1，不同位为0），然后算异或后的数 里面有多少个1. import java.util.*; public class Transf
算法 | 第2章 链表相关《程序员面试金典》
多氯环己烷的博客
10-14 417
第2章 链表相关《程序员面试金典》前言0. *经验总结0.1 程序员面试金典 P790.20.30.41. []1.1 考虑点1.2 解法1.2.11.2.21.2.32. []2.1 考虑点2.2 解法2.2.12.2.22.2.33. []3.1 考虑点3.2 解法3.2.13.2.23.2.34. []4.1 考虑点4.2 解法4.2.14.2.24.2.35. []5.1 考虑点5.2 解法5.2.15.2.25.2.36. []6.1 考虑点6.2 解法6.2.16.2.26.2.37
算法 | 第3章 栈与队列相关《程序员面试金典》
多氯环己烷的博客
10-17 283
@TOC 前言 一些可以从书上获取的经验值点： 1. 2. 3. 最后 新人制作，如有错误，欢迎指出，感激不尽！ 欢迎关注公众号，会分享一些更日常的东西！ 如需转载，请标注出处！
算法 | 第1章 数组与字符串相关《程序员面试金典》
多氯环己烷的博客
09-08 335
数组与字符串相关算法笔记前言1. 经验总结2.3.最后 前言 本系列笔记主要记录笔者刷《程序员面试金典》算法的一些想法与经验总结，按专题分类，主要由两部分构成：经验值点和经典题目。其中重点放在经典题目上； 1. 经验总结 对应课本【P76】页； 数组问题与字符串问题往往是相通的； 散列表是一种通过将键（key）映射为值（value）从而实现快速查找的数据结构； 2. 3. 最后 新人制作，如有错误，欢迎指出，感激不尽！ 欢迎关注公众号，会分享一些更日常的东西！ 如需转载，请标注出
程序员面试金典（第 6 版）(简单篇)
qq_39493185的博客
01-11 1121
程序员面试金典（第 6 版）(简单篇)
程序员面试金典总结 - leetcode 程序员面试金典系列
随便发挥的博客
10-09 511
程序员面试金典总结
LeetCode程序员面试金典（第 6 版）上
u011895157的博客
09-17 728
LeetCode程序员面试金典（第 6 版）上
程序员面试金典（第 6 版）
[ 25'h ]
01-19 1146
程序员面试金典（第 6 版） 力扣 (LeetCode)
程序员面试金典 第五版 带书签目录
06-06
第8～9 章从数据结构、概念与算法、知识类问题和附加面试题4 个方面，为读者呈现了出自微软、苹果、谷歌等多家知名公司的150 道编程面试题，并针对每一道面试题目，分别给出了详细的解决方案。 本书适合程序开发和...
程序员面试金典-中文第五版-高清带目录.txt
05-09
包含资源链接！！！本书是原谷歌资深面试官的经验之作，层层紧扣程序员面试的...第8～9 章从数据结构、概念与算法、知识类问题和附加面试题4 个方面，为读者呈现了出自微软、苹果、谷歌等多个顶级公司的面试题目和技巧
程序员面试金典-5版
08-02
第8～9 章从数据结构、概念与算法、知识类问题和附加面试题4 个方面，为读者呈现了出自微软、苹果、谷歌等多家知名公司的150 道编程面试题，并针对每一道面试题目，分别给出了详细的解决方案。 本书适合程序开发和...
面试 | Java 算法的 ACM 模式
热门推荐
多氯环己烷的博客
04-07 1万+
经常在 LeetCode 上用核心代码模式刷题的小伙伴突然用 ACM 模式可能会适应不过来，把时间花在输入输出上很浪费时间，因此本篇笔记对 Java 算法的 ACM 模式做了个小总结；
Java | Java常用API方法总结
多氯环己烷的博客
08-29 1万+
个人总结的Java常用API手册汇总常用APIJavaAPI1 java.langStringStringBuilderIntegerparseXxxMathObjectSystemThrowableThreadRunnable/接口Class\*reflect反射相关FieldConstructor\MethodClassLoader2 java.utilScannerObectsDate(瞬时)Calendar(日历)Random*数据结构相关Collection/接口Iterator/接口List/接
电科 | 传感器及其应用技术
多氯环己烷的博客
05-10 3447
传感器及其应用技术
微服务架构 | 7.1 基于 OAuth2 的安全认证
多氯环己烷的博客
02-02 3194
OAuth2 是一个基于令牌的安全验证和授权框架。他允许用户使用第三方验证服务进行验证。 如果用户成功进行了验证， 则会出示一个令牌，该令牌必须与每个请求一起发送。然后，验证服务可以对令牌进行确认；
程序员面试宝典第五版pdf
最新发布
01-17
《程序员面试宝典第五版pdf》是一本对程序员进行面试准备非常有帮助的书籍。这本书主要包括了面试中常见的问题及其解答，并且还介绍了一些常见的编程题目和算法问题。通过学习这本书，程序员可以更好地准备面试，提高自己的技术水平和面试表现。 书中的内容涵盖了诸多方面，包括数据结构、算法、操作系统、数据库、网络等等，这些都是面试时经常被问到的知识点。书中对每个知识点进行了详细的讲解，还提供了一些实际的例题进行练习，读者可以通过这些例题来加深对知识点的理解，提升解题能力。 另外，这本书还介绍了一些面试技巧和注意事项，比如在面试时应该如何回答问题、如何展现自己的优势、如何处理棘手的问题等。这些技巧对于帮助面试者在面试中展现出自己的最佳状态非常有帮助。 总的来说，《程序员面试宝典第五版pdf》是一本非常实用的书籍，对于正在准备面试的程序员来说具有很高的参考价值。它不仅可以帮助程序员巩固自己的专业知识，还可以提供一些面试技巧，帮助面试者更好地应对各种面试挑战。希望更多的程序员能够通过这本书提升自己的面试技能，取得满意的工作机会。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

多氯环己烷

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

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

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

打赏作者

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

抵扣说明：

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

余额充值