jyzwf / algorithm Goto Github PK

/**
 * 
 * @param {Array} nums 
 * @param {Number} target 
 */
var twoSum = function (nums, target) {
	for (let i = 0, len = nums.length; i < len; i++) {
		for (let j = i + 1; j < len; j++) {
			if (nums[i] + nums[j] === target) {
				return [i, j]
			}
		}
	}
};

/**
 * 
 * @param {Array} nums 
 * @param {Number} target 
 */
var twoSum = function (nums, target) {
	var len = nums.length;
	var hash = {};
	var i = 0;
	do {
		var a = nums[i];
		var j = hash[a];
		if (j !== undefined) {
			return [j, i];
		} else {
			hash[target - a] = i;
		}
	} while (++i < len);
};

console.log(twoSum([3, 2, 4, 5], 6))

Given "abcabcbb", the answer is "abc", which the length is 3.

Given "bbbbb", the answer is "b", with the length of 1.

Given "pwwkew", the answer is "wke", with the length of 3. Note that the answer must be a substring, "pwke" is a subsequence and not a substring.

/**
 * @param {string} s
 * @return {number}
 */
var lengthOfLongestSubstring = function (s) {
    let max = 0
    let tempMaxNoRepeateStr = '',
        finalMaxNoRepeateStr = ''
    for (let i = 0, len = s.length; i < len; i++) {
        let repeatePos = tempMaxNoRepeateStr.indexOf(s[i])
        if (repeatePos == -1) {
            tempMaxNoRepeateStr += s[i];
            if(max<=tempMaxNoRepeateStr.length){
                finalMaxNoRepeateStr = tempMaxNoRepeateStr
            }
        } else {
            let length = tempMaxNoRepeateStr.length;
            if (length > max) {
                max = length
                finalMaxNoRepeateStr = tempMaxNoRepeateStr
            }
            tempMaxNoRepeateStr = tempMaxNoRepeateStr.substring(repeatePos + 1) + s[i]
        }
    }

    return finalMaxNoRepeateStr.length
};

// 利用滑动窗口
var lengthOfLongestSubstring = function (s) {
    let len = s.length,
        max = 0,
        sumPos = 0
    if (len < 2) return len
    for (let i = 0, j = 1; j < len && i < j; j++) {
        let subStr = s.substring(i, j),
            strPos = subStr.indexOf(s[j])
        if (strPos == -1) {
            if (j - i + 1 > max) max = j - i + 1
        } else {
            if ((j - i) > max) max = j - i
            sumPos = i = strPos + sumPos + 1
        }
    }

    return max
}

nums1 = [1, 3]
nums2 = [2]

The median is 2.0

nums1 = [1, 2]
nums2 = [3, 4]

The median is (2 + 3)/2 = 2.5

var findMedianSortedArrays = function (nums1, nums2) {
    let len1 = nums1.length,
        len2 = nums2.length

    let middlePos = parseInt((len1 + len2) / 2)  // 获取中间数位置

    let finalAry = [...nums1, ...nums2].sort((a, b) => a - b),
        middleNum
    if ((len1 + len2) % 2 == 0) {
        middleNum = (finalAry[middlePos] + finalAry[middlePos - 1]) / 2
    } else {
        middleNum = finalAry[middlePos]
    }

    return middleNum
};

/**
 * 
 * @param {Array} arr 
 */

let findMinPositiveInt = (arr) => {
    let r = arr.length,
        l = 0;


    while (l < r) {
        if (arr[l] === l + 1) {
            l++
        } else if (arr[l] <= l || arr[l] > r || arr[arr[l] - 1] === arr[l]) {
            // 不合法数，比 r 大或者小，，这时候，最小正整数就在 [l+1 —— r-1] 中，
            // 最后一个判断 arr[arr[l] - 1] === arr[l] 是为了当元素不在自己应该在的位置，调整位置后，刚好该位置上的数已经是正确的数了，这时候，a[l]就是重复数，删除之
            arr[l] = arr[--r]
        } else {  // 合法，那么就将这个数摆到合理的位置，就是说 arr[i] 存 i+1
            swap(arr, l)
        }
    }

    return l + 1
}


/**
 * 
 * @param {Array} arr 
 * @param {Number} l 
 */

let swap = (arr, l) => {
    let temp = arr[l]
    arr[l] = arr[arr[l] - 1]
    arr[temp - 1] = temp
}

var convert1 = function (s, numRows) {
    let zigzagCollection = new Array(numRows).fill('')
    let len = s.length,
        j = 0,
        _isForward = true   // 是否是正向

    if (numRows == 1) return 时
    for (let i = 0; i < len; i++) {
        zigzagCollection[j] += s[i]

        if (j >= numRows - 1) {
            _isForward = false
        } else if (j <= 0) {
            _isForward = true
        }

        _isForward ? j++ : j--
    }

    return zigzagCollection
};

let logestPalindrome = function (s) {
    let p = [],
        mx = 0,
        id = 0

    let i

    let newStr = '#'
    let len = str.length
    for (i = 0; i < len; i++) {// 将字符串转化为奇数长度获取到新的字符串 
        newStr += str[i] + '#'
    }

    let newLen = newStr.length

    for (i = 0; i < newLen; i++) {
        p[i] = 0
    }

    for (i = 0; i < newLen; i++) { // 获取到所有的子回文的长度值组成的数组  
        p[i] = mx > i ? Math.min(p[2 * id - i], mx - i) : 1

        while ((newStr[i + p[i]] == newStr[i - p[i]]) && newStr[i + p[i]]) {// 超出其半径的位置再做额外判断，确保 newStr[i + p[i]] 是存在的  
            p[i]++
        }

        // 当有更大的回文串出现时，更新中心位置和最大边界值
        if (i + p[i] > mx) {
            id = i
            mx = id + p[i]
        }
    }

    return p        // 返回一个每个字符最大子串的数组
}