软件测试工程师面试刷题：简单JAVA算法题以及解法

• 买卖股票的最佳时机

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

 

示例 1：

输入：[7,1,5,3,6,4]
输出：5

解题思路：

1. 我们需要在历史价格中找到最低点买入，然后在最低点之后的最高点卖出。

2. 我们可以遍历数组，记录当前遇到的最低价格，同时计算当前价格与最低价格的差值（即当前能获得的利润），并更新最大利润。

3. 初始化：将最低价格设为第一个元素，最大利润设为0。

4. 从第二天开始遍历，对于每一天：

   • 如果当前价格比之前记录的最低价格还低，那么更新最低价格。

   • 否则，计算当前价格减去最低价格得到的利润，如果这个利润大于当前记录的最大利润，则更新最大利润。

5. 遍历结束后，返回最大利润。

class Solution {
    public int maxProfit(int[] prices) {
        if (prices.length < 2) {
            return 0;
        }

        int lowestPrice = prices[0];
        int profit = 0;
        for (int i = 1; i < prices.length; i++) {
            if (prices[i] < lowestPrice) {
                lowestPrice = prices[i];
            } else {
                if ((prices[i] - lowestPrice) > profit) {
                    profit = prices[i] - lowestPrice;
                }
            }
        }
        return profit;
    }
}

 

• 杨辉三角2

给定一个非负索引 rowIndex，返回「杨辉三角」的第 rowIndex 行。

在「杨辉三角」中，每个数是它左上方和右上方的数的和。

 

示例 1:

输入: rowIndex = 3
输出: [1,3,3,1]

class Solution {
    public List<Integer> getRow(int rowIndex) {
        List<Integer> row = new ArrayList<>();

        for (int i = 0; i <= rowIndex; i++) {
            // 在开头添加1，为计算新行做准备
            row.add(0, 1);

            // 更新中间的值（除了第一个和最后一个）
            for (int j = 1; j < row.size() - 1; j++) {
                row.set(j, row.get(j) + row.get(j + 1));
            }
        }
        return row;
    }
}

 

• 路径总和

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。

叶子节点 是指没有子节点的节点。

 

示例 1：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
输出：true

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean hasPathSum(TreeNode root, int targetSum) {
        if (root == null) {
            return false;
        }

        // 如果是叶子节点，检查路径和是否等于目标值
        if (root.left == null && root.right == null) {
            return root.val == targetSum;
        }

        // 递归检查左子树和右子树
        boolean leftTree = hasPathSum(root.left, targetSum - root.val);
        boolean rightTree = hasPathSum(root.right, targetSum - root.val);

        return leftTree || rightTree;
    }
}

 

• 杨辉三角

给定一个非负整数 numRows，生成「杨辉三角」的前 numRows 行。

在「杨辉三角」中，每个数是它左上方和右上方的数的和。

class Solution {
    public List<List<Integer>> generate(int numRows) {
        List<List<Integer>> result = new ArrayList<>();
        if (numRows == 0) {
            return result;
        }

        //第一行
        List<Integer> firstRow = new ArrayList<>();
        firstRow.add(1);
        result.add(firstRow);

        for (int i = 1; i < numRows; i++) {
            List<Integer> prevRow = result.get(i - 1);
            List<Integer> currentRow = new ArrayList<>();

            //每行的第一个元素总是1
            currentRow.add(1);

            //中间的第j个元素等于上一行的第j-1个元素加上第j个元素
            for (int j = 1; j < i; j++) {
                currentRow.add(prevRow.get(j - 1) + prevRow.get(j));
            }

            //最后一个元素也是1
            currentRow.add(1);
            result.add(currentRow);
        }

        return result;
    }
}

 

• 二叉树的最小深度

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明：叶子节点是指没有子节点的节点。

 

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：2

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int minDepth(TreeNode root) {
        if(root==null){
            return 0;
        }

        Queue<TreeNode> queue=new LinkedList<>();
        queue.offer(root);
        int depth=1; // 根节点深度为1

        while (!queue.isEmpty()){
            int levelSize=queue.size();

            // 遍历当前层的所有节点
            for(int i=0; i<levelSize;i++){
                TreeNode node=queue.poll();

                // 检查是否是叶子节点
                if(node.left==null && node.right==null){
                    return depth;
                }

                // 将子节点加入队列
                if(node.left!=null){
                    queue.offer(node.left);
                }
                if(node.right!=null){
                    queue.offer(node.right);
                }
            }
            // 当前层遍历完毕，深度+1
            depth++;
        }
        return depth;
    }
}

 

• 平衡二叉树

给定一个二叉树，判断它是否是 平衡二叉树  

 

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：true

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isBalanced(TreeNode root) {
        if (root == null) {
            return true;
        }

        // 检查当前节点是否平衡
        int leftHeight = getHeight(root.left);
        int rightHeight = getHeight(root.right);

        if (Math.abs(leftHeight - rightHeight) > 1) {
            return false;
        }
        
        // 递归检查左右子树
        return (isBalanced(root.left) && isBalanced(root.right));

    }

    private int getHeight(TreeNode node) {
        if (node == null) {
            return 0;
        }
        return Math.max(getHeight(node.left), getHeight(node.right)) + 1;
    }
}

 

• 将有序数组转换为二叉搜索树

给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 平衡 二叉搜索树。

 

示例 1：

输入：nums = [-10,-3,0,5,9]
输出：[0,-3,9,-10,null,5]
解释：[0,-10,5,null,-3,null,9] 也将被视为正确答案：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode sortedArrayToBST(int[] nums) {

        return buildBST(nums, 0, nums.length-1);
    }

    private TreeNode buildBST(int[] nums, int left, int right){
        if(left>right){
            return null;
        }

        int mid=left+(right-left)/2;
        TreeNode root= new TreeNode(nums[mid]);

        //递归构建左子树和右子树
        root.left=buildBST(nums,left,mid-1);
        root.right=buildBST(nums, mid+1, right);
        return root;
    }
}

 

• 二叉树的最大深度

给定一个二叉树 root ，返回其最大深度。

二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。

 

示例 1：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int maxDepth(TreeNode root) {
        //递归
        if (root == null) {
            return 0;
        }

        int leftDepth = maxDepth(root.left);
        int rightDepth = maxDepth(root.right);

        return Math.max(leftDepth, rightDepth) + 1;
    }
}

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int depth = 0;

        while (!queue.isEmpty()) {
            //这个levelSize = 当前层级的节点数量
            int levelSize = queue.size();

            //遍历当前层的左右节点
            for (int i = 0; i < levelSize; i++) {
                TreeNode node = queue.poll();

                //将下一层的节点加入队列
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            //完成一层的遍历，深度+1
            depth++;
        }
        return depth;
    }
}

 

• 对称二叉树

给你一个二叉树的根节点 root ， 检查它是否轴对称。

 

示例 1：

输入：root = [1,2,2,3,4,4,3]
输出：true

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isSymmetric(TreeNode root) {
        if (root == null) {
            return true;
        }
        return isMirror(root.left, root.right);
    }

    private boolean isMirror(TreeNode t1, TreeNode t2) {
        // 如果两个节点都为null，是对称的
        if (t1 == null && t2 == null) {
            return true;
        }

        // 如果只有一个节点为null，不对称
        if (t1 == null || t2 == null) {
            return false;
        }

        // 检查当前节点值是否相等，且子树是否镜像对称
        return (t1.val == t2.val) && isMirror(t1.left, t2.right) && isMirror(t1.right, t2.left);
    }
}

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isSymmetric(TreeNode root) {
        if (root == null) {
            return true;
        }

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root.left);
        queue.offer(root.right);

        while (!queue.isEmpty()) {
            TreeNode node1 = queue.poll();
            TreeNode node2 = queue.poll();

            // 如果两个节点都为null，继续检查
            if (node1 == null && node2 == null) {
                continue;
            }

            // 如果只有一个节点为null，或者节点值不同，不对称
            if (node1 == null || node2 == null || node1.val != node2.val) {
                return false;
            }

            // 将镜像位置的节点成对加入队列
            queue.offer(node1.left);
            queue.offer(node2.right);
            queue.offer(node1.right);
            queue.offer(node2.left);
        }

        return true;
    }
}

 

• 相同的树

给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

 

示例 1：

输入：p = [1,2,3], q = [1,2,3]
输出：true

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isSameTree(TreeNode p, TreeNode q) {
        //递归
        if (p == null && q == null) {
            return true;
        }

        if (p == null || q == null) {
            return false;
        }

        if (p.val != q.val) {
            return false;
        }

        return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
    }
}

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isSameTree(TreeNode p, TreeNode q) {
        //迭代算法
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(p);
        queue.offer(q);

        while (!queue.isEmpty()) {
            TreeNode node1 = queue.poll();
            TreeNode node2 = queue.poll();

            //// 如果两个节点都为null，继续检查下一对节点
            if (node1 == null && node2 == null) {
                continue;
            }

            // 如果只有一个节点为null，或者节点值不同，返回false
            if (node1 == null || node2 == null || node1.val != node2.val) {
                return false;
            }
            queue.offer(node1.left);
            queue.offer(node2.left);
            queue.offer(node1.right);
            queue.offer(node2.right);
        }

        // 将左子树和右子树节点加入队列
        return true;
    }
}

 

• 二叉树的中序遍历

给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。

 

示例 1：

输入：root = [1,null,2,3]
输出：[1,3,2]

示例 2：

输入：root = []
输出：[]

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null) {
            return result;
        }
            
        List<Integer> left = inorderTraversal(root.left);
        int rootVal = root.val;
        List<Integer> right = inorderTraversal(root.right);
        result.addAll(left);
        result.add(rootVal);
        result.addAll(right);
        return result;
    }
}

 

• 删除排序链表中的重复元素

给定一个已排序的链表的头 head ， 删除所有重复的元素，使每个元素只出现一次 。返回 已排序的链表 。

 

示例 1：

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

提示：

• 链表中节点数目在范围 [0, 300] 内
• -100 <= Node.val <= 100
• 题目数据保证链表已经按升序 排列

/**
 * 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) {
        if (head== null || head.next == null)
            return head;

        ListNode current = head;
        while (current.next != null) {
            if (current.val == current.next.val) {
                current.next = current.next.next;
            } else {
                current = current.next;
            }
        }
        return head;
    }
}

 

• 爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

 

示例 1：

输入：n = 2
输出：2
解释：有两种方法可以爬到楼顶。
1. 1 阶 + 1 阶
2. 2 阶

示例 2：

输入：n = 3
输出：3
解释：有三种方法可以爬到楼顶。
1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶

 

提示：

• 1 <= n <= 45

class Solution {
    public int climbStairs(int n) {
        //由于每次可以爬1或2个台阶，所以到达第 i 阶可以从第 i-1 阶爬1个台阶到达，或者从第 i-2 阶爬2个台阶到达。
        if (n <= 1)
            return 1;

        int first = 1; // 爬到第1阶的方法数
        int second = 2; // 爬到第2阶的方法数

        for (int i = 3; i <= n; i++) {
            int current = first + second;
            first = second;
            second = current;
        }
        return second;
    }
}

 

• x的平方根

给你一个非负整数 x ，计算并返回 x 的 算术平方根 。

由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。

注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。

 

示例 1：

输入：x = 4
输出：2

示例 2：

输入：x = 8
输出：2
解释：8 的算术平方根是 2.82842..., 由于返回类型是整数，小数部分将被舍去。

本题要找的是使得 <span class="katex"><span class="katex-html"><span class="base"><span class="strut"><span class="mord"><span class="mord mathnormal">a<span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist"><span class="pstrut"><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2<span class="mspace"><span class="mrel">≤<span class="mspace"><span class="base"><span class="strut"><span class="mord mathnormal">x 的最大的 <span class="math math-inline"><span class="katex"><span class="katex-html"><span class="base"><span class="strut"><span class="mord mathnormal">a。

class Solution {
    public int mySqrt(int x) {
        if (x == 0)
            return 0;
        if (x == 1)
            return 1;
        int left = 1;
        int right = x / 2;

        //二分查找
        while (left <= right) {
            //计算中间值 mid，使用 left + (right - left) / 2 来避免整数溢出
            int mid = left + (right - left) / 2;

            //如果 mid 的平方等于 x，直接返回 mid
            if ((long) mid * mid == x) {
                return mid;
            }
            //如果 mid 的平方小于 x，移动 left 到 mid + 1 以查找更大的潜在平方根
            else if ((long) mid * mid < x) {
                left = mid + 1;
            }
            //如果 mid 的平方大于 x，移动 right 到 mid - 1 以查找更小的潜在平方根
            else {
                right = mid - 1;
            }
        }
        return right;
    }
}

 

• 二进制求和

给你两个二进制字符串 a 和 b ，以二进制字符串的形式返回它们的和。

示例 1：

输入:a = "11", b = "1"
输出："100"

示例 2：

输入：a = "1010", b = "1011"
输出："10101"

二进制的进位规则是「逢二进一」，即当求和结果 <span class="katex"><span class="katex-html"><span class="base"><span class="strut"><span class="mrel">>=<span class="mspace"><span class="base"><span class="strut"><span class="mord">2 时，需要向前进位。

class Solution {
    public String addBinary(String a, String b) {
        //在 Java 中,如果字符串超过 33 位，不能转化为 Integer
        //所以下面的方法不够健壮
        //return Integer.toBinaryString(Integer.parseInt(a,2)+Integer.parseInt(b,2));
        StringBuilder temp = new StringBuilder();
        int i = a.length() - 1;
        int j = b.length() - 1;
        int carry = 0;

        while (i >= 0 || j >= 0 || carry != 0) {// a 没遍历完，或 b 没遍历完，或进位不为 0
            int digitA = i >= 0 ? a.charAt(i) - '0' : 0;// 当前 a 的取值
            int digitB = j >= 0 ? b.charAt(j) - '0' : 0;// 当前 b 的取值
            int sum = digitA + digitB + carry;// 当前位置相加的结果
            carry = sum >= 2 ? 1 : 0;// 是否有进位
            sum = sum >= 2 ? sum-2 : sum;// 去除进位后留下的数字
            temp.append(sum);// 把去除进位后留下的数字拼接到结果中
            i--;
            j--;
        }
        return temp.reverse().toString();// 把结果反转并返回

    }
}

 

• 加一

给定一个表示 大整数 的整数数组 digits，其中 digits[i] 是整数的第 i 位数字。这些数字按从左到右，从最高位到最低位排列。这个大整数不包含任何前导 0。

将大整数加 1，并返回结果的数字数组。

 

示例 1：

输入：digits = [1,2,3]
输出：[1,2,4]
解释：输入数组表示数字 123。
加 1 后得到 123 + 1 = 124。
因此，结果应该是 [1,2,4]。

示例 2：

输入：digits = [9]
输出：[1,0]
解释：输入数组表示数字 9。
加 1 得到了 9 + 1 = 10。
因此，结果应该是 [1,0]。

class Solution {
    public int[] plusOne(int[] digits) {
        int n = digits.length;
        for (int i = n - 1; i >= 0; i--) {
            //在代码中，return digits是在遇到当前位小于9时执行，此时 digits[i]++ 后直接返回，不会执行后面的 digits[i]=0。而只有当当前位等于9时，才会执行 digits[i]=0，并且不会return，而是继续循环。
            if (digits[i] < 9) {
                digits[i]++; // 进位
                return digits;
            }
            else{
                digits[i] = 0; // 进位数字的右边数字都变成 0
            }
            
        }

        // digits 全是 9，加一后变成 100...00
        //在Java中，当创建一个新的整数数组时，所有元素都会被自动初始化为0。因此，当我们执行 int[] ans = new int[n + 1]; 时，新数组 ans 的所有元素都是0。然后我们只需要将第一位置为1（ans[0] = 1;），其余位置自然就是0，所以不需要显式赋值。
        int[] ans = new int[n + 1];
        ans[0] = 1;
        return ans;
    }
}

 

• 最后一个单词的长度

给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中 最后一个 单词的长度。

单词 是指仅由字母组成、不包含任何空格字符的最大子字符串。

 

示例 1：

输入：s = "Hello World"
输出：5
解释：最后一个单词是“World”，长度为 5。

class Solution {
    public int lengthOfLastWord(String s) {
        int wordLength=0;
        for(int i=s.length()-1; i>=0; i--){
            if(s.charAt(i)!=' '){
                wordLength++;
                if(i>=1 && s.charAt(i-1)==' '){
                    break;
                }
            }
        }
        return wordLength;
    }
}

 

• 搜索插入位置

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

请必须使用时间复杂度为 O(log n) 的算法。

 

示例 1:

输入: nums = [1,3,5,6], target = 5
输出: 2

//暴力算法
class Solution {
    public int searchInsert(int[] nums, int target) {
        if(nums.length==0){return 0;}
        
        for(int i=0; i<nums.length; i++){
            if(nums[i]==target){return i;}
        }
        int i=0;
        for(i=0;i< nums.length; i++){
            if(nums[i]>target){
                return i;
            }
            if(i==nums.length-1) {
                return i+1;
            }      
        }
        return i+1;
    }
}

//二分查找算法
class Solution {
    public int searchInsert(int[] nums, int target) {
        int l=0;
        int r=nums.length-1;

        while(l<=r){
            int mid = (l+r)/2;
            if(nums[mid]==target){return mid;}
            if(nums[mid]>target){
                r=mid-1;
            }
            if(nums[mid]<target){
                l=mid+1;
            }
        }
        return l;
        
    }
}

 

• 找出字符串中第一个匹配项的下标

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回  -1 。

 

示例 1：

输入：haystack = "sadbutsad", needle = "sad"
输出：0
解释："sad" 在下标 0 和 6 处匹配。
第一个匹配项的下标是 0 ，所以返回 0 。

class Solution {
    public int strStr(String haystack, String needle) {
        int haystackLength = haystack.length();
        int needleLength = needle.length();

        if(needleLength > haystackLength) return -1;

        for(int i = 0; i + needleLength < = haystackLength; i++){
            boolean flag=true;
            for(int j=0; j < needleLength; j++){
                if(needle.charAt(j)!=haystack.charAt(i+j)){
                    flag=false;
                    break;
                }
            }
            if(flag) return i;
        }

        return -1;
    }
}

 

• 移除元素

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素。元素的顺序可能发生改变。然后返回 nums 中与 val 不同的元素的数量。

假设 nums 中不等于 val 的元素数量为 k，要通过此题，您需要执行以下操作：

• 更改 nums 数组，使 nums 的前 k 个元素包含不等于 val 的元素。nums 的其余元素和 nums 的大小并不重要。
• 返回 k。

用户评测：

评测机将使用以下代码测试您的解决方案：

int[] nums = [...]; // 输入数组
int val = ...; // 要移除的值
int[] expectedNums = [...]; // 长度正确的预期答案。
                            // 它以不等于 val 的值排序。

int k = removeElement(nums, val); // 调用你的实现

assert k == expectedNums.length;
sort(nums, 0, k); // 排序 nums 的前 k 个元素
for (int i = 0; i < actualLength; i++) {
    assert nums[i] == expectedNums[i];
}

如果所有的断言都通过，你的解决方案将会 通过。

 

示例 1：

输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2,_,_]
解释：你的函数函数应该返回 k = 2, 并且 nums中的前两个元素均为 2。
你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。

class Solution {
    public int removeElement(int[] nums, int val) {
        if(nums.length==0){
            return 0;
        }
        int slow=0;
        int fast=0;
        while(fast<nums.length){
            if(nums[fast]==val){
                fast++;
            }
            else{
                nums[slow]=nums[fast];
                slow++;
                fast++;
            }
        }
        return slow;
    }
}

 

• 删除有序数组中的重复项

给你一个 非严格递增排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。然后返回 nums 中唯一元素的个数。

考虑 nums 的唯一元素的数量为 k ，你需要做以下事情确保你的题解可以被通过：

• 更改数组 nums ，使 nums 的前 k 个元素包含唯一元素，并按照它们最初在 nums 中出现的顺序排列。nums 的其余元素与 nums 的大小不重要。
• 返回 k 。

判题标准:

系统会用下面的代码来测试你的题解:

int[] nums = [...]; // 输入数组
int[] expectedNums = [...]; // 长度正确的期望答案

int k = removeDuplicates(nums); // 调用

assert k == expectedNums.length;
for (int i = 0; i < k; i++) {
    assert nums[i] == expectedNums[i];
}

如果所有断言都通过，那么您的题解将被 通过。

 

示例 1：

输入：nums = [1,1,2]
输出：2, nums = [1,2,_]
解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。

class Solution {
    public int removeDuplicates(int[] nums) {
        int n=nums.length;
        if(n==0){
            return 0;
        }
        if(n==1){
            return 1;
        }

        //定义两个指针，快指针表示遍历数组到达的下标位置，慢指针表示下一个不同元素要填入的位置
        int fast=1; 
        int slow=1;
        while(fast<n){
            if(nums[fast]!=nums[fast-1]){
                nums[slow]=nums[fast];
                slow++;
            }
            fast++;
        }
        return slow;
    }
}

 

• 合并两个有序链表

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 

示例 1：

输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]

/**
 * 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 mergeTwoLists(ListNode list1, ListNode list2) {
        //引入伪头结点：由于初始状态合并链表中无节点，因此循环第一轮时无法将节点添加到合并链表中。初始化一个辅助节点dum作为合并链表的伪头节点，将各节点添加至dum之后
        ListNode dum=new ListNode(0);
        ListNode cur=dum;

        while(list1 !=null && list2!=null){
            if(list1.val<list2.val){
                cur.next=list1;
                list1=list1.next;
            }
            else {
                cur.next=list2;
                list2=list2.next;
            }
            cur=cur.next;
        }
        cur.next=list1 !=null? list1:list2;
        //合并链表在伪头结点dum之后，因此返回dum.next即可
        return dum.next;
    }
}

 

• 找不同

给定两个字符串 s 和 t ，它们只包含小写字母。

字符串 t 由字符串 s 随机重排，然后在随机位置添加一个字母。

请找出在 t 中被添加的字母。

 

示例 1：

输入：s = "abcd", t = "abcde"
输出："e"
解释：'e' 是那个被添加的字母。

 1 class Solution {
 2     public char findTheDifference(String s, String t) {
 3         if(s==null) {
 4             return t.charAt(0);
 5         }
 6 
 7         int[] count = new int[26];
 8         for(char c:s.toCharArray()){
 9             //char c是当前字符
10             //'a'是字符常量，在ASCII中值为97
11             // c-'a'计算的是字符c相对于'a'的偏移量
12             //如果c='a', 'a'-'a'=0
13             //如果c='b', 'b'-'a'=1
14             //所以count[0]对应字母a, count[1]对应字母b... 
15             count[c-'a']++;
16         }
17         for(char c: t.toCharArray()){
18             count[c-'a']--;
19             if(count[c-'a']<0){
20                 return c;
21             }
22         }
23         return ' ';
24     }
25 }

 

• 交替合并字符串

给你两个字符串 word1 和 word2 。请你从 word1 开始，通过交替添加字母来合并字符串。如果一个字符串比另一个字符串长，就将多出来的字母追加到合并后字符串的末尾。

返回 合并后的字符串 。

示例 1：

输入：word1 = "abc", word2 = "pqr"
输出："apbqcr"
解释：字符串合并情况如下所示：
word1：  a   b   c
word2：    p   q   r
合并后：  a p b q c r

 1 class Solution {
 2     public String mergeAlternately(String word1, String word2) {
 3         if(word1 ==null) return word2;
 4         if(word2 == null) return word1;
 5 
 6         StringBuilder result = new StringBuilder();
 7         int i=0;
 8 
 9         while(i<word1.length() && i<word2.length()){
10             result.append(word1.charAt(i));
11             result.append(word2.charAt(i));
12             i++;
13         }
14 
15         result.append(word1.substring(i));
16         result.append(word2.substring(i));
17 
18         return result.toString();
19     }
20 }

 

• 字符串轮转

字符串轮转。给定两个字符串s1和s2，请编写代码检查s2是否为s1旋转而成（比如，waterbottle是erbottlewat旋转后的字符串）。

示例 1：

 输入：s1 = "waterbottle", s2 = "erbottlewat"
 输出：True

示例 2：

 输入：s1 = "aa", s2 = "aba"
 输出：False

 1 class Solution {
 2     public boolean isFlipedString(String s1, String s2) {
 3         if(s1==null || s2==null || s1.length()!= s2.length()) {
 4             return false;
 5         }
 6         //如果s2是s1旋转得到的，那么s2一定是s1+s1的子串
 7         String doubleS1=s1+s1;
 8         return doubleS1.contains(s2);
 9     }
10 }

 

• 判断字符是否唯一

实现一个算法，确定一个字符串 s 的所有字符是否全都不同。

示例 1：

输入: s = "leetcode"
输出: false 

示例 2：

输入: s = "abc"
输出: true

 1 class Solution {
 2     public boolean isUnique(String astr) {
 3         if(astr.length()==1 || astr.length()==0){
 4             return true;
 5         }
 6         for(int i=0;i<astr.length()-1;i++){
 7             for(int j=i+1; j<astr.length();j++){
 8                 if(astr.charAt(i)==astr.charAt(j)){
 9                     return false;
10                 }
11             }
12         }
13         return true;
14     }
15 }

 

• 有效的括号

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

1. 左括号必须用相同类型的右括号闭合。
2. 左括号必须以正确的顺序闭合。
3. 每个右括号都有一个对应的相同类型的左括号。

 1 class Solution {
 2     public boolean isValid(String s) {
 3         //如果字符串长度为奇数，肯定不匹配
 4         if(s.length() %2 !=0) return false;
 5 
 6         Stack<Character> stack =new Stack<>();
 7 
 8         for(char c : s.toCharArray()){
 9             //如果是左括号，压入栈中
10             if(c=='(' || c=='{' || c=='['){
11                 stack.push(c);
12             }
13             //如果是右括号
14             else{
15                 //栈为空，已经没有与之相匹配的左括号，返回不匹配
16                 if(stack.isEmpty()){
17                     return false;
18                 }
19                 //弹出栈顶元素，并匹配
20                 char top=stack.pop();
21                 if((c==')' && top != '(') || 
22                 (c==']' && top != '[') || 
23                 (c=='}' && top != '{')) {
24                     return false;
25                 }
26             }
27         }
28         //最终栈为空，说明全部弹出，返回匹配
29         return stack.isEmpty();
30     }
31 }

 

• 最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串 ""。

示例 1：

输入：strs = ["flower","flow","flight"]
输出："fl"

示例 2：

输入：strs = ["dog","racecar","car"]
输出：""
解释：输入不存在公共前缀。

 1 class Solution {
 2     public String longestCommonPrefix(String[] strs) {
 3         if(strs.length==0) return "";
 4 
 5         String ans = strs[0];
 6         for(int i=1;i<strs.length;i++){
 7             int j=0;
 8             for(; j<ans.length() && j<strs[i].length();j++){
 9                 if(ans.charAt(j)!= strs[i].charAt(j))
10                     break;
11             }
12             ans=ans.substring(0,j);
13         }
14         return ans;
15     }
16 }

 

• 罗马数字转整数

罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。

字符          数值
I             1
V             5
X             10
L             50
C             100
D             500
M             1000

例如， 罗马数字 2 写做 II ，即为两个并列的 1 。12 写做 XII ，即为 X + II 。 27 写做  XXVII, 即为 XX + V + II 。

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

• I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
• X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。 
• C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。

给定一个罗马数字，将其转换成整数。

class Solution {
    public int romanToInt(String s) {
        Map<Character, Integer> map = new HashMap<>(); 
        map.put('I',1);
        map.put('V',5);
        map.put('X',10);
        map.put('L',50);
        map.put('C',100);
        map.put('D',500);
        map.put('M',1000);

        int result=0;
        int previousvalue=0;

        for(int i=s.length()-1; i>=0;i--){
            Character currentChar = s.charAt(i);
            int currentValue=map.get(currentChar);

            if(currentValue < previousvalue){
                result=result-currentValue;
            }
            else {
                result=result+currentValue;
            }
            previousvalue=currentValue;
        }
        return result;
    }
}

 

• 两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案，并且你不能使用两次相同的元素。

你可以按任意顺序返回答案。

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int length = nums.length;
        for(int i=0; i<length-1;i++){
            for(int j=i+1; j<length;j++){
                if(nums[i]+nums[j]==target){
                    return new int[]{i,j};
                }
            }
        }
        return new int[]{};
    }
}

 

• 回文数

给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。

回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

• 例如，121 是回文，而 123 不是。

class Solution {
    public boolean isPalindrome(int x) {
        if(x<0){
            return false;
        }
        else {
            int rev=0;
            int num=x;
            while(num!=0){
                rev=rev*10 +num%10;
                num=num/10;
            }
            return (rev==x);
        }
    }
}

 

• 合并两个有序数组

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。

请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。

注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

 1 class Solution {
 2     public void merge(int[] nums1, int m, int[] nums2, int n) {
 3         for(int i=0; i<n; i++){
 4             nums1[m+i]=nums2[i];
 5         }
 6         //Arrays.sort(nums1);
 7         
 8         int len=nums1.length;
 9         //外循环控制排序轮数
10         for(int i=0; i<len-1;i++){
11             //内循环进行相邻元素比较和交换
12             for(int j=0; j<len-1-i;j++){
13                 //如果前面元素大于后面元素，则交换
14                 if(nums1[j]>nums1[j+1]){
15                     //交换元素
16                     int temp = nums1[j];
17                     nums1[j]=nums1[j+1];
18                     nums1[j+1]=temp;
19                 }
20             }
21         }
22     }
23 }