测开面试算法题

最新推荐文章于 2023-06-26 19:29:49 发布
最新推荐文章于 2023-06-26 19:29:49 发布
阅读量319 收藏
点赞数
分类专栏： 测试面试题 文章标签： 算法 java 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33214066/article/details/120646914
版权

1.Z 字形变换
将一个给定字符串 s 根据给定的行数 numRows ，以从上往下、从左到右进行 Z 字形排列。

输入：s = “PAYPALISHIRING”, numRows = 4
输出：“PINALSIGYAHRPI”
解释：
P I N
A L S I G
Y A H R
P I

思路：先确定有几行数据，存储数据先递增再递减

package com.exerice;

import java.util.ArrayList;
import java.util.List;

//Z字形变化
public class ZTest {
    public static void main(String[] args) {
        String s="LEETCOD";
        System.out.println(convert(s,3));
    }

    public static String convert(String s, int numRows) {
        if(numRows <2){ return s;}
        List<StringBuilder> result = new ArrayList<>();
        for(int i=0;i<numRows;i++){
            result.add(new StringBuilder());
        }
        int m=0,flag=-1;
        for(int i =0;i<s.length();i++){
            result.get(m).append(s.charAt(i));
            if(m==0 || m==numRows-1){flag=-flag;}
            m+=flag;
        }
        StringBuilder resultAll = new StringBuilder();
        for(int i=0;i<result.size();i++){
            resultAll.append(result.get(i));
        }
        return resultAll.toString();
    }
}

2.字符串转换整数 (atoi)

import java.util.regex.Matcher;
import java.util.regex.Pattern;
class Solution {
    public int myAtoi(String s) {
       int result=0;
        String regex="^[\\+\\-]?\\d+";
        Pattern p = Pattern.compile(regex);
        Matcher m = p.matcher(s.trim());
        if (m.find()){
            try{
            result=Integer.parseInt(m.group());
            }catch (Exception e){
                result = s.trim().charAt(0) == '-' ? Integer.MIN_VALUE: Integer.MAX_VALUE;
            }
        }
        return result;

    }
}

3.盛最多水的容器
https://leetcode-cn.com/problems/container-with-most-water/

class Solution {
    public int maxArea(int[] height) {
    int i=0,j=height.length-1;
        int max=0;
        while(i<j){
            if(height[i]<height[j]){
                max=Math.max(max,(j-i)*height[i++]);
            }else{
                max=Math.max(max,(j-i)*height[j--]);
            }

        }
        return max;
    }
}

4.整数转罗马数字

class Solution {
    public String intToRoman(int num) {
        String[] ge={"","I","II","III","IV","V","VI","VII","VIII","IX"};
        String[] shi={"","X","XX","XXX","XL","L", "LX", "LXX", "LXXX", "XC"};
        String[] bai={"","C","CC","CCC","CD","D","DC", "DCC", "DCCC", "CM"};
        String[] qian={"","M","MM","MMM"};
        StringBuilder result=new StringBuilder();
        result.append(qian[num/1000]).append(bai[num%1000/100]).append(shi[num%100/10]).append(ge[num%10]);
        return result.toString();
    }
}

5.罗马数字转整数

class Solution {
    public int romanToInt(String s) {
        Map<Character, Integer> symbolValues = new HashMap<Character, Integer>() {{
        put('I', 1);
        put('V', 5);
        put('X', 10);
        put('L', 50);
        put('C', 100);
        put('D', 500);
        put('M', 1000);
    }};
    int result=0;
    for(int i=0;i<s.length();i++){
        char value=s.charAt(i);
        if(i<s.length()-1 && symbolValues.get(value)<symbolValues.get(s.charAt(i+1))){
            result+=-symbolValues.get(value);
        }else{
            result+=symbolValues.get(value);
        }

    }
    return result;
    }
}

6.最长公共前缀
输入：strs = [“flower”,“flow”,“flight”]
输出：“fl”

package com.exerice;

public class LongestPubString {
    public static void main(String[] args) {
        String[] strings={"aabbcc","aabb","aabcdef"};
        System.out.println(pub(strings));

    }
    

    public static String pub(String[] strings){
        String ret =strings[0];
        for(int i=1;i<strings.length;i++){
            while (!strings[i].startsWith(ret)){
                ret=ret.substring(0,ret.length()-1);
                if(ret.length() == 0){
                    return "";
                }
            }
        }
        return ret;
    }
}

7.最接近的三数之和
输入：nums = [-1,2,1,-4], target = 1
输出：2
解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。

class Solution {
    public int threeSumClosest(int[] nums, int target) {
        int jishu= nums[0]+nums[1]+nums[2];
        Arrays.sort(nums);
        for(int i=0;i<nums.length-2;i++){
            if(i >0 &&nums[i]==nums[i-1]) continue;
            int j = i+1, k = nums.length - 1;
            while (j<k){
                int sum =nums[i]+nums[j]+nums[k];
                if(Math.abs(target-sum)<Math.abs(target-jishu)){
                    jishu=sum;
                }
                if(sum>target){
                    k--;
                }else if(sum < target){
                    j++;
                }else {
                    return jishu;
                }
            }
        }
        return jishu;

    }
}

8.电话号码的字母组合
输入：digits = “23”
输出：[“ad”,“ae”,“af”,“bd”,“be”,“bf”,“cd”,“ce”,“cf”]

package com.exerice;

import java.util.*;

//电话号码的字母组合，用队列解决
public class letterCombinations {
    public static void main(String[] args) {
        String digits="23";
        System.out.println(letterCombinations(digits));
    }
    public static List<String> letterCombinations(String digits) {
        if(digits == null || digits.length() ==0){
            return new ArrayList<>();
        }
       String[] phone ={"abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
        Queue<String> stringQueue =new LinkedList<>();
        stringQueue.offer("");
        for(int i=0;i<digits.length();i++){
            int len1=stringQueue.size();
            for(int j=0;j<len1;j++){
                String tmp = stringQueue.poll();
                System.out.println("tmp:"+tmp);
                int m =digits.charAt(i)-48-2;
                for(char letter:phone[m].toCharArray()){
                    stringQueue.offer(tmp+letter);
                    System.out.println(""+tmp+letter);
                }
            }
        }
        return (List<String>) stringQueue;
    }
}

9.连续最长子序列

package com.exerice;

//最长递增子序列
//输入：nums = [10,9,2,5,3,7,101,18]
//解释：最长递增子序列是 [2,3,7,101]，因此长度为 4
public class IncreasingsTest {
    public static void main(String[] args) {
        int[] arr = {10, 9, 2, 5, 3, 7, 101, 1};
        System.out.println(length(arr));

    }

    public static int length(int[] arr) {
        int len = arr.length;
        int[] num = new int[len];
        num[0] = 1;
        int max = 1;
        for (int i = 1; i < len; i++) {
            num[i] = 1;
            for (int j = 0; j < i; j++) {
                if (arr[j] < arr[i]) {
                    num[i] = Math.max(num[i], num[j] + 1);
                }
            }
            max = Math.max(max, num[i]);

        }

        return max;

    }
}

10.括号生成
输入：n = 3
输出：["((()))","(()())","(())()","()(())","()()()"]

package com.exerice;

import java.util.ArrayList;
import java.util.List;


//括号生成,输入：n = 3
//输出：["((()))","(()())","(())()","()(())","()()()"]
// 解题思路
//     1. 将问题抽象成树形结构遍历问题
//      2.判断是是否是有效括号
public class KuoHaoNewTest {
    public static void main(String[] args) {
        int n =3;
        System.out.println(generateParenthesis(3));
    }
    public static List<String> generateParenthesis(int n) {
        List<String> res = new ArrayList<>();
        List<String> result = new ArrayList<>();
        if(n<=0){return res;}
        dnf(n,"",res);
        for(String key:res){
            if(isvalid(key)){
                result.add(key);
            }

        }
        return result;

    }
    public static void dnf(int n,String path,List<String> res){
        if(path.length() == 2*n){
            res.add(path);
            return;
        }
        dnf(n,path+"(",res);
        dnf(n,path+")",res);

    }

    //https://leetcode-cn.com/problems/generate-parentheses/solution/pei-yang-chou-xiang-si-wei-hui-su-jie-fa-7dwu/

    //判断是否是有效括号
    public static boolean isvalid(String str){
        while (str.contains("()")){
            str=str.replaceAll("\\(\\)","");
        }
        return str.length()==0;
    }

}

11.全排列


import java.util.ArrayList;
import java.util.List;

public class AllZuHeTest {
    public static void main(String[] args) {
        int[] arr = {1, 2};
        System.out.println(all(arr));

    }
    public static List<List<Integer>> all(int[] arr) {
        List<List<Integer>> lists = new ArrayList<>();
        List<Integer> path = new ArrayList<>();
        dfs(arr, -1, path, lists);
        return lists;
    }

    public static void dfs(int[] nums, int index, List<Integer> path, List<List<Integer>> lists) {
        if(path.size() == nums.length){
            lists.add(new ArrayList<>(path));
            return;
        }
        for(int i=0;i<nums.length;i++){
            if(path.contains(nums[i])){continue;}
            path.add(nums[i]);
            dfs(nums,i,path,lists);
            path.remove(path.size()-1);
        }
    }
}

12.全排列 II
给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。
输入：nums = [1,1,2]
输出：
[[1,1,2],
[1,2,1],
[2,1,1]]

package com.exerice;

import java.util.ArrayList;
import java.util.List;

public class AllZuHeTest2 {
    public static void main(String[] args) {
        int[] arr = {1,1,2};
        System.out.println(all(arr));

    }
    public static List<List<Integer>> all(int[] arr) {
        List<List<Integer>> lists = new ArrayList<>();
        List<Integer> path = new ArrayList<>();
        boolean[] used= new boolean[arr.length];
        dfs(arr, -1, path, lists,used);
        return lists;
    }

    public static void dfs(int[] nums, int index, List<Integer> path, List<List<Integer>> lists,boolean[] used) {
        if(path.size() == nums.length){
            lists.add(new ArrayList<>(path));
            return;
        }
        for(int i=0;i<nums.length;i++){
            if(used[i]){continue;}
            if(i>0 &&nums[i]== nums[i-1] && used[i-1]){continue;}
            path.add(nums[i]);
            used[i] = true;
            dfs(nums,i,path,lists,used);
            used[i] = false;
            path.remove(path.size()-1);
        }
    }
}

13.链表两两交换

package com.exerice;

//两两交换链表中的节点
//如果链表中至少有两个节点，则在两两交换链表中的节点之后
// ，原始链表的头节点变成新的链表的第二个节点，原始链表的第二个节点变成新的链表的头节点。
// 链表中的其余节点的两两交换可以递归地实现。在对链表中的其余节点递归地两两交换之后，更新节点之间的指针关系
// ，即可完成整个链表的两两交换。

public class ListNodeTranfer {
    public ListNode swapPairs(ListNode head) {
        if(head == null || head.next == null){
            return head;
        }
        ListNode NewHead = head.next;
        head.next=swapPairs(NewHead.next);
        NewHead.next=head;
        return NewHead;

    }
}

14.链表反转

package com.testfan.ll;


//链表反转
public class ListNodeTest2 {
    public ListNode test3(ListNode head) {
        ListNode result = null;
        ListNode cur = head;
        while (cur != null) {
            ListNode node = cur.next;
            cur.next = result;
            result = cur;
            cur = node;
        }
        return result;

    }
}

14.有N个手机，编号为1-N，点开一次开灯再点一次关灯。第一次开所有点灯，第二次开编号为2的倍数的灯，第三次开编号为3的倍数的灯，。。。。m次

package com.testfan.ll;

import java.util.HashMap;

//思路：定义一个map,key存放灯的编号，value存放点了几次。点一次加1，奇数的就是亮的灯
public class KaiDenTest {
    public static void main(String[] args) {
        System.out.println(light(5,3));

    }
    public static int light(int n,int m){
        int liangDengNUm =0;
        HashMap<Integer,Integer> resultMap = new HashMap<>();
        for(int i=1;i<n+1;i++){
            resultMap.put(i,1);
        }
        for(int i:resultMap.keySet()){
            for(int j=2;j<m+1;j++){
                if(i%j==0 ){
                    int value = resultMap.get(i)+1;
                    resultMap.put(i,value);
                }
            }
        }
        for(Integer value:resultMap.values()){
            if(!(value%2 ==0)){
                liangDengNUm+=1;
            }

        }

        return liangDengNUm;

    }

}

15.股票收益最大

package exercise;
/*
*股票收益最大
* 有一道算法题，很有意思：给你一个数组，代表每天股票的买/卖价序列，要求在序列期间内最多只允许买、卖各一次（先买后卖，买要在卖之前），
* 求此期间内的最大收益是多少（可以选择不卖，即收益为0）
 */


public class ArrayTest {
    public static void main(String[] args) {
        int[] arr ={7,1,5,3,6,4};
        System.out.println("股票最大收益："+mostIncome2(arr));
    }
    public static int mostIncome(int[] arr){
        int max =0;
        for(int i=0;i<arr.length;i++){
            for(int j=i+1;j<arr.length-1;j++){
                if(arr[i]< arr[j] && arr[j]- arr[i] >max){
                   max = arr[j]- arr[i];
                }
            }
        }
        return max;
    }
    //第二种思路：动态规划
    //遍历到第一天的时候，我们记住价格，遍历到第二天的时候，我们可以得到前两天的最小值，遍历到第三天的时候，
    // 我们可以得到前三天的最小值……当我们遍历到N天的时候，我们可以得到前N天的最小值，然后和N+1天的价格相比，
    // 如果N+1天的价格小于等于前N天的最小值，那么肯定是不能卖的，那么就刷新最小值！如果N+1天的价格大于前N天的最小值
    // ，那么就计算前N天的最小值与N+1天的价格的差，也就是盈利差，并随时记录下来！
    public static int mostIncome2(int[] arr){
        int minValue = arr[0];
        int max =0;
        for(int i=1;i<arr.length;i++){
            if(arr[i] >minValue){
                max=Math.max(max,arr[i]-minValue);
            }else {
                minValue=arr[i];
            }
        }
        return max;
    }

}

16.n!的阶乘有多少个0

package exercise;
/*
*n!的阶乘有多少个0,主要看有多少个5
 */
public class NTest {
    public static void main(String[] args) {
        int num =10000;
        System.out.println(test(num));
    }
    public static int test(int num){
        int result=0;
        int tmp =5;
        while (tmp <= num){
            result=result+num/tmp;
            tmp=tmp*5;
        }

        return result;

    }
}
  1. 数字转字符串
package exercise;

/*
* 数字转字符串
* */
public class IntTurnString {
    public static void main(String[] args) {
        int s = 333322;
        System.out.println(turn(s));
    }
    public static String turn(int num){
        StringBuilder result= new StringBuilder();
        while (num !=0){
            result.append(num%10);
            num=num/10;
        }

        return  result.reverse().toString();
    }
}
qq_33214066
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
测试开发面试算法
qq_19299071的博客
04-11 324
import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.FileW...
测试岗位面试常见算法题集锦
weixin_42770598的博客
07-13 410
常见简单算法题
谈一谈测开刷算法
我去热饭的博客
06-29 594
    说起算法，谈虎色变。我见过不少优秀的测试大佬，高级测开，但是一谈到算法，立即退却。算法题在我们测试领域内到底有没有用呢？有的人说有用，但是却找不出几个用到了算法的地方。有的人说没用，因为不会什么算法也照样顺利完成工作。算法在测试领域真的只能算是锦上添花么？是不是我不清楚 也不敢妄下结论。但是我觉得算法常用在俩个地方： 很底层的数据处理上简单的业务逻辑上底层的数据处理，那种很高难度的算法，缓慢逻辑的优化。博主的确用过很多算法在这些底层的上面，但是都有一
测开面试 | Python常问算法
aihuanshang9340的博客
06-02 212
1、排序 从小到大排序：sorted(list) 从大到小排序：sorted(list, reverse=True) sort() 方法，改变原有数组的顺序 sort(reverse=True) #!/bin/Python alist = [1, 4, 2, 3, 7, 6] print(sorted(alist)) print(sorted(alist, reverse=True)...
测试&测开面试要知道的那些事--算法篇（LeetCode_Python）
weixin_73348410的博客
03-22 418
面试中一些常问的算法题
面试常见基础算法题总结
04-29
面试中的算法题是每个IT求职者都需要准备的重要环节，涵盖了数据结构、算法设计与分析等多个领域。以下是对一些常见算法题目的详细解析： 1. **红黑树**：红黑树是一种自平衡二叉查找树，它保持了二叉搜索树的特性...
Python自动化测试笔试面试题精选
09-17
此外，面试题中还涉及到了基本的算法，如排序、查找和递归。在处理数组问题时，如两数之和的例题4，虽然题目没有明确要求，但可以通过哈希表来提高查找效率，避免O(n^2)的时间复杂度。在哈希表中，查找目标与当前值...
面试常见算法题
05-17
以下是一些常见的面试算法题及其详解： 1. **二分查找**：二分查找是一种在有序数组中寻找特定元素的搜索算法。它通过不断缩小查找范围，每次将查找区间减半，直到找到目标元素或确定其不存在。了解如何设计递归或...
前端面试题之算法智力题汇集.zip
最新发布
06-21
在前端开发领域，面试往往包含了对技术能力的全方位考察，其中算法和智力题是衡量候选人逻辑思维和问题解决能力的重要部分。"前端面试题之算法智力题汇集"这个压缩包文件，很显然，是一个集锦，包含了众多针对前端...
测开面试知识点（一）
lyy07210的博客
04-13 327
1、HTTP和HTTPS HTTP：是互联网上应用最为广泛的一种网络协议，是一个客户端和服务器端请求和应答的标准（TCP），用于从WWW服务器传输超文本到本地浏览器的传输协议，它可以使浏览器更加高效，使网络传输减少。 HTTPS：是以安全为目标的HTTP通道，简单讲是HTTP的安全版，即HTTP下加入SSL层，HTTPS的安全基础是SSL，因此加密的详细内容就需要SSL。 HTTPS协议的主要作用可以分为两种：一种是建立一个信息安全通道，来保证数据传输的安全；另一种就是确认网站的真实性。 区别： 1、HTT
java工程师或者测开工程师笔试算法题
qq_45908682的博客
05-09 1370
题目：假设有n个面试官，每个面试者预约的时间是[ai， bi]（包括边界），1号面试官在bi时刻结束后，至多能继续bi+1时刻开始的面试，请帮忙计算1号面试官至多能面试多少个面试者。 这个只能过82%的测试用例 ： 这个应该可以过完 不过来不及了 笔试结束了 ： ......
测试开发面试真题—算法（百度）
xidianlina的博客
10-24 6473
1、请列举常用的算法，并说明其时间复杂读，并说明排序思想？ ①冒泡排序：量量比较待排序数据元素的大小，发现两个数据元素的次序相反时进行交换，直到没有反序的数据元素为止。时间复杂度是O(n*2)。稳定的。 public class bubble1 { public static void main(String[] args) { int[] array = { 7, 8, 3, 1,
【测试面试】测试开发面试算法高频题，这些题你会多少？
大佬云集技术答疑交流群：743262921(进群暗号:222)
12-01 1043
测试开发是近几年行业中一个流行词，既然是测试开发工程师，那么代码开发能力是最基本的要求，所以面试时必然少不了一些算法题考验你的编程功底。斐波那契数列？青蛙爬楼梯就是斐波那契数列的演化，解题思路一样。写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项。F(0) = 0 , F(1) = 1 F(N) = F(N - 1) + F(N - 2) , 其中 N > 1斐波那契数列由 0 和 1 开始，之后的斐波那契数就是由之前的两数相加而得出。方法一：递归。
60道测开面试题，背完直接涨工资
伤心的辣条
07-22 449
，备注“入群”，大家可以一起探讨交流软件测试，共同学习软件测试技术、面试等软件测试方方面面，还会有免费直播课，收获更多测试技巧，我们一起进阶Python自动化测试/测试开发，走向高薪之路。今天整理的面试题可以保障通过技术面试，但是经历的项目，对测试工作的感觉和理解才是通往大厂的门票！5、说说JVM的内存模型，紧接着引用，紧接着垃圾回收算法，具体讲一下分代算法的实现；19、介绍一下线程池，线程池的线程数量取值应该怎么取，有使用过哪些线程池。37、HttpClient你说说里面的具体实现吧？...
测试面试常问算法题（python）
weixin_44199939的博客
07-28 1176
测试面试常问算法题（python） 测试面试常问python算法 一些自己在面试自动化测试或测试开发岗时常被问到的python算法题，大多都是一些列表相关的操作，在此记录并和大家分享，转载请注明出处。 1.写一个函数比较两个列表是否相等 a=[1,2,3] b=[2,3,1] c=[1,4,3] a与b为True,a与c为False 看到这个有些同学可能会觉得直接判断两个列表是否相等不就行了，注意a和b虽然元素一样但实际是不相等的哦，直接比较是会返回False的。所以这道题其实是想让我们比较列表内的元素是否
十道腾讯算法真题解析
m0_63171455的博客
03-10 1618
前言 大家好，收集了腾讯常考的十道算法题（真题）。在金三银四，希望对大家有帮助呀。 重排链表 最长递增子序列 环形链表 反转链表 最长回文子串 全排列 LRU 缓存 合并K个升序链表 无重复字符的最长子串 删除链表的倒数第 N 个结点 1. 重排链表 给定一个单链表 L 的头节点 head ，单链表 L 表示为： L0 → L1 → … → Ln - 1 → Ln 复制代码 请将其重新排列后变为： L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 →
测试进阶面试必问12个算法题，洞悉出题思路，拿的就是高薪！
公众号【伤心的辣条】资料领取~
06-26 1155
其基本思想是：选定一个基准值，将列表分成两个子列表，小于基准值的放在左边，大于或等于基准值的放在右边，然后递归地对左、右两个子列表进行排序，最终将整个列表排序。在数学上，这一数列以如下递推的方法定义：F(0)=1，F(1)=1, F(n)=F(n - 1)+F(n - 2)（n ≥ 2，n ∈ N*）。具体实现时，先选择列表中间的元素作为基准值 pivot，然后将列表分成三部分：小于基准值的放在左边，等于基准值的放在中间，大于基准值的放在右边。最后，计数器的值就是包含数字 3 的元素的个数。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值