Java基础算法题

简介

实现一些基本的算法，你可以不看，但是不能不会，算法小白可以跟着一起练习。

二分查找

题目1：查找目标值的第一个出现位置
要求：

• 给定一个升序数组 nums 和目标值 target，返回 target 第一次出现的索引，若不存在返回 -1。

• 示例：

  输入：nums = [1,2,2,2,3], target = 2 → 输出：1
  输入：nums = [5,7,7,8,8,10], target = 6 → 输出：-1

答案：

public int firstOccurrence(int nums[],int target){
        int result = -1;
        int left = 0;
        int right = nums.length-1;
        while (left<=right){
            int mid =left + (right - left)/2;
            if(nums[mid]==target){
                result = mid;
                right = mid - 1;//找更前边的target
            } else if (nums[mid]<target) {
                left = mid + 1;
            }else {
                right = mid - 1;
            }
        }


        return result;
    }

 链表操作

题目1：反转链表

要求：

• 反转一个单链表。

• 示例：

  输入：1 → 2 → 3 → null → 输出：3 → 2 → 1 → null

答案：

须知：如果你在idea上练习，你需要添加一个ListNode类，要不然会报错。

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; }
}

 public ListNode reverseList(ListNode head){
        ListNode prev = null;
        ListNode curr = head;
        while (curr != null){
            ListNode nextTemp = curr.next;
            curr.next = prev;
            prev = curr;
            curr =nextTemp;
        }



        return  prev;
    }

题目2：合并两个有序链表

要求：

• 合并两个升序链表，返回合并后的新链表。

• 示例：

  输入：1→3→5 和 2→4→6 → 输出：1→2→3→4→5→6

public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
    ListNode dummy = new ListNode(-1);
    ListNode curr = dummy;
    while (l1 != null && l2 != null) {
        if (l1.val <= l2.val) {
            curr.next = l1;
            l1 = l1.next;
        } else {
            curr.next = l2;
            l2 = l2.next;
        }
        curr = curr.next;
    }
    curr.next = (l1 != null) ? l1 : l2;
    return dummy.next;
}

字符串处理

题目1：最长回文子串

要求：

• 给定字符串 s，找到 s 中最长的回文子串。

• 示例：

  输入："babad" → 输出："bab" 或 "aba"
  输入："cbbd" → 输出："bb"

答案

public String longestPalindrome(String s) {
    if (s == null || s.length() < 1) return "";
    int start = 0, end = 0;
    for (int i = 0; i < s.length(); i++) {
        int len1 = expandAroundCenter(s, i, i);     // 奇数长度
        int len2 = expandAroundCenter(s, i, i + 1); // 偶数长度
        int maxLen = Math.max(len1, len2);
        if (maxLen > end - start) {
            start = i - (maxLen - 1) / 2;
            end = i + maxLen / 2;
        }
    }
    return s.substring(start, end + 1);
}

private int expandAroundCenter(String s, int left, int right) {
    while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
        left--;
        right++;
    }
    return right - left - 1;
}

题目2：字符串转换整数（atoi）

要求：

• 实现一个函数，将字符串转换为整数（类似 atoi）。

• 规则：忽略前导空格，检查正负号，读取连续数字字符，若超出整数范围则截断。

• 示例：

  输入："   -42" → 输出：-42
  输入："4193 with words" → 输出：4193

public int myAtoi(String s) {
    if (s == null) return 0;
    s = s.trim();
    if (s.isEmpty()) return 0;

    int sign = 1;
    int i = 0;
    if (s.charAt(0) == '-' || s.charAt(0) == '+') {
        sign = (s.charAt(0) == '-') ? -1 : 1;
        i++;
    }

    long result = 0;
    while (i < s.length() && Character.isDigit(s.charAt(i))) {
        result = result * 10 + (s.charAt(i) - '0');
        if (result * sign > Integer.MAX_VALUE) return Integer.MAX_VALUE;
        if (result * sign < Integer.MIN_VALUE) return Integer.MIN_VALUE;
        i++;
    }
    return (int) (result * sign);
}