《剑指offer》Java实现——每天9题——第2天

面试题10 斐波那契数列

题目一：求斐波那契数列的第n项。写一个函数，输入n，求斐波那契数列的第n项。

测试用例

• 功能测试（如输入3、5、10）
• 边界值测试（如输入0,1,2）
• 性能测试（输入较大的数字，如40、50、100等）

实现代码

/**
     * 求斐波拉契数列的第n项。
     * @param n 第n项
     * @return 第n项的值
     */
    public static long Fibonacci(int n){
        int[] result  = {0,1};
        if (n<0)
            return -1;
        if (n<2)
            return result[n];

        long fibNMinusOne = 1;
        long fibNMinusTwo = 0;
        long fibN = 0;
        for (int i=2;i<=n;i++){
            fibN = fibNMinusOne+fibNMinusTwo;

            fibNMinusTwo = fibNMinusOne;
            fibNMinusOne = fibN;
        }

        return fibN;
    }

使用循环而不是递归是因为递归造成了大量的重复计算，时间效率极差。

题目二：青蛙跳台阶问题。一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个n级台阶总共有多少种跳法。

跳一级台阶有一种方法，二级台阶有两种方法，当n>2时，f(n)=f(n-1)+f(n-2)，这就是斐波拉契数列。

面试题11 旋转数组的最小数字

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如，数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1.

测试用例

• 功能测试（数组中有重复数字或者没有重复数字）
• 边界值测试（旋转了0个元素，即数组升序；只包含一个数字的数组）
• 特殊输入测试（输入空数组）

实现代码

/**
     * 主方法，对外的接口，用于处理数组为空或者数组大小小于1的特殊情况
     * @param arr 数组
     * @return 最小的数
     * @throws Exception 数组输入错误
     */
    public static int getMini(int[] arr) throws Exception {
        if (arr == null || arr.length <= 0)
            throw new Exception("数组输入错误");
        else
            return getMini(arr,0,arr.length-1);
    }

    /**
     * 核心方法。找到并返回最小值
     * @param arr 数组
     * @param start 起始位置
     * @param end 终点位置
     * @return 最小数
     */
    public static int getMini(int[] arr,int start,int end){
        //start<end 针对数组只有一个元素的特殊情况，此时start=end
        //arr[start]>=arr[end] 针对数组本身递增的特殊情况
        while (start < end && arr[start]>=arr[end]) {
            int mid = (start + end) / 2;
            if (arr[start] > arr[mid])
                return getMini(arr, start, mid);
            else if (arr[start] < arr[mid])
                return getMini(arr, mid, end);
            else
                return arr[mid + 1];
        }
        return arr[start];
    }

算法思路

由于旋转后的数组分为有序的两部分，故使用二分查找的思想，每次判断均去除一半的元素。时间效率为O(logn)。要特别注意特殊情况，如数组递增，有重复数字等情况。

面试题12 矩阵中的路径

请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一格开始，每一步可以向左、右、上、下移动一格。如果一条路径经过了矩阵的某一各，那么该路径不能再次进入该格子。

测试用例

• 功能测试（存在或者不存在路径）
• 边界值测试（矩阵只有一行或者只有一列；矩阵和路径中的所有字母都是相同的）
• 特殊值测试（矩阵为空）

实现代码

/**
     * 计算矩阵路径的主方法，进行参数校验，递归控制的工作。
     * @param matrix 矩阵
     * @param rows 行数
     * @param cols 列数
     * @param str 需要匹配字符数组
     * @return true 字符串匹配成功 or false 字符串匹配失败
     */
    public static boolean hasPath(char[] matrix,int rows,int cols,char[] str){
        if (matrix == null || rows<1 || cols<1 || str == null)  //参数校验
            return false;

        boolean[] visit = new boolean[rows*cols]; //标记矩阵，访问过的置true

        for (int i=0;i<rows;i++)
            for (int j = 0;j<cols;j++)
                if (hasPathCore(matrix,rows,cols,i,j,str,0,visit))
                    return true;
        return false;
    }

    /**
     * 查找矩阵路径的核心方法。负责路径匹配和回退等工作。
     * @param matrix 矩阵
     * @param rows 总行数
     * @param cols 总列数
     * @param row 当前行数
     * @param col 当前列数
     * @param str 需要匹配的字符数组
     * @param current 当前位置
     * @param visit 标记矩阵
     * @return true当前位置符合 or false 当前位置不符合
     */
    private static boolean hasPathCore(char[] matrix, int rows, int cols, int row, int col, char[] str, int current, boolean[] visit) {
        int index = row*cols+col; //当前位置
        if (row >= rows || col>=cols ||row <0 || col<0 || visit[index] || matrix[index] != str[current])
            return false;

        visit[index] = true; // current下标的字符匹配成功
        if (current == str.length-1) //字符串的最后一个字符匹配成功，结束
            return true;

        current++; //准备匹配下一个字符
        if (hasPathCore(matrix,rows,cols,row-1,col,str,current,visit) ||
            hasPathCore(matrix,rows,cols,row+1,col,str,current,visit) ||
            hasPathCore(matrix,rows,cols,row,col-1,str,current,visit)  ||
            hasPathCore(matrix,rows,cols,row,col+1,str,current,visit))
            return true;
        current--; //四个方向都不对，返回上一层
        visit[index] = false;
        return false;
    }

    public static void main(String[] args) {
        char[] matrix = {'a','b','c','e',
                        's','f','c','s',
                        'a','d','e','e'};
        String str = "abfb";
        System.out.println(hasPath(matrix, 3, 4, str.toCharArray()));
    }

算法思路

利用回溯法，对每一步的可能路径进行尝试，若成功，则继续深入，直至匹配成功；若失败，则退回上一层，寻找其他可能的路径。如果所有路径均行不通，则匹配失败。

面试题13 机器人的运动范围

地上有一个m行n列的方格。一个机器人从坐标（0,0）的个字开始移动，它每次可以上、下、左、右移动一格，但不能进入行坐标和列坐标的位数之和大于k的格子。例如，当k等于18时，机器人能够进入方格（35,37），因为3+5+3+7=18。但它不能进入方格（35,38），因为3+5+3+8=19。请问该机器人能够到达多少格子？

测试样例

• 功能测试（方格为多行多列；k为正数）
• 边界值测试（方格只有一行或者只有一列；k等于0）
• 特殊值测试（k为负数）

实现代码

/**
     * 计算可以进入的格子数目
     * @param rows 行数
     * @param cols 列数
     * @param k 限制值
     * @return 步数
     */
    public static int movingCount(int rows,int cols,int k){
        int count = 0;
        for (int row=0;row<rows;row++)
            for (int col=0;col<cols;col++)
                if (getDigitSum(row,col) <= k)
                    count++;
        return count;
    }

    /**
     * 计算两个数字的位数和
     * @param row 行
     * @param col 列
     * @return 位数和
     */
    private static int getDigitSum(int row, int col) {
        int sum = 0;
        while (row>0) {
            sum += row % 10;
            row /= 10;
        }
        while (col>0){
            sum += col%10;
            col /=10;
        }
        return sum;
    }

    public static void main(String[] args) {
        System.out.println(movingCount(4,4,4));
    }

算法思路

相当于计算一个m*n的矩阵中，行、列数的位数之和小于等于k的格子的个数。

面试题14 剪绳子

给你一根长度为n的绳子，请把绳子剪成m段（m，n都是整数，且m，n均大于1），每段绳子的长度记为k[0],k[1],…,k[m]。请问k[0]Xk[1]X…Xk[m]可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长为2,3,3的三段，此时得到的最大乘积是18.

测试用例

• 功能测试（绳子的初始长度大于5）
• 边界值测试（绳子的初始长度分别是0~4）

实现代码

方式一：动态规划

/**
     * 基于动态规划思想的实现方式
     * @param len 绳子长度
     * @return 最大乘积
     */
    public static int maxAfterCutting_Solution1(int len){
        if (len <2)
            return 0;
        if (len == 2)
            return 1;
        if (len == 3)
            return 2;

        int[] products = new int[len+1];
        products[0] = 0;
        products[1] = 1;
        products[2] = 2;
        products[3] = 3;

        int max = 0;
        for (int i=4;i<=len;i++){
            max=0;
            for (int j=1;j<=i/2;j++){
                int product = products[j]*products[i-j];
                if (max < product)
                    max = product;
            }
            products[i]=max;
        }

        return products[len];
    }

    /**
     * 基于贪婪算法的思想，尽可能多地剪长度等于3的段
     * @param len 绳子长度
     * @return 最大乘积
     */
    public static int maxAfterCutting_Solution2(int len){
        if (len <2)
            return 0;
        if (len == 2)
            return 1;
        if (len == 3)
            return 2;

        //尽可能多地减去长度为3的是绳子段
        int timesOf3 = len/3;
        if (len-timesOf3*3 == 1)
            timesOf3 -= 1;
        int timesOf2 = (len-timesOf3*3)/2;

        return (int)(Math.pow(3,timesOf3)*Math.pow(2,timesOf2));
    }

    public static void main(String[] args) {
        System.out.println(maxAfterCutting_Solution1(7));
        System.out.println(maxAfterCutting_Solution2(7));
    }

算法思路

方式一是基于动态规划，从下往上解决问题的原理。方式二是基于贪婪算法的思想。

面试题15 二进制中1的个数

请实现一个函数，输入一个整数，输出该数二进制表示中1的个数。例如，把9表示成二进制是1001，有2位是1.因此，如果输入9，则该函数输出2.

测试用例

• 正数（包括边界值1）
• 负数
• 0

实现代码

/**
     * 利用了如下原理：“一个数减1，再和原数相与，能去掉该数二进制表示中的最右边的一个1”
     * @param n 整数
     * @return 1的个数
     */
    public static int numOfOne(int n){
        if (n == 0)
            return 0;
        int count=0;
        while (n != 0){
            count++;
            n = (n-1) & n;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(numOfOne(0));
        System.out.println(numOfOne(8));
        int n = -10;
        System.out.println(n + "的二进制中1的个数：" + numOfOne(n));
    }

实现原理

把一个整数减1，再和原数按位与，得到的结果相当于把整数的二进制表示中最右边的1变成0。

面试题16 数值的整数次方

实现函数double Power(double base,int exponent)，求base的exponent此方。不得使用库函数，同时不需要考虑大数问题。

测试样例

• 功能测试（底数、指数分别设置成正数、负数和0）

实现代码

 /**
     * 计算一个数的整数次方
     * @param base 底数
     * @param exponent 指数
     * @return 结果
     * @throws Exception 求0的0次方
     */
    public static double Power(double base,int exponent) throws Exception {
        boolean isNegative = false;
        if (base == 0 && exponent <= 0)
            throw new Exception("pow(0,0)");
        if (base == 0)
            return 0;
        if (exponent == 0)
            return 1;

        if (exponent<0) {
            isNegative = true;
            exponent= (-exponent);
        }
        double result = powerWithAbsExp(base,exponent);
        if (isNegative)
            result = (-result);
        return result;
    }

    /**
     * 使用exponent的绝对值，先求平方，在平方的基础上求4次方，然后8次方....
     * @param base 底数
     * @param exponent 指数的绝对值
     * @return 结果的绝对值
     */
    private static double powerWithAbsExp(double base, int exponent) {
        if (exponent == 0)
            return 1;
        if (exponent == 1)
            return base;

        double result = powerWithAbsExp(base,exponent >>1);
        result *= result;
        if (exponent %2 == 1)
            result *= base;

        return result;
    }

    public static void main(String[] args) throws Exception {
        System.out.println(Power(2.0,3));
    }

算法思路

要求一个数的n次方，可以先求平方，在平方的基础上求4次方，然后8次方。这样求一个数的32次方只需要计算5次乘法。>>1等同于除以2，但是效率比除法要高很多。

面试题17 打印从1到最大的n位数

输入数字n，按顺序打印出从1到最大的n位十进制数。比如输入3，则打印出1、2、一直到最大的3位数999.

测试样例

• 功能测试（大于1的正整数）
• 边界测试（n=1，n为非常非常大的数）
• 负面测试（输入的n<1)

实现代码

/**
     * 打印的主方法，对外的调用接口
     * @param n 位数
     */
    public static void printToMaxOfNDigits(int n){
        if (n<1)
            return;
        char[] number = new char[n];
        for (int i=0;i<10;i++){
            number[0]=(char)('0'+i);
            printToMaxOfNDigitsRecursively(number,0);
        }
    }

    /**
     * 打印的核心递归方法
     * @param number 字符数组
     * @param index 标示位置的变量
     */
    private static void printToMaxOfNDigitsRecursively(char[] number,int index) {
        if (index == number.length-1) {
            printNumber(number);
            return;
        }
        for (int i=0;i<10;i++){
            number[index+1] = (char)(i+'0');
            printToMaxOfNDigitsRecursively(number,index+1);
        }
    }

    /**
     * 人性化的打印方法，去掉了数字前面无用的0
     * @param number 数字
     */
    private static void printNumber(char[] number) {
        boolean isReady = false;
        for (int i=0;i<number.length;i++){
            if (!isReady && number[i] == '0')
                continue;
            isReady = true;
            System.out.print(number[i]);
        }
        System.out.println();
    }

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

算法思路

这是一个大数问题。需要考虑的问题有：一、当n非常大，以至于long类型都装不下（考虑用字符数组模拟数字）二、使用字符模拟数字的方式代码量大，很难在面试有限的时间里完成，因此需要简化（使用排列的递归实现进行简化）。三、打印数字时应该去掉前面无用的0，增加用户友好性。

面试题18 删除链表的节点

在O(1)的时间内删除链表节点。给定单向链表的头指针和一个节点指针，顶一个一个函数在O(1)时间内删除该节点。链表节点与函数定义如下：

class ListNode{
    int nodeValue;
    ListNode nextNode;
}
void deleteNode(ListNode head,ListNode nodeTobeDeleted);

测试样例

• 功能测试（输入一个头节点和一个指针）
• 边界测试（指针指向头节点，指针指向尾节点;链表只有一个节点）
• 负面测试（节点为空；指针为空；节点不在链表中）

实现代码

/**
 * 链表节点类
 */
class ListNode{
    int nodeValue;
    ListNode nextNode;

    public ListNode(int nodeValue) {
        this.nodeValue = nodeValue;
    }
}

public class InterQuestions18 {
    public static void deleteNode(ListNode head,ListNode nodeTobeDeleted){
        if (head == null || nodeTobeDeleted == null)
            return;

        if (nodeTobeDeleted.nextNode == null) {//要删除的节点是尾节点
            if (head.nextNode == null) {
                head = null;
                return;
            }
            deleteTail(head, nodeTobeDeleted);
        }
        else{
            nodeTobeDeleted.nodeValue = nodeTobeDeleted.nextNode.nodeValue;
            nodeTobeDeleted.nextNode = nodeTobeDeleted.nextNode.nextNode;
        }
    }

    private static void deleteTail(ListNode head, ListNode nodeTobeDeleted) {
        ListNode current = head;
        while (current != null){
            if (current.nextNode == nodeTobeDeleted)
                current.nextNode = nodeTobeDeleted.nextNode;
            current = current.nextNode;
        }
    }
    //测试
    public static void main(String[] args) {
        ListNode root = new ListNode(0);
        ListNode node1 = new ListNode(1);
        ListNode node2 = new ListNode(2);
        ListNode node3 = new ListNode(3);

        root.nextNode=node1;
        node1.nextNode=node2;
        node2.nextNode=node3;

        printListNode(root);
        deleteNode(root,node1);
        printListNode(root);
        deleteNode(root,root);
        printListNode(root);
        deleteNode(root,node3);
        printListNode(root);
    }

    /**
     * 打印链表的函数，方便测试效果
     * @param root  链表头节点
      */
    public static void printListNode(ListNode root){
        ListNode current = root;
        while (current!=null){
            System.out.print(current.nodeValue+",");
            current = current.nextNode;
        }
        System.out.println();
    }

}
/* 运行结果：
0,1,2,3,
0,2,3,
2,3,
2,
*/

算法思路

当链表只有一个节点时，将头节点设为null；当要删除的节点是尾节点tail时，从头节点依次遍历到尾节点tail的前一个节点，执行删除；当要删除的节点是非尾节点时，将尾节点的下一个节点的值复制到该节点，然后删除下一个节点。