Java笔试模拟试题（四）

最新推荐文章于 2022-11-20 11:27:37 发布

韶光不负

最新推荐文章于 2022-11-20 11:27:37 发布

阅读量246

点赞数 3

分类专栏：算法 Java Java面试题文章标签： java 算法

本文链接：https://blog.csdn.net/weixin_47514459/article/details/124256462

版权

Java 同时被 3 个专栏收录

76 篇文章 1 订阅

订阅专栏

Java面试题

26 篇文章 1 订阅

订阅专栏

算法

18 篇文章 0 订阅

订阅专栏

1，斐波那契（Fibonacci）数列

写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项（即 F(N)）。斐波那契数列的定义如下：

F(0) = 0, F(1) = 1
F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
斐波那契数列由 0 和 1 开始，之后的斐波那契数就是由之前的两数相加而得出。

答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。

示例 1：

输入：n = 2
输出：1
示例 2：

输入：n = 5
输出：5

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/fei-bo-na-qi-shu-lie-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

动态规划：创建一个数组把计算结果储存起来，遍历数组注意数组遍历从2开始因为，0，1，已经赋值

class Solution {
    public int fib(int n) {
    if(n==0){
           return 0;
       }
    if(n==1){
            return 1;
       }
    int[] dp = new int[n+1];
    dp[0] = 0;
    dp[1] = 1;
    for(int i=2;i<=n;i++){
         dp[i]=(dp[i-1]+dp[i-2])%1000000007;
       }
    return dp[n];
    }
}

2，青蛙跳台

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

答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。

示例 1：

输入：n = 2
输出：2
示例 2：

输入：n = 7
输出：21

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/qing-wa-tiao-tai-jie-wen-ti-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

动态规划：

class Solution {
    public int numWays(int n) {
        if (n <= 1) return 1;
        int[] dp = new int[n+1];
        dp[0] = 1;
        dp[1] = 1;
        for (int i = 2; i < n+1 ; i++) {
            dp[i] = (dp[i-1]+dp[i-2])%1000000007;
        }
        return  dp[n];
    }
}

3，股票最大利润

假设把某股票的价格按照时间先后顺序存储在数组中，请问买卖该股票一次可能获得的最大利润是多少？

示例 1:

输入: [7,1,5,3,6,4]
输出: 5
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。
示例 2:

输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/gu-piao-de-zui-da-li-run-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

动态规划：

class Solution {
    public int maxProfit(int[] prices) {
        //        判断特殊情况
        if (prices == null || prices.length == 0) return 0;
        
        int len = prices.length-1;
        //        假设第一个最小
        int res = 0 , min_num = prices[0]; 
        
        for (int i = 1; i <= len ; i++) {
            //如果比我假设的最小值小，最小值发生改变
            if (prices[i] <= min_num){
                min_num = prices[i];
            }else {
                //如果比我假设的最小值大，比较与原来的值谁大
                res = Math.max(res,prices[i] - min_num);
            }
            
        }
        return res;
        
    }
}

4，删除排序链表中重复的数

给定一个已排序的链表的头 head ，删除原始链表中所有重复数字的节点，只留下不同的数字。返回已排序的链表。

示例 1：

输入：head = [1,2,3,3,4,4,5]
输出：[1,2,5]
示例 2：

输入：head = [1,1,1,2,3]
输出：[2,3]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        //记录前置节点，处理要删除的情况
        ListNode pre = dummy;
        //记录当前节点，需要遍历整个链表
        ListNode cur = head;

        while(cur != null){
            //找到下一个cur和cur.next不相同的位置
            while(cur.next != null && cur.val == cur.next.val){
                cur = cur.next;
            }
            //cur往前走一步，为不相同的两个值的后者，如3->3->4, 不相同的位置为3->4,后者为4
            cur = cur.next;
            /** 
            * 如果前置节点和cur的位置超过2，如1->2->3，3和1的距离未超过2，反之1->2->2->3,3和1的距离超过2
            * 则将前置节点pre直接连接当前节点cur
            * 否则前置节点向前
            */
            if(pre.next.next != cur){
                pre.next = cur;
            }else{
                pre = pre.next;
            }
        }

        return dummy.next;
    }
}

5，跳跃游戏2

给你一个非负整数数组 nums ，你最初位于数组的第一个位置。

数组中的每个元素代表你在该位置可以跳跃的最大长度。

你的目标是使用最少的跳跃次数到达数组的最后一个位置。

假设你总是可以到达数组的最后一个位置。

示例 1:

输入: nums = [2,3,1,1,4]
输出: 2
解释: 跳到最后一个位置的最小跳跃数是 2。
从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。
示例 2:

输入: nums = [2,3,0,1,4]
输出: 2

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/jump-game-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
    public int jump(int[] nums) {
       //特殊情况处理
        if(nums.length == 1) return 0;
        //new_max ：记录最大步长，max_i： 记录最大步长到达的下标 res：记录次数
        int new_max = 0,max_i = 0, res = 0;
        for (int i = 0; i < nums.length ; i++) {
            int num = nums[i];
            //选择出最大步长
            new_max = Math.max(new_max,num+i);
            //判断当前下表和 步长最大是否相等
            if (i == max_i){
                //没到终点，次数加一
                res+=1;
                max_i = new_max; //跟新最大下标
                
                if (max_i >= nums.length){  
                    //最大下标大于数组长度 ，结束循环
                    break;
                }
            }
        }
        return  res;

    }
}

6，验证回文字符串

给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。

说明：本题中，我们将空字符串定义为有效的回文串。

示例 1:

输入: "A man, a plan, a canal: Panama"
输出: true
解释："amanaplanacanalpanama" 是回文串
示例 2:

输入: "race a car"
输出: false
解释："raceacar" 不是回文串

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/valid-palindrome
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路：转小写——>去空格——>判断

class Solution {
    public boolean isPalindrome(String s) {
        if (s == null || s .length()== 0 ) return true;
        // 把原有字符串全部变为小写

        s = s.toLowerCase();
        
        // 再把原有字符串的所有字符数字放到新的字符串中
        String str = "";
        for (int i = 0; i < s.length(); i++)
        {
            if ((s.charAt(i) >= 'a' && s.charAt(i) <= 'z') || (s.charAt(i)>= '0' && s.charAt(i) <= '9'))
            {
                str += s.charAt(i);
            }
        }

        // 最后判断是不是回文串
        int front = 0;
        int end = str.length()-1;
        while (front != str.length()/2)
        {
            if (str.charAt(front) != str.charAt(end))
            {
                return false;
            }
            front++;
            end--;
        }
        return true;

    }
}

7,字符的最短距离

给你一个字符串 s 和一个字符 c ，且 c 是 s 中出现过的字符。

返回一个整数数组 answer ，其中 answer.length == s.length 且 answer[i] 是 s 中从下标 i 到离它最近的字符 c 的距离。

两个下标 i 和 j 之间的距离为 abs(i - j) ，其中 abs 是绝对值函数。

示例 1：

输入：s = "loveleetcode", c = "e"
输出：[3,2,1,0,1,0,0,1,2,2,1,0]
解释：字符 'e' 出现在下标 3、5、6 和 11 处（下标从 0 开始计数）。
距下标 0 最近的 'e' 出现在下标 3 ，所以距离为 abs(0 - 3) = 3 。
距下标 1 最近的 'e' 出现在下标 3 ，所以距离为 abs(1 - 3) = 2 。
对于下标 4 ，出现在下标 3 和下标 5 处的 'e' 都离它最近，但距离是一样的 abs(4 - 3) == abs(4 - 5) = 1 。
距下标 8 最近的 'e' 出现在下标 6 ，所以距离为 abs(8 - 6) = 2 。
示例 2：

输入：s = "aaab", c = "b"
输出：[3,2,1,0]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/shortest-distance-to-a-character
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

瞻前顾后：数组中下标的计算当e在前面时候，下标为i-prev，当e在后面为 prev - i,在进行比较

class Solution {
    public int[] shortestToChar(String s, char c) {
        int len = s.length();
        char ch[]=s.toCharArray();
        int answer []=new int[len];
        int pre = Integer.MIN_VALUE/2;
        //前面遍历一遍 i-pre
        for(int i = 0;i < len;i++){
            if(ch[i] == c){
                pre = i;
            }
            answer[i] = i - pre;
            }
        pre = Integer.MAX_VALUE/2;
        //后面遍历一遍 pre- i
        for(int i = len-1; i >= 0;i--){
            if (ch[i] == c){
                pre = i;
            }
            //比较找到最小值，最近
            answer[i] = Math.min(answer[i],pre-i); 
        }

        return answer;
    }
}

韶光不负

关注

3
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java笔试模拟试题（四）

/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int val, ListNode next) { this.val = val; this.next = next; } * }.
复制链接

扫一扫