- 博客(67)
- 资源 (5)
- 收藏
- 关注
RSS订阅原创 leetcode128 最长连续序列(三种方法)
//方法一：数组先去重后排序，最后遍历查询最长连续序列 // let result = 1,count=1 // if(nums.length==0) return 0 // nums = Array.from(new Set(nums)) // nums.sort((a,b)=>{return a-b }) // for(let i=0;i<nums.length-1;i++){ // if(nums[i+1]==nums[i]+1){ ...
2021-04-21 22:22:02
168
原创 leetcode 3 无重复字符的最长子串
无重复字符的最长子串给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度思路：滑动窗口1.创建set集合存放不重复字符，定义左右指针2.右指针每次向右移动一格，直到出现重复字符，将此时左右字符的长度存入ans中3.此时左指针向右移动一格，去掉set集合中的最前面字符4.重复2.3步骤，直到左指针到头5. 返回ansvar lengthOfLongestSubstring = function(s) { let length = s.length let result
2021-04-03 16:42:59
108
原创 消息订阅与发布
const pubSub = { //订阅唯一的id id:1, //频道和回调保存容器 callbacks:{}}//订阅频道pubSub.subscribe = function(channel,callback){ //创建唯一的编号 let token = "token" + this.id++ if(this.callbacks[channel]){ this.callbacks[channel][token] = ca
2021-03-29 09:42:51
487
原创 字符串的反转、回文字符串的判断
/** * 字符串反转 * 1.将字符串转为数组 2.数组反转 3.join()方法拼接成字符串 * @param {String} str */function reverseString(str){ let arr = [...str] arr.reverse() let result = arr.join('') return result}/** * 判断回文字符串 * 1.通过字符串反转和字符串比较，判断是否是回文字符串 * @para
2021-03-28 21:56:12
221
原创 浅拷贝和深拷贝
浅拷贝的两种方式：/** * 浅拷贝：当修改对象中属性值时，另一个对象中的属性也会跟着发生改变 * @param {*} target */function clone1(target){ //类型判断 [] {} null if(typeof target == 'object' && target != null){ if(Array.isArray(target)){ return [...target] ..
2021-03-28 21:38:55
61
原创 leetcode146 LRU缓存机制
/* put if(key) 更新节点值 将节点移到链表的头部 else if(缓存满了) 移出最后一个节点，删除它在哈希表中的映射 新建一个节点 在哈希表中增加映射 把节点加到链表头部 get if(key) 返回节点值
2021-03-27 22:51:31
48
原创 leetcode142 环形链表||
/* 方法一：哈希表，将节点放入set中，如果set中已经有了这个节点，说明有环，返回即可 */ // let list = new Set() // while(head){ // if(list.has(head)) // return head // list.add(head) // head = head.next // } // return null /*
2021-03-27 22:01:14
45
原创 数组扁平化
/** * 数组扁平化：将多维数组转换成一维数组 * 方法一：递归 * @param {Array} arr */function flatten1(arr){ let result = [] arr.forEach(item=>{ if(Array.isArray(item)){ result = result.concat(flatten1(item)) }else{ result = re
2021-03-27 20:46:03
58
原创 三种数组去重的方法
//方法一：forEach和indexOf 效率较低，双重遍历function unique(arr){ const result = [] arr.forEach(item => { if(result.indexOf(item)==-1){ result.push(item) } }); return result}//方法二：forEach+对象容器 利用对象存储下标，可以快速判断这个元素是否重.
2021-03-27 17:52:34
192
原创 javascript的节流和防抖
throttle() 节流<body> <script src='./throttle.js'></script> <script> //绑定滚动事件 window.addEventListener('scroll',throttle(function(e){ console.log(e) },500)) </script></body&g..
2021-03-27 16:26:32
119
原创 自定义call方法和apply方法
/* call(Fn,obj,...args) Fn为要执行的函数 obj是this指向的对象 ...args是形参*/function call(Fn,obj,...args){ //判断obj对象是否存在 if(obj === undefined || obj === null){ obj = globalThis } //为obj添加临时方法 obj.temp = Fn //调用temp方法 let
2021-03-26 16:00:02
142
原创 leetcode2 两数相加
给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。请你将两个数相加，并以相同形式返回一个表示和的链表。你可以假设除了数字 0 之外，这两个数都不会以 0 开头。思路：1.n1 = 链表1.val n2 = 链表2.val carry = 进位值2.carry = (n1+n2+carry)/10 result.val = (n1+n2+carry)%103.长度短的
2021-03-24 10:09:55
43
原创 哈希表的封装
//封装哈希表function hashTable(){ // 属性 this.storage = [] this.count = 0 this.limit = 7 // 设计哈希函数 // 将字符串转换成比较大的数字：hashCode // 将大的数字hashCode压缩到数组范围（大小）之内 hashTable.prototype.hashFunc = function(str,size){ let hashCode =
2021-03-23 09:37:35
102
原创 leetcode160 相交链表
编写一个程序，找到两个单链表相交的起始节点思路：方法一：哈希表1.遍历链表A，将其节点放入哈希表中2.遍历链表B，如果哈希表中存在链表B的元素，返回该元素方法二：双指针1.指针1指向headA，指针2指向headB2.指针1遍历完headA，重定位到headB指针2遍历完headB，重定位到headA3.如果两者相同，则说明必有相交处（PA + AC + PB = PB + AC + PA）var getIntersectionNode = function(headA, headB)
2021-03-22 17:18:54
92
原创 leetcode876 链表的中间结点
给定一个头结点为 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。思路：快慢指针法1.快慢指针指向头节点，快指针运动2步，慢指针运动1步 当fast==null || fast.next==null,慢指针指向中间节点function ListNode(val) { this.val = val; this.next = null;}var middleNode = function(head) { let fast = head
2021-03-22 16:46:45
60
原创 leetcode206反转链表
反转一个单链表思路：指针1.创建两个指针p，q 依次反转链表，直到q为nullvar reverseList = function(head) { let p=null let q=head while(q){ let temp = q.next q.next = p p = q q = temp } head.next = null return p};...
2021-03-22 11:49:27
45
原创 leetcode348 数组交集
给定两个数组，编写一个函数来计算它们的交集思路：排序+指针1.先排序2.p指针指向nums1[0],q指向nums2[0]3.将较小的那个指针++4.如果两者相等且不等于pre，将其加入新数组，更新prev5.如果一个指针为null，结束循环，返回新数组注意：用好pre进行去重var intersection = function(nums1, nums2) { let result = [] nums1.sort((a,b)=>{return a-b}) nums2
2021-03-22 11:28:15
67
原创 leetcode141环形链表
给定一个链表，判断链表中是否有环。思路：1.快慢指针，fast=head.next slow=head2.如果有环，快指针必将追上慢指针 如果没环，fast==null || slow == null return falsevar hasCycle = function(head) { if(head==null || head.next==null) return false let fast = head.next let slow = head while(
2021-03-22 10:52:31
57
原创 leetcode21 合并两个有序链表
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。思路：1.添加一个哨兵节点，用l2，l2分别指向链表的开头2.比较两者中较小的那个，将其放入新链表中function ListNode(val, next) { this.val = (val===undefined ? 0 : val) this.next = (next===undefined ? null : next)}var mergeTwoLists = function(
2021-03-22 10:39:22
50
原创 leetcode19删除链表的倒数第N个节点
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。思路：快慢指针1.建立虚拟节点0，fast向前走n+1步2.fast与slow同步走，这样fast与slow之间相差n3.如果fast==null，说明删除的是头节点4.如果fast！=null，正常处理var removeNthFromEnd = function(head, n) { let dummy = new ListNode(-1,head) let fast = dummy let slow
2021-03-22 09:54:36
63
原创 集合的封装（交集，并集，子集，差集）
function Set(){ this.items = {} //has方法 Set.prototype.has = function(value){ return this.items.hasOwnProperty(value) } //add方法 Set.prototype.add = function(value){ //value 如果存在 如果不存在 if(this.has(value)){
2021-03-21 22:50:06
300
原创 双向链表的封装
function DoublyLinkedList(){ function Node(data){ this.data = data this.prev = null this.next = null } this.head = null this.tail = null this.length = 0 //append方法 DoublyLinkedList.prototype.append = func
2021-03-21 15:59:57
101
原创 单向链表的封装
function LinkedList(){ //内部的类：节点类 function Node(data) { this.data = data this.next = null } this.head = null this.length = 0 //append方法 LinkedList.prototype.append = function (data) { //创建一个新节点 //
2021-03-20 16:50:07
107
原创 leetcode53 最大子序和
给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和思路：dp[i]=max{dp[i-1]+nums[i],nums[i]}var maxSubArray = function(nums) { let length=nums.length let pre=0 let result= nums[0] for(let i=1;i<length+1;i++){ pre=Math.max(nums[i-1],
2021-03-20 10:41:38
28
原创 leetcode14 最长公共前缀
var longestCommonPrefix = function(strs) { //先将字符串1设为ans，将ans与字符串2，3，4...比较求公共字符串，最终求得公共字符串 if(!strs.length) return '' let ans=strs[0] for(i=1;i<strs.length;i++){ let j=0; for(;j<ans.length&&j<strs[i].length
2021-03-19 19:57:34
42
原创 leetcode746使用最小花费爬楼梯
数组的每个下标作为一个阶梯，第 i 个阶梯对应着一个非负数的体力花费值 cost[i]（下标从 0 开始）。每当你爬上一个阶梯你都要花费对应的体力值，一旦支付了相应的体力值，你就可以选择向上爬一个阶梯或者爬两个阶梯。请你找出达到楼层顶部的最低花费。在开始时，你可以选择从下标为 0 或 1 的元素作为初始阶梯。var minCostClimbingStairs = function(cost) { let dp=new Array(cost.length+1).fill(0) dp[0]
2021-03-19 19:39:23
73
原创 leetcode70爬楼梯
爬楼梯问题和凑零钱问题，主要是排列和组合的区别假设你正在爬楼梯。需要 n 阶你才能到达楼顶。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？注意：给定 n 是一个正整数。转移方程：dp[j]=dp[j-1]+dp[j-2]边界：dp[0]=1 dp[1]=1var climbStairs = function(n) { dp=new Array(n+1).fill(0) dp[0]=1 dp[1]=1 for(let j=2;j&l
2021-03-19 19:26:12
36
原创 leetcode518 零钱兑换||
给定不同面额的硬币和一个总金额。写出函数来计算可以凑成总金额的硬币组合数。假设每一种面额的硬币有无限个。思路：动态规划，求组合数建立一个元素全为0的数组，遍历coins.length次数组每次遍历时，都要根据coin的值，改变dp中的值dp[0]=1dp[x]+=dp[x-coin]var change = function(amount, coins) { dp=new Array(amount+1).fill(0) dp[0]=1 for(coin of co
2021-03-19 17:39:11
114
原创 leetcode226翻转二叉树
翻转一棵二叉树。思路：递归终止条件： node==null递归条件：左右子树交换var invertTree=function (root) { if (!root) return null if(root){ let temp=root.left root.left=root.right root.right=temp } invertTree(root.left) invertTree(root.right) ret
2021-03-19 15:18:10
48
原创 leetcode230 二叉搜索树中的第k小的元素
给定一个二叉搜索树的根节点 root ，和一个整数 k ，请你设计一个算法查找其中第 k 个最小元素（从 1 开始计数）var kthSmallest = function(root, k) { //方法一：递归 中序遍历，放入数组，查找第k个元素 let result=[] const midOrder=(root)=>{ if(result.length==k) return if(root!=null){ midOr
2021-03-19 14:51:18
70
原创 求二叉树中两个指定节点的最短距离
给定一个二叉树, 找到该树中两个指定节点间的最短距离思路：求最近公共祖先节点，然后再求最近公共祖先节点到两个指定节点的路径，再求两个节点的路径之和const shortestDistance=function (root,p,q) { let lowestCA=lowerCommonAncestor(root,p,q) let pDis=[],qDis=[] getPath(lowestCA,p,pDis) getPath(lowestCA,q,qDis) ret
2021-03-19 11:23:34
1788
原创 leetcode113 二叉树的路径总和
给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。思路：1.终止条件：nodenull || 叶子节点 node.val+sumtargetSum2.递归条件：左子树和右子树均需递归var pathSum = function(root, targetSum) { const result=[] const pathSumFunction=(node,path,sum) =>{ i
2021-03-18 11:17:57
119
原创 归并排序
归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。再来看看治阶段，我们需要将两个已经有序的子序列合并成一个有序序列，比如上图中的最后一次合并，要将[4,5,7,8]和[1,2,3,6]两个已经有序的子序列，合并为最终序列[1,2,3,4,5,6,7,8]，来看下实现步骤。归并排序是稳
2021-03-18 09:13:41
47
原创 leetcode112 二叉树路径总和（DFS递归和BFS遍历）
给你二叉树的根节点 root 和一个表示目标和的整数 targetSum ，判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。思路：方法一：递归1.终止条件：叶子节点，return false2.递归返回值：left+=递归返回值right+=递归返回值if(left!=target && right!=target) return falsereturn true方法二：BFS用两个队列q1、q2 q1用来装当前的
2021-03-17 16:43:23
92
原创 leetcode110 平衡二叉树
给定一个二叉树，判断它是否是高度平衡的二叉树。本题中，一棵高度平衡二叉树定义为：一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。思路：递归(从底向上)终止条件：叶子节点，返回0 。递归返回值：左子树的高度为left，右子树的高度为rightleft=-1 || right==-1 return -1abs(left-right)>1,return -1abs(left-right)<=1,return max{left,right}+1var isBalanc
2021-03-17 15:38:14
60
原创 leetcode 236二叉树的最近公共祖先
给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。百度百科中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”思路：递归终止条件：碰到p或q 碰到叶子节点递归返回：左子树和右子树判断条件：1.p和q在分列左右子树，左子树和右子树返回均不为null返回root2.p和q在左子树或右子树中，左右子树中有一个返回不为null返回该子树的返回值3.p和q不在左右
2021-03-17 15:00:16
46
原创 leetcode105 从前序与中序遍历中构造二叉树
根据一棵树的前序遍历与中序遍历构造二叉树。思路：1.根据前序数组，找到根节点2.根据中序数组中的根节点，找到左子树的长度3.根据左子树的长度，找到左右子树的前序数组和中序数组4.递归调用，直到前序数组为nullfunction TreeNode(val, left, right) { this.val = (val===undefined ? 0 : val) this.left = (left===undefined ? null : left) this.right
2021-03-17 14:20:35
41
原创 leetcode104 二叉树的最大深度
给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。思路：利用回溯法，先求左子树的最大深度，再求右子树的最大深度，整棵树的最大深度为两者最大值+1var maxDepth = function(root) { //方法一：通过层序遍历，求最大深度 // let resLength=0 // if(!root) return resLength // let q=[] // q.push(root) // while(
2021-03-17 11:21:54
61
原创 leetcode107 二叉树的层次遍历
给定一个二叉树，返回其节点值自底向上的层序遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）思路：1.创建一个数组result,创建一个队列q，将root加入队列2. 每次从队列中取出一个节点，将该节点的左右节点放入队列每次while循环必须将队列中所有节点遍历完，才能进行下一次循环while(q.length!=0){ let subResult=[] result.push(node.val) for (let i = 0; i <
2021-03-17 10:11:49
40
原创 leetcode102 二叉树的层次遍历
给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。思路：1.创建一个数组result,创建一个队列q，将root加入队列2. 每次从队列中取出一个节点，将该节点的左右节点放入队列每次while循环必须将队列中所有节点遍历完，才能进行下一次循环while(q.length!=0){node=q.shift()result.push(node.val)for (let i = 0; i <q.length; i++) {if(node.left)
2021-03-17 09:50:49
43
毕业设计（论文）中期进展情况检查表
2019-04-10
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人