【力扣刷题——双指针】附力扣链接、题目描述、方法及代码（ 27、26、283、844、977、344、剑指 Offer05、151、206 、19、面试题 02.07、142、15、18、）后续再补充

已于 2022-06-05 16:24:44 修改
阅读量238 收藏
点赞数 1
分类专栏： 算法-刷题 文章标签： leetcode 算法 双指针
于 2022-05-28 11:05:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47540091/article/details/124973779
版权

😀如果对你有帮助的话😊
🌺为博主点个赞吧 👍
👍点赞是对博主最大的鼓励😋
💓爱心发射~💓

目录

27. 移除元素——简单

力扣

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
int len = removeElement(nums, val);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

示例 1：

输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2]
解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。

示例 2：

输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3]
解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。

方法一：通用

class Solution {
    public int removeElement(int[] nums, int val) {
        int i = 0;
        for(int x : nums){
            if(x != val){
                nums[i++] = x;
            }
        }
        return i;
    }
}

方法二：双指针

class Solution {
    public int removeElement(int[] nums, int val){
        int j = nums.length - 1;
        for(int i=0 ; i<=j; i++ ){
            if(nums[i] == val){
                swap(nums, i--, j--);
            }
        }
        return j+1;
    }

    void swap(int[] nums, int i, int j){
            int b = nums[i];
            nums[i] = nums[j];
            nums[j] = b;
        }
}

26. 删除有序数组中的重复项——简单

力扣

给你一个 升序排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。

由于在某些语言中不能改变数组的长度，所以必须将结果放在数组nums的第一部分。更规范地说，如果在删除重复项之后有 k 个元素，那么 nums 的前 k 个元素应该保存最终结果。

将最终结果插入 nums 的前 k 个位置后返回 k 。

不要使用额外的空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

判题标准:

系统会用下面的代码来测试你的题解:

int[] nums = [...]; // 输入数组
int[] expectedNums = [...]; // 长度正确的期望答案

int k = removeDuplicates(nums); // 调用

assert k == expectedNums.length;
for (int i = 0; i < k; i++) {
    assert nums[i] == expectedNums[i];
}

如果所有断言都通过，那么您的题解将被 通过。

示例 1：

输入：nums = [1,1,2]
输出：2, nums = [1,2,_]
解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。

示例 2：

输入：nums = [0,0,1,1,1,2,2,3,3,4]
输出：5, nums = [0,1,2,3,4]
解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。

双指针

class Solution {
    public int removeDuplicates(int[] nums) {
        int n = nums.length;
        int j=0;
        for(int i=0; i<n; ++i){
            if(nums[i] != nums[j]){
                nums[++j] = nums[i];
            }
        }
        return j+1;
    }
}

283. 移动零

力扣

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

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

示例 1:

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

示例 2:

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

双指针

class Solution {
    public void moveZeroes(int[] nums) {
        if(nums==null){
            return;
        }
        int slowIndex = 0;
        for(int fastIndex=0; fastIndex<nums.length;fastIndex++){
            if(nums[fastIndex] != 0){
                int n = nums[fastIndex];
                nums[fastIndex] = nums[slowIndex];
                nums[slowIndex++] = n;
            }
        }
    }
}

844. 比较含退格的字符串——简单

力扣

给定 s 和 t 两个字符串，当它们分别被输入到空白的文本编辑器后，如果两者相等，返回 true 。# 代表退格字符。

注意：如果对空文本输入退格字符，文本继续为空。

示例 1：

输入：s = "ab#c", t = "ad#c"
输出：true
解释：s 和 t 都会变成 "ac"。

示例 2：

输入：s = "ab##", t = "c#d#"
输出：true
解释：s 和 t 都会变成 ""。

示例 3：

输入：s = "a#c", t = "b"
输出：false
解释：s 会变成 "c"，但 t 仍然是 "b"。

方法一：栈

class Solution {
    public boolean backspaceCompare(String s, String t) {
        return build(s).equals(build(t));
    }
    public String build(String str){
        StringBuffer ret = new StringBuffer();   //new 栈
        int length = str.length();  //输入字符串长
        // 判断是否为#
        for(int i =0; i<length; ++i){
            char j = str.charAt(i); //取字符串一位
            // 判断是否为#
            if(j != '#'){
                ret.append(j); // 不为#，入栈
            }else{
                if(ret.length() > 0){
                     ret.deleteCharAt(ret.length() - 1);// 为#，出栈一个
                }
            }
        }
        
        // 返回字符串
        return ret.toString();

    }
}

方法二：双指针

class Solution {
    public boolean backspaceCompare(String s, String t) {
        // 双指针
        // 用i，j指针 指向s，t的最后位，从后往前走
        // 用skipS，skipT来表示字符串中#的数量
        // 先判断i，j大于0，
        //      判断字符串中是否为 #，skipS等是否大于0   
        int i = s.length()-1, j = t.length()-1;
        int skipS = 0, skipT = 0;
        while(i>=0 || j>=0){
            while(i>=0){
                if(s.charAt(i) == '#'){
                    skipS++;
                    i--;
                }else if(skipS>0){
                    skipS--;
                    i--;
                }else{
                    break;
                }
            }
            while(j>=0){
                if(t.charAt(j) == '#'){
                    skipT++;
                    j--;
                }else if(skipT>0){
                    skipT--;
                    j--;
                }else{
                    break;
                }
            }
            if(i>=0 && j>=0){
                if(s.charAt(i) != t.charAt(j)){
                    return false;
                }
            }else{
                if(i>=0 || j>=0){
                    return false;
                }
            }
            i--;
            j--;
        }
        return true;
    }
}

977. 有序数组的平方——简单

力扣

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

示例 1：

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]

示例 2：

输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]

方法一：暴力

class Solution {
    public int[] sortedSquares(int[] nums) {
        int a = nums.length;
        int[] ans = new int[a];  // 定义数组
        // 循环，做平方
        for(int i =0; i<a; i++){
            ans[i] = nums[i]*nums[i];
        }
        // 数组排序
        Arrays.sort(ans);
        return ans;

    }

方法二：双指针

class Solution {
    //双指针
    public int[] sortedSquares(int[] nums) {
        //定义左指针、右指针、存放的数组、数组指针
        int k = nums.length-1;
        int left = 0;
        int right = nums.length-1;
        int[] result = new int[nums.length];
        //循环，大的存数组
        while(left<=right){
            if(nums[left]*nums[left]<nums[right]*nums[right]){
                result[k--] = nums[right]*nums[right];
                --right;
            }else{
                result[k--] = nums[left]*nums[left];
                ++left;
            }
        }
        return result;
    }
}

344. 反转字符串——简单

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

示例 1：

输入：s = ["h","e","l","l","o"]
输出：["o","l","l","e","h"]

示例 2：

输入：s = ["H","a","n","n","a","h"]
输出：["h","a","n","n","a","H"]

提示：

  • 1 <= s.length <= 105
  • s[i] 都是 ASCII 码表中的可打印字符

方法一：双指针

class Solution {
    public void reverseString(char[] s) {
        // 左指针指向前，右指针指向后
        // 互相调换位置
        int n = s.length;
        for(int l=0, r=n-1; l < r; ++l,--r){
            char temp = s[l];
            s[l] = s[r];
            s[r] = temp;
        }
    }
}

剑指 Offer 05. 替换空格——简单

力扣

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

示例 1：

输入：s = "We are happy."
输出："We%20are%20happy."

方法一：遍历添加

class Solution {
    public String replaceSpace(String s) {
        // 将字符串转换为数组
        StringBuilder res = new StringBuilder();
        // 将数组换为字符串
        for(Character c : cs){
            if(c == ' '){
                res.append("%20");
            }else{
                res.append(c);
            }
        }
        return res.toString();
    }
}

151. 颠倒字符串中的单词——中等

力扣

给你一个字符串 s ，颠倒字符串中 单词 的顺序。

单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。

返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。

注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。

示例 1：

输入：s = "the sky is blue"
输出："blue is sky the"

示例 2：

输入：s = "  hello world  "
输出："world hello"
解释：颠倒后的字符串中不能存在前导空格和尾随空格。

示例 3：

输入：s = "a good   example"
输出："example good a"
解释：如果两个单词间有多余的空格，颠倒后的字符串需要将单词间的空格减少到仅有一个。

提示：

  • 1 <= s.length <= 104
  • s 包含英文大小写字母、数字和空格 ’ ’
  • s 中 至少存在一个 单词

方法一：使用语言特性

class Solution {
    // 方法一：使用语言特性
    public String reverseWords(String s) {
        // 拆分字符串split     翻转字符串reverse     拼接字符串join
        // 去掉空白字符 trim
        s = s.trim();
        // 正则匹配连续的空白字符作为分隔符分割
        //  Arrays.asList 该方法是将数组转化成List集合的方法。
        // \\s+ 正则表达式
        List<String> wordList = Arrays.asList(s.split("\\s+"));
        Collections.reverse(wordList);
        return String.join(" ",wordList);

    }
}

方法二：双端队列

class Solution {
    public String reverseWords(String s) {
        /*
            1、删除左边空字符串
            2、删除右边空字符串
            3、循环--
                - 当单词长度不为0 ， 字符到空格的时候，将单词存到队列
                - 字符不为空，存到单词中
        */
        int le = 0, ri = s.length() - 1;
        while(le<=ri && s.charAt(le)==' '){
            ++le;
        }
        while(le<=ri && s.charAt(ri)==' '){
            --ri;
        }
        Deque<String> d = new ArrayDeque<String>();   //创建ArrayDeque双端队列
        StringBuilder word = new StringBuilder();   //适用于单线程下在字符串缓冲区进行大量操作
        while(le<=ri){
            char cc = s.charAt(le);
            if((word.length() != 0) && (cc == ' ')){
                d.offerFirst(word.toString()); // 将单词 push 到队列的头部
                word.setLength(0); 
                //toString() 方法用于返回以一个字符串表示的 Number 对象值
            }else if(cc != ' '){
                word.append(cc);
            }
            ++le;
        }
        d.offerFirst(word.toString());
        // join--将一个数组或者List的各项通过分隔符连接成字符串
        return String.join(" ",d);

    }
}

206. 反转链表——简单

力扣链接
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：
在这里插入图片描述

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例 2：
在这里插入图片描述

输入：head = [1,2]
输出：[2,1]

示例 3：

输入：head = []
输出：[]

方法一：双指针法

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre = null;
        ListNode cur = head;
        ListNode temp = null;
        //双指针法
        while(cur != null){
            temp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;
    }
}

方法二：递归

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        if(head==null || head.next == null) return head;

        ListNode newHead = reverseList(head.next);
        head.next.next = head;
        head.next = null;
        return newHead;
    }
}

19. 删除链表的倒数第 N 个结点—中等

力扣链接

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

示例 1：

在这里插入图片描述

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

示例 2：

输入：head = [1], n = 1
输出：[]

示例 3：

输入：head = [1,2], n = 1
输出：[1]

方法一：双指针

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode slow = dummy;
        ListNode fast = head;
        for(int i=0; i<n; ++i){
            fast = fast.next;
        }
        while(fast!=null){
            slow = slow.next;
            fast = fast.next;
        }
        slow.next = slow.next.next;
        return dummy.next;

    }
}

面试题 02.07. 链表相交——简单

力扣

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

图示两个链表在节点 c1 开始相交：

在这里插入图片描述

题目数据 保证 整个链式结构中不存在环。
注意，函数返回结果后，链表必须 保持其原始结构 。

示例 1：
在这里插入图片描述

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

示例 2：
在这里插入图片描述

输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at '2'
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例 3：

在这里插入图片描述

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。

双指针

题解地址

A= A!=null ? A.next:headB;

当A不为空，A=A.next
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode A = headA;
        ListNode B = headB;
        while(A != B){
            A= A!=null ? A.next:headB;
            B= B!=null ? B.next:headA;
        }
        return A;
    }
}

在这里插入图片描述

142. 环形链表 II——中等

力扣

给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

示例 1：

在这里插入图片描述

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：
在这里插入图片描述

输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

在这里插入图片描述

输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环。

双指针

题解地址
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode fast = head;  //双指针
        ListNode slow = head;
        //找到两个指针相遇的节点 f=2s f=s+nb ----> s=nb
        while(true){
            if(fast==null || fast.next==null) return null;
            fast = fast.next.next;
            slow = slow.next;
            if(fast==slow) break;
        }
        fast = head; // slow走了nb，再走a就是入口
        // 在一次相遇  就是环形入口 
        while(slow != fast){
            fast = fast.next;
            slow = slow.next;
        }
        return slow;
    }
}

15. 三数之和——中等

力扣

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。

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

示例 1：

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]

示例 2：

输入：nums = []
输出：[]

示例 3：

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

排序 + 双指针

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> lists = new ArrayList<>();
        int len = nums.length;
        // 特殊情况的数组
        if(len<3 || nums == null) return lists;
        // 数组排序
        Arrays.sort(nums);
        // 双指针循环
        //      1、nums[i]>0 直接return，因为后边不可能等于0 
        //      2、重复元素跳过
        //      3、当 l < r，进循环，result==0，存数据，result<0,l右移。result>0，r左移
        for(int i=0; i<len; ++i){
            if(nums[i]>0) return lists;
            if(i>0 && nums[i] == nums[i-1]) continue;
            int l=i+1, r=len-1;
            while(l<r){
                int result = nums[i] + nums[l] + nums[r];
                if(result==0){
                    List<Integer> bb = new ArrayList<>();
                    bb.add(nums[i]);
                    bb.add(nums[l]);
                    bb.add(nums[r]);
                    lists.add(bb);
                    while(l<r && nums[l+1] == nums[l]) ++l;
                    while(l<r && nums[r-1] == nums[r]) --r;
                    ++l;
                    --r;
                }else if(result<0){
                    ++l;
                }else{
                    --r;
                }
            }
        }
        return lists;

    }
}

18. 四数之和——中等

力扣

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

  • 0 <= a, b, c, d < n
  • a、b、c 和 d 互不相同
  • nums[a] + nums[b] + nums[c] + nums[d] == target

你可以按 任意顺序 返回答案 。

示例 1：

输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

示例 2：

输入：nums = [2,2,2,2,2], target = 8
输出：[[2,2,2,2]]

排序+双指针

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        // 根据三数之和 ——两层for循环
        // 第一个for循环第一个数，第二个for循环第二个数
        // 双指针 l-第三个数，r-第四个数
        List<List<Integer>> lists = new ArrayList<>();
        int len = nums.length;

        Arrays.sort(nums);
        for(int i=0; i<len; ++i){
            // 与上一个数相同，跳过
            if(i>0 && nums[i-1] == nums[i]){
                continue;
            }

            for(int j=i+1; j<len; ++j){
                // 去重
                if(j>i+1 && nums[j-1] == nums[j]){
                    continue;
                }

                int l = j+1, r = len-1;
                while(l < r){
                    int result = nums[i] + nums[j] + nums[l] + nums[r];
                    if(result == target){
                        List<Integer> b = new ArrayList<>();
                        b.add(nums[i]); 
                        b.add(nums[j]); 
                        b.add(nums[l]); 
                        b.add(nums[r]); 
                        lists.add(b);
                        while(l<r && nums[r-1] == nums[r]) --r;
                        while(l<r && nums[l+1] == nums[l]) ++l;

                        --r;
                        ++l;
                    }else if(result < target){
                        ++l;
                    }else{
                        --r;
                    }
                }

            }
        }
        return lists;
    }
}
-Blue.
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Leetcode：力扣刷题截图
02-16
Leetcode：力扣刷题截图
2021年5月8号，力扣刷题记录---Java---双指针法
weixin_44477093的博客
05-17 143
刷题记录 剑指 Offer 05. 替换空格 题目地址 题目描述 请实现一个函数，把字符串 s 中的每个空格替换成"%20"。 示例 1： 输入：s = "We are happy." 输出："We%20are%20happy." 思路 为了将字符串中的空格转换成“%20”，就是将字符串中的一个空格字符转换成三个确定的字符。那么可以将字符串进行遍历，在遇到空格之时将空格转换成三个字符“%20”。 代码及注释 class Solution { public void reverseString(ch
力扣两数之和双指针思想（java版）
执梗的博客
07-02 575
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。 你可以按任意顺序返回答案。 作为力扣的第一题当然是十分简单，暴力使用两层for循环查找也是不会超时的，当然它的时间复杂度比较高为O（n^2） 暴力做法 class Solution { public: vector<int> twoSum(ve..
力扣刷题记录
hxiaowang的博客
05-06 3356
给你两个字符串，请你从这两个字符串中找出最长的特殊序列。 「最长特殊序列」定义如下：该序列为某字符串独有的最长子序列（即不能是其他字符串的子序列）。 子序列可以通过删去字符串中的某些字符实现，但不能改变剩余字符的相对顺序。空序列为所有字符串的子序列，任何字符串为其自身的子序列。 输入为两个字符串，输出最长特殊序列的长度。如果不存在，则返回 -1。 class Solution { ...
力扣刷题算法截图汇总2021
04-02
力扣刷题算法截图汇总2021
力扣刷题力扣刷题力扣刷题力扣刷题
07-16
力扣刷题力扣刷题力扣刷题
【力扣刷题】数组-链表-哈希-双指针
06-21
【力扣刷题】数组-链表-哈希-双指针
使用力扣刷题的经验.pdf
04-21
本文主要是讲如何使用力扣进行刷题，此文是我根据自己的刷题经验进行编写的，主要针对的用户包括刚刚接触编程的小伙伴，还有就是有一些算法基础想提升自己的算法能力的小伙伴。
力扣刷题精选11111
03-23
力扣刷题精选11111
力扣刷题精选题目0528
05-28
力扣刷题精选题目0528
前端小白力扣刷题工具及流程
zdxjdd3的博客
10-14 1518
前端小白力扣刷题工具及流程 视频是从B站上看的https://www.bilibili.com/video/BV1xX4y1T746?from=search&seid=312394340605128532&spm_id_from=333.337.0.0，路线图仓库地址：https://github.com/Orime112/leetcode-js-roadmap 1.安装插件 1.1code runner（方便调试） [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(
力扣刷题系列——动态规划II
qq_43568704的博客
08-19 1393
常见的动态规划问题(二） 本文转载于GitHub地址：https://github.com/CyC2018/CS-Notes/，仅作为个人日后复习。整合了多方面的资料，侵删。 引例解析： 内容来源于公众号文章：https://mp.weixin.qq.com/s/lKQI0aS1MBwfPujC-m_zkA 运用动态规划四部曲来进行解答： //解法一 public int coinChange(int[] coins, int amount) { // 子问题： ...
笔记89：LeetCode_135_分发糖果
weixin_44063383的博客
05-20 318
注：代码随想录中没有很清楚的提起想出方法的思路，只是给出了解决这个问题的大致思路和代码；下面我将介绍一下我的思考过程，并贴出实现代码；aaaa。
力扣HOT100 - 1143. 最长公共子序列
qq_61504864的博客
05-20 359
【代码】力扣HOT100 - 1143. 最长公共子序列。
每日5题Day7 - LeetCode 31 - 35
alimamaalala的博客
05-19 215
注意这道题的处理逻辑，我们应该走最右边的数i开始，向左遍历找到小于他的数j，然后交换，一定要注意交换后右边序列（j所在位置的后一位）也要满足是升序（因为刚刚已经完成升序了，每次升一点，所有子序列就要满足是最小升序，如果看文字太抽象，请用[2,3,1]这个例子自行模拟）
力扣HOT100 - 72. 编辑距离
qq_61504864的博客
05-20 292
【代码】力扣HOT100 - 72. 编辑距离。
LeetCode 264 —— 丑数 II
最新发布
seniusen的博客
05-21 809
之后得到的数字序列。然后，每一次，我们只需要从这三个队列头部取一个最小的元素作为下一个丑数即可。当三个队列有一个为空的时候，我们就取出下一个丑数，分别填充到三个队列中去。上面的方法可以进一步优化，其实每一次比较的时候我们只用到了三个队列头部的元素，而三个队列头部的元素又分别是某一个丑数乘以。，所以后面的丑数肯定是前面的丑数分别乘以。，由于丑数的质因子只包含。，分别代表前面的丑数乘以。这样，我们维护三个队列，后得到的数字，所以，
笔记88：LeetCode_134_加油站
weixin_44063383的博客
05-19 1070
这个题的题目条件给的不太严谨，题目描述中说“如果存在解，则保证它是唯一的”，通过我的实践，我发现这句话的意思其实是本题的所有样例只有两种情况，无解/有唯一解；而不可能存在多个解的情况；
力扣hot100学习记录(五)
m0_56685529的博客
05-19 299
用L数组记录nums[i]前缀的乘积，用R数组记录nums[i]后缀的乘积。给你一个整数数组 nums，返回 数组 answer ，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积。给一个数组nums，返回数组 answer ，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积。给定一个 m x n 的矩阵，如果一个元素为 0 ，则将其所在行和列的所有元素都设为 0。
力扣刷题C++常用操作
10-18
好的，关于力扣刷题C++常用操作，我可以给你一些常见的操作和技巧： 1. 使用 STL 容器和算法库：STL（Standard Template Library）是 C++ 标准库中的一个重要组成部分，包含了许多常用的容器和算法。在力扣刷题中，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

-Blue.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值