数据结构系列二---[一周leetcode刷题记录]

最新推荐文章于 2022-10-17 15:42:05 发布

牛小小小婷～

最新推荐文章于 2022-10-17 15:42:05 发布

阅读量197

点赞数

分类专栏：数据结构文章标签： npm json 前端

本文链接：https://blog.csdn.net/hannah2233/article/details/123319153

版权

数据结构专栏收录该内容

16 篇文章 0 订阅

订阅专栏

2022.2.27

一、 496. 下一个更大元素 I

nums1 中数字 x 的下一个更大元素是指 x 在 nums2 中对应位置右侧的第一个比 x 大的元素。

给你两个没有重复元素的数组 nums1 和 nums2 ，下标从 0 开始计数，其中nums1 是 nums2 的子集。

对于每个 0 <= i < nums1.length ，找出满足 nums1[i] == nums2[j] 的下标 j ，并且在 nums2 确定 nums2[j] 的下一个更大元素。如果不存在下一个更大元素，那么本次查询的答案是 -1 。

返回一个长度为 nums1.length 的数组 ans 作为答案，满足 ans[i] 是如上所述的下一个更大元素。

var nextGreaterElement = function(nums1, nums2) {
    const map = new Map();
    const stack = [];
    for (let i = nums2.length - 1; i >= 0; --i) {
        const num = nums2[i];
        while (stack.length && num >= stack[stack.length - 1]) {
            stack.pop();
        }
        map.set(num, stack.length ? stack[stack.length - 1] : -1);
        stack.push(num);
    }
    const res = new Array(nums1.length).fill(0).map((_, i) => map.get(nums1[i]));
    return res;
};

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number[]}
 */
// var nextGreaterElement = function(nums1, nums2) {
    // AC超时              
    // const res = [];
    // for(let i = 0; i<nums1.length; i++){
    //     for(let j = 0; j < nums2.length; j++){
    //         if(nums1[i] === nums2[j]){
    //             for(let h = j; j<nums2.length; h++){
    //                 if(nums2[h] > nums2[j]){
    //                     res.push(nums2[h]);
    //                     break;
    //                 }
    //             }
    //         }
    //     }
    // }
    // return res;
    
// };

// AC
// var nextGreaterElement = function(nums1, nums2) {
//     const m = nums1.length, n = nums2.length;
//     const res = new Array(m).fill(0);
//     for (let i = 0; i < m; ++i) {
//         let j = 0;
//         while (j < n && nums2[j] !== nums1[i]) {
//             ++j;
//         }
//         let k = j + 1;
//         while (k < n && nums2[k] < nums2[j]) {
//             ++k;
//         }
//         res[i] = k < n ? nums2[k] : -1;
//     }
//     return res;
// };




// 单调栈
const nextGreaterElement = (nums1, nums2) => {
    const m = nums1.length, n = nums2.length;
    const res = new Array(m).fill(-1);
    const stack = [];
    
    for(let i = 0; i<m; ++i){
        let j = 0;
        while(nums1[i] !== nums2[j]){
            ++j;
        }
        for(let h = n-1; h>j; --h){  // 反向入栈
            while(stack.length && nums2[h]>stack[stack.length - 1]){
                stack.pop();
            }
            res[i] = stack.length ? stack[stack.length -1] : -1;
            stack.push(nums2[h]);
        }
    }
    return res;
};

----------奇奇怪怪的写法-----------

//     const m = nums.length;
//     const res = new Array(m).fill(0);
//     const stack = [];
//     for(let i = m-1; i > 0; i--){  // 反向入栈
//         while (stack.length  && num >= stack[stack.length -1])   // 大于栈顶元素
//             stack.pop();
//         res[i] = stack.length ? stack[stack.length -1] : -1;
//         stack.push(nums[i]);
//     }
//     return res;

2022.2.28

一、剑指 Offer II 038. 每日温度

给定一个整数数组 temperatures ，表示每天的温度，返回一个数组 answer ，其中 answer[i] 是指在第 i 天之后，才会有更高的温度。如果气温在这之后都不会升高，请在该位置用 0 来代替。

每次都是：：： wocao，我真TM聪明！！！立马提交，卧槽？？？？

3.1复盘：真感动啊！！，就少了=，测试用例硬是没有卡住

/**
 * @param {number[]} temperatures
 * @return {number[]}
 */
var dailyTemperatures = function(temperatures) {
    const TL = temperatures.length;
    const res = new Array(TL).fill(0);
    const stack = [];

    for(let i = TL-1; i >= 0 ;i--){ // 反向入栈
        while(stack.length && temperatures[stack[stack.length -1]] <= temperatures[i]) {
            stack.pop(); // 个子矮就出战
        } 
        res[i] = stack.length ? stack[stack.length-1] - i : 0;
        stack.push(i);
    }
    return res;
};

二、 739. 每日温度

三、 197. 上升的温度

2022.3.2

二、 503. 下一个更大元素 II

给定一个循环数组 nums （ nums[nums.length - 1] 的下一个元素是 nums[0] ），返回 nums 中每个元素的下一个更大元素。

数字 x 的下一个更大的元素是按数组遍历顺序，这个数字之后的第一个比它更大的数，这意味着你应该循环地搜索它的下一个更大的数。如果不存在，则输出 -1 。

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var nextGreaterElements = function(nums) {
    const m = nums.length;
    const res = new Array(m).fill(0);
    const stack = [];
    // 将数组长度翻倍
    for (let i = 2*m-1; i >= 0; i--){  // 反向入栈
        while (stack.length  && nums[i%m] >= stack[stack.length -1]) {  // 大于栈顶元素
            stack.pop();
        }
        // 利用 % 求模 防止索引越界
        res[i%m] = stack.length ? stack[stack.length -1] : -1;
        stack.push(nums[i%m]);
    }
    return res;
};

一、 556. 下一个更大元素 III

案例没过

/**
 * @param {number} n
 * @return {number}
 */
var nextGreaterElement = function(n) {
    let s = n.toString().split(''), size = s.length;
    if (size <= 1) return -1;
    let i = size - 2, j = size - 1;
    for(; i >= 0; i--){
        if (s[i] < s[i + 1]) 
            break;
    }

    if (i < 0) return -1;

    for(; j >= 0; j--){
        if (s[j] > s[i]) 
            break;
    } 
    [s[i], s[j]] = [s[j], s[i]];
    let res = +(s.slice(0, i + 1).join('') + s.slice(i + 1).reverse().join(''))
    return res >= 2 ** 31 ? -1 : res
};

2022.3.3

一、 125. 验证回文串

给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。

**说明：**本题中，我们将空字符串定义为有效的回文串。

/**
 * @param {string} s
 * @return {boolean}
 */
var isPalindrome = function(s) {
    let valid = s.toLowerCase().match(/[a-z0-9]+/g);// valid为进行正则匹配后筛选出来的数组
    if(!valid){
        return true;
    }
    let str = valid.join("");// 数据预处理(正则匹配)后得到的字符串
    let comp = str.split("").reverse().join("");// 将字符串翻转
    return comp === str;
};

2022.3.4

一、239. 滑动窗口最大值

给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。

返回滑动窗口中的最大值。

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {number[]}
 */
var maxSlidingWindow = function(nums, k) {
    const queue = []; 
    const res = []; 

   for(let i = 0; i<nums.length ;i++){
        while(queue.length && nums[queue[queue.length-1]] <= nums[i]) {
            // 队尾小，丢队尾
            queue.pop();
        }
        queue.push(i);
        // 判断对头是不是多出来了
        while(queue[0] <= i-k){
            queue.shift(); 
        }

        if(i>= k-1){
            res.push(nums[queue[0]]);
        }
   }
   return res;
};

2022.3.6

一、剑指 Offer II 041. 滑动窗口的平均值

给定一个整数数据流和一个窗口大小，根据该滑动窗口的大小，计算滑动窗口里所有数字的平均值。

实现 MovingAverage 类：

MovingAverage(int size) 用窗口大小 size 初始化对象。
double next(int val) 成员函数 next 每次调用的时候都会往滑动窗口增加一个整数，请计算并返回数据流中最后 size 个值的移动平均值，即滑动窗口里所有数字的平均值。

/**
 * Initialize your data structure here.
 * @param {number} size
 */
var MovingAverage = function(size) {
    this.items = [];
    this.size = size;
    this.count = 0;
};

/** 
 * @param {number} val
 * @return {number}
 */
MovingAverage.prototype.next = function(val) {
    if(this.items.length === this.size){
        // 队列先进的先出
        this.items.shift();
    }
    this.items.push(val);
    this.count = 0;
    for(let i = 0; i < this.items.length; i++){
        this.count += this.items[i];
    }
    return this.count/this.items.length;
};

/**
 * Your MovingAverage object will be instantiated and called as such:
 * var obj = new MovingAverage(size)
 * var param_1 = obj.next(val)
 */

二、剑指 Offer 59 - I. 滑动窗口的最大值

三、480. 滑动窗口中位数

哇哇哇，快写完了，中位数写成了平均数，我说怎么“困难”的题目这么简单，然后…这题解真不容易啊，卧槽艹艹艹艹艹 /(ㄒoㄒ)/~~

中位数是有序序列最中间的那个数。如果序列的长度是偶数，则没有最中间的数；此时中位数是最中间的两个数的平均数。

例如：

[2,3,4]，中位数是 3
[2,3]，中位数是 (2 + 3) / 2 = 2.5
给你一个数组 nums，有一个长度为 k 的窗口从最左端滑动到最右端。窗口中有 k 个数，每次窗口向右移动 1 位。你的任务是找出每次窗口移动后得到的新窗口中元素的中位数，并输出由它们组成的数组。