LeetCode 热题100 --双指针

news2024/10/5 17:11:42

双指针

b站UP主蜜糖:由于数据特征的有序性(大小或者正负),所以可以证明当前节点一定是优于过往节点,从而可以通过数据的维度数量的指针,逐步的迭代收敛最终找到最优解。

283.移动零

相关标签 : 数组 双指针 难度 : 简单


给定一个数组 nums,编写一个函数将所有 0 移动到数组的末尾,同时保持非零元素的相对顺序。

请注意 ,必须在不复制数组的情况下原地对数组进行操作。

示例 1:

输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]

示例 2:

输入: nums = [0]
输出: [0]

提示:

  • 1 <= nums.length <= 104
  • -231 <= nums[i] <= 231 - 1

进阶: 你能尽量减少完成的操作次数吗?

解析:

原地 :不能新建数组

一开始的想法:

1.判断每个节点是不是为0

2.把其他数值都挪动 【需要优化】

3.将0挪到最后面

这里其实很麻烦,假如第一个数就是0。那你把0挪到最后面,一开始他后面的数字都往前挪了一位。但是这些数字都没有被判断过,挪了后又得判断,很浪费时间。这得n^2的复杂度了。

1.双指针 交换

左指针指向当前已经处理好的序列的尾部, 右指针指向待处理序列的头部

左节点是存了为0的节点,右节点是选择到最新不为0的节点,用来替换。

public void moveZeroes(int[] nums) {
    // 左指针指向当前已经处理好的序列的尾部, 右指针指向待处理序列的头部
    int n = nums.length, left = 0, right = 0;
    // 从头开始处理,处理到最后一个数
    // 为0的话,左指针就直接记录下来为0的那个节点的(因为这里是每次都先将left+1,实则指向下一个节点)
    // 然后等到不为0时,右指针已经指向了不为0节点。此时只需要将当前不为0的节点与为0的节点替换就行了。
    // 等于左节点是存了为0的节点,右节点是选择到最新不为0的节点。来替换的。因此需要先将左节点++可以锁定,然后右节点开始找。
    while (right < n) {
        if (nums[right] != 0) {
            swap(nums, left, right);
            left++;
        }
        right++;
    }

}
// 交换代码
public void swap(int[] nums, int left, int right) {
    int temp = nums[left];
    nums[left] = nums[right];
    nums[right] = temp;
}
// 目标节点,也就是为0的节点
int index = 0;
int count = nums.length;

// 让指针从头走到尾,i就记录当前节点
for (int i = 0; i < count; i++) {
    // 假如指针所指的值为0,index指向的就是为0的节点。
    // 假如第一个为0,那这个时候index也就是指向0的。
    // 为了能使index指向0,所以它要比i早+1,然后假如正常的话就无所谓了,继续加就行。
    // 这里当指向0的时候,直接跳转到不为0的点
    if (nums[i] == 0){
        continue;
    }
    // 不为0就正常不理就行。但是这个代码主要是针对假如跳转到不为0的点后,就覆盖掉原来为0的点【index指向的就是为0的节点】
    // 
    if (index < i) {
        nums[index] = nums[i];
    }
    index ++;
}

//前面的那一块已经把不为0的都按顺序挪好了,然后处理完后的节点就都补0
for (int i = index; i < count; i++) {
    //最后的时候index就是已经指向了
    nums[i] = 0;
    
}


11.盛最多水的容器

相关标签 :贪心 数组 双指针 难度 : 中等


给定一个长度为 n 的整数数组 height 。有 n 条垂线,第 i 条线的两个端点是 (i, 0)(i, height[i])

找出其中的两条线,使得它们与 x 轴共同构成的容器可以容纳最多的水。

返回容器可以储存的最大水量。

**说明:**你不能倾斜容器。

img

输入:[1,8,6,2,5,4,8,3,7]
输出:49 
解释:图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下,容器能够容纳水(表示为蓝色部分)的最大值为 49。

示例 2:

输入:height = [1,1]
输出:1

提示:

  • n == height.length
  • 2 <= n <= 105
  • 0 <= height[i] <= 104
解析:

这里面其实就是看容器的左右两边,他是一个短板效应;水的高度代表着这个容器的宽度了。整体的容器面积等于:左右两边高度较短的一边 min(height[i] , height[j]) × 底边的宽度(W) 【长方形面积公式】

根据判断容积的公式定义字段来计算,循环下去计算,然后存下来最大容积就行了。

【这里的双指针就是用于指定左右边界,就是这个容器的两边,用来方便计算】

public int maxArea(int[] height) {
    // 根据判断容积的公式定义字段来计算
    // 临时容积
    int tempArea = 0;
    // 左边的柱子
    int left = 0;
    // 右边的柱子
    int right = height.length - 1;
    // 最终返回结果
    int area = 0;
    // 不断判断左右两边柱子的长度,较小的柱子进行移动,计算并收集最长的容积
    while (left < right) {
        // 先计算,然后每次移动完接着计算
        tempArea = Math.min(height[left], height[right]) * (right - left);
        area = Math.max(tempArea, area);
        // 判断那边短,就那边移动
        if (height[left] < height[right]) {
            left++;
        } else {
            right--;
        }

    }
    return area;
}

15.三数之和

相关标签 :数组 双指针 排序 难度 : 中等


给你一个整数数组 nums ,判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != ji != kj != k ,同时还满足 nums[i] + nums[j] + nums[k] == 0 。请

你返回所有和为 0 且不重复的三元组。

**注意:**答案中不可以包含重复的三元组。

示例 1:

输入:nums = [-1,0,1,2,-1,-4]
输出:[[-1,-1,2],[-1,0,1]]
解释:
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意,输出的顺序和三元组的顺序并不重要。

示例 2:

输入:nums = [0,1,1]
输出:[]
解释:唯一可能的三元组和不为 0 。

示例 3:

输入:nums = [0,0,0]
输出:[[0,0,0]]
解释:唯一可能的三元组和为 0 。

提示:

  • 3 <= nums.length <= 3000
  • -105 <= nums[i] <= 105

解析:

这里不能使用哈希。因为他需要返回多组答案,哈希的性质是:

键值对存储:我们通常只关心键(即元素本身),而不关心元素的组合

实则就是做:查询两个和为0的数,并且返回所有结果,然后还要去重。

1.第一个循环进行的是固定一个值,移动他下一个值和结尾的值,判断相加为0。

​ int sum = nums[i] + nums[left] + nums[right];

2.排好序了,然后去重就是内外循环都判断是不是指针所指的值是不是一样的。

    public static List<List<Integer>> threeSum(int[] nums) {
        ArrayList<List<Integer>> result = new ArrayList<>();
        if (nums == null || nums.length < 3) {   
            return result;
        }

        Arrays.sort(nums);
        // 这里i < nums.length - 2,代表数的返回只用判断到倒数第三位。因为至少有两个元素在它之后来形成一个三元组
        for (int i = 0; i < nums.length - 2; i++) {
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            int left = i + 1;
            int right = nums.length - 1;
            while (left < right) {
                int sum = nums[i] + nums[left] + nums[right];
                // 去重需要内循环和外循环都做判断。
                if (sum == 0) {
                    result.add(Arrays.asList(nums[i], nums[left], nums[right]));
                    // 当你找到一个和为0的三元组时,需要移动指针,继续判断。
                    // 需要移动两个指针,因为已经有了这个结果了。你只移动一个,结果都还是一样的,等于确定了2个数,第三个肯定是固定的。
                    left++;
                    right--;
                    // 跳过重复的元素
                    // 因为都是排好序的,假如相同的话,那么都是连在一起的
                    // 这里属于内循环判断。
                    while (left < right && nums[left] == nums[left - 1]) {
                        left++;
                    }
                    while (left < right && nums[right] == nums[right + 1]) {
                        right--;
                    }
                    // 这里假如和小于0,因为right指向的是最大的值了,无法在提升。就让left移动,增加值的大小
                } else if (sum < 0) {
                    left++;
                } else {
                    right++;
                }
            }
        }
        return result;
    }

42.接雨水

相关标签 :栈 数组 双指针 动态规划 单调栈 难度 : 困难


给定 n 个非负整数表示每个宽度为 1 的柱子的高度图,计算按此排列的柱子,下雨之后能接多少雨水。

img

输入:height = [0,1,0,2,1,0,1,3,2,1,2,1]
输出:6
解释:上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图,在这种情况下,可以接 6 个单位的雨水(蓝色部分表示雨水)。 

示例 2:

输入:height = [4,2,0,3,2,5]
输出:9

提示:

  • n == height.length
  • 1 <= n <= 2 * 104
  • 0 <= height[i] <= 105
【单调栈】

做这道题之前可以先看看其他的题目,有着一曲共同之妙。 【单调栈】

【单调栈】 适合解决 求当前元素左边或者右边第一个比当前元素大或者小的元素。

简单来说就是 栈(先进后出)里面元素是保证单调递增或者单调递减

LeetCode 739 每日温度

标签:栈 数组 单调栈 难度: 中等


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

示例 1:

输入: temperatures = [73,74,75,71,69,72,76,73]
输出: [1,1,4,2,1,1,0,0]

示例 2:

输入: temperatures = [30,40,50,60]
输出: [1,1,1,0]

示例 3:

输入: temperatures = [30,60,90]
输出: [1,1,0]

提示:

  • 1 <= temperatures.length <= 105
  • 30 <= temperatures[i] <= 100

知道单调栈的应用场景,那么这道题很明显就是可以直接使用单调栈来解决。

单调栈 适合解决 求当前元素左边或者右边第一个比当前元素大或者小的元素。】

1.决定单调栈里面放什么内容。

这里在栈里面放元素的下标 【索引】(方便去计算元素的距离差值,根据题目的要求)

2.决定单调栈是要递增还是递减

这里通过需求,假如递增,那么就是求右边第一个比当前元素大的值。因为是单调递增的,递减就是需要求右边第一个比当前元素小的值。

单调栈初始值设置为 0 ,初始化栈。存的是下标值,然后是第一个数的下标,这样到时候返回也是0,没问题。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

然后开始运行单调栈的逻辑:

遍历数组的i的值与栈顶的值对比大小

小于的时候,就进行存入单调栈中。

在这里插入图片描述

大于的时候,

这个时候可以进行 当前值的下标值 - 栈顶的下标值 = 就等于相差的天数

在这里插入图片描述

然后因为栈顶是按照单调递增的【越往后越大】,后面的数也可以进行比较,假如大就继续pop和记录。假如小于栈顶的值,那么肯定也比后面的值小,直接放 push 进去栈就行了。

在这里插入图片描述

因为后面可能有些值没pop出去,还在栈里面。但是数组定义了大小的,那些没弹出的,数组就默认为0了

代码实现:
public int[] dailyTemperatures(int[] temperatures) { 

    // 获取数组的长度,定义一个结果数组。(长度是一样大的)
    int length = temperatures.length;
    int[] result = new int[length];

    // 单调栈
    LinkedList<Integer> stack = new LinkedList<>();
    // 单调栈初始值设置为 0 ,初始化栈。
    stack.push(0);
    // 遍历数组中的每一个值
    for (int i = 0; i < length; i++) {
        // 假如新的数小于或者等于【栈顶】的值,就将它的下标存进去。反正是具有单调性的
        if (temperatures[i] <= temperatures[stack.peek()]) {
            stack.push(i);
            // 假如新的值大于【栈顶】的值,那么说明找到了第一个比它大的值
            // 这个时候可以进行 当前值的下标值 - 栈顶的下标值 = 就等于相差的天数
            // 然后因为栈顶是按照单调递增的【越往后越大】,后面的数也可以进行比较,假如大就继续pop和记录。假如小于栈顶的值,那么肯定也比后面的值小,直接放 push 进去栈就行了。
        } else {
            while (!stack.isEmpty() && temperatures[i] > temperatures[stack.peek()]) {
                result[stack.peek()] = i - stack.peek();
                stack.pop();
            }
            stack.push(i);
        }
    }
    // 因为后面可能有些值没pop出去,还在栈里面。但是数组定义了大小的,那些没弹出的,数组就默认为0了
    return result;
}

然后回到刚刚的接雨水题目:

img

这里可以先用暴力解法理清楚思路:

就两次for循环,第一循环这个数组【模拟让每一个数组的值为底】,第二个是找到左边和右边第一个比它大的值中较小的那个值【短板效应 面积公式依旧是 min(h1,h2) * x(宽)】 (这样就是把自己作为一个凹槽,把全部的凹槽加起来,就是总的了)

然后这里就出现了单调栈的应用场景了:【单调栈】 适合解决 求当前元素左边或者右边第一个比当前元素大或者小的元素。

在这里插入图片描述

直接用题目的意思,然后存的话就继续存下标就行了。逻辑和之前的基本差不多,就是当遇到比栈顶大的时候,就把 i 的值 和栈顶后面的元素【 pop()以后再peek() 就是了】取一个较小值【短板】为 h ,宽就是下标相减,然后再-1 就是当前的宽 h*w = 面积。

接雨水代码实现:
class Solution {
    public int trap(int[] height) {  
        int size = height.length;

        if (size <= 2)
            return 0;

        Stack<Integer> stack = new Stack<>();
        stack.push(0);

        int result = 0;

        for (int i = 1; i < size; i++) {

            if (height[i] < height[stack.peek()]) {
                stack.push(i);
            } else if (height[i] == height[stack.peek()]) {
                stack.pop();
                stack.push(i);
            } else {
                while (!stack.isEmpty() && (height[i] > height[stack.peek()])) {
                    int mid = stack.pop();
                    if (!stack.isEmpty()) {
                        int left = stack.peek();
                        int h = Math.min(height[left], height[i]) - height[mid];
                        int w = i - left - 1;
                        int s = h * w;
                        if (s > 0)
                            result = result + s;
                    }
                }
                stack.push(i);
            }
        }
        return result;
    }
}

下面这道题就很类似接雨水,可以多做巩固一下:

LeetCode 84 柱状图中最大的矩形

标签:栈 数组 单调栈 难度: 困难


给定 n 个非负整数,用来表示柱状图中各个柱子的高度。每个柱子彼此相邻,且宽度为 1 。

求在该柱状图中,能够勾勒出来的矩形的最大面积。

示例 1:

img

输入:heights = [2,1,5,6,2,3] 
输出:10
解释:最大的矩形为图中红色区域,面积为 10

示例 2:

img

输入: heights = [2,4]
输出: 4

提示:

  • 1 <= heights.length <=105
  • 0 <= heights[i] <= 104

其实这道题的题意很清晰易懂,也容易知道大概的方向,就是做起来比较麻烦。

矩形的面积就是:长(x轴为底) * 宽 (y轴为宽)

要想面积最大,要么就是长最长,宽最宽。

其实一次做过来,看上面的图,感觉就是遍历每一个下标的方块,然后他要是找到它左右两边第一个比自己小的话,那就是它所能构成最大的值了,假如没比自己小的,那就是自己了。

此题的特点给数组首尾都加了一个元素 0

因为假如数组刚好是单调递增的话,那么入栈以后,就是刚刚好单调递减。就都不会有计算面积的情况了。所以这个时候需要在数组的尾部加一个0,这样就可以计算 面积了。

假如一开始数组里面就是单调递减的,那么第二个数入栈判断就开始计算面积了,可是计算面积需要3个元素,而且栈顶元素出栈,栈会有空的情况,所以需要在数组头部加一个0。

【当前的高 * (前一个比自己矮的,后一个比自己矮的 两者下标之差 - 1)】

int largestRectangleArea(int[] heights) {

    Stack<Integer> stack = new Stack<Integer>();

    // 数组扩容,在头和尾各加入一个元素
    int[] newHeights = new int[heights.length + 2];
    // 这里是为了应对上诉的两种情况。
    newHeights[0] = 0;
    newHeights[newHeights.length - 1] = 0;
    for (int i = 0; i < heights.length; i++) {
        newHeights[i + 1] = heights[i];
    }
    heights = newHeights;
    stack.push(0);
    int result = 0;

    //后续操作基本就是常规的了,明白面积公式即可,
    for (int i = 0; i < heights.length; i++) {
        if (heights[i] > heights[stack.peek()]) {
            stack.push(i);
        } else if (heights[i] == heights[stack.peek()]) {
            stack.pop();
            stack.push(i);
        } else {
            while (heights[i] < heights[stack.peek()]) {
                int mid = stack.peek();
                stack.pop();
                int left = stack.peek();
                int right = i;
                int w = right - left - 1;
                int h = heights[mid];
                result = Math.max(result, w * h);
            }
            stack.push(i);
        }
    }
    return result;

}

496.下一个更大元素 I

标签:栈 数组 哈希表 单调栈 难度: 简单


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

给你两个 没有重复元素 的数组 nums1nums2 ,下标从 0 开始计数,其中nums1nums2 的子集。

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

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

示例 1:

输入:nums1 = [4,1,2], nums2 = [1,3,4,2].
输出:[-1,3,-1]
解释:nums1 中每个值的下一个更大元素如下所述:
- 4 ,用加粗斜体标识,nums2 = [1,3,4,2]。不存在下一个更大元素,所以答案是 -1 。
- 1 ,用加粗斜体标识,nums2 = [1,3,4,2]。下一个更大元素是 3 。
- 2 ,用加粗斜体标识,nums2 = [1,3,4,2]。不存在下一个更大元素,所以答案是 -1 。

示例 2:

输入:nums1 = [2,4], nums2 = [1,2,3,4].
输出:[3,-1]
解释:nums1 中每个值的下一个更大元素如下所述:
- 2 ,用加粗斜体标识,nums2 = [1,2,3,4]。下一个更大元素是 3 。
- 4 ,用加粗斜体标识,nums2 = [1,2,3,4]。不存在下一个更大元素,所以答案是 -1 。

提示:

  • 1 <= nums1.length <= nums2.length <= 1000
  • 0 <= nums1[i], nums2[i] <= 104
  • nums1nums2中所有整数 互不相同
  • nums1 中的所有整数同样出现在 nums2

**进阶:**你可以设计一个时间复杂度为 O(nums1.length + nums2.length) 的解决方案吗?

一看题目第一眼,下一个更大元素。这个就很容易让人想起单调栈

nums1 = [4,1,2], nums2 = [1,3,4,2].
比如 4 ,找到nums1[i] == nums2[j] 的下标 j。
nums2 = [1,3,4,2]。 不存在下一个更大元素,所以答案是 -1 。

然后需要定义一个数组存储结果,而数组的大小自然就是nums1的大小,因为是根据nums1的每个数据进行判断的。而对于这个数组的初始值,因为假如没有比他大的就为-1,这个意味着单调栈的数据没有进到这个数组中,那么就得给这个数组设置一个默认的初始值 -1。

int[] res = new int[nums1.length];
Stack<Integer> stack = new Stack<>();
// 不存在对应位置就输出 -1 ,所以result数组如果某位置没有被赋值,那么就应该是是-1,所以就初始化为-1。
Arrays.fill(res, -1);

接着就是需要有判断nums2[i]是否在nums1中出现过这个点,这里可以用到hashmap,快速进行查询。

**一般哈希表都是用来快速判断一个元素是否出现集合里。**没有重复元素

HashMap<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < nums1.length; i++) {
    map.put(nums1[i], i);
}

而后后续就是利用单调栈,然后单调递增,遇到比栈顶大的,就进行pop,并且判断该数是否存在于nums1中,然后根据数组下标存即可。

for (int i = 0; i < nums2.length; i++) {
    while (!stack.isEmpty() && nums2[stack.peek()] < nums2[i]) {
        int pre = nums2[stack.pop()];
        if (map.containsKey(pre)) {
            res[map.get(pre)] = nums2[i];
        }
    }
    stack.push(i);
}
return res;

503.下一个更大元素II

标签:栈 数组 单调栈 难度: 中等


给定一个循环数组 numsnums[nums.length - 1] 的下一个元素是 nums[0] ),返回 nums 中每个元素的 下一个更大元素

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

示例 1:

输入: nums = [1,2,1]
输出: [2,-1,2]
解释: 第一个 1 的下一个更大的数是 2;
数字 2 找不到下一个更大的数; 
第二个 1 的下一个最大的数需要循环搜索,结果也是 2。

示例 2:

输入: nums = [1,2,3,4,3]
输出: [2,3,4,-1,4]

提示:

  • 1 <= nums.length <= 104
  • -109 <= nums[i] <= 109

一些基本信息读取:

下一个更大元素 单调栈了。然后如果不存在,则输出 -1 ,设置结果数组大小为原数组长度,初始化值为-1。然后这道题的特殊点就是循环数组。这一开始很容易就是想到,直接把原本数组再接在原始数组后面,这样就可以使用单调栈计算出每一个元素的下一个最大值。

原始想法实现:
int n = nums.length;
// 创建一个新的数组 ,大小为原始数组2倍
int[] doubledNums = new int[n * 2];
// 复制元素到新数组中
System.arraycopy(nums, 0, doubledNums, 0, n);
System.arraycopy(nums, 0, doubledNums, n, n);
// 初始化结果数组,大小为原数组长度,初始值为-1
int[] result = new int[n];
for (int i = 0; i < n; i++) {
    result[i] = -1;
}
// 使用单调栈
Stack<Integer> stack = new Stack<>();
stack.push(0);

后续就是通用的,如果当前元素大于栈顶元素,则栈顶元素找到了下一个更大元素。

while (!stack.isEmpty() && doubledNums[i] > doubledNums[stack.peek()]) {
int index = stack.pop();
if (index < n) {
   result[index] = doubledNums[i];
}

而后学习了下 代码随想录 的思想 : 扩充nums数组相当于多了一个O(n)的操作。其实也可以不扩充nums,而是在遍历的过程中模拟走了两边nums。

【取余】

public int[] nextGreaterElements(int[] nums) { 

    //边界判断
    if (nums == null || nums.length <= 1) {
        return new int[]{-1};
    }
    int size = nums.length;
    int[] result = new int[size];//存放结果
    Arrays.fill(result, -1);//默认全部初始化为-1
    Stack<Integer> stack = new Stack<>();//栈中存放的是nums中的元素下标
    // 等于走两边这个数组,用取余就知道当前的下标值具体原数组中的多少
    for (int i = 0; i < 2 * size; i++) {
        while (!stack.empty() && nums[i % size] > nums[stack.peek()]) {
            result[stack.peek()] = nums[i % size];//更新result
            stack.pop();//弹出栈顶
        }
        stack.push(i % size);
    }
    return result;
}

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/1857533.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

计算机网络 —— 应用层(电子邮件)

计算机网络 —— 应用层&#xff08;电子邮件&#xff09; 电子邮件发送电子邮件的过程SMTP特性工作流程 电子邮件格式MIME关键组件工作方式 POP/IMAPPOP&#xff08;邮局协议&#xff09;IMAP&#xff08;因特网邮件访问协议&#xff09; 基于万维网的电子邮箱特点优势常见的基…

营销复盘秘籍,6步法让你的活动效果翻倍

在营销的世界中&#xff0c;每一次活动都是一次探险&#xff0c;而复盘就是探险后的宝藏图&#xff0c;指引我们发现问题、提炼经验、优化策略。 想要学习如何复盘&#xff0c;只要了解以下复盘六大步骤&#xff0c;即可不断总结&#xff0c;逐渐走向卓越。 第一步&#xff1…

lvgl v8.3 windows仿真

1&#xff0c;下载安装codeblocks20.03 https://zenlayer.dl.sourceforge.net/project/codeblocks/Binaries/20.03/Windows/codeblocks-20.03mingw-setup.exe?viasf1 2&#xff0c;下载代码 git clone --recurse-submodules https://github.com/lvgl/lv_port_win_codeblock…

fairseq (Facebook AI Research) 包

0. Abstract 最近在看一个用 RNNs 网络做 Translation 任务的程序, 关于数据处理部分, 主要用到工具包 sentencepiece 和 fairseq, 前者主要是对文本进行分词处理, 后者则是对已分词的文本进行二进制化和快速加载. 包越方便使用, 就说明包装得越狠, 也就越令人一头雾水, 本文简…

虚拟机拖拽文档造成缓存过大

查看文件夹大小&#xff1a;du -h --max-depth1 缓存位置&#xff1a;~/.cache/vmware/drag_and_drop 删除&#xff1a;rm -fr ~/.cache/vmware/drag_and_drop 释放了3GB

Javascript中的this关键字指向

this关键字介绍 不同情况下的this 1.对象调用方法中的this 2.在全局使用this(单独使用) 3.函数中的this 4.函数严格模式下 5.事件中的this 6.构造函数中的this 7.箭头函数没有this call()、apply()、bind() 的用法 this关键字介绍 面向对象语言中 this 表示当前对象…

JavaScript中的内置对象

// 用法2&#xff1a;参数&#xff1a;指定的时间的字符串 创建一个指定的时间 // new Date(‘2018-12-12 12:00:00’) var date1 new Date(‘2018-12-12 12:00:00’); console.log(date1); // 用法3&#xff1a; 参数可以是年月日时分秒 月份从0开始 // var date2 new …

基于Java实验室课程管理系统设计和实现(源码+LW+调试文档+讲解等)

&#x1f497;博主介绍&#xff1a;✌全网粉丝10W,CSDN作者、博客专家、全栈领域优质创作者&#xff0c;博客之星、平台优质作者、专注于Java、小程序技术领域和毕业项目实战✌&#x1f497; &#x1f31f;文末获取源码数据库&#x1f31f; 感兴趣的可以先收藏起来&#xff0c;…

Linux 阻塞和非阻塞 IO 实验学习

Linux 阻塞和非阻塞 IO 实验学习 IO 指的是 Input/Output&#xff0c;也就是输入/输出&#xff0c;是应用程序对驱动设备的输入/输出操作。当应用程序对设备驱动进行操作的时候&#xff0c;如果不能获取到设备资源&#xff0c;那么阻塞式 IO 就会将应用程序对应的线程挂起&…

【初阶数据结构】二叉树(附题)

目录 1.树概念及结构 1.1树的概念 1.2 树的相关概念&#xff08;树结构的相关概念命名参考自然树和人的血缘关系&#xff09; 1.3 树的表示 1.4 树在实际中的运用&#xff08;表示文件系统的目录树结构&#xff0c;初次之外网盘中使用到&#xff09; 2.二叉树概念及结构 …

Google浏览器快捷方式固定到任务栏启动被其他网页劫持

场景复现 1、Google浏览器设置启动时继续浏览上次打开的网页 2、先浏览CSDN网站&#xff0c;然后关闭Google浏览器 3、再次打开Google浏览器时&#xff0c;除了显示我们上次浏览的CSDN网页外&#xff0c;还默认打开了百度网页 解决办法 1、在Google浏览器中新建标签页&am…

Redis缓存雪崩(主从复制、哨兵模式(脑裂)、分片集群)

缓存雪崩&#xff1a; 在同一时段大量的缓存key同时失效或者Redis服务宕机&#xff0c;导致大量请求到达数据库&#xff0c;带来巨大压力。 方法一&#xff1a; 给不同key的TTL添加随机值&#xff0c;以此避免同一时间大量key失效。&#xff08;用于解决同一时间大量key过期&…

linux笔记10--编辑器之神VIM

文章目录 1. 简单介绍① 为什么叫vim② linux常见的编辑器③ 注意事项④ 其它 2. 操作模式的划分① 两种 -- 国际上普通模式(命令操作模式)插入模式 ② 三种 -- 国内普通模式如何进入与退出界面 插入模式如何进入与退出界面 命令模式如何进入与退出界面常见的命令模式 ③ 区别④…

RFID技术在人工晶体清洗台上的应用案例分析

RFID技术在人工晶体清洗台上的应用案例分析 应用背景 在医疗领域中人工晶体清洗台发挥着极为重要的作用&#xff0c;随着市场需求的持续增长、技术的不断创新、定制化趋势的加强以及环保要求的提高&#xff0c;人工晶体清洗台不免暴露出一下应用痛点需要解决。 痛点&#xff…

SAP ABAP 常用的便利小手段:大写+自动对齐

目录 一&#xff0c;字体变大写 二&#xff0c;自动对齐行 一&#xff0c;字体变大写 找到上面的ユーティリティ⇒設定、 在【ユーザ固有の設定】里选择&#xff0c;【打文字】&#xff0c;同时勾除【名称を変更しない】 二&#xff0c;自动对齐行 在页面右下角找到黄色的【…

Java如何快速实现发送模版消息?

Java如何快速实现发送模版消息&#xff1f; 这次分析模版消息&#xff1a; 公众号&#xff08;小程序同理&#xff09;登录微信公众平台&#xff0c;创建模版&#xff0c;拿到模版id, 拿到appid,appSecret&#xff0c;根据开发文档找到对应功能的api进行开发即可&#xff0c;记…

EcmaScript6全新语法特性-----EcmaScript6(1)

age : 20,language : "Eng"}// 对象也可以用结构表达式来获取对应的值const { name,age,language} person;// 这样可以将我们获取的值name变成abc这个变量// const { name:abc,age,language} person;// 字符串拓展let str "Hello,vue";// 判断是否以xxx…

ES6 逐点突破系列 -- 函数的扩展

} f() // 1 var x 1; function foo(x, y function() { x 2; }) { var x 3; y(); console.log(x); } foo() // 3 x // 1 上面代码中&#xff0c;函数foo的参数形成一个单独作用域。这个作用域里面&#xff0c;首先声明了变量x&#xff0c;然后声明了变量y&#xf…

Axios发送ajax请求

}, // 请求体参数 data: { username: ‘admin’, password: ‘admin’ } }).then(response>{ // 响应状态码 console.log(response.status); // 响应状态字符串 console.log(response.statusText); // 响应头信息 console.log(response.headers); // 响应体 c…

docker 部署的 wordpress 接入阿里云短信服务 详细实操介绍

一、阿里云短信服务配置&#xff1a; 1、登录 阿里云短信服务 完成指引短信相关配置 2、创建RAM用户 并完成授权 出于安全及规范考虑 需通过RAM 用户来完成OponApl 接口调用&#xff0c;创建成功需完成短信接口&#xff08;AliyunDysmsFullAccess、AliyunDysmsReadOnlyAccess…