剑指Offer系列之题11~题15

目录
  • 11.矩形覆盖
  • 12.二进制中1的个数
  • 13. 数值的整数次方
  • 14.调整数组顺序使奇数位于偶数前面
  • 15.链表中倒数第k个结点

11.矩形覆盖

我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形,总共有多少种方法?
比如n=3时,2*3的矩形块有3种覆盖方法:
剑指Offer系列之题11~题15_第1张图片

斐波那契数列的应用

第一次竖着放一块类比为走一步,第一次横着放两块类比为走两步


代码与上面的斐波那契数列类题目类似,此处不再赘述;剑指Offer系列之题6~题10。

12.二进制中1的个数

输入一个整数,输出该数二进制表示中1的个数。其中负数用补码表示。

除法运算比移位运算效率低的多,应尽可能用移位运算代替乘除法。

对一个数减1,会导致其最右边的1变为0,在该1后面的0全变为1;然后将减1后的数与原数相与,则令原数最右边的1变为0。根据这个思路,与操作可以进行多少次,便是多少个1.


1.进行它的位数次 与操作 判断1:

public class Solution {
    public int NumberOf1(int n) {
        //正数的原码、反码、补码都相同;负数的反码是原码按位取反,补码是原码按位取反(符号位不变),最后+1
        int count=0;
        int flag=1;
        while(flag!=0){
            if((n & flag)!=0){//与运算不为0,证明n的该位是1
                count++;
            }
            flag=flag <<1;//flag左移1位,判断n的下一位是否为1

        }
        return count;
    }
}

2.减1后相与:

public class Solution {
    public int NumberOf1(int n) {
        //正数的原码、反码、补码都相同;负数的反码是原码按位取反,补码是原码按位取反(符号位不变),最后+1
        int count=0;
        int flag=1;
        while(n!=0){
            n=n&(n-1);//将最右边一位1与之后的位都变为0;5&4即0110&0100,得0100
            count++;
        }
        return count;
    }
}

13. 数值的整数次方

给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。保证base和exponent不同时为0。

double类型的值的次方不能以普通的相乘形式求出


1.普通解法:

public class Solution {
    public double Power(double base, int exponent) {
        //指数为正,负
        if(base==0)
            return 0;
        if(exponent==0){
            return 1;
        }
        boolean flag=false;
        if(exponent<0){//负指数
            exponent=-exponent;
            flag=true;
        }
        double res=1.0;
        for(int i=0;i

2.利用奇偶的n/2相乘递归:

public class Solution {
    public double Power(double base, int exponent) {
        //指数为正,负
        if(base==0){
            return 0;
        }
        if(exponent==0){
            return 1;
        }
        if(exponent==1){
            return base;
        }
        if(exponent<0){//当指数为负指数
            base=1/base;
            exponent=-exponent;
        }
        //递归
        double res=Power(base,exponent >>>1 );//求出n/2
        //判断奇偶,奇数:a^n=a^(n/2)*a^(n/2)*a,偶数:a^n=a^(n/2)*a^(n/2)
        res*=res;
        if((exponent & 1)==1){
            //奇数
            res*=base;
        }
        return res;
  }
}

3.快速幂迭代:

假设求3^13 ,13的二进制位1101,3^13 = 3^8 * 3^4 * 3^1

从最右边开始与运算(利用位运算进行移位):

第一位是1,该位的值是3^1 ,则res=res*base;base=base*base(该步求出下一位的值)

第二位是0,该位的值是3^2 ,因为0所以不参与运算,只求出下一位的值,base*=base;

第三位是1,该位的值是3^4 ,则res=res*base(此时base的值是3^4);base*=base;

第四位是1,该位的值是3^8 ,则res=res*base(此时base的值是3^8);base*=base;

退出循环。

public class Solution {
    public double Power(double base, int exponent) {
        if(base==0)
            return 0;
        if(exponent==0)
            return 1;
        long n=exponent;
        if(n<0){//当指数为负指数
            base=1/base;
            n=-n;
        }
        double res=1.0;
        while(n>0){
            if((n & 1)==1){//若当前位是1
                res*=base;
            }
            base*=base;
            n=n>>1;//右移一位
        }
        return res;
  }
}

14.调整数组顺序使奇数位于偶数前面

输入一个整数数组,实现一个函数来调整该数组中数字的顺序,使得所有的奇数位于数组的前半部分,所有的偶数位于数组的后半部分,并保证奇数和奇数,偶数和偶数之间的相对位置不变。

因为相对位置不变,所以需要稳定,都需要遍历。


1.暴力解法:

/**
*  分别统计奇数偶数的数量,然后用两个数组存储,最后再放回原数组。
*/
public class Solution {
    public void reOrderArray(int [] array) {
        int jCount=0;
        int oCount=0;
        for(int i=0;i

2.插入排序思想:

public class Solution {
    public void reOrderArray(int [] array) {
        //相对位置不变,稳定性
        //插入排序的思想
        int m = array.length;
        int k = 0;//记录已经摆好位置的奇数的个数;也可以看作下一个奇数的下标
        for (int i = 0; i < m; i++) {
            if ((array[i] & 1) == 1) {//若为奇数
                int j = i;//当前奇数所处位置
                while (j > k) {//j >= k+1 此处将该奇数移到最前面奇数之后
                    int tmp = array[j];
                    array[j] = array[j-1];
                    array[j-1] = tmp;
                    j--;
                }
                k++;
            }
        }
    }
}

15.链表中倒数第k个结点

输入一个链表,输出该链表中倒数第k个结点。

双指针

public class Solution {
    public ListNode FindKthToTail(ListNode head,int k) {
        //双指针  快指针比慢指针多走k-1步,当快指针到达末尾时,慢指针在倒数k结点
        if(k<=0)
            return null;
        if(head==null)
            return null;
        if(head.next==null)
            return head;

        ListNode slow=head;
        ListNode fast=head;
        int step=0;
        while(fast.next!=null){
            if(step=k-1){
                slow=slow.next;
            }
            step++;
            fast=fast.next;
            */
        }//当fast走到末尾,slow也走到了倒数第k个结点
        if(step链表长度
            return null;
        return slow;
    }
}

如有错误,欢迎指正

你可能感兴趣的:(剑指Offer系列之题11~题15)