LeetCode 热题100 --双指针

双指针

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;
}
  • 16
    点赞
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
1. Two Sum 2. Add Two Numbers 3. Longest Substring Without Repeating Characters 4. Median of Two Sorted Arrays 5. Longest Palindromic Substring 6. ZigZag Conversion 7. Reverse Integer 8. String to Integer (atoi) 9. Palindrome Number 10. Regular Expression Matching 11. Container With Most Water 12. Integer to Roman 13. Roman to Integer 14. Longest Common Prefix 15. 3Sum 16. 3Sum Closest 17. Letter Combinations of a Phone Number 18. 4Sum 19. Remove Nth Node From End of List 20. Valid Parentheses 21. Merge Two Sorted Lists 22. Generate Parentheses 23. Swap Nodes in Pairs 24. Reverse Nodes in k-Group 25. Remove Duplicates from Sorted Array 26. Remove Element 27. Implement strStr() 28. Divide Two Integers 29. Substring with Concatenation of All Words 30. Next Permutation 31. Longest Valid Parentheses 32. Search in Rotated Sorted Array 33. Search for a Range 34. Find First and Last Position of Element in Sorted Array 35. Valid Sudoku 36. Sudoku Solver 37. Count and Say 38. Combination Sum 39. Combination Sum II 40. First Missing Positive 41. Trapping Rain Water 42. Jump Game 43. Merge Intervals 44. Insert Interval 45. Unique Paths 46. Minimum Path Sum 47. Climbing Stairs 48. Permutations 49. Permutations II 50. Rotate Image 51. Group Anagrams 52. Pow(x, n) 53. Maximum Subarray 54. Spiral Matrix 55. Jump Game II 56. Merge k Sorted Lists 57. Insertion Sort List 58. Sort List 59. Largest Rectangle in Histogram 60. Valid Number 61. Word Search 62. Minimum Window Substring 63. Unique Binary Search Trees 64. Unique Binary Search Trees II 65. Interleaving String 66. Maximum Product Subarray 67. Binary Tree Inorder Traversal 68. Binary Tree Preorder Traversal 69. Binary Tree Postorder Traversal 70. Flatten Binary Tree to Linked List 71. Construct Binary Tree from Preorder and Inorder Traversal 72. Construct Binary Tree from Inorder and Postorder Traversal 73. Binary Tree Level Order Traversal 74. Binary Tree Zigzag Level Order Traversal 75. Convert Sorted Array to Binary Search Tree 76. Convert Sorted List to Binary Search Tree 77. Recover Binary Search Tree 78. Sum Root to Leaf Numbers 79. Path Sum 80. Path Sum II 81. Binary Tree Maximum Path Sum 82. Populating Next Right Pointers in Each Node 83. Populating Next Right Pointers in Each Node II 84. Reverse Linked List 85. Reverse Linked List II 86. Partition List 87. Rotate List 88. Remove Duplicates from Sorted List 89. Remove Duplicates from Sorted List II 90. Intersection of Two Linked Lists 91. Linked List Cycle 92. Linked List Cycle II 93. Reorder List 94. Binary Tree Upside Down 95. Binary Tree Right Side View 96. Palindrome Linked List 97. Convert Binary Search Tree to Sorted Doubly Linked List 98. Lowest Common Ancestor of a Binary Tree 99. Lowest Common Ancestor of a Binary Search Tree 100. Binary Tree Level Order Traversal II

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值