LeetCode 编程

作者: Jiwenjie | 来源:发表于2018-10-22 19:43 被阅读12次

    给一个包含 n 个整数的数组 S, 找到和与给定整数 target 最接近的三元组,返回这三个数的和。

    For example, given array S = {-1 2 1 -4}, and target = 1.
    
    The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).
    

    解答部分

    public class Solution {
        
        public int threeSumClose(int[] numbers, int target) {
            if (numbers == null || numbers.length < 3) {
                return -1;
            }
            
            Arrays.sort(numbers);   // 对数组进行排序
            int bestSum = numbers[0] + numbers[1] + numbers[2];
            for (int i = 0; i < numbers.length; i++) {
                int start = i + 1, end = numbers.length - 1;
                while (start < end) {
                    int sum = numbers[i] + numbers[start] + numbers[end];
                    if (Math.abs(target - sum) < Math.abs(target - bestSum)) {
                        bestSum = sum;  // 通过 Math 比较新的三个数之和与初始三数和大小,进行数值的调换
                    }
                    if (sum < target) {
                        start++;    //如果第二次的和大于初始的三数和且和小于目标值,则把start++,注意数组是排过序的。
                    } else {
                        end--;  // 如果第二次的和大于初始的三数和且和大于目标值,则 end--。
                    }
                }
            }
            return bestSum;
        }
        
    }
    

    二:电话号码的字母组合

    给定一个仅包含数字 2-9 的字符串,返回所有它能表示的字母组合。

    给出数字到字母的映射如下(与电话按键相同)。注意 1 不对应任何字母。

    按键对应的拼音字母截图如下

    08.png
    输入:"23"
    输出:["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].
    

    分析:把每个数字按键和各个的字母对应起来封装即可。


    15.png

    四数之和

    描述:给定一个包含 n 个整数的数组 nums 和一个目标值 target,判断 nums 中是否存在四个元素 a,b,c,和 d,使得 a + b + c + d 的值和 target 相等?找出所有满足条件且不重复的四元组。

    tips:答案中不可以包含重复的四元组

    public class Solution {
        public List<List<Integer>> fourSum(int[] num, int target) {
            List<List<Integer>> rst = new ArrayList<List<Integer>>();
            Arrays.sort(num);   // 排序
            for (int i = 0; i < num.length - 3; i ++) {
                if (i != 0 && num[i] == num[i - 1]) {
                    continue;
                }
                for (int j = i + 1; j < num.length - 2; j ++) {
                    if (j != i + 1 && num[j] == num[j - 1])
                        continue;
                    int left = j + 1;
                    int right = num.length - 1;
                    while (left < right) {
                        int sum = num[i] + num[j] + num[left] + num[right];
                        if (sum < target) {
                            left ++;
                        } else if (sum > target) {
                            right --;
                        } else {
                            ArrayList<Integer> tmp = new ArrayList<Integer>();
                            tmp.add(num[i]);
                            tmp.add(num[j]);
                            tmp.add(num[left]);
                            tmp.add(num[right]);
                            rst.add(tmp);
                            left++;
                            right--;
                            while (left < right && num[left] == num[left - 1]) {
                                left++;
                            }
                            while (left < right && num[right] == num[right + 1]) {
                                right--;
                            }
                        }
                    }
                }
            }
            return rst;
        }
    }
    
    

    删除链表的倒数第 N 个节点

    给定一个链表,删除链表的倒数第 n 个节点,并且返回链表的头结点。

    示例:

    给定一个链表: 1->2->3->4->5, 和 n = 2.
    
    当删除了倒数第二个节点后,链表变为 1->2->3->5.
    

    说明:

    给定的 n 保证是有效的。

    介绍,思想就是定义两个指针,可以第一个先走 n 步,之后在同时移动这两个指针即可。

    public class Solution {
        public ListNode removeFromEnd(ListNode head, int n) {
            if (n <= 0) {
                return null;
            }
            
            ListNode dummy = new ListNode(0);
            dummy.next = head;
            
            ListNode preDelete = dummy; // 定义一个指针指向第一个节点
            for (int i = 0; i < n; i ++) {
                if (head == null) {
                    return null;
                }
                head = head.next;
            }
            while (head != null) {
                head = head.next;
                preDelete = preDelete.next;
            }
            preDelete.next = preDelete.next.next;
            return dummy.next;
            
        }
    }
    

    括号匹配题目

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

    示例 1:

    输入: "()"
    输出: true
    

    示例 2:

    输入: "()[]{}"
    输出: true
    

    示例 3:

    输入: "(]"
    输出: false
    

    示例 4:

    输入: "([)]"
    输出: false
    

    示例 5:

    输入: "{[]}"
    输出: true
    

    tips:toCharArray() 方法将字符串转换为字符数组。2,注意题目要求不是输入的括号需要成对出现才行。只要有不匹配的就可以直接返回 false。

    public class Solution {
        public boolean isValidParentheses(String s) {
            Stack<Character> stack = new Stack<>();
            for (char c : s.toCharArray()) {
                if (c == '(' || c == '[' || c == '{') {
                    stack.push(c);
                }
                if (c == ')') {
                    if (stack.isEmpty() || stack.pop() != '(') {
                        return false;
                    }
                }
                if (c == ']') {
                    if (stack.isEmpty() || stack.pop() != '[') {
                        return false;
                    }
                }
                if (c == '}') {
                    if (stack.isEmpty() || stack.pop() != '{') {
                        return false;
                    }
                }
            }
            return stack.isEmpty();
        }
    }
    
    

    解析:这里大家需要注意题目的具体意思,只要每个相邻的括号无法匹配,就说明对比失败,直接返回 false,所以这里每次都是和栈顶的元素比较。

    括号生成

    给出 n 代表生成括号的对数,写出一个函数,使其能够生成 所有 可能的并且有效的括号组合

    [
      "((()))",
      "(()())",
      "(())()",
      "()(())",
      "()()()"
    ]
    

    解答:

    class Solution {
        public List<String> generateParenthesis(int n) {
            List<String> ans = new ArrayList();
            backtrack(ans, "", 0, 0, n);
            return ans;
        }
    
        public void backtrack(List<String> ans, String cur, int open, int close, int max){
            if (cur.length() == max * 2) {
                ans.add(cur);
                return;
            }
    
            if (open < max)
                backtrack(ans, cur+"(", open+1, close, max);
            if (close < open)
                backtrack(ans, cur+")", open, close+1, max);
        }
    }
    

    相关文章

      网友评论

        本文标题:LeetCode 编程

        本文链接:https://www.haomeiwen.com/subject/wxqnzftx.html