LeetCode刷题之旅

最新推荐文章于 2024-05-11 19:11:56 发布
最新推荐文章于 2024-05-11 19:11:56 发布
阅读量288 收藏
点赞数 1
分类专栏： leetcode刷题 文章标签： leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35122713/article/details/88322194
版权

LeetCode刷题之旅

一、链表

1.链表逆序（leetcode 206.Reverse Linked List）esay

题目描述：已知链表头节点指针head，将链表逆序。

思路：从链表的头节点依次遍历，每遍历一个节点就进行逆序， 使用头插法进行逆序。

代码实现：

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

2.链表部分逆序（leedcode92.Reverse Linked List2）medium

题目描述：已知链表头节点指针head，将链表从位置m到n逆序。

思路：需要完成m到n位置的链表逆序，其中逆序算法已经清楚，只需要确定开始逆序的位置（从起始节点后移m个位置），以及需要逆序的节点个数（m-n+1）。同时，需要记录开始逆序节点的前驱（pre_start），以便逆序完可以直接链接上。逆置段尾结点的后继也需要记录。需要注意一点，讨论m是否为1，如果从第一个节点开始逆置，则逆置完的链表段头节点即为起始节点。

代码实现：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseBetween(ListNode head, int m, int n) {
        if (head == null || head.next == null) return head;
        ListNode pre_start, new_start, new_end;
        pre_start = new_start = new_end = null;
        ListNode list = head; //记录list
        int length = n-m+1; //长度
        int steps = m-1;
        while(head!=null && steps!=0) {
            pre_start = head;
            head = head.next;
            steps--; //head指针移动到m对应位置
        }
        new_end = head;
        ListNode next_head = null;
        while (head!=null && length!=0) {
            next_head = head.next;
            head.next = new_start;
            new_start = head;
            head = next_head;
            length--; //逆序length个节点
        }

        new_end.next = head;
        if (m == 1) {
            list = new_start;
        } else {
            pre_start.next = new_start; //将pre_start链接上逆置后的链表段
        }
        return list;

3.求两个链表的交点（leetcode160.Intersection of Two Linked Lists）easy

题目描述：已知链表A的头节点指针headA，链表B的头结点指针headB，两个链表相交，求两个链表相交的交点

思路：1.使用set集合。遍历链表A，将A中节点对应的指针（地址）存入set中。遍历链表B，将B中节点对应的指针（地址），在set中查找，发现在set中的第一个节点地址，即是两个链表的起始交点。

​ 2.若链表A与链表B相交，则只是相交节点的前面链表段不相同。分别计算链表A与B的长度，将较长的链表起点移动到与短链表起点对齐的地方，这样一同出发，相交点即是指针相同的交点。

代码实现：

/**
 * 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) {
        if (headA == null || headB == null) return null;
        ListNode listA = headA;
        ListNode listB = headB;
        int lengthA = 0;
        int lengthB = 0;
        while(headA != null) {
            lengthA++;
            headA = headA.next;
        } // 计算链表A的长度
        while(headB != null) {
            lengthB++;
            headB = headB.next;
        } // 计算链表B的长度
        int dis = 0;
        if (lengthB > lengthA) {
            dis = lengthB - lengthA;
            while(dis > 0){
                listB = listB.next;
                dis--;
            }
        } else {
            dis = lengthA - lengthB;
            while(dis > 0){
                listA = listA.next;
                dis--;
            }
        } //将较长链表的起点移动到与短链表起点对齐的地方
        while (listA!=listB && listA!=null && listB!=null) {
            listA = listA.next;
            listB = listB.next;
        }
        return listA;    
    }      
}

4.链表求环（leetcode 141.Linked List Cycle）easy

问题描述：已知链表可能有环，若有环则返回true，否则返回false

思路：因为只需要判断是否有环，不用确定起始节点，所以方法较多，列举常见的两种。

1.利用set集合，依次将节点指针插入set中，当在set中查找，第一个在set中发现的节点地址，即是链表环的起点

2.从起点开始遍历，依次判断该节点的next是否为本身，如果是，则返回true；如果不是，则将该节点的next指针指向自己，并递归遍历其后面的链表。

代码实现：方法1:

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        if (head == null) return false;
        Set <ListNode> nodeSet = new HashSet<ListNode>();        
        while(head != null) {
            if (nodeSet.contains(head)) {
                return true;
            } else {
                nodeSet.add(head);
                head = head.next;
            }
        }
        return false;
    }
}

方法2：

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        if (null == head) return false;
        if (head == head.next) return true;
        ListNode n = head.next; 
        head.next = head; // 将指针指向自己
        return hasCycle(n);
    }
}

5.链表求环2（leetcode 142.Linked List Cycle2）medium

问题描述：已知链表可能有环，若有环则返回环起始节点，否则返回NULL

思路：1.简单的方法是，利用set集合实现。依次将节点指针插入set中，当在set中查找，第一个在set中发现的节点地址，即是链表环的起点。

​ 2.相对巧妙的想法，利用快慢指针实现。见下面，fast与slow指针同时从起点X出发，其中fast是slow速度的两倍，当fast指针追到slow指针时，此时相遇于Z点。对于slow指针，走了a+b的路程。那么fast指针的路程为2（a+b），同时也为 a+b+c+b，即a+2b+c=2(a+b)，得a=c。这时，如果从它们的交点Z出发的话，同时有一指针head从起点X出发，必会相交于Y点，也即为环的起始点。
在这里插入图片描述

代码实现：方法1

/**
 * 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) {
        // if (null == head) return null;
        Set<ListNode> nodeSet = new HashSet<ListNode>();
        while(head != null) {
            if (nodeSet.contains(head)) {
                return head;
            } else {
                nodeSet.add(head);
            }
            head = head.next;
        }
        return null;
    }
}

方法2：

/**
 * 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 = fast;
        while (fast!=null && fast.next!=null && fast.next.next!=null) {      
            fast = fast.next.next;
            slow = slow.next;
            if (fast == slow) { // fast与slow指针相交时
                while (head != slow) {
                    head = head.next; // head指针从起始点出发
                    slow = slow.next;
                }
                return head;
            }               
        }
        return null;
    }
}

6.链表划分（leetcode86.Partition List）medium

问题描述：已知链表头指针head与数值x，将所有小于x的节点放在大于等于x的节点前，且保存这些节点的原来的相对位置。如，划分前：1->4->3->2->5->2，x=3，划分后：1->2->2->4->3->5

思路：遍历链表，将小于x的节点插入到新链表less_head中，将大于等于x的节点插入到新链表more_head中，然后将more_head.next插入在less_head的末尾，返回less_head即可。

或者直接将原链表中大于x的节点移出并链接为新链表mhead，然后将mhead链接至原链表的结尾即可。

代码实现：方法1

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode partition(ListNode head, int x) {
        ListNode lhead = new ListNode(0); // 使用两个链表less_head和more_head来分别记录
        ListNode less_head = lhead;    
        ListNode mhead = new ListNode(0);
        ListNode more_head = mhead;
        while(head!=null) {
            if (head.val < x) {
                lhead.next = head;
                lhead = lhead.next;
            } else {
                mhead.next = head;
                mhead = mhead.next;
            }
            head = head.next;
        }
        mhead.next = null;
        lhead.next = more_head.next;
        
        return less_head.next;
    }
}

方法2：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode partition(ListNode head, int x) {       
        ListNode list = new ListNode(0); // 将原链表中大于x的值连接为一个链表mhead
        list.next = head;
        ListNode new_head = list;
        ListNode more_head = new ListNode(0);
        ListNode mhead = more_head;
        while(list.next!=null) {
            if (list.next.val < x) {
                list = list.next;
            } else {
                more_head.next = list.next;
                more_head = more_head.next;
                list.next = list.next.next;           
            }
        }
        list.next = mhead.next;
        more_head.next = null;
        return new_head.next;
    }
}

7.链表的深度拷贝（leetcode138.Copy List With Random Pointer）medium

问题描述：已知一个复杂的链表，链表节点除了有一个指向下一个节点的next指针，还有一个random指针，指向本链表的任意某个节点（也可能指向自己），求这个链表的深度拷贝（构造生成一个完全新的链表，即使原链表毁坏，新链表也可独立使用）

思路：本问题中，主要是一个random指针也需要拷贝下来。利用map来实现，其中map的key记录原链表的各个节点，value来保存新建的节点（val值为key中节点的值），对于新建的节点的next和random指向的节点位置，由对应的key获得。即，map.get(head).next = map.get(head.next)、map.get(head).random = map.get(head.random)。

代码实现：

/*
// Definition for a Node.
class Node {
    public int val;
    public Node next;
    public Node random;

    public Node() {}

    public Node(int _val,Node _next,Node _random) {
        val = _val;
        next = _next;
        random = _random;
    }
};
*/
class Solution {
    public Node copyRandomList(Node head) {
        if (head == null) return null;
        Map<Node, Node> map = new HashMap<>();
        Node iter = head;
        while(iter != null) {
            map.put(iter, new Node(iter.val));
            iter = iter.next;
        } // 将链表的各个节点指针存为map的key，value为该节点的拷贝。
        iter = head;
        while(iter != null) {
            map.get(iter).next = map.get(iter.next);
            map.get(iter).random = map.get(iter.random);
            iter = iter.next;
        }
        return map.get(head);
    }
}

8.排序链表的合并（2个）（leetcode21.Merge Two Sorted Lists）easy

问题描述：已知两个已排序链表头结点l1和l2，将这两个链表合并，合并之后仍是有序的，返回合并后链表头节点。

思路：本题相对简单，依次比较l1和l2的头结点，谁小就将谁插入新链表l中。最后返回l链表即可。

代码实现：方法1

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode l = new ListNode(0);
        ListNode head = l;
        while(l1!=null && l2!=null) {
            if (l1.val < l2.val) {
                head.next = l1;
                head = head.next; 
                l1 = l1.next;
            } else {
                head.next = l2;
                head = head.next;
                l2 = l2.next;
            }
        }
        if (l1 != null) head.next = l1; // 如果l1还有剩余节点，直接链接到l后面
        else head.next = l2; // l2还有剩余
        return l.next;
    }
}

方法2（递归实现）：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {        
        if(l1 == null) return l2;
		if(l2 == null) return l1;
		if(l1.val < l2.val){
			l1.next = mergeTwoLists(l1.next, l2);
			return l1;
		} else{
			l2.next = mergeTwoLists(l1, l2.next);
			return l2;
		}
    }
}

9.排序链表的合并（多个）（leetcode23.Merge K Sorted Lists）hard

问题描述：已知k个已排序链表头结点l1和l2，将这k个链表合并，合并之后仍是有序的，返回合并后链表头节点。

思路：本题相当于上一题难度变大，主要是如何分配这k个链表，让其分别两两合并，最后合并为一个整体。如果采用暴力破解，从第一个开始，合并第二个，然后再合并第三个。。。，共k个链表，平均每个链表有n个节点，则时间复杂度为：(n+n)+(2n+n)+(3n+n)+…+((k-1)n+n) = (1+2+3+…+k-1)n+(k-1)n = (k^2+k-1)/2*n = O(k^2 *n).

另一个思路，采用分治法，即两两进行合并。第一轮，进行k/2次，每次处理2n个；第二轮，进行k/4次，每次处理4n个，…，最后一次，进行k/(2logk)次，每次处理2logk*n个值。时间复杂度为：k/2 *2n+k/4 *4n+…+k/(2^logk) *(2^logk *n) = nk+nk+…+nk = O(klogk * n)。
代码实现：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        return mergeKLists(lists, 0, lists.length-1);
    }
    
    public ListNode mergeKLists(ListNode[] lists, int first, int end) {
        if (first == end) return lists[first];
        if (first > end) return null;
        if (end-first == 1) return mergeTwoLists(lists[first], lists[end]);
        int mid = (first + end)/2;
        ListNode l1 = mergeKLists(lists, first, mid); // 递归合并前半部分
        ListNode l2 = mergeKLists(lists, mid+1, end); // 递归合并后半部分
        return mergeTwoLists(l1, l2);
    }
    
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) { // 合并两个链表
        if (l1 == null) return l2;
        if (l2 == null) return l1;
        if (l1.val < l2.val) {
            l1.next = mergeTwoLists(l1.next, l2);
            return l1;
        } else {
            l2.next = mergeTwoLists(l1, l2.next);
            return l2;
        }
    }
}

利用数组实现：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        if (lists.length == 0) return null;
        if (lists.length == 1) return lists[0];
        if (lists.length == 2) return mergeTwoLists(lists[0], lists[1]);
        int mid = lists.length/2;
        ListNode[] lists1 = new ListNode[mid];
        for (int i=0; i<mid; i++) { // 将lists前半部分存入数组list1[]中
            lists1[i] = lists[i];
        }
        ListNode[] lists2 = new ListNode[lists.length-mid];
        for (int i=mid; i<lists.length; i++) { // 将lists后半部分存入数组list2[]中
            lists2[i-mid] = lists[i];
        }        
        ListNode sub_list1 = mergeKLists(lists1); // 将list1[]中链表合并
        ListNode sub_list2 = mergeKLists(lists2); // 将list2[]中链表合并
        return mergeTwoLists(sub_list1, sub_list2);
    }
      
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if (l1 == null) return l2;
        if (l2 == null) return l1;
        if (l1.val < l2.val) {
            l1.next = mergeTwoLists(l1.next, l2);
            return l1;
        } else {
            l2.next = mergeTwoLists(l1, l2.next);
            return l2;
        }
    }
}
Coderwangz
关注
专栏目录
_leetcode：leetcode刷题之旅
02-23
本项目“_leetcode：leetcode刷题之旅”显然是一位热衷于Java技术并致力于LeetCode刷题的程序员的心血结晶。 在这个项目中，`_leetcode-master`很可能是一个包含了该程序员在LeetCode上刷题的整个过程的代码仓库。...
leetcode 最常见的150道前端面试题
油墨香^-^的博客
02-07 1647
1、如果dp[i - 1] < 0，也就是当前遍历到nums的i，之前的最大子序和是负数，那么我们就没必要继续加它了，因为dp[i] = dp[i - 1] + nums[i] 会比nums[i]更小，所以此时还不如dp[i] = nums[i]，就是目前遍历到i的最大子序和呢。所以总体上看来，2的因子是远远多于5的因子的，所以我们只需要找5的倍数就可以了。这是一道很典型的用栈解决的问题， 给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。
leetcode前端JS算法入门（持续更新）
qq_45993474的博客
03-20 302
【代码】leetcode前端JS算法入门（持续更新）
一、leetcode笔记前端-数组
qq_43851886的博客
06-29 229
前端leetcode笔记，数组相关
前端数据结构与算法（LeetCode真题附上个人题解~持续更新）
weixin_59278546的博客
05-27 210
【代码】前端数据结构与算法（LeetCode真题附上个人题解~持续更新）
2024年Web前端最新leetcode 最常见的 150 道前端面试题（简单题上），2024年最新前端面试中常问的MMAP到底是啥东东
最新发布
2401_84447297的博客
05-11 848
总的来说，面试官要是考察思路就会从你实际做过的项目入手，考察你实际编码能力，就会让你在电脑敲代码，看你用什么编辑器、插件、编码习惯等。所以我们在回答面试官问题时，有一个清晰的逻辑思路，清楚知道自己在和面试官说项目说技术时的话就好了开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】哈希表 + 计数类型除了上面的那道题，在最热门的简单题型中还有一些记数类型的题，我们一一解答，这是一类题型387. 字符串中的第一个唯一字符一看题目，唯一，条件反射，记数题啊，map走起！
LeetCodeJourney:LeetCode刷题之旅
03-06
《LeetCode刷题之旅：深度探索算法与数据结构》 在编程的世界里，LeetCode是一个备受推崇的在线平台，它提供了丰富的算法挑战题目，旨在帮助开发者提升编程技能、理解和掌握核心算法以及数据结构。本项目...
leetcode:开始LeetCode刷题之旅
04-27
密码开始LeetCode刷题之旅列表=====>开始于2015-09-06 <=====反向链表II 重新订购清单k组中的反向节点轮换清单排序清单成对交换节点=====>结束于2015-09-30 <====== 种类=====>从2015-10-08开始<===== 2个...
leetcode寻找最近的-LeetCode:记录自己的LeetCode刷题之旅
07-01
在本文中，我们将深入探讨与"LeetCode:记录自己的LeetCode刷题之旅"相关的主题，主要涉及LeetCode这个在线编程平台及其对提升编程技能的重要作用。LeetCode是一个广受欢迎的平台，它为程序员提供了一系列算法题目，...
leetcode:记录一下我的leetcode刷题之旅
03-10
Leetcode刷题记录 记录一下自己的刷题思路，过渡来源很杂，不只leetcode，还有别的地方的，但是大部分是leetcode。 译文指导我直接写在代码注释里，方便阅读理解。 咨询问题可以联系邮箱或者知乎私信，每天都会看。 ...
leetcode题库-g_algorithm:前端算法合集
06-29
leetcode题库 g_algorithm 前端算法代码收集库 旨在帮助大家提高javascript编码水平，代码规范，面对面试官问最难的算法问题也能从容应对 这是一个常见的js算法面试题收集库，包含测试，欢迎，如果库中没有的算法，欢迎提issue或者PR。 这里先介绍几个在线代码练习平台： 在线练习 在线面试编程 关于代码规范 俗话说，无规矩不成方圆，所以平时一定要养成良好的编码习惯 关于代码测试 学习测试和持续集成(Continuous Integration，简称CI，意思是，在一个项目中，任何人对代码库的任何改动，都会触发CI服务器自动对项目进行构建，自动运行测试，甚至自动部署到测试环境。这样做的好处就是，随时发现问题，随时修复。因为修复问题的成本随着时间的推移而增长，越早发现，修复成本越低)。 4. 常见算法 4.1 二分查找 算法介绍 二分法查找，也称折半查找，是一种在有序数组中查找特定元素的搜索算法。查找过程可以分为以下步骤： （1）首先，从有序数组的中间的元素开始搜索，如果该元素正好是目标元素（即要查找的元素），则搜索过程结束，否则进行下一步。 （2）如果目标元素大于
leetcode 最常见的 150 道前端面试题（简单题上）
热门推荐
前端开发博客
08-22 1万+
大家好，之前分享leetcode 最常见的150道前端面试题（简单题下）上篇来了。前言本文题目选自LeetCode 精选 TOP 面试题[1]，而这些题在自己和同事亲身经历中，确实遇到...
leetcode 最常见的前端基础算法面试题汇总
weixin_52546522的博客
08-13 1916
目录二叉树二叉树前中后遍历套路详解对称二叉树二叉树的最大深度将有序数组转化为二叉搜索树栈有效的括号最小栈动态规划最大子序和爬楼梯数学问题加一x的平方根Excel表序列号阶乘中的零颠倒二进制位丢失的数字的幂Fizz Buzz环问题环形链表快乐数前端面试题人事+项目小程序HTML5\CSS3JSReact 把这些基础算法题掌握好，基础不牢地动山摇，后面中级题很多都是在这些基础题的基础上的。 二叉树 二叉树前中后遍历套路详解 前序遍历题目如下： root节点是A节点（下图的A节点），然后让你按照下图数字的顺序依次
前端工程师leetcode算法面试必备-二分搜索算法（下）
js2030code的博客
03-15 259
( 例如，数组 [0,0,1,2,2,5,6] 可能变为 [2,5,6,0,0,1,2] )。这种条件下，最容易想到的就是通过两重循环暴力搜索当前数字是否与后面的数字重复的方法来解决，但是这种方案的时间复杂度为 O(n^2)，既然涉及到了搜索，就可以尝试通过二分搜索算法将时间复杂度降低到 O(nlogn)。除了上述二分搜索算法的处理方法之外，可能最简单暴力的方法就是通过嵌套循环找出长度最小的连续子数组，但是这种方法的时间复杂度为 O(n^2)，有没有方法将其降低到 O(n) 的时间复杂度呢？
leetcode 最常见的150道前端面试题（简单题下）
zz_jesse的博客
05-30 462
本文题目选自 LeetCode 精选 TOP 面试题[1]，这些题在自己和同事亲身经历中，确实遇到的几率在百分之80%以上（成都和北京的前端岗位）。本篇是简单题（下）20题左右，上半部分详见leetcode 最常见的 150 道前端面试题（简单题上）二叉树（DFS）二叉树前中后遍历套路详解前序遍历题目如下：root节点是A节点（下图的A节点），然后让你按照下图数字的顺序依...
LeetCode刷题--JavaScript版
金戋的博客
06-12 3845
经学长介绍发现这个刷题的网站,于是闲着无聊的时候就上去刷刷(不定时更新)地址:https://leetcode-cn.com;下面,好戏开始1. 两数之和var twoSum = function(nums, target) {    for(let i = 0; i &lt; nums.length ; i++){        for(let j = i+1 ; j &lt; nums.len...
LeetCode 刷题技巧与学习方法
WS的小屋
04-05 3399
根据一本书中所讲的：《异类：不一样的成功启示录》，我们学习一项技术或者精通一个领域一定要经过 3 个阶段。 Chunk it up Deliberate Practicing Feedback 中文意思是： 切碎知识点 刻意练习 反馈 下面我们就这几个方面来探讨如何正确的刷题： 本文重点来探讨第二点，也就是刻意练习，这也是刷题行为的核心。 一、Deliberate Practicing 刷...
JS前端算法（leetcode实战）
sps891826343的博客
07-02 644
JS前端算法（leetcode实战） 给出一个字符串数组words组成的一本英语词典。从中找出最长的一个单词，该单词是由words词典中其他单词逐步添加一个字母组成。若其中有多个可行的答案，则返回答案中字典序最小的单词。 若无答案，则返回空字符串。 示例 1: 输入: words = [“w”,“wo”,“wor”,“worl”, “world”] 输出: “world” 解释: 单词"world"可由"w", “wo”, “wor”, 和 "worl"添加一个字母组成。 示例 2: 输入: words =
Go语言的LeetCode刷题之旅-003-无重复字符的最长子串
邱权武(isfive)的博客
06-28 584
Go语言的LeetCode刷题之旅-03-无重复字符的最长子串 题目： 给定一个字符串，找出不含有重复字符的最长子串的长度。 示例： 给定 “abcabcbb” ，没有重复字符的最长子串是 “abc” ，那么长度就是3。 给定 “bbbbb” ，最长的子串就是 “b” ，长度是1。 给定 “pwwkew” ，最长子串是 “wke” ，长度是3。请注意答案必须是一个子串，”pwk...
LeetCode刷题攻略：二分法与双指针模板
"LeetCode刷题模板.pdf" 这篇文档主要涵盖了LeetCode刷题中常见的两种算法模板——二分法和双指针法，并提供了相应的代码模板、关键属性和具体题目的应用示例。以下是对这两种方法的详细解释： 1. 二分法 - 什么...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值