编程题

题目来源力扣(LeetCode)

提示：文章为题目顺序，非做题顺序

---

1. 两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
你可以按任意顺序返回答案。

将数组整体遍历，然后对每一个数在数组中找一个相加等于目标的数，如果出现就返回数组。但是需要将数组遍历多遍，需要耗费大量内存。

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

---

7. 整数反转

给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
将这个数取余10，然后加上上一个数的10倍，最后，判断是否可能出现溢出现象。

class Solution {
    public int reverse(int x) {
        long res = 0;
        while (x != 0) {
           res = res * 10 + x % 10;
           x /= 10;
        }
        if ((int) res == res) {
            return (int) res;
        } else {
            return 0;
        }
    }
}

---

9. 回文数

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

将这个数取余10，然后加上上一个数的10倍，再与原数进行比较，然后判断是否相同。

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

---

13. 罗马数字转整数

罗马数字包含以下七种字符: 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。
给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。

先将罗马数字字符与对应数值使用HashMap联系起来，因为存在IX和XI等这种由同样两个符号但顺序不一样的组合，所以需要同时判断两个字符才能得出正确的结果，因此设置一个变量来保存上一个字符，接着根据后面一个字符进行运算。

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

---

14. 最长公共前缀

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

首先，我们未知输入字符串数组的长度以及，每一个字符串的长度，因此，做两个判断，如果字符串数组的长度为0，那么直接返回空串，接着我们将整个字符串数组内的字符串长度最小的长度值给取出来，以便我们用于遍历时不会索引越界，接这从第一个字符开始直到最小长度值依次遍历每一个字符串，当出现第一个不相同的字符，返回从0到当前位置的字符串，当遍历结束，返回以最小长度的字符串作为最长公共前缀。

class Solution {
    public String longestCommonPrefix(String[] strs) {
        if (strs.length == 0) {
            return "";
        }
        int min = strs[0].length();
        for (String s : strs) {
            if (s.isEmpty()) {
                return "";
            }
            min = Math.min(min, s.length());
        }
        int i = 0;
        while (i < min) {
            for (String s : strs) {
                if (strs[0].charAt(i) != s.charAt(i)) {
                    return strs[0].substring(0, i);
                }
            }
            i++;
        }
        return strs[0].substring(0, i);
    }
}

---

20. 有效的括号

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

有效字符串需满足：

1. 左括号必须用相同类型的右括号闭合。
2. 左括号必须以正确的顺序闭合。

注意空字符串可被认为是有效字符串。

先将输入的左括号((、[、{)保存到LinkedList堆栈中，然后将出现的右括号对比最后一次出现的左括号，如果匹配就继续判断，如果匹配就判断字符串无效。整个字符串全部判断完成之后，判断堆栈中是否还存在元素没有被匹配。

import java.util.LinkedList;
class Solution {
    public boolean isValid(String s) {
        LinkedList<Character> list = new LinkedList<>();
        for (char c : s.toCharArray()) {
            if (c == '(' || c == '[' || c == '{') {
                list.push(c);
            } else {
                if (list.isEmpty()) {
                    return false;
                }
                if (c == ')' && list.pop() == '(') {
                   continue;
                }
                if (c == ']' && list.pop() == '[') {
                    continue;
                }
                if (c == '}' && list.pop() == '{') {
                    continue;
                }
                return false;
            }
        }
        return list.isEmpty();
    }
}

---

21. 合并两个有序链表

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

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

创建一个新的ListNode名为listNode来作为初始点，并将其备份为list，用来后续操作。判断l1与l2的元素依次比较，将小的那一个元素所指向的对象赋值给list的next，然后将小的那个元素指向它自己的next对象，直至某一个链表为空，然后将非空的一个链表赋值给list的next，然后返回最初的listNode的next。

/**
 * 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 l1, ListNode l2) {
        ListNode listNode = new ListNode();
        ListNode list = listNode; 
        while (l1 != null && l2 != null) {
            if (l1.val < l2.val) {
                list.next = l1;
                l1 = l1.next;
            } else {
                list.next = l2;
                l2 = l2.next;
            }
            list = list.next;
        }
        list.next = (l1 == null) ? l2 : l1;
        return listNode.next;
    }
}

---

26. 删除排序数组中的重复项

给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。
不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

首先判断传入数组长度是否为0，如果为0，这返回长度0。如果不为0，这将索引为0的元素赋值给临时变量，设置一个变量count来表示当前重复元素数，依次遍历数组直到数组非重复元素结束nums.length - count，依次判断当前元素与上一个非重复元素是否相等，如果相等这将后面的元素依次向前移动一个，直到非重复元素减一结束nums.length - 1 - count，然后让当前遍历索引减一，使其再次判断当前索引下的元素(因为重复了后面元素会往前面移动，当前索引下已经是后面一个元素了)；如果不相等那么就将当前元素赋值给上一个非重复元素tmp，最后返回不重复元素的长度num.length - count。

class Solution {
    public int removeDuplicates(int[] nums) {
        if (nums.length == 0) {
            return 0;
        }
        int count = 0;
        int tmp = nums[0];
        for (int i = 1; i < nums.length - count; i++) {
            if (nums[i] == tmp) {
                for (int j = i; j < nums.length - 1 - count; j++) {
                    nums[j] = nums[j + 1];
                }
                count++;
                i--;
            } else {
                tmp = nums[i];
            }
        }
        return nums.length - count;
    }
}

---

27. 移除元素

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

双指针思想：创建两个指针，使用目标指针存放新的值，使用原指针遍历数组，如果一个遇到一个元素与目标值相同，则目标指针不增加。

class Solution {
    public int removeElement(int[] nums, int val) {
        int j = 0;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] != val) {
                nums[j] = nums[i];
                j++;
            }
        }
        return j;
    }
}

---

28. 实现 strStr()

实现 strStr() 函数。
给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。

遍历目标数组，当出现目标数组中有字符与给定数组的第一个字符相同时，判断之后的字符是否都和给定数组的之后字符都相同，如果都相同就返回第一个相同字符索引，如果不相同继续遍历直至结束。

class Solution {
    public int strStr(String haystack, String needle) {
        int hl = haystack.length();
        int nl = needle.length();
        if (needle.equals("")) {
            return 0;
        }
        for (int i = 0; i < hl + 1 - nl; i++) {
            if (haystack.charAt(i) == needle.charAt(0)) {
                int j = 1;
                while (j < nl && i + j < hl && haystack.charAt(i + j) == needle.charAt(j)) {
                    j++;
                }
                if (j == nl) {
                    return i;
                }
            }
        }
        return -1;
    }
}

---

35. 搜索插入位置

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

先判断目标值是否小于数组第一个元素，如果小于直接返回0。如果不小于将遍历数组，在遍历中判断是否与目标值相同，相同则返回索引；判断是否存在一个位置，左边比目标值小，右边比目标值大，那么返回索引加一。当遍历完整个数组都没有以上情况时，说明目标值大于数组中所有的元素，就返回整个数组的长度。

class Solution {
    public int searchInsert(int[] nums, int target) {
        if (target < nums[0]) {
            return 0;
        }
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] == target) {
                return i;
            }
            if (i + 1 < nums.length && nums[i] < target && nums[i + 1] > target) {
                return i + 1;
            }
        }
        return nums.length;
    }
}

---

168. Excel表列名称

给定一个正整数，返回它在 Excel 表中相对应的列名称。
例如，

1 -> A
2 -> B
3 -> C
…
26 -> Z
27 -> AA
28 -> AB
…

和回文数一样的想法，去除每26个数的值，然后加上A的ASCII码值，然后得到该位的字母，然后反转，得到从大到小的顺序

class Solution {
    public String convertToTitle(int n) {
        StringBuilder string = new StringBuilder();
        while (n > 0) {
            n--;
            string.append((char) (n % 26 + 'A'));
            n = n / 26;
        }
        return string.reverse().toString();
    }
}

---