习题练习03

最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 “”。

示例 1:

输入: [“flower”,“flow”,“flight”] 输出: “fl” 示例 2:

输入: [“dog”,“racecar”,“car”] 输出: “” 解释: 输入不存在公共前缀。

说明:

所有输入只包含小写字母 a-z 。

/**
 * @param {string[]} strs
 * @return {string}
 */
var longestCommonPrefix = function(strs) {
  if(strs.length == 0) 
        return "";
    let ans = strs[0];
    for(let i =1;i<strs.length;i++) {
        let j=0;
        for(;j<ans.length && j < strs[i].length;j++) {
            if(ans[j] != strs[i][j])
                break;
        }
        ans = ans.substr(0, j);
        if(ans === "")
            return ans;
    }
    return ans;
};

有效括号

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

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。

示例 1:

输入: “()” 输出: true 示例 2:

输入: “()[]{}” 输出: true 示例 3:

输入: “(]” 输出: false 示例 4:

输入: “([)]” 输出: false 示例 5:

输入: “{[]}” 输出: true

/**
 * @param {string} s
 * @return {boolean}
 */
var isValid = function(s) {
  const len = s.length;
    /**
     * 特殊情况处理
     **/ 

    // 空字符串可被认为是有效字符串
    if(len === 0) {
        return true;
    }

    // 剪枝，字符串长度为奇数，必然无效
    if(len % 2 === 1) {
        return false;
    }

    // 定义字符串匹配 map
    const map = {
        '}' : '{',
        ')' : '(',
        ']' : '['
    }
    // 使用栈来校验闭合情况
    const stack = []
    for (let i = 0; i <= len - 1; i++) {
        if(!map[s[i]]) {
            // 左括号，入栈
            stack.push(s[i]);
        } else {
            // 右括号，出栈，判断如果与前一个括号不匹配，返回 false
            if(map[s[i]] !== stack.pop()) {
                return false;
            } 
        }
        // 剪枝，如果待匹配左括号的数量超过一半，返回 false （奇数已先前排除）
        if(stack.length > len / 2) {
            return false;
        }
    }
    
    // 遍历结束，如果仍有未匹配完的左括号，返回 false
    if(stack.length > 0) {
        return false;
    } else {
        return true;
    }
};

合并两个有序链表

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

示例：

输入：1->2->4, 1->3->4 输出：1->1->2->3->4->4

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} l1
 * @param {ListNode} l2
 * @return {ListNode}
 */
var mergeTwoLists = function(l1, l2) {
    if(l1 === null){
        return l2;
    }
    if(l2 === null){
        return l1;
    }
    if(l1.val < l2.val){
        l1.next = mergeTwoLists(l1.next, l2);
        return l1;
    }else{
        l2.next = mergeTwoLists(l1, l2.next);
        return l2;
    }
};