LeetCode 剑指offer练习题 1

用两个栈实现队列

//用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的
//功能。(若队列中没有元素，deleteHead 操作返回 -1 ) 
// 示例 1： 
// 输入：
//["CQueue","appendTail","deleteHead","deleteHead"]
//[[],[3],[],[]]
//输出：[null,null,3,-1]
// 
// 示例 2： 
// 输入：
//["CQueue","deleteHead","appendTail","appendTail","deleteHead","deleteHead"]
//[[],[],[5],[2],[],[]]
//输出：[null,-1,null,null,5,2]
// 
// 提示： 
// 1 <= values <= 10000 
// 最多会对 appendTail、deleteHead 进行 10000 次调用 
// 解题思路：两个栈A，B放入数据时候放到A里面，取出操作时把A的从头到尾放到B里面，再从B中取出，即实现了先入先出，取的时候先从B中取，B中空的话就从A中往B中倒完再取

import java.util.Stack;

//leetcode submit region begin(Prohibit modification and deletion)
class CQueue {

    private Stack<Integer> stack1;
    private Stack<Integer> stack2;
    public CQueue() {
        stack1 = new Stack();
        stack2 = new Stack();
    }

    public void appendTail(int value) {
        stack1.push(value);
    }

    public int deleteHead() {
        if (!stack2.isEmpty())
            return stack2.pop();
        if (!stack1.isEmpty()){
            while (!stack1.isEmpty()){
                stack2.push(stack1.pop());
            }
            return stack2.pop();
        }
        return -1;
    }
}

斐波那契数列、青蛙跳台阶问题

//写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项（即 F(N)）。斐波那契数列的定义如下： 
//
// 
//F(0) = 0,   F(1) = 1
//F(N) = F(N - 1) + F(N - 2), 其中 N > 1. 
//
// 斐波那契数列由 0 和 1 开始，之后的斐波那契数就是由之前的两数相加而得出。 
//
//一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。 
// 答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。 
//
// 
//
// 示例 1： 
//
// 
//输入：n = 2
//输出：1
// 
//
// 示例 2： 
//
// 
//输入：n = 5
//输出：5
// 
//
// 
//
// 提示： 
// 解题思路：使用递归的方法会造成内存溢出，所有不推荐。
// 使用循环相加的方法更快 
// 青蛙的问题，当台阶大于2时，每次跳到终点的时候只有跳一下或者跳两下两种方式。所以需要计算出跳到终点前1格和前2格的所有跳法相加即可。 如果能跳1，2，3阶的话同理。
// 0 <= n <= 100 

//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    public int fib(int n) {
         /* if(n == 0){
            return 0;
        }else if ( n == 1){
            return 1;
        } else {
            return (fib(n-1)+fib(n-2))%1000000007;
        }*/
        if (n < 2){return n;}
        int first = 0;
        int second = 1;
        for (int i = 2 ; i <= n ; i ++){
            second = first + second;
            first = second - first;
            second  = second%1000000007;

        }
        return second;
    }
}
//leetcode submit region end(Prohibit modification and deletion)

数组中重复的数字

//找出数组中重复的数字。 
//
// 
//在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请
//找出数组中任意一个重复的数字。 
//
// 示例 1： 
//
// 输入：
//[2, 3, 1, 0, 2, 5, 3]
//输出：2 或 3 
//
// 限制： 
//
// 2 <= n <= 100000 
// 解题思路：1简单的方法就可以使用HashSet的值不可重复性质实现
// 2 因为长度是n，数组的值范围是0-n-1所以必有至少一个数字是重复的，遍历将对应位置的值放到对应索引上面，放之前判断一下对应位置的值是否和要放的值相等，相等则返回，不等则放。


//import java.util.HashSet;

//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    public int findRepeatNumber(int[] nums) {
        //方法1  使用HashSet的不可重复性
       /* HashSet<Integer> set = new HashSet<Integer>();
        for (int i = 0; i < nums.length; i++) {
            if (set.contains(nums[i]))
                return nums[i];
            else
                set.add(nums[i]);
        }*/

       //方法二
        for (int i = 0; i < nums.length; i++) {
            if (i != nums[i]){
                if (nums[nums[i]] == nums[i]){
                    return nums[i];
                }
                int temp = nums[nums[i]];
                nums[nums[i]] = nums[i];
                nums[i] = temp;
            }
        }
        return -1;
    }
}

二维数组中的查找

//在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个高效的函数，输入这样的一个二维数组和一个
//整数，判断数组中是否含有该整数。 
//
// 
//
// 示例: 
//
// 现有矩阵 matrix 如下： 
//
// 
//[
//  [1,   4,  7, 11, 15],
//  [2,   5,  8, 12, 19],
//  [3,   6,  9, 16, 22],
//  [10, 13, 14, 17, 24],
//  [18, 21, 23, 26, 30]
//]
// 
//
// 给定 target = 5，返回 true。 
//
// 给定 target = 20，返回 false。 
//
//
//
// 限制： 
//
// 0 <= n <= 1000 
//
// 0 <= m <= 1000 
//
// 
//
// 注意：本题与主站 240 题相同：https://leetcode-cn.com/problems/search-a-2d-matrix-ii/ 
// Related Topics 数组 二分查找 分治 矩阵 
// 
// 解题思路：以某一行或者某一列的最大值、另外一个的最小值的点开始比较 利用从上往下、从左往右递增的原则，每次比较都能排除掉一部分数据，然后根据比较的结果进行移动比较的点。


//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    public boolean findNumberIn2DArray(int[][] matrix, int target) {
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return false;
        }
        int row= matrix.length;
        int col = matrix[0].length;
        int x = 0 ;
        int y = row -1;
        while (x <= col-1 && y >= 0){
            if (matrix[y][x] == target)
                return true;
            else if (matrix[y][x] < target){
                x ++ ;
            } else {
                y -- ;
            }
        }
        return false;
    }
}