diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..32d5107 --- /dev/null +++ b/.gitignore @@ -0,0 +1,42 @@ +target/ +!.mvn/wrapper/maven-wrapper.jar +!**/src/main/**/target/ +!**/src/test/**/target/ + +### IntelliJ IDEA ### +.idea/modules.xml +.idea/jarRepositories.xml +.idea/compiler.xml +.idea/libraries/ +.idea +*.iws +*.iml +*.ipr + +target/ + + +### Eclipse ### +.apt_generated +.classpath +.factorypath +.project +.settings +.springBeans +.sts4-cache + +### NetBeans ### +/nbproject/private/ +/nbbuild/ +/dist/ +/nbdist/ +/.nb-gradle/ +build/ +!**/src/main/**/build/ +!**/src/test/**/build/ + +### VS Code ### +.vscode/ + +### Mac OS ### +.DS_Store \ No newline at end of file diff --git a/LICENSE b/LICENSE deleted file mode 100644 index 261eeb9..0000000 --- a/LICENSE +++ /dev/null @@ -1,201 +0,0 @@ - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. diff --git a/README.md b/README.md new file mode 100644 index 0000000..8b1ebb6 --- /dev/null +++ b/README.md @@ -0,0 +1,10 @@ +# leetcode-cn.com 题解 + +## easy +[easy题解](src/main/java/com/mine/study/easy/easy.md) + +## medium +[medium题解](src/main/java/com/mine/study/medium/medium.md) + +## hard +[hard题解](src/main/java/com/mine/study/hard/hard.md) diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..f6984e3 --- /dev/null +++ b/pom.xml @@ -0,0 +1,22 @@ + + + 4.0.0 + + com.mine.study + leetcode-algorithm + 1.0-SNAPSHOT + + + 8 + UTF-8 + ${java.version} + ${java.version} + ${project.encoding} + ${project.encoding} + ${project.encoding} + + + + \ No newline at end of file diff --git a/src/main/java/com/mine/study/BST.java b/src/main/java/com/mine/study/BST.java new file mode 100644 index 0000000..8f4b24f --- /dev/null +++ b/src/main/java/com/mine/study/BST.java @@ -0,0 +1,86 @@ +package com.mine.study; + +import java.util.LinkedList; +import java.util.Queue; + +/** + * 二叉搜索树 + */ +public class BST { + + public TreeNode root; + + public BST() { + root = null; + } + + + public void addNode(int value) { + root = addNode(root, value); + } + + // 向以node为根的二分搜索树中插入元素e，递归算法 + // 返回插入新节点后二分搜索树的根 + private TreeNode addNode(TreeNode node, int value) { + if (node == null) { + return new TreeNode(value); + } + if (value < node.val) { + node.left = addNode(node.left, value); + } else if (value > node.val) { + node.right = addNode(node.right, value); + } + return node; + } + + // 中序遍历 + public void inOrder() { + inOrder(root); + } + + // 指定节点 中序遍历 + public void inOrderNode(TreeNode root) { + inOrder(root); + } + + private void inOrder(TreeNode node) { + if (node == null) { + return; + } + inOrder(node.left); + System.out.println(node.val); + inOrder(node.right); + } + + + // 前序遍历 + public void preOrder() { + preOrder(root); + } + + private void preOrder(TreeNode node) { + if (node == null) { + return; + } + System.out.println(node.val); + preOrder(node.left); + preOrder(node.right); + } + + //层序遍历 + public void levelOrder() { + Queue queue = new LinkedList<>(); + queue.add(root); + while(!queue.isEmpty()) { + TreeNode node = queue.remove(); + System.out.println(node.val); + + if (node.left != null) { + queue.add(node.left); + } + if (node.right != null) { + queue.add(node.right); + } + } + } +} diff --git a/src/main/java/com/mine/study/ListNode.java b/src/main/java/com/mine/study/ListNode.java new file mode 100644 index 0000000..904c7a9 --- /dev/null +++ b/src/main/java/com/mine/study/ListNode.java @@ -0,0 +1,46 @@ +package com.mine.study; + +/** + * 单向链表节点 + */ +public class ListNode { + public int val; + public ListNode next; + + public ListNode(int x) { + val = x; + } + + // 链表节点的构造函数 + // 使用arr为参数，创建一个链表，当前的ListNode为链表头结点 + public ListNode(int[] arr) { + if (arr == null || arr.length == 0) + throw new IllegalArgumentException("arr can not be empty"); + + this.val = arr[0]; + ListNode cur = this; + for (int i = 1; i < arr.length; i++) { + cur.next = new ListNode(arr[i]); + cur = cur.next; + } + } + + // 以当前节点为头结点的链表信息字符串 当测试有环链表的时候 不能覆盖的toString()方法 会内存溢出 + /*@Override + public String toString(){ + + StringBuilder s = new StringBuilder(); + ListNode cur = this; + while(cur != null){ + s.append(cur.val + "->"); + cur = cur.next; + } + s.append("NULL"); + return s.toString(); + }*/ + + @Override + public String toString() { + return String.valueOf(this.val); + } +} diff --git a/src/main/java/com/mine/study/MainApp.java b/src/main/java/com/mine/study/MainApp.java new file mode 100644 index 0000000..8fd0204 --- /dev/null +++ b/src/main/java/com/mine/study/MainApp.java @@ -0,0 +1,7 @@ +package com.mine.study; + +public class MainApp { + public static void main(String[] args) { + System.out.println("Hello world!"); + } +} \ No newline at end of file diff --git a/src/main/java/com/mine/study/TreeNode.java b/src/main/java/com/mine/study/TreeNode.java new file mode 100644 index 0000000..dba4dfd --- /dev/null +++ b/src/main/java/com/mine/study/TreeNode.java @@ -0,0 +1,9 @@ +package com.mine.study; + +public class TreeNode { + + public int val; + public TreeNode left; + public TreeNode right; + public TreeNode(int x) { val = x; } +} diff --git a/src/main/java/com/mine/study/design_pattern/AbstractFactory/AbstractFactory.java b/src/main/java/com/mine/study/design_pattern/AbstractFactory/AbstractFactory.java new file mode 100644 index 0000000..f08c47b --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/AbstractFactory/AbstractFactory.java @@ -0,0 +1,12 @@ +package com.mine.study.design_pattern.AbstractFactory; + + +/** + * @author:Sun Hongwei + * @2020/3/13 下午11:26 + * File Description：抽象工厂：提供了产品的生成方法。 + */ +public interface AbstractFactory { + public concreteProductA newProductA(); + public concreteProductB newProductB(); +} diff --git a/src/main/java/com/mine/study/design_pattern/AbstractFactory/AbstractFactory.txt b/src/main/java/com/mine/study/design_pattern/AbstractFactory/AbstractFactory.txt new file mode 100644 index 0000000..7ed3b01 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/AbstractFactory/AbstractFactory.txt @@ -0,0 +1,27 @@ +抽象工厂：AbstractFactory + +是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。 + +抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。 + + +使用抽象工厂模式一般要满足以下条件: +1.系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品。 +2.系统一次只可能消费其中某一族产品，即同族的产品一起使用。 + +抽象工厂模式除了具有工厂方法模式的优点外，其他主要优点如下: +1.可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。 +2.当增加一个新的产品族时不需要修改原代码，满足开闭原则。 +其缺点是：当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。 + + +抽象工厂模式的主要角色: +抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。 +具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。 +抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。 +具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它 同具体工厂之间是多对一的关系。 + +抽象工厂模式通常适用于以下场景： +1.当需要创建的对象是一系列相互关联或相互依赖的产品族时，如电器工厂中的电视机、洗衣机、空调等。 +2.系统中有多个产品族，但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。 +3.系统中提供了产品的类库，且所有产品的接口相同，客户端不依赖产品实例的创建细节和内部结构。 \ No newline at end of file diff --git a/src/main/java/com/mine/study/design_pattern/AbstractFactory/AbstractFactory_UML.png b/src/main/java/com/mine/study/design_pattern/AbstractFactory/AbstractFactory_UML.png new file mode 100644 index 0000000..18f9976 Binary files /dev/null and b/src/main/java/com/mine/study/design_pattern/AbstractFactory/AbstractFactory_UML.png differ diff --git a/src/main/java/com/mine/study/design_pattern/AbstractFactory/ConcreteFactoryA.java b/src/main/java/com/mine/study/design_pattern/AbstractFactory/ConcreteFactoryA.java new file mode 100644 index 0000000..b23ef3b --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/AbstractFactory/ConcreteFactoryA.java @@ -0,0 +1,18 @@ +package com.mine.study.design_pattern.AbstractFactory; + +/** + * @author:Sun Hongwei + * @2020/3/13 下午11:28 + * File Description：具体工厂：实现了产品的生成方法。 + */ +public class ConcreteFactoryA implements AbstractFactory{ + public concreteProductA newProductA(){ + System.out.println("具体工厂 1 生成-->具体产品 11..."); + return new concreteProductA(); + } + + public concreteProductB newProductB(){ + System.out.println("具体工厂 2 生成-->具体产品 22..."); + return new concreteProductB(); + } +} diff --git a/src/main/java/com/mine/study/design_pattern/AbstractFactory/Product.java b/src/main/java/com/mine/study/design_pattern/AbstractFactory/Product.java new file mode 100644 index 0000000..55827e2 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/AbstractFactory/Product.java @@ -0,0 +1,10 @@ +package com.mine.study.design_pattern.AbstractFactory; + +/** + * @author:Sun Hongwei + * @2020/3/13 下午9:59 + * File Description：抽象产品：提供了产品的接口 + */ +public interface Product { + public void show(); +} diff --git a/src/main/java/com/mine/study/design_pattern/AbstractFactory/concreteProductA.java b/src/main/java/com/mine/study/design_pattern/AbstractFactory/concreteProductA.java new file mode 100644 index 0000000..7deeba0 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/AbstractFactory/concreteProductA.java @@ -0,0 +1,13 @@ +package com.mine.study.design_pattern.AbstractFactory; + + +/** + * @author:Sun Hongwei + * @2020/3/13 下午10:01 + * File Description：具体产品A：实现抽象产品中的抽象方法 + */ +public class concreteProductA implements Product { + public void show(){ + System.out.println("具体产品A:-______-"); + } +} diff --git a/src/main/java/com/mine/study/design_pattern/AbstractFactory/concreteProductB.java b/src/main/java/com/mine/study/design_pattern/AbstractFactory/concreteProductB.java new file mode 100644 index 0000000..541e0f2 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/AbstractFactory/concreteProductB.java @@ -0,0 +1,13 @@ +package com.mine.study.design_pattern.AbstractFactory; + + +/** + * @author:Sun Hongwei + * @2020/3/13 下午10:02 + * File Description：具体产品B：实现抽象产品中的抽象方法 + */ +public class concreteProductB implements Product { + public void show(){ + System.out.println("具体产品B:-______-"); + } +} diff --git a/src/main/java/com/mine/study/design_pattern/Adapter/Adapte b/src/main/java/com/mine/study/design_pattern/Adapter/Adapte new file mode 100644 index 0000000..2b47691 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Adapter/Adapte @@ -0,0 +1,13 @@ +适配器模式：Adapter + +将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。 + +优点： +1.客户端通过适配器可以透明地调用目标接口。 +2.复用了现存的类，程序员不需要修改原有代码而重用现有的适配者类。 +3.将目标类和适配者类解耦，解决了目标类和适配者类接口不一致的问题。 + +模式结构： +目标（Target）接口：当前系统业务所期待的接口，它可以是抽象类或接口。 +适配者（Adaptee）类：它是被访问和适配的现存组件库中的组件接口。 +适配器（Adapter）类：它是一个转换器，通过继承或引用适配者的对象，把适配者接口转换成目标接口，让客户按目标接口的格式访问适配者。 diff --git a/src/main/java/com/mine/study/design_pattern/Adapter/Adaptee.java b/src/main/java/com/mine/study/design_pattern/Adapter/Adaptee.java new file mode 100644 index 0000000..6b24fe2 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Adapter/Adaptee.java @@ -0,0 +1,12 @@ +package com.mine.study.design_pattern.Adapter; + +/** + * @author:Sun Hongwei + * @2020/3/11 下午7:14 + * File Description：适配器接口 + */ +public class Adaptee { + public void specificRequest(){ + System.out.println("适配器"); + } +} diff --git a/src/main/java/com/mine/study/design_pattern/Adapter/AdapterDemo/ElectricAdapter.java b/src/main/java/com/mine/study/design_pattern/Adapter/AdapterDemo/ElectricAdapter.java new file mode 100644 index 0000000..c804350 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Adapter/AdapterDemo/ElectricAdapter.java @@ -0,0 +1,18 @@ +package com.mine.study.design_pattern.Adapter.AdapterDemo; + +/** + * @author:Sun Hongwei + * @2020/3/13 下午6:58 + * File Description：电能适配器，引入Motor接口 + */ +public class ElectricAdapter implements Motor{ + // 适配器内创建ElectricMotor实例对象 + private ElectricMotor emoter; + public ElectricAdapter(){ + emoter=new ElectricMotor(); + } + + public void drive(){ + emoter.electricDrive(); + } +} diff --git a/src/main/java/com/mine/study/design_pattern/Adapter/AdapterDemo/ElectricMotor.java b/src/main/java/com/mine/study/design_pattern/Adapter/AdapterDemo/ElectricMotor.java new file mode 100644 index 0000000..1c06fa6 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Adapter/AdapterDemo/ElectricMotor.java @@ -0,0 +1,12 @@ +package com.mine.study.design_pattern.Adapter.AdapterDemo; + +/** + * @author:Sun Hongwei + * @2020/3/13 下午6:54 + * File Description：适配者1：电能发动机 + */ +public class ElectricMotor { + public void electricDrive(){ + System.out.println("电能发动机!"); + } +} diff --git a/src/main/java/com/mine/study/design_pattern/Adapter/AdapterDemo/Motor.java b/src/main/java/com/mine/study/design_pattern/Adapter/AdapterDemo/Motor.java new file mode 100644 index 0000000..d85d48c --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Adapter/AdapterDemo/Motor.java @@ -0,0 +1,10 @@ +package com.mine.study.design_pattern.Adapter.AdapterDemo; + +/** + * @author:Sun Hongwei + * @2020/3/13 下午6:53 + * File Description：目标类：Motor(发动机） + */ +public interface Motor { + public void drive(); +} diff --git a/src/main/java/com/mine/study/design_pattern/Adapter/AdapterDemo/MotorAdapterTest.java b/src/main/java/com/mine/study/design_pattern/Adapter/AdapterDemo/MotorAdapterTest.java new file mode 100644 index 0000000..44b1f1d --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Adapter/AdapterDemo/MotorAdapterTest.java @@ -0,0 +1,14 @@ +package com.mine.study.design_pattern.Adapter.AdapterDemo; + +/** + * @author:Sun Hongwei + * @2020/3/13 下午7:06 + * File Description：Adapter测试类 + */ +public class MotorAdapterTest { + public static void main(String[] args) { + System.out.println("适配者模式调用： "); + OpticalAdapter opticalAdapter=new OpticalAdapter(); + opticalAdapter.drive(); + } +} diff --git a/src/main/java/com/mine/study/design_pattern/Adapter/AdapterDemo/OpticalAdapter.java b/src/main/java/com/mine/study/design_pattern/Adapter/AdapterDemo/OpticalAdapter.java new file mode 100644 index 0000000..72d5ac0 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Adapter/AdapterDemo/OpticalAdapter.java @@ -0,0 +1,17 @@ +package com.mine.study.design_pattern.Adapter.AdapterDemo; + +/** + * @author:Sun Hongwei + * @2020/3/13 下午7:02 + * File Description：OpticalAdapter:光能适配器 + */ +public class OpticalAdapter { + //通过适配器类来创建motor类实例对象，并且调用motor类的方法 + private OpticalMotor omoter; + public OpticalAdapter(){ + omoter=new OpticalMotor(); + } + public void drive(){ + omoter.opticalDrive(); + } +} diff --git a/src/main/java/com/mine/study/design_pattern/Adapter/AdapterDemo/OpticalMotor.java b/src/main/java/com/mine/study/design_pattern/Adapter/AdapterDemo/OpticalMotor.java new file mode 100644 index 0000000..34544a1 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Adapter/AdapterDemo/OpticalMotor.java @@ -0,0 +1,12 @@ +package com.mine.study.design_pattern.Adapter.AdapterDemo; + +/** + * @author:Sun Hongwei + * @2020/3/13 下午6:56 + * File Description：适配者2：光能发动机 + */ +public class OpticalMotor { + public void opticalDrive(){ + System.out.println("光能发动机! "); + } +} diff --git a/src/main/java/com/mine/study/design_pattern/Adapter/AdapterTest.java b/src/main/java/com/mine/study/design_pattern/Adapter/AdapterTest.java new file mode 100644 index 0000000..0c32fa4 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Adapter/AdapterTest.java @@ -0,0 +1,14 @@ +package com.mine.study.design_pattern.Adapter; + +/** + * @author:Sun Hongwei + * @2020/3/11 下午7:32 + * File Description：Adapter测试类 + */ +public class AdapterTest { + public static void main(String[] args) { + System.out.println("适配器模式测试开始："); + Target target=new ClassAdapter(); + target.request(); + } +} diff --git a/src/main/java/com/mine/study/design_pattern/Adapter/Adapter_UML.png b/src/main/java/com/mine/study/design_pattern/Adapter/Adapter_UML.png new file mode 100644 index 0000000..c115b15 Binary files /dev/null and b/src/main/java/com/mine/study/design_pattern/Adapter/Adapter_UML.png differ diff --git a/src/main/java/com/mine/study/design_pattern/Adapter/ClassAdapter.java b/src/main/java/com/mine/study/design_pattern/Adapter/ClassAdapter.java new file mode 100644 index 0000000..48c412d --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Adapter/ClassAdapter.java @@ -0,0 +1,13 @@ +package com.mine.study.design_pattern.Adapter; + +/** + * @author:Sun Hongwei + * @2020/3/11 下午7:31 + * File Description：适配器类 + */ +public class ClassAdapter extends Adaptee implements Target{ + @Override + public void request(){ + specificRequest(); + } +} diff --git a/src/main/java/com/mine/study/design_pattern/Adapter/Target.java b/src/main/java/com/mine/study/design_pattern/Adapter/Target.java new file mode 100644 index 0000000..24ac8ea --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Adapter/Target.java @@ -0,0 +1,10 @@ +package com.mine.study.design_pattern.Adapter; + +/** + * @author:Sun Hongwei + * @2020/3/11 下午7:11 + * File Description：目标接口 + */ +public interface Target { + public void request(); +} diff --git a/src/main/java/com/mine/study/design_pattern/Decorator/Component.java b/src/main/java/com/mine/study/design_pattern/Decorator/Component.java new file mode 100644 index 0000000..6c822b4 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Decorator/Component.java @@ -0,0 +1,10 @@ +package com.mine.study.design_pattern.Decorator; + +/** + * @author:Sun Hongwei + * @2020/3/13 下午11:58 + * File Description：抽象构件角色 + */ +public interface Component { + public void operation(); +} diff --git a/src/main/java/com/mine/study/design_pattern/Decorator/ConcreteComponent.java b/src/main/java/com/mine/study/design_pattern/Decorator/ConcreteComponent.java new file mode 100644 index 0000000..68aa8c5 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Decorator/ConcreteComponent.java @@ -0,0 +1,16 @@ +package com.mine.study.design_pattern.Decorator; + +/** + * @author:Sun Hongwei + * @2020/3/13 下午11:58 + * File Description：具体构件角色 + */ +public class ConcreteComponent implements Component{ + public ConcreteComponent(){ + System.out.println("创建具体构件角色"); + } + + public void operation(){ + System.out.println("调用具体构件角色的方法operation()"); + } +} diff --git a/src/main/java/com/mine/study/design_pattern/Decorator/ConcreteDecorator.java b/src/main/java/com/mine/study/design_pattern/Decorator/ConcreteDecorator.java new file mode 100644 index 0000000..7310598 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Decorator/ConcreteDecorator.java @@ -0,0 +1,21 @@ +package com.mine.study.design_pattern.Decorator; + +/** + * @author:Sun Hongwei + * @2020/3/14 上午12:03 + * File Description：具体装饰角色 + */ +public class ConcreteDecorator extends Decorator{ + public ConcreteDecorator(Component component){ + super(component); + } + + public void operation(){ + super.operation(); + addFunction(); + } + + public void addFunction(){ + System.out.println("为具体构件角色增加额外的功能addedFunction()"); + } +} diff --git a/src/main/java/com/mine/study/design_pattern/Decorator/Decorate_UML.png b/src/main/java/com/mine/study/design_pattern/Decorator/Decorate_UML.png new file mode 100644 index 0000000..8b0a8bc Binary files /dev/null and b/src/main/java/com/mine/study/design_pattern/Decorator/Decorate_UML.png differ diff --git a/src/main/java/com/mine/study/design_pattern/Decorator/Decorator b/src/main/java/com/mine/study/design_pattern/Decorator/Decorator new file mode 100644 index 0000000..95f8448 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Decorator/Decorator @@ -0,0 +1,25 @@ +装饰模式：Decorator + +指在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式，它属于对象结构型模式。 + +主要优点有： +1.采用装饰模式扩展对象的功能比采用继承方式更加灵活。 +2.可以设计出多个不同的具体装饰类，创造出多个不同行为的组合。 + +主要缺点是：装饰模式增加了许多子类，如果过度使用会使程序变得很复杂。 + +模式的结构：装饰模式主要包含以下角色。 +抽象构件（Component）角色：定义一个抽象接口以规范准备接收附加责任的对象。 +具体构件（Concrete Component）角色：实现抽象构件，通过装饰角色为其添加一些职责。 +抽象装饰（Decorator）角色：继承抽象构件，并包含具体构件的实例，可以通过其子类扩展具体构件的功能。 +具体装饰（ConcreteDecorator）角色：实现抽象装饰的相关方法，并给具体构件对象添加附加的责任。 + +应用场景： +1.当需要给一个现有类添加附加职责，而又不能采用生成子类的方法进行扩充时。例如，该类被隐藏或者该类是终极类或者采用继承方式会产生大量的子类。 +2.当需要通过对现有的一组基本功能进行排列组合而产生非常多的功能时，采用继承关系很难实现，而采用装饰模式却很好实现。 +3.当对象的功能要求可以动态地添加，也可以再动态地撤销时。 + + + + + diff --git a/src/main/java/com/mine/study/design_pattern/Decorator/Decorator.java b/src/main/java/com/mine/study/design_pattern/Decorator/Decorator.java new file mode 100644 index 0000000..a049691 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Decorator/Decorator.java @@ -0,0 +1,17 @@ +package com.mine.study.design_pattern.Decorator; + +/** + * @author:Sun Hongwei + * @2020/3/14 上午12:00 + * File Description：抽象装饰角色 + */ +public class Decorator implements Component{ + private Component component; + public Decorator(Component component){ + this.component=component; + } + + public void operation(){ + component.operation(); + } +} diff --git a/src/main/java/com/mine/study/design_pattern/Decorator/DecoratorTest.java b/src/main/java/com/mine/study/design_pattern/Decorator/DecoratorTest.java new file mode 100644 index 0000000..82d05cd --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Decorator/DecoratorTest.java @@ -0,0 +1,18 @@ +package com.mine.study.design_pattern.Decorator; + +/** + * @author:Sun Hongwei + * @2020/3/14 上午12:23 + * File Description：装饰模式测试 + */ +public class DecoratorTest { + public static void main(String[] args) { + Component p=new ConcreteComponent(); + p.operation(); + System.out.println("----------"); + Component d=new ConcreteDecorator(p); + d.operation(); + + + } +} diff --git a/src/main/java/com/mine/study/design_pattern/FactoryMethod/AbstractFactory.java b/src/main/java/com/mine/study/design_pattern/FactoryMethod/AbstractFactory.java new file mode 100644 index 0000000..5e21db6 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/FactoryMethod/AbstractFactory.java @@ -0,0 +1,10 @@ +package com.mine.study.design_pattern.FactoryMethod; + +/** + * @author:Sun Hongwei + * @2020/3/13 下午10:00 + * File Description：抽象工厂：提供了厂品的生成方法 + */ +public interface AbstractFactory { + public Product newProduct(); +} diff --git a/src/main/java/com/mine/study/design_pattern/FactoryMethod/FactoryMethod b/src/main/java/com/mine/study/design_pattern/FactoryMethod/FactoryMethod new file mode 100644 index 0000000..de7ad79 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/FactoryMethod/FactoryMethod @@ -0,0 +1,21 @@ +工厂方法模式：Factory Method +定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。 +这满足创建型模式中所要求的“创建与使用相分离”的特点。 + +工厂方法模式的主要优点有： +1.用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程； +2.在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类，无须对原工厂进行任何修改，满足开闭原则； + +缺点是：每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度。 + +模式的结构 +工厂方法模式的主要角色如下: +抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法newProduct()来创建产品。 +具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。 +抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。 +具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。 + +适用于以下场景: +1.客户只知道创建产品的工厂名，而不知道具体的产品名。如 TCL 电视工厂、海信电视工厂等。 +2.创建对象的任务由多个具体子工厂中的某一个完成，而抽象工厂只提供创建产品的接口。 +3.客户不关心创建产品的细节，只关心产品的品牌。 \ No newline at end of file diff --git a/src/main/java/com/mine/study/design_pattern/FactoryMethod/Factory_Method_UML.png b/src/main/java/com/mine/study/design_pattern/FactoryMethod/Factory_Method_UML.png new file mode 100644 index 0000000..46a6625 Binary files /dev/null and b/src/main/java/com/mine/study/design_pattern/FactoryMethod/Factory_Method_UML.png differ diff --git a/src/main/java/com/mine/study/design_pattern/FactoryMethod/Factory_Test.java b/src/main/java/com/mine/study/design_pattern/FactoryMethod/Factory_Test.java new file mode 100644 index 0000000..537c223 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/FactoryMethod/Factory_Test.java @@ -0,0 +1,23 @@ +package com.mine.study.design_pattern.FactoryMethod; + +/** + * @author:Sun Hongwei + * @2020/3/13 下午10:09 + * File Description：工厂方法测试类 + */ +public class Factory_Test { + public static void main(String[] args) { + try { + AbstractFactory fa=new concreteFactoryA(); + Product pa=fa.newProduct(); + pa.show(); + + AbstractFactory fb=new concreteFactoryB(); + Product pb=fb.newProduct(); + pb.show(); + + }catch (Exception e){ + System.out.println(e.getMessage()); + } + } +} diff --git a/src/main/java/com/mine/study/design_pattern/FactoryMethod/Product.java b/src/main/java/com/mine/study/design_pattern/FactoryMethod/Product.java new file mode 100644 index 0000000..9720088 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/FactoryMethod/Product.java @@ -0,0 +1,10 @@ +package com.mine.study.design_pattern.FactoryMethod; + +/** + * @author:Sun Hongwei + * @2020/3/13 下午9:59 + * File Description：抽象产品：提供了产品的接口 + */ +public interface Product { + public void show(); +} diff --git a/src/main/java/com/mine/study/design_pattern/FactoryMethod/concreteFactoryA.java b/src/main/java/com/mine/study/design_pattern/FactoryMethod/concreteFactoryA.java new file mode 100644 index 0000000..0b769b1 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/FactoryMethod/concreteFactoryA.java @@ -0,0 +1,13 @@ +package com.mine.study.design_pattern.FactoryMethod; + +/** + * @author:Sun Hongwei + * @2020/3/13 下午10:07 + * File Description：具体工厂A：实现了产品A的生成方法 + */ +public class concreteFactoryA implements AbstractFactory { + public Product newProduct(){ + System.out.println("具体工厂A生成-->具体产品A..."); + return new concreteProductA(); + } +} diff --git a/src/main/java/com/mine/study/design_pattern/FactoryMethod/concreteFactoryB.java b/src/main/java/com/mine/study/design_pattern/FactoryMethod/concreteFactoryB.java new file mode 100644 index 0000000..081735d --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/FactoryMethod/concreteFactoryB.java @@ -0,0 +1,13 @@ +package com.mine.study.design_pattern.FactoryMethod; + +/** + * @author:Sun Hongwei + * @2020/3/13 下午10:08 + * File Description：具体工厂B：实现了产品B的生成方法 + */ +public class concreteFactoryB implements AbstractFactory { + public Product newProduct(){ + System.out.println("具体工厂B生成-->具体产品B..."); + return new concreteProductB(); + } +} diff --git a/src/main/java/com/mine/study/design_pattern/FactoryMethod/concreteProductA.java b/src/main/java/com/mine/study/design_pattern/FactoryMethod/concreteProductA.java new file mode 100644 index 0000000..92950b0 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/FactoryMethod/concreteProductA.java @@ -0,0 +1,12 @@ +package com.mine.study.design_pattern.FactoryMethod; + +/** + * @author:Sun Hongwei + * @2020/3/13 下午10:01 + * File Description：具体产品A：实现抽象产品中的抽象方法 + */ +public class concreteProductA implements Product { + public void show(){ + System.out.println("具体产品A:-______-"); + } +} diff --git a/src/main/java/com/mine/study/design_pattern/FactoryMethod/concreteProductB.java b/src/main/java/com/mine/study/design_pattern/FactoryMethod/concreteProductB.java new file mode 100644 index 0000000..30ef14f --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/FactoryMethod/concreteProductB.java @@ -0,0 +1,12 @@ +package com.mine.study.design_pattern.FactoryMethod; + +/** + * @author:Sun Hongwei + * @2020/3/13 下午10:02 + * File Description：具体产品B：实现抽象产品中的抽象方法 + */ +public class concreteProductB implements Product{ + public void show(){ + System.out.println("具体产品B:-______-"); + } +} diff --git a/src/main/java/com/mine/study/design_pattern/Observer/ConcreteObserver1.java b/src/main/java/com/mine/study/design_pattern/Observer/ConcreteObserver1.java new file mode 100644 index 0000000..1d66bb7 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Observer/ConcreteObserver1.java @@ -0,0 +1,12 @@ +package com.mine.study.design_pattern.Observer; + +/** + * @author:Sun Hongwei + * @2020/3/11 下午5:44 + * File Description：具体观察者1 + */ +public class ConcreteObserver1 implements Observer{ + public void response(){ + System.out.println("观察者1做出回应！—————————————>"); + } +} diff --git a/src/main/java/com/mine/study/design_pattern/Observer/ConcreteObserver2.java b/src/main/java/com/mine/study/design_pattern/Observer/ConcreteObserver2.java new file mode 100644 index 0000000..920ac93 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Observer/ConcreteObserver2.java @@ -0,0 +1,12 @@ +package com.mine.study.design_pattern.Observer; + +/** + * @author:Sun Hongwei + * @2020/3/11 下午5:46 + * File Description：具体观察者2 + */ +public class ConcreteObserver2 implements Observer{ + public void response(){ + System.out.println("观察者2做出回应！—————————————>"); + } +} diff --git a/src/main/java/com/mine/study/design_pattern/Observer/ConcreteSubject.java b/src/main/java/com/mine/study/design_pattern/Observer/ConcreteSubject.java new file mode 100644 index 0000000..9a22f8d --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Observer/ConcreteSubject.java @@ -0,0 +1,20 @@ +package com.mine.study.design_pattern.Observer; + +/** + * @author:Sun Hongwei + * @2020/3/11 下午6:00 + * File Description：具体目标 + */ +public class ConcreteSubject extends Subject{ + + @Override + public void notifyObserver(){ + System.out.println("具体的目标——————————————"); + for(Object obs:observers){ + ((Observer)obs).response(); + } + + } + + +} diff --git a/src/main/java/com/mine/study/design_pattern/Observer/Observer b/src/main/java/com/mine/study/design_pattern/Observer/Observer new file mode 100644 index 0000000..f2ea603 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Observer/Observer @@ -0,0 +1,22 @@ +观察者模式：Observer + +多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。 +这种模式有时又称作发布-订阅模式、模型-视图模式，它是对象行为型模式。 + +主要优点: +1.降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系。 +2.目标与观察者之间建立了一套触发机制。 + +主要缺点: +1.目标与观察者之间的依赖关系并没有完全解除，而且有可能出现循环引用。 +2.当观察者对象很多时，通知的发布会花费很多时间，影响程序的效率。 + +模式的结构： +抽象主题（Subject）角色：也叫抽象目标类，它提供了一个用于保存观察者对象的聚集类和增加、删除观察者对象的方法，以及通知所有观察者的抽象方法。 +具体主题（Concrete Subject）角色：也叫具体目标类，它实现抽象目标中的通知方法，当具体主题的内部状态发生改变时，通知所有注册过的观察者对象。 +抽象观察者（Observer）角色：它是一个抽象类或接口，它包含了一个更新自己的抽象方法，当接到具体主题的更改通知时被调用。 +具体观察者（Concrete Observer）角色：实现抽象观察者中定义的抽象方法，以便在得到目标的更改通知时更新自身的状态。 + +应用场景： +1.对象间存在一对多关系，一个对象的状态发生改变会影响其他对象。 +2.当一个抽象模型有两个方面，其中一个方面依赖于另一方面时，可将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。 \ No newline at end of file diff --git a/src/main/java/com/mine/study/design_pattern/Observer/Observer.java b/src/main/java/com/mine/study/design_pattern/Observer/Observer.java new file mode 100644 index 0000000..939608e --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Observer/Observer.java @@ -0,0 +1,10 @@ +package com.mine.study.design_pattern.Observer; + +/** + * @author:Sun Hongwei + * @2020/3/11 下午5:32 + * File Description：抽象观察者 + */ +public interface Observer { + void response(); +} diff --git a/src/main/java/com/mine/study/design_pattern/Observer/ObserverDemo/Bear.java b/src/main/java/com/mine/study/design_pattern/Observer/ObserverDemo/Bear.java new file mode 100644 index 0000000..4712887 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Observer/ObserverDemo/Bear.java @@ -0,0 +1,24 @@ +package com.mine.study.design_pattern.Observer.ObserverDemo; + +import java.util.Observer; +import java.util.Observable; + +/** + * @author:Sun Hongwei + * @2020/3/13 下午7:43 + * File Description：具体观察者类：空方 + */ +public class Bear implements Observer { + public void update(Observable o, Object arg){ + Float price=((Float)arg).floatValue(); + if(price>0){ + System.out.println("空方发现： oil上涨"+price+"元! "); + }else{ + System.out.println("空方发现： oil下跌"+(-price)+"元! "); + } + } + + public void response(){ + System.out.println("response"); + } +} diff --git a/src/main/java/com/mine/study/design_pattern/Observer/ObserverDemo/Bull.java b/src/main/java/com/mine/study/design_pattern/Observer/ObserverDemo/Bull.java new file mode 100644 index 0000000..b39eb2b --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Observer/ObserverDemo/Bull.java @@ -0,0 +1,25 @@ +package com.mine.study.design_pattern.Observer.ObserverDemo; + +import java.util.Observer; +import java.util.Observable; + + +/** + * @author:Sun Hongwei + * @2020/3/13 下午7:23 + * File Description：具体观察者：多方 + */ +public class Bull implements Observer { + public void update(Observable o, Object arg){ + Float price=((Float)arg).floatValue(); + if(price>0){ + System.out.println("多方发现： oil上涨"+price+"元! "); + }else{ + System.out.println("多方发现： oil下跌"+(-price)+"元! "); + } + } + + public void response(){ + System.out.println("response"); + } +} diff --git a/src/main/java/com/mine/study/design_pattern/Observer/ObserverDemo/OilFuture.java b/src/main/java/com/mine/study/design_pattern/Observer/ObserverDemo/OilFuture.java new file mode 100644 index 0000000..2a5fb35 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Observer/ObserverDemo/OilFuture.java @@ -0,0 +1,31 @@ +package com.mine.study.design_pattern.Observer.ObserverDemo; + +import java.util.ArrayList; +import java.util.List; +import java.util.Observable; +import java.util.Observer; + + +/** + * @author:Sun Hongwei + * @2020/3/13 下午7:17 + * File Description：具体目标：OilFuture原油期货 + */ +public class OilFuture extends Observable { + private float price; + public float getPrice(){ + return this.price; + } + public void setPrice(float price){ + super.setChanged(); //设置内部标志位，注明数据发生变化 + super.notifyObservers(price); //通知观察者价格改变了 + this.price=price; + } + + protected List observers=new ArrayList(); + //增加观察者 + public void add(Observer observer){ + observers.add(observer); + } + +} diff --git a/src/main/java/com/mine/study/design_pattern/Observer/ObserverDemo/Tests.java b/src/main/java/com/mine/study/design_pattern/Observer/ObserverDemo/Tests.java new file mode 100644 index 0000000..1ef32ba --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Observer/ObserverDemo/Tests.java @@ -0,0 +1,23 @@ +package com.mine.study.design_pattern.Observer.ObserverDemo; + +import java.util.Observer; +import java.util.Observable; + +/** + * @author:Sun Hongwei + * @2020/3/13 下午7:27 + * File Description：Observer测试类 + */ +public class Tests { + public static void main(String[] args) { + OilFuture oilFuture=new OilFuture(); + Observer bull=new Bull(); //多方 + Observer bear=new Bear(); //空方 + + oilFuture.addObserver(bull); + oilFuture.addObserver(bear); + oilFuture.setPrice(10); + oilFuture.setPrice(-3); + + } +} diff --git a/src/main/java/com/mine/study/design_pattern/Observer/ObserverTest.java b/src/main/java/com/mine/study/design_pattern/Observer/ObserverTest.java new file mode 100644 index 0000000..2ecbc1b --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Observer/ObserverTest.java @@ -0,0 +1,17 @@ +package com.mine.study.design_pattern.Observer; + +/** + * @author:Sun Hongwei + * @2020/3/11 下午5:47 + * File Description：Observer测试类 + */ +public class ObserverTest { + public static void main(String[] args) { + Subject subject=new ConcreteSubject(); + Observer obs1=new ConcreteObserver1(); + Observer obs2=new ConcreteObserver2(); + subject.add(obs1); + subject.add(obs2); + subject.notifyObserver(); + } +} diff --git a/src/main/java/com/mine/study/design_pattern/Observer/Observer_UML.png b/src/main/java/com/mine/study/design_pattern/Observer/Observer_UML.png new file mode 100644 index 0000000..1bd781b Binary files /dev/null and b/src/main/java/com/mine/study/design_pattern/Observer/Observer_UML.png differ diff --git a/src/main/java/com/mine/study/design_pattern/Observer/Subject.java b/src/main/java/com/mine/study/design_pattern/Observer/Subject.java new file mode 100644 index 0000000..0a4952d --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Observer/Subject.java @@ -0,0 +1,27 @@ +package com.mine.study.design_pattern.Observer; + +import java.util.ArrayList; +import java.util.List; + +/** + * @author:Sun Hongwei + * @2020/3/11 下午5:42 + * File Description：抽象目标 + */ +abstract class Subject { + protected List observers=new ArrayList(); + + //增加观察者 + public void add(Observer observer){ + observers.add(observer); + } + + //删除观察者 + public void delete(Observer observer){ + observers.remove(observer); + } + + //通知观察者 + public abstract void notifyObserver(); + +} diff --git a/src/main/java/com/mine/study/design_pattern/Prototype/Prototype b/src/main/java/com/mine/study/design_pattern/Prototype/Prototype new file mode 100644 index 0000000..e375898 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Prototype/Prototype @@ -0,0 +1,17 @@ +原型模式：Prototype +用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。 +在这里，原型实例指定了要创建的对象的种类。用这种方式创建对象非常高效，根本无须知道对象创建的细节。 + +原型模式包含以下主要角色: + +抽象原型类：规定了具体原型对象必须实现的接口。 +具体原型类：实现抽象原型类的 clone() 方法，它是可被复制的对象。 +访问类：使用具体原型类中的 clone() 方法来复制新的对象。 + + +原型模式通常适用于以下场景: +1.对象之间相同或相似，即只是个别的几个属性不同的时候。 +2.对象的创建过程比较麻烦，但复制比较简单的时候。 + + + diff --git a/src/main/java/com/mine/study/design_pattern/Prototype/PrototypeTest.java b/src/main/java/com/mine/study/design_pattern/Prototype/PrototypeTest.java new file mode 100644 index 0000000..9176d80 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Prototype/PrototypeTest.java @@ -0,0 +1,15 @@ +package com.mine.study.design_pattern.Prototype; + +/** + * @author:Sun Hongwei + * @2020/3/13 下午11:48 + * File Description：原型模式的测试类 + */ +public class PrototypeTest { + public static void main(String[] args) throws CloneNotSupportedException{ + Realizetype obj1=new Realizetype(); + Realizetype obj2=(Realizetype)obj1.clone(); + System.out.println("obj1==obj2? "+(obj1==obj2)); + + } +} diff --git a/src/main/java/com/mine/study/design_pattern/Prototype/Prototype_UML.png b/src/main/java/com/mine/study/design_pattern/Prototype/Prototype_UML.png new file mode 100644 index 0000000..7f0ad2d Binary files /dev/null and b/src/main/java/com/mine/study/design_pattern/Prototype/Prototype_UML.png differ diff --git a/src/main/java/com/mine/study/design_pattern/Prototype/Realizetype.java b/src/main/java/com/mine/study/design_pattern/Prototype/Realizetype.java new file mode 100644 index 0000000..b2d2423 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Prototype/Realizetype.java @@ -0,0 +1,16 @@ +package com.mine.study.design_pattern.Prototype; + +/** + * @author:Sun Hongwei + * @2020/3/13 下午11:46 + * File Description：具体原型类 + */ +public class Realizetype implements Cloneable{ + Realizetype(){ + System.out.println("具体原型创建成功"); + } + public Object clone() throws CloneNotSupportedException{ + System.out.println("具体原型复制成功"); + return (Realizetype)super.clone(); + } +} diff --git a/src/main/java/com/mine/study/design_pattern/Proxy/Proxy b/src/main/java/com/mine/study/design_pattern/Proxy/Proxy new file mode 100644 index 0000000..3de2e22 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Proxy/Proxy @@ -0,0 +1,17 @@ +代理模式：Proxy + +通过定义一个继承抽象主题的代理来包含真实主题，从而实现对真实主题的访问。 + +由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象， +代理对象作为访问对象和目标对象之间的中介。 + + +模式结构： +抽象主题（Subject）类：通过接口或抽象类声明真实主题和代理对象实现的业务方法。 +真实主题（Real Subject）类：实现了抽象主题中的具体业务，是代理对象所代表的真实对象，是最终要引用的对象。 +代理（Proxy）类：提供了与真实主题相同的接口，其内部含有对真实主题的引用，它可以访问、控制或扩展真实主题的功能。 + +优点： +1.代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用； +2.代理对象可以扩展目标对象的功能； +3.代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度； \ No newline at end of file diff --git a/src/main/java/com/mine/study/design_pattern/Proxy/Proxy.java b/src/main/java/com/mine/study/design_pattern/Proxy/Proxy.java new file mode 100644 index 0000000..4788bad --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Proxy/Proxy.java @@ -0,0 +1,26 @@ +package com.mine.study.design_pattern.Proxy; + +/** + * @author:Sun Hongwei + * @2020/3/11 下午3:04 + * File Description：代理 + */ +public class Proxy implements Subject{ + private RealSubject realSubject; + + public void request(){ + if (realSubject == null) { + realSubject=new RealSubject(); + } + preRequest(); + realSubject.request(); + postRequest(); + } + + public void preRequest(){ + System.out.println("访问前处理----"); + } + public void postRequest(){ + System.out.println("访问后处理----"); + } +} diff --git a/src/main/java/com/mine/study/design_pattern/Proxy/ProxyTest.java b/src/main/java/com/mine/study/design_pattern/Proxy/ProxyTest.java new file mode 100644 index 0000000..c00e9e2 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Proxy/ProxyTest.java @@ -0,0 +1,14 @@ +package com.mine.study.design_pattern.Proxy; + +/** + * @author:Sun Hongwei + * @2020/3/11 下午2:49 + * File Description：Proxy测试 + */ +public class ProxyTest { + public static void main(String[] args) { + Proxy proxy=new Proxy(); + proxy.request(); + } + +} diff --git a/src/main/java/com/mine/study/design_pattern/Proxy/Proxy_UML.png b/src/main/java/com/mine/study/design_pattern/Proxy/Proxy_UML.png new file mode 100644 index 0000000..35c30a3 Binary files /dev/null and b/src/main/java/com/mine/study/design_pattern/Proxy/Proxy_UML.png differ diff --git a/src/main/java/com/mine/study/design_pattern/Proxy/RealSubject.java b/src/main/java/com/mine/study/design_pattern/Proxy/RealSubject.java new file mode 100644 index 0000000..a088247 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Proxy/RealSubject.java @@ -0,0 +1,12 @@ +package com.mine.study.design_pattern.Proxy; + +/** + * @author:Sun Hongwei + * @2020/3/11 下午2:49 + * File Description：真实主题 + */ +public class RealSubject implements Subject{ + public void request(){ + System.out.println("访问真实主题"); + } +} diff --git a/src/main/java/com/mine/study/design_pattern/Proxy/Subject.java b/src/main/java/com/mine/study/design_pattern/Proxy/Subject.java new file mode 100644 index 0000000..bacd4b0 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Proxy/Subject.java @@ -0,0 +1,10 @@ +package com.mine.study.design_pattern.Proxy; + +/** + * @author:Sun Hongwei + * @2020/3/11 下午2:58 + * File Description：抽象主题 + */ +public interface Subject { + void request(); +} diff --git a/src/main/java/com/mine/study/design_pattern/Singleton/HungrySingleton.java b/src/main/java/com/mine/study/design_pattern/Singleton/HungrySingleton.java new file mode 100644 index 0000000..f922229 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Singleton/HungrySingleton.java @@ -0,0 +1,14 @@ +package com.mine.study.design_pattern.Singleton; + +/** + * @author:Sun Hongwei + * @2020/3/11 下午2:13 + * File Description：饿汉式单例：类一旦加载的时候，就创建一个单例 + */ +public class HungrySingleton { + private static final HungrySingleton instance=new HungrySingleton(); + private HungrySingleton(){}; + public static HungrySingleton getInstance(){ + return instance; + } +} diff --git a/src/main/java/com/mine/study/design_pattern/Singleton/LazySingleton.java b/src/main/java/com/mine/study/design_pattern/Singleton/LazySingleton.java new file mode 100644 index 0000000..bb4c0b8 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Singleton/LazySingleton.java @@ -0,0 +1,20 @@ +package com.mine.study.design_pattern.Singleton; + +/** + * @author:Sun Hongwei + * @2020/3/11 下午2:02 + * File Description：懒汉式单例模式：类加载时不会生成单例，只有第一次getInstance时会创建这个单例 + */ +public class LazySingleton { + //保证instance在所有线程同步 + private static volatile LazySingleton instance=null; + private LazySingleton(){} //避免类在外部实例化 + + public static synchronized LazySingleton getInstance() { + if(instance==null){ + instance=new LazySingleton(); + } + return instance; + } + +} diff --git a/src/main/java/com/mine/study/design_pattern/Singleton/Singleton b/src/main/java/com/mine/study/design_pattern/Singleton/Singleton new file mode 100644 index 0000000..7390a09 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Singleton/Singleton @@ -0,0 +1,14 @@ +单例模式：Singleton + +为了节省内存资源、保证数据内容的一致性，对某些类要求只能创建一个实例,且该类能自行创建这个实例的一种模式。 + +在计算机系统中，还有 Windows 的回收站、操作系统中的文件系统、多线程中的线程池、 +显卡的驱动程序对象、打印机的后台处理服务、应用程序的日志对象、数据库的连接池、网站的计数器、 +Web 应用的配置对象、应用程序中的对话框、系统中的缓存等常常被设计成单例。 + + + +应用场景： + 1.某类只要求生成一个对象时，比如身份证号 + 2.当对象需要被共享的场合。可以节省内存，加快对象访问速度。如Web配置对象，数据库连接池等 + 3.当某类需要频繁实例化，并且创建对象又频繁被销毁的时候，如多线程的线程池，网络连接池等 \ No newline at end of file diff --git a/src/main/java/com/mine/study/design_pattern/Singleton/SingletonDemo.java b/src/main/java/com/mine/study/design_pattern/Singleton/SingletonDemo.java new file mode 100644 index 0000000..b24fe26 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Singleton/SingletonDemo.java @@ -0,0 +1,47 @@ +package com.mine.study.design_pattern.Singleton; + + +/** + * @author:Sun Hongwei + * @2020/3/11 下午2:22 + * File Description：只能创建一个SHW + */ +public class SingletonDemo { + public static class Sunhongwei{ + private static volatile Sunhongwei instance=null; + + private Sunhongwei() { + System.out.println("生产一个Sun Hongwei"); + } + + public static synchronized Sunhongwei getInstance(){ + //同步 + if(instance==null){ + instance=new Sunhongwei(); + }else{ + System.out.println("已经有Sun Hongwei了，不能再生产了"); + } + return instance; + } + + public void getName(){ + System.out.println("我是 Sun Hongwei!!!"); + } + } + public static void main(String[] args) { + Sunhongwei shw1=Sunhongwei.getInstance(); + shw1.getName(); + Sunhongwei shw2=Sunhongwei.getInstance(); + shw2.getName(); + + //判断是否是同一个对象 + if(shw1==shw2){ + System.out.println("他们是同一个Sun Hongwei"); + }else { + System.out.println("他们不是用一个Sun Hongwei!!!"); + } + } + +} + + diff --git a/src/main/java/com/mine/study/design_pattern/Singleton/Singleton_UML.png b/src/main/java/com/mine/study/design_pattern/Singleton/Singleton_UML.png new file mode 100644 index 0000000..4608e5d Binary files /dev/null and b/src/main/java/com/mine/study/design_pattern/Singleton/Singleton_UML.png differ diff --git a/src/main/java/com/mine/study/design_pattern/Strategy/ConcreteStrategyA.java b/src/main/java/com/mine/study/design_pattern/Strategy/ConcreteStrategyA.java new file mode 100644 index 0000000..452e7ea --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Strategy/ConcreteStrategyA.java @@ -0,0 +1,12 @@ +package com.mine.study.design_pattern.Strategy; + +/** + * @author:Sun Hongwei + * @2020/3/15 下午3:04 + * File Description：具体策略类A + */ +public class ConcreteStrategyA implements Strategy{ + public void strategyMethod(){ + System.out.println("具体策略A的策略方法被访问！"); + } +} diff --git a/src/main/java/com/mine/study/design_pattern/Strategy/ConcreteStrategyB.java b/src/main/java/com/mine/study/design_pattern/Strategy/ConcreteStrategyB.java new file mode 100644 index 0000000..00de03c --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Strategy/ConcreteStrategyB.java @@ -0,0 +1,13 @@ +package com.mine.study.design_pattern.Strategy; + +/** + * @author:Sun Hongwei + * @2020/3/15 下午3:07 + * File Description：具体策略类B + */ +public class ConcreteStrategyB implements Strategy { + public void strategyMethod(){ + System.out.println("具体策略B的策略方法被访问！"); + } + +} diff --git a/src/main/java/com/mine/study/design_pattern/Strategy/Context.java b/src/main/java/com/mine/study/design_pattern/Strategy/Context.java new file mode 100644 index 0000000..d537ce4 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Strategy/Context.java @@ -0,0 +1,19 @@ +package com.mine.study.design_pattern.Strategy; + +/** + * @author:Sun Hongwei + * @2020/3/15 下午3:26 + * File Description：环境类 + */ +public class Context { + private Strategy strategy; + public Strategy getStrategy(){ + return strategy; + } + public void setStrategy(Strategy strategy){ + this.strategy=strategy; + } + public void strategyMethod(){ + strategy.strategyMethod(); + } +} diff --git a/src/main/java/com/mine/study/design_pattern/Strategy/Strategy b/src/main/java/com/mine/study/design_pattern/Strategy/Strategy new file mode 100644 index 0000000..5140b2f --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Strategy/Strategy @@ -0,0 +1,29 @@ +策略模式：Strategy + +该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。 +策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进行管理。 + + +主要优点如下: +1.多重条件语句不易维护，而使用策略模式可以避免使用多重条件语句。 +2.策略模式提供了一系列的可供重用的算法族，恰当使用继承可以把算法族的公共代码转移到父类里面，从而避免重复的代码。 +3.策略模式可以提供相同行为的不同实现，客户可以根据不同时间或空间要求选择不同的。 +4.策略模式提供了对开闭原则的完美支持，可以在不修改原代码的情况下，灵活增加新算法。 +5.策略模式把算法的使用放到环境类中，而算法的实现移到具体策略类中，实现了二者的分离。 + +主要缺点如下: +1.客户端必须理解所有策略算法的区别，以便适时选择恰当的算法类。 +2.策略模式造成很多的策略类。 + + +策略模式的主要角色如下。 +1.抽象策略（Strategy）类：定义了一个公共接口，各种不同的算法以不同的方式实现这个接口，环境角色使用这个接口调用不同的算法，一般使用接口或抽象类实现。 +2.具体策略（Concrete Strategy）类：实现了抽象策略定义的接口，提供具体的算法实现。 +3.环境（Context）类：持有一个策略类的引用，最终给客户端调用。 + +具体应用场景： +1.一个系统需要动态地在几种算法中选择一种时，可将每个算法封装到策略类中。 +2.一个类定义了多种行为，并且这些行为在这个类的操作中以多个条件语句的形式出现，可将每个条件分支移入它们各自的策略类中以代替这些条件语句。 +3.系统中各算法彼此完全独立，且要求对客户隐藏具体算法的实现细节时。 +4.系统要求使用算法的客户不应该知道其操作的数据时，可使用策略模式来隐藏与算法相关的数据结构。 +5.多个类只区别在表现行为不同，可以使用策略模式，在运行时动态选择具体要执行的行为。 diff --git a/src/main/java/com/mine/study/design_pattern/Strategy/Strategy.java b/src/main/java/com/mine/study/design_pattern/Strategy/Strategy.java new file mode 100644 index 0000000..d18823b --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Strategy/Strategy.java @@ -0,0 +1,10 @@ +package com.mine.study.design_pattern.Strategy; + +/** + * @author:Sun Hongwei + * @2020/3/15 下午3:02 + * File Description：抽象策略类 + */ +public interface Strategy { + public void strategyMethod(); +} diff --git a/src/main/java/com/mine/study/design_pattern/Strategy/StrategyTest.java b/src/main/java/com/mine/study/design_pattern/Strategy/StrategyTest.java new file mode 100644 index 0000000..3f00e84 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/Strategy/StrategyTest.java @@ -0,0 +1,21 @@ +package com.mine.study.design_pattern.Strategy; + +/** + * @author:Sun Hongwei + * @2020/3/15 下午3:37 + * File Description： + */ +public class StrategyTest { + public static void main(String[] args) { + Context context=new Context(); + Strategy strategyA=new ConcreteStrategyA(); + context.setStrategy(strategyA); + context.strategyMethod(); + System.out.println("-------------------"); + + Strategy strategyB=new ConcreteStrategyB(); + context.setStrategy(strategyB); + context.strategyMethod(); + } + +} diff --git a/src/main/java/com/mine/study/design_pattern/Strategy/Strategy_UML.png b/src/main/java/com/mine/study/design_pattern/Strategy/Strategy_UML.png new file mode 100644 index 0000000..d37f198 Binary files /dev/null and b/src/main/java/com/mine/study/design_pattern/Strategy/Strategy_UML.png differ diff --git a/src/main/java/com/mine/study/design_pattern/TemplateMethod/AbstractClass.java b/src/main/java/com/mine/study/design_pattern/TemplateMethod/AbstractClass.java new file mode 100644 index 0000000..15d995a --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/TemplateMethod/AbstractClass.java @@ -0,0 +1,21 @@ +package com.mine.study.design_pattern.TemplateMethod; + +/** + * @author:Sun Hongwei + * @2020/3/15 下午2:42 + * File Description：抽象类 + */ +public abstract class AbstractClass { + public void templateMethod(){ // 模板方法 + SpecialMethod(); + abstractMethod1(); + abstractMethod2(); + } + + public void SpecialMethod(){ + System.out.println("抽象类的具体方法被调用"); + } + + public abstract void abstractMethod1(); //抽象方法1 + public abstract void abstractMethod2(); //抽象方法2 +} diff --git a/src/main/java/com/mine/study/design_pattern/TemplateMethod/ConcreteClass.java b/src/main/java/com/mine/study/design_pattern/TemplateMethod/ConcreteClass.java new file mode 100644 index 0000000..44451f6 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/TemplateMethod/ConcreteClass.java @@ -0,0 +1,16 @@ +package com.mine.study.design_pattern.TemplateMethod; + +/** + * @author:Sun Hongwei + * @2020/3/15 下午2:46 + * File Description：具体子类 + */ +public class ConcreteClass extends AbstractClass{ + public void abstractMethod1(){ + System.out.println("抽象方法1的实现被调用..."); + } + public void abstractMethod2(){ + System.out.println("抽象方法2的实现被调用..."); + } + +} diff --git a/src/main/java/com/mine/study/design_pattern/TemplateMethod/TemplateMethod b/src/main/java/com/mine/study/design_pattern/TemplateMethod/TemplateMethod new file mode 100644 index 0000000..139b4a9 --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/TemplateMethod/TemplateMethod @@ -0,0 +1,35 @@ +模板方法模式：TemplateMethod + +定义一个操作中的算法骨架，而将算法的一些步骤延迟到子类中，使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。 +它是一种类行为型模式。 + +主要优点如下: +1.它封装了不变部分，扩展可变部分。它把认为是不变部分的算法封装到父类中实现，而把可变部分算法由子类继承实现，便于子类继续扩展。 +2.它在父类中提取了公共的部分代码，便于代码复用。 +3.部分方法是由子类实现的，因此子类可以通过扩展方式增加相应的功能，符合开闭原则。 + +该模式的主要缺点如下: +1.对每个不同的实现都需要定义一个子类，这会导致类的个数增加，系统更加庞大，设计也更加抽象。 +2.父类中的抽象方法由子类实现，子类执行的结果会影响父类的结果，这导致一种反向的控制结构，它提高了代码阅读的难度。 + + +模板方法模式包含以下主要角色。 + +(1) 抽象类（Abstract Class）：负责给出一个算法的轮廓和骨架。它由一个模板方法和若干个基本方法构成。这些方法的定义如下。 + +① 模板方法：定义了算法的骨架，按某种顺序调用其包含的基本方法。 + +② 基本方法：是整个算法中的一个步骤，包含以下几种类型。 +抽象方法：在抽象类中申明，由具体子类实现。 +具体方法：在抽象类中已经实现，在具体子类中可以继承或重写它。 +钩子方法：在抽象类中已经实现，包括用于判断的逻辑方法和需要子类重写的空方法两种。 + +(2) 具体子类（Concrete Class）：实现抽象类中所定义的抽象方法和钩子方法，它们是一个顶级逻辑的一个组成步骤 + + +模板方法模式通常适用于以下场景: +1.算法的整体步骤很固定，但其中个别部分易变时，这时候可以使用模板方法模式，将容易变的部分抽象出来，供子类实现。 +2.当多个子类存在公共的行为时，可以将其提取出来并集中到一个公共父类中以避免代码重复。首先，要识别现有代码中的不同之处，并且将不同之处分离为新的操作。最后，用一个调用这些新的操作的模板方法来替换这些不同的代码。 +3.当需要控制子类的扩展时，模板方法只在特定点调用钩子操作，这样就只允许在这些点进行扩展。 + + diff --git a/src/main/java/com/mine/study/design_pattern/TemplateMethod/TemplateMethodTest.java b/src/main/java/com/mine/study/design_pattern/TemplateMethod/TemplateMethodTest.java new file mode 100644 index 0000000..166285e --- /dev/null +++ b/src/main/java/com/mine/study/design_pattern/TemplateMethod/TemplateMethodTest.java @@ -0,0 +1,13 @@ +package com.mine.study.design_pattern.TemplateMethod; + +/** + * @author:Sun Hongwei + * @2020/3/15 下午2:49 + * File Description：模板方法测试类 + */ +public class TemplateMethodTest { + public static void main(String[] args) { + AbstractClass tm=new ConcreteClass(); + tm.templateMethod(); + } +} diff --git a/src/main/java/com/mine/study/design_pattern/TemplateMethod/TemplateMethod_UML.png b/src/main/java/com/mine/study/design_pattern/TemplateMethod/TemplateMethod_UML.png new file mode 100644 index 0000000..dbe81ea Binary files /dev/null and b/src/main/java/com/mine/study/design_pattern/TemplateMethod/TemplateMethod_UML.png differ diff --git a/src/main/java/com/mine/study/easy/L13.java b/src/main/java/com/mine/study/easy/L13.java new file mode 100644 index 0000000..33ef9bb --- /dev/null +++ b/src/main/java/com/mine/study/easy/L13.java @@ -0,0 +1,133 @@ +package com.mine.study.easy; + +import java.util.HashMap; +import java.util.Map; + +/** + * #### 13. 罗马数字转整数 + *

+ * 罗马数字包含以下七种字符:`I`，`V`，`X`，`L`，`C`，`D`和`M`。 + *

+ * ``` + * 字符 数值 + * I 1 + * V 5 + * X 10 + * L 50 + * C 100 + * D 500 + * M 1000 + * ``` + *

+ * 例如， 罗马数字 2 写做`II`，即为两个并列的 1。12 写做XII，即为`X`+`II`。 27 写做`XXVII`, 即为`XX`+`V`+`II`。 + *

+ * 通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例， + * 例如 4 不写做`IIII`，而是`IV`。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为`IX`。这个特殊的规则只适用于以下六种情况： + *

+ * - `I`可以放在`V`(5) 和`X`(10) 的左边，来表示 4 和 9。 + * - `X`可以放在`L`(50) 和`C`(100) 的左边，来表示 40 和90。 + * - `C`可以放在`D`(500) 和`M`(1000) 的左边，来表示400 和900。 + *

+ * 给定一个罗马数字，将其转换成整数。输入确保在 1到 3999 的范围内。 + *

+ * **示例1:** + *

+ * ``` + * 输入:"III" + * 输出: 3 + * ``` + *

+ * **示例2:** + *

+ * ``` + * 输入:"IV" + * 输出: 4 + * ``` + *

+ * **示例3:** + *

+ * ``` + * 输入:"IX" + * 输出: 9 + * ``` + *

+ * **示例4:** + *

+ * ``` + * 输入:"LVIII" + * 输出: 58 + * 解释: L = 50, V= 5, III = 3. + * ``` + *

+ * **示例5:** + *

+ * ``` + * 输入:"MCMXCIV" + * 输出: 1994 + * 解释: M = 1000, CM = 900, XC = 90, IV = 4. + * ``` + */ +public class L13 { + // 解法1：使用Map + public int romanToInt(String s) { + Map map = new HashMap<>(); + map.put('I', 1); + map.put('V', 5); + map.put('X', 10); + map.put('L', 50); + map.put('C', 100); + map.put('D', 500); + map.put('M', 1000); + + int ret = 0; + int preNum = map.get(s.charAt(0)); + for (int i = 1, length = s.length(); i < length; i++) { + int num = map.get(s.charAt(i)); + if (preNum < num) { // 左边的数字小于右边的数字 + ret = -preNum; + } else { // 左边的数字大于等于右边的数字 + ret += preNum; + } + preNum = num; + } + return ret; + } + + // 解法2 + public int romanToInt2(String s) { + int ret = 0; + int preNum = getValue(s.charAt(0)); + + for (int i = 1, length = s.length(); i < length; i++) { + int num = getValue(s.charAt(i)); + if (preNum < num) { // 左边的数字小于右边的数字 + ret = -preNum; + } else { // 左边的数字大于等于右边的数字 + ret += preNum; + } + preNum = num; + } + return ret; + } + + private int getValue(char ch) { + switch (ch) { + case 'I': + return 1; + case 'V': + return 5; + case 'X': + return 10; + case 'L': + return 50; + case 'C': + return 100; + case 'D': + return 500; + case 'M': + return 1000; + default: + return 0; + } + } +} diff --git a/src/main/java/com/mine/study/easy/L14.java b/src/main/java/com/mine/study/easy/L14.java new file mode 100644 index 0000000..cfdad62 --- /dev/null +++ b/src/main/java/com/mine/study/easy/L14.java @@ -0,0 +1,29 @@ +package com.mine.study.easy; + +/** + *

最长公共前缀
+ * + *

编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串 ""。

+ * + * 
+ * Input: ["flower","flow","flight"]；Output: "fl"
+ * Input: ["dog","racecar","car"]；Output: ""；Explanation: 输入不存在公共前缀。
+ *
+ */ +public class L14 { + + public String longestCommonPrefix(String[] strs) { + if ((strs == null) || (strs.length == 0)) { + return ""; + } + for (int i = 0, length = strs[0].length(); i < length; i++) { + char currentChar = strs[0].charAt(i); + for (int j = 1, len = strs.length; j < len; j++) { // 比较每个字符串相应位置上的值 + if ((strs[j].length() == i) || (currentChar != strs[j].charAt(i))) { + return strs[0].substring(0, i); + } + } + } + return strs[0]; + } +} diff --git a/src/main/java/com/mine/study/easy/L9.java b/src/main/java/com/mine/study/easy/L9.java new file mode 100644 index 0000000..9e48048 --- /dev/null +++ b/src/main/java/com/mine/study/easy/L9.java @@ -0,0 +1,122 @@ +package com.mine.study.easy; + +/** + *

Palindrome Number

+ *

回文数

+ * + * Determine whether an integer is a palindrome. + * An integer is a palindrome when it reads the same backward as forward. + * 判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。 + * + * Examples: + * + * Input: 121 Output: true + * + * Input: -121 Output: false + * Explanation: From left to right, it reads -121. From right to left, it becomes 121-. + * Therefore it is not a palindrome. + * + * Input: 10 Output: false + * Explanation: Reads 01 from right to left. Therefore it is not a palindrome. + */ +public class L9 { + + /** + * desc:使用字符串反转后的值与原先的字符串进行比较（不推荐） + * + * @param x + * @return boolean + */ + @Deprecated + public boolean isPalindrome1(int x) { + String origin = String.valueOf(x); + String result = new StringBuilder(origin).reverse().toString(); + return result.equals(origin); + } + + /** + * desc:转为字符数组使用双指针法 + * + * @param x + * @return boolean + */ + public boolean isPalindrome2(int x) { + // 将整数转为字符数组 + char[] charArray = String.valueOf(x).toCharArray(); + // 左指针 + int left = 0; + // 右指针 + int right = charArray.length - 1; + // 遍历字符串 + while (left < right) { + // 当左指针和右指针指向的字符不同时，返回false + if (charArray[left] != charArray[right]) { + return false; + } + left++; + right--; + } + return true; + } + + /** + * desc:使用整数反转的方式 + * + * @param x + * @return boolean + */ + public boolean isPalindrome3(int x) { + if (x < 0) { + return false; + } + long origin = x; + // 反转后结果，考虑会溢出 + long reverseNum = 0; + while (x != 0) { + reverseNum = reverseNum * 10 + x % 10; + x /= 10; + } + return origin == reverseNum; + } + + /** + * desc:求出左半部分和右半部分的数字进行比较 + * + * 负数和个位数上为0的非0数字不是回文数，其余数字要判断左半部分和右半部分是否相等。 + * (1)整数位数为偶数个： + * |------|--------|------------------|----------| + * | 数字 | 个位数 | 翻转后得到的数字 | 剩余数字 | + * | 1221 | 1 | 0*10+1=1 | 122 | + * | 122 | 2 | 1*10+2=12 | 12 | + * |------|--------|------------------|----------| + * 剩余数字和翻转数字相等，退出翻转，为回文数。 + * (2)整数位数为奇数个： + * |-------|--------|------------------|----------| + * | 数字 | 个位数 | 翻转后得到的数字 | 剩余数字 | + * | 12321 | 1 | 0*10+1=1 | 1232 | + * | 1232 | 2 | 1*10+2=12 | 123 | + * | 123 | 3 | 12*10+3=123 | 12 | + * |-------|--------|------------------|----------| + * 剩余数字小于翻转数字，退出翻转。因为3为中心数，去掉3，两边相等，为回文数。 + * + * @param x + * @return + * boolean + */ + public boolean isPalindrome4(int x) { + // 排除负数和个位数上为0的非0数字 + if ((x < 0) || (x!=0 && x % 10 == 0)) { + return false; + } + + int reverseNum = 0; + + // 翻转 + while (x > reverseNum) { + reverseNum = reverseNum * 10 + x % 10; + x /= 10; + } + return reverseNum == x || reverseNum / 10 == x; + } + +} diff --git a/src/main/java/com/mine/study/easy/easy.md b/src/main/java/com/mine/study/easy/easy.md new file mode 100644 index 0000000..bd99b32 --- /dev/null +++ b/src/main/java/com/mine/study/easy/easy.md @@ -0,0 +1,694 @@ +# easy 问题目录 +地址：https://leetcode-cn.com/problemset/all/?page=1&difficulty=EASY + +# easy 问题列表 + +| 题目 | 题解 | 通过率 | 难度 | +| ---- | ----- | ------ | ----- | +| 1. 两数之和 | 17600 | 52.5% | 简单 | +| 9. 回文数 | 6414 | 57.3% | 简单 | +| 13. 罗马数字转整数 | 5099 | 62.5% | 简单 | +| 14. 最长公共前缀 | 5107 | 42.3% | 简单 | +| 20. 有效的括号 | 7339 | 44.6% | 简单 | +| 21. 合并两个有序链表 | 5115 | 66.6% | 简单 | +| 26. 删除有序数组中的重复项 | 5956 | 54.0% | 简单 | +| 27. 移除元素 | 5493 | 59.4% | 简单 | +| 28. 实现 strStr() | 4329 | 40.5% | 简单 | +| 35. 搜索插入位置 | 5516 | 45.3% | 简单 | +| 53. 最大子数组和 | 5247 | 54.9% | 简单 | +| 58. 最后一个单词的长度 | 3374 | 40.1% | 简单 | +| 66. 加一 | 4347 | 45.9% | 简单 | +| 67. 二进制求和 | 2232 | 53.9% | 简单 | +| 69. x 的平方根 | 2659 | 38.8% | 简单 | +| 70. 爬楼梯 | 4808 | 53.7% | 简单 | +| 83. 删除排序链表中的重复元素 | 2617 | 53.6% | 简单 | +| 88. 合并两个有序数组 | 4439 | 52.3% | 简单 | +| 94. 二叉树的中序遍历 | 3186 | 75.8% | 简单 | +| 100. 相同的树 | 2438 | 59.7% | 简单 | +| 101. 对称二叉树 | 3139 | 57.6% | 简单 | +| 104. 二叉树的最大深度 | 3457 | 77.0% | 简单 | +| 108. 将有序数组转换为二叉搜索树 | 1566 | 76.7% | 简单 | +| 110. 平衡二叉树 | 1952 | 57.0% | 简单 | +| 111. 二叉树的最小深度 | 2786 | 50.3% | 简单 | +| 112. 路径总和 | 2328 | 53.2% | 简单 | +| 118. 杨辉三角 | 2401 | 74.8% | 简单 | +| 119. 杨辉三角 II | 1608 | 68.3% | 简单 | +| 121. 买卖股票的最佳时机 | 4632 | 57.8% | 简单 | +| 125. 验证回文串 | 2282 | 46.9% | 简单 | +| 136. 只出现一次的数字 | 3086 | 72.2% | 简单 | +| 141. 环形链表 | 3740 | 51.4% | 简单 | +| 144. 二叉树的前序遍历 | 2540 | 71.0% | 简单 | +| 145. 二叉树的后序遍历 | 2064 | 75.8% | 简单 | +| 155. 最小栈 | 2058 | 58.1% | 简单 | +| 157. 用 Read4 读取 N 个字符 | 106 | 54.2% | 简单 | +| 160. 相交链表 | 2765 | 62.7% | 简单 | +| 163. 缺失的区间 | 201 | 34.5% | 简单 | +| 168. Excel表列名称 | 918 | 43.6% | 简单 | +| 169. 多数元素 | 2846 | 66.7% | 简单 | +| 170. 两数之和 III - 数据结构设计 | 124 | 42.9% | 简单 | +| 171. Excel 表列序号 | 1103 | 71.6% | 简单 | +| 175. 组合两个表 | 1763 | 73.6% | 简单 | +| 181. 超过经理收入的员工 | 856 | 69.2% | 简单 | +| 182. 查找重复的电子邮箱 | 766 | 79.3% | 简单 | +| 183. 从不订购的客户 | 751 | 67.1% | 简单 | +| 190. 颠倒二进制位 | 1055 | 71.0% | 简单 | +| 191. 位1的个数 | 1595 | 75.8% | 简单 | +| 193. 有效电话号码 | 163 | 33.2% | 简单 | +| 195. 第十行 | 167 | 43.9% | 简单 | +| 196. 删除重复的电子邮箱 | 530 | 67.1% | 简单 | +| 197. 上升的温度 | 676 | 53.4% | 简单 | +| 202. 快乐数 | 1926 | 62.7% | 简单 | +| 203. 移除链表元素 | 2327 | 53.4% | 简单 | +| 205. 同构字符串 | 1068 | 49.9% | 简单 | +| 206. 反转链表 | 9109 | 72.9% | 简单 | +| 217. 存在重复元素 | 2603 | 55.6% | 简单 | +| 219. 存在重复元素 II | 1480 | 44.4% | 简单 | +| 225. 用队列实现栈 | 5076 | 67.6% | 简单 | +| 226. 翻转二叉树 | 2904 | 79.1% | 简单 | +| 228. 汇总区间 | 805 | 56.7% | 简单 | +| 231. 2 的幂 | 1627 | 50.4% | 简单 | +| 232. 用栈实现队列 | 1732 | 68.9% | 简单 | +| 234. 回文链表 | 2664 | 51.5% | 简单 | +| 235. 二叉搜索树的最近公共祖先 | 1338 | 67.2% | 简单 | +| 237. 删除链表中的节点 | 1503 | 85.9% | 简单 | +| 242. 有效的字母异位词 | 2380 | 65.3% | 简单 | +| 243. 最短单词距离 | 145 | 66.1% | 简单 | +| 246. 中心对称数 | 142 | 47.8% | 简单 | +| 252. 会议室 | 195 | 57.1% | 简单 | +| 257. 二叉树的所有路径 | 1429 | 69.6% | 简单 | +| 258. 各位相加 | 1152 | 71.0% | 简单 | +| 263. 丑数 | 962 | 51.2% | 简单 | +| 266. 回文排列 | 134 | 69.1% | 简单 | +| 268. 丢失的数字 | 1753 | 65.7% | 简单 | +| 270. 最接近的二叉搜索树值 | 165 | 57.4% | 简单 | +| 278. 第一个错误的版本 | 1796 | 45.2% | 简单 | +| 283. 移动零 | 4620 | 63.9% | 简单 | +| 290. 单词规律 | 1352 | 45.3% | 简单 | +| 292. Nim 游戏 | 883 | 70.7% | 简单 | +| 293. 翻转游戏 | 102 | 71.9% | 简单 | +| 303. 区域和检索 - 数组不可变 | 1333 | 74.7% | 简单 | +| 326. 3 的幂 | 714 | 50.6% | 简单 | +| 338. 比特位计数 | 1734 | 78.7% | 简单 | +| 342. 4的幂 | 903 | 52.1% | 简单 | +| 344. 反转字符串 | 2729 | 78.5% | 简单 | +| 345. 反转字符串中的元音字母 | 1188 | 54.2% | 简单 | +| 346. 数据流中的移动平均值 | 169 | 71.7% | 简单 | +| 349. 两个数组的交集 | 2053 | 74.1% | 简单 | +| 350. 两个数组的交集 II | 2033 | 56.1% | 简单 | +| 359. 日志速率限制器 | 82 | 74.0% | 简单 | +| 367. 有效的完全平方数 | 1195 | 44.8% | 简单 | +| 374. 猜数字大小 | 741 | 52.1% | 简单 | +| 383. 赎金信 | 1625 | 64.3% | 简单 | +| 387. 字符串中的第一个唯一字符 | 1623 | 54.8% | 简单 | +| 389. 找不同 | 1273 | 68.4% | 简单 | +| 392. 判断子序列 | 1977 | 52.1% | 简单 | +| 401. 二进制手表 | 742 | 61.8% | 简单 | +| 404. 左叶子之和 | 1527 | 60.5% | 简单 | +| 405. 数字转换为十六进制数 | 526 | 55.7% | 简单 | +| 408. 有效单词缩写 | 96 | 34.6% | 简单 | +| 409. 最长回文串 | 1625 | 55.6% | 简单 | +| 412. Fizz Buzz | 692 | 71.3% | 简单 | +| 414. 第三大的数 | 1348 | 39.4% | 简单 | +| 415. 字符串相加 | 1374 | 54.8% | 简单 | +| 422. 有效的单词方块 | 68 | 43.5% | 简单 | +| 434. 字符串中的单词数 | 991 | 39.7% | 简单 | +| 441. 排列硬币 | 875 | 45.8% | 简单 | +| 448. 找到所有数组中消失的数字 | 1417 | 65.5% | 简单 | +| 453. 最小操作次数使数组元素相等 | 743 | 61.3% | 简单 | +| 455. 分发饼干 | 1679 | 57.2% | 简单 | +| 459. 重复的子字符串 | 872 | 50.8% | 简单 | +| 461. 汉明距离 | 1655 | 81.6% | 简单 | +| 463. 岛屿的周长 | 1124 | 70.2% | 简单 | +| 476. 数字的补数 | 939 | 71.0% | 简单 | +| 482. 密钥格式化 | 487 | 47.0% | 简单 | +| 485. 最大连续 1 的个数 | 1216 | 61.0% | 简单 | +| 492. 构造矩形 | 466 | 60.7% | 简单 | +| 495. 提莫攻击 | 1030 | 60.3% | 简单 | +| 496. 下一个更大元素 I | 1758 | 71.1% | 简单 | +| 500. 键盘行 | 845 | 74.4% | 简单 | +| 501. 二叉搜索树中的众数 | 749 | 53.1% | 简单 | +| 504. 七进制数 | 741 | 52.1% | 简单 | +| 506. 相对名次 | 809 | 65.3% | 简单 | +| 507. 完美数 | 471 | 49.0% | 简单 | +| 509. 斐波那契数 | 2379 | 66.6% | 简单 | +| 511. 游戏玩法分析 I | 176 | 72.7% | 简单 | +| 512. 游戏玩法分析 II | 183 | 54.0% | 简单 | +| 520. 检测大写字母 | 1127 | 57.4% | 简单 | +| 521. 最长特殊序列 Ⅰ | 508 | 73.8% | 简单 | +| 530. 二叉搜索树的最小绝对差 | 830 | 62.8% | 简单 | +| 541. 反转字符串 II | 1067 | 59.5% | 简单 | +| 543. 二叉树的直径 | 1580 | 56.9% | 简单 | +| 551. 学生出勤记录 I | 838 | 56.8% | 简单 | +| 557. 反转字符串中的单词 III | 1974 | 74.2% | 简单 | +| 559. N 叉树的最大深度 | 888 | 74.4% | 简单 | +| 561. 数组拆分 I | 891 | 78.0% | 简单 | +| 563. 二叉树的坡度 | 658 | 65.6% | 简单 | +| 566. 重塑矩阵 | 964 | 66.6% | 简单 | +| 572. 另一棵树的子树 | 1010 | 47.5% | 简单 | +| 575. 分糖果 | 892 | 71.0% | 简单 | +| 577. 员工奖金 | 117 | 69.4% | 简单 | +| 584. 寻找用户推荐人 | 151 | 72.1% | 简单 | +| 586. 订单最多的客户 | 141 | 73.3% | 简单 | +| 589. N 叉树的前序遍历 | 935 | 76.1% | 简单 | +| 590. N 叉树的后序遍历 | 802 | 77.9% | 简单 | +| 594. 最长和谐子序列 | 594 | 56.5% | 简单 | +| 595. 大的国家 | 328 | 74.1% | 简单 | +| 596. 超过5名学生的课 | 366 | 45.8% | 简单 | +| 597. 好友申请 I：总体通过率 | 102 | 44.2% | 简单 | +| 598. 范围求和 II | 527 | 57.2% | 简单 | +| 599. 两个列表的最小索引总和 | 648 | 57.2% | 简单 | +| 603. 连续空余座位 | 163 | 65.0% | 简单 | +| 604. 迭代压缩字符串 | 74 | 38.0% | 简单 | +| 605. 种花问题 | 1491 | 32.9% | 简单 | +| 606. 根据二叉树创建字符串 | 660 | 63.1% | 简单 | +| 607. 销售员 | 151 | 67.8% | 简单 | +| 610. 判断三角形 | 94 | 65.0% | 简单 | +| 613. 直线上的最近距离 | 103 | 80.6% | 简单 | +| 617. 合并二叉树 | 1780 | 78.9% | 简单 | +| 619. 只出现一次的最大数字 | 105 | 45.9% | 简单 | +| 620. 有趣的电影 | 380 | 77.2% | 简单 | +| 627. 变更性别 | 450 | 81.5% | 简单 | +| 628. 三个数的最大乘积 | 882 | 52.4% | 简单 | +| 637. 二叉树的层平均值 | 834 | 69.4% | 简单 | +| 643. 子数组最大平均数 I | 704 | 44.4% | 简单 | +| 645. 错误的集合 | 813 | 41.9% | 简单 | +| 653. 两数之和 IV - 输入 BST | 809 | 63.0% | 简单 | +| 657. 机器人能否返回原点 | 695 | 78.4% | 简单 | +| 661. 图片平滑器 | 495 | 64.5% | 简单 | +| 671. 二叉树中第二小的节点 | 760 | 48.3% | 简单 | +| 674. 最长连续递增序列 | 1000 | 52.5% | 简单 | +| 680. 验证回文字符串 Ⅱ | 997 | 40.1% | 简单 | +| 682. 棒球比赛 | 873 | 72.2% | 简单 | +| 693. 交替位二进制数 | 742 | 65.4% | 简单 | +| 696. 计数二进制子串 | 540 | 63.7% | 简单 | +| 697. 数组的度 | 941 | 60.1% | 简单 | +| 700. 二叉搜索树中的搜索 | 1188 | 77.4% | 简单 | +| 703. 数据流中的第 K 大元素 | 668 | 52.0% | 简单 | +| 704. 二分查找 | 2966 | 54.4% | 简单 | +| 705. 设计哈希集合 | 515 | 63.9% | 简单 | +| 706. 设计哈希映射 | 489 | 63.9% | 简单 | +| 709. 转换成小写字母 | 784 | 77.3% | 简单 | +| 716. 最大栈 | 97 | 47.2% | 简单 | +| 717. 1 比特与 2 比特字符 | 747 | 55.4% | 简单 | +| 720. 词典中最长的单词 | 631 | 51.9% | 简单 | +| 724. 寻找数组的中心下标 | 1048 | 48.6% | 简单 | +| 728. 自除数 | 656 | 78.8% | 简单 | +| 733. 图像渲染 | 924 | 58.1% | 简单 | +| 734. 句子相似性 | 48 | 47.6% | 简单 | +| 744. 寻找比目标字母大的最小字母 | 756 | 49.5% | 简单 | +| 746. 使用最小花费爬楼梯 | 1803 | 61.7% | 简单 | +| 747. 至少是其他数字两倍的最大数 | 833 | 45.8% | 简单 | +| 748. 最短补全词 | 509 | 67.8% | 简单 | +| 760. 找出变位映射 | 108 | 83.6% | 简单 | +| 762. 二进制表示中质数个计算置位 | 447 | 75.7% | 简单 | +| 766. 托普利茨矩阵 | 692 | 70.5% | 简单 | +| 771. 宝石与石头 | 1249 | 85.2% | 简单 | +| 783. 二叉搜索树节点最小距离 | 741 | 59.8% | 简单 | +| 796. 旋转字符串 | 749 | 63.0% | 简单 | +| 800. 相似 RGB 颜色 | 45 | 70.8% | 简单 | +| 804. 唯一摩尔斯密码词 | 751 | 82.2% | 简单 | +| 806. 写字符串需要的行数 | 580 | 69.1% | 简单 | +| 812. 最大三角形面积 | 124 | 63.1% | 简单 | +| 819. 最常见的单词 | 617 | 46.4% | 简单 | +| 821. 字符的最短距离 | 897 | 73.3% | 简单 | +| 824. 山羊拉丁文 | 675 | 65.3% | 简单 | +| 830. 较大分组的位置 | 620 | 54.3% | 简单 | +| 832. 翻转图像 | 1012 | 79.5% | 简单 | +| 836. 矩形重叠 | 709 | 48.4% | 简单 | +| 844. 比较含退格的字符串 | 1353 | 49.4% | 简单 | +| 852. 山脉数组的峰顶索引 | 889 | 70.3% | 简单 | +| 859. 亲密字符串 | 790 | 34.5% | 简单 | +| 860. 柠檬水找零 | 972 | 58.5% | 简单 | +| 867. 转置矩阵 | 802 | 66.7% | 简单 | +| 868. 二进制间距 | 636 | 69.5% | 简单 | +| 872. 叶子相似的树 | 784 | 65.2% | 简单 | +| 876. 链表的中间结点 | 2451 | 70.7% | 简单 | +| 883. 三维形体投影面积 | 519 | 76.6% | 简单 | +| 884. 两句话中的不常见单词 | 537 | 72.0% | 简单 | +| 888. 公平的糖果交换 | 511 | 64.0% | 简单 | +| 892. 三维形体的表面积 | 711 | 63.9% | 简单 | +| 896. 单调数列 | 809 | 58.0% | 简单 | +| 897. 递增顺序搜索树 | 798 | 74.2% | 简单 | +| 905. 按奇偶排序数组 | 1272 | 71.3% | 简单 | +| 908. 最小差值 I | 512 | 74.3% | 简单 | +| 914. 卡牌分组 | 666 | 38.6% | 简单 | +| 917. 仅仅反转字母 | 946 | 60.2% | 简单 | +| 922. 按奇偶排序数组 II | 920 | 71.3% | 简单 | +| 925. 长按键入 | 727 | 38.3% | 简单 | +| 929. 独特的电子邮件地址 | 261 | 64.6% | 简单 | +| 933. 最近的请求次数 | 699 | 77.1% | 简单 | +| 937. 重新排列日志文件 | 445 | 64.0% | 简单 | +| 938. 二叉搜索树的范围和 | 892 | 82.1% | 简单 | +| 941. 有效的山脉数组 | 674 | 39.3% | 简单 | +| 942. 增减字符串匹配 | 263 | 73.4% | 简单 | +| 944. 删列造序 | 209 | 68.4% | 简单 | +| 953. 验证外星语词典 | 254 | 55.4% | 简单 | +| 961. 在长度 2N 的数组中找出重复 N 次的元素 | 356 | 67.7% | 简单 | +| 965. 单值二叉树 | 484 | 68.7% | 简单 | +| 976. 三角形的最大周长 | 657 | 58.8% | 简单 | +| 977. 有序数组的平方 | 2237 | 69.0% | 简单 | +| 989. 数组形式的整数加法 | 677 | 46.9% | 简单 | +| 993. 二叉树的堂兄弟节点 | 896 | 55.6% | 简单 | +| 997. 找到小镇的法官 | 747 | 53.0% | 简单 | +| 999. 可以被一步捕获的棋子数 | 593 | 69.2% | 简单 | +| 1002. 查找共用字符 | 684 | 72.2% | 简单 | +| 1005. K 次取反后最大化的数组和 | 1157 | 51.6% | 简单 | +| 1009. 十进制整数的反码 | 270 | 59.0% | 简单 | +| 1013. 将数组分成和相等的三个部分 | 970 | 39.2% | 简单 | +| 1018. 可被 5 整除的二进制前缀 | 405 | 51.4% | 简单 | +| 1021. 删除最外层的括号 | 731 | 78.5% | 简单 | +| 1022. 从根到叶的二进制数之和 | 333 | 71.3% | 简单 | +| 1025. 除数博弈 | 711 | 70.8% | 简单 | +| 1030. 距离顺序排列矩阵单元格 | 471 | 70.9% | 简单 | +| 1037. 有效的回旋镖 | 156 | 43.8% | 简单 | +| 1046. 最后一块石头的重量 | 1022 | 65.8% | 简单 | +| 1047. 删除字符串中的所有相邻重复项 | 1216 | 72.6% | 简单 | +| 1050. 合作过至少三次的演员和导演 | 90 | 77.0% | 简单 | +| 1051. 高度检查器 | 420 | 75.9% | 简单 | +| 1056. 易混淆数 | 78 | 42.5% | 简单 | +| 1064. 不动点 | 84 | 64.8% | 简单 | +| 1065. 字符串的索引对 | 88 | 55.5% | 简单 | +| 1068. 产品销售分析 I | 80 | 86.6% | 简单 | +| 1069. 产品销售分析 II | 70 | 81.6% | 简单 | +| 1071. 字符串的最大公因子 | 699 | 58.7% | 简单 | +| 1075. 项目员工 I | 91 | 69.6% | 简单 | +| 1076. 项目员工II | 105 | 49.1% | 简单 | +| 1078. Bigram 分词 | 458 | 65.7% | 简单 | +| 1082. 销售分析 I | 118 | 76.3% | 简单 | +| 1083. 销售分析 II | 125 | 52.8% | 简单 | +| 1084. 销售分析III | 148 | 55.0% | 简单 | +| 1085. 最小元素各数位之和 | 90 | 77.4% | 简单 | +| 1086. 前五科的均分 | 96 | 68.1% | 简单 | +| 1089. 复写零 | 345 | 58.2% | 简单 | +| 1099. 小于 K 的两数之和 | 116 | 59.6% | 简单 | +| 1103. 分糖果 II | 1152 | 63.8% | 简单 | +| 1108. IP 地址无效化 | 748 | 83.8% | 简单 | +| 1113. 报告的记录 | 61 | 53.5% | 简单 | +| 1114. 按序打印 | 656 | 65.3% | 简单 | +| 1118. 一月有多少天 | 55 | 63.9% | 简单 | +| 1119. 删去字符串中的元音 | 163 | 86.8% | 简单 | +| 1122. 数组的相对排序 | 967 | 70.8% | 简单 | +| 1128. 等价多米诺骨牌对的数量 | 499 | 54.3% | 简单 | +| 1133. 最大唯一数 | 77 | 64.9% | 简单 | +| 1134. 阿姆斯特朗数 | 61 | 77.3% | 简单 | +| 1137. 第 N 个泰波那契数 | 1185 | 60.8% | 简单 | +| 1141. 查询近30天活跃用户数 | 110 | 49.2% | 简单 | +| 1142. 过去30天的用户活动 II | 58 | 37.3% | 简单 | +| 1148. 文章浏览 I | 67 | 71.5% | 简单 | +| 1150. 检查一个数是否在数组中占绝大多数 | 101 | 59.8% | 简单 | +| 1154. 一年中的第几天 | 551 | 64.2% | 简单 | +| 1160. 拼写单词 | 956 | 68.5% | 简单 | +| 1165. 单行键盘 | 132 | 83.5% | 简单 | +| 1173. 即时食物配送 I | 97 | 75.4% | 简单 | +| 1175. 质数排列 | 151 | 49.2% | 简单 | +| 1176. 健身计划评估 | 77 | 46.9% | 简单 | +| 1179. 重新格式化部门表 | 224 | 64.1% | 简单 | +| 1180. 统计只含单一字母的子串 | 84 | 77.7% | 简单 | +| 1184. 公交站间的距离 | 307 | 58.4% | 简单 | +| 1185. 一周中的第几天 | 484 | 62.6% | 简单 | +| 1189. “气球” 的最大数量 | 726 | 68.7% | 简单 | +| 1196. 最多可以买到的苹果数量 | 68 | 68.2% | 简单 | +| 1200. 最小绝对差 | 300 | 68.1% | 简单 | +| 1207. 独一无二的出现次数 | 892 | 72.9% | 简单 | +| 1211. 查询结果的质量和占比 | 77 | 66.4% | 简单 | +| 1213. 三个有序数组的交集 | 157 | 78.1% | 简单 | +| 1217. 玩筹码 | 414 | 70.0% | 简单 | +| 1221. 分割平衡字符串 | 1202 | 84.4% | 简单 | +| 1228. 等差数列中缺失的数字 | 64 | 53.7% | 简单 | +| 1232. 缀点成线 | 482 | 46.4% | 简单 | +| 1241. 每个帖子的评论数 | 75 | 59.4% | 简单 | +| 1243. 数组变换 | 67 | 53.4% | 简单 | +| 1251. 平均售价 | 120 | 77.1% | 简单 | +| 1252. 奇数值单元格的数目 | 352 | 74.7% | 简单 | +| 1260. 二维网格迁移 | 292 | 60.7% | 简单 | +| 1266. 访问所有点的最小时间 | 483 | 82.6% | 简单 | +| 1271. 十六进制魔术数字 | 49 | 51.1% | 简单 | +| 1275. 找出井字棋的获胜者 | 189 | 54.7% | 简单 | +| 1279. 红绿灯路口 | 21 | 63.1% | 简单 | +| 1280. 学生们参加各科测试的次数 | 87 | 49.9% | 简单 | +| 1281. 整数的各位积和之差 | 740 | 83.3% | 简单 | +| 1287. 有序数组中出现次数超过25%的元素 | 259 | 60.0% | 简单 | +| 1290. 二进制链表转整数 | 835 | 80.8% | 简单 | +| 1294. 不同国家的天气类型 | 97 | 65.3% | 简单 | +| 1295. 统计位数为偶数的数字 | 690 | 80.6% | 简单 | +| 1299. 将每个元素替换为右侧最大元素 | 485 | 78.8% | 简单 | +| 1303. 求团队人数 | 116 | 82.4% | 简单 | +| 1304. 和为零的N个唯一整数 | 422 | 71.7% | 简单 | +| 1309. 解码字母到整数映射 | 376 | 76.3% | 简单 | +| 1313. 解压缩编码列表 | 585 | 83.2% | 简单 | +| 1317. 将整数转换为两个无零整数的和 | 220 | 61.8% | 简单 | +| 1322. 广告效果 | 74 | 59.3% | 简单 | +| 1323. 6 和 9 组成的最大数字 | 546 | 75.3% | 简单 | +| 1327. 列出指定时间段内所有的下单产品 | 68 | 68.9% | 简单 | +| 1331. 数组序号转换 | 257 | 53.0% | 简单 | +| 1332. 删除回文子序列 | 333 | 78.0% | 简单 | +| 1337. 矩阵中战斗力最弱的 K 行 | 750 | 69.2% | 简单 | +| 1342. 将数字变成 0 的操作次数 | 938 | 82.5% | 简单 | +| 1346. 检查整数及其两倍数是否存在 | 363 | 43.0% | 简单 | +| 1350. 院系无效的学生 | 95 | 85.0% | 简单 | +| 1351. 统计有序矩阵中的负数 | 634 | 75.3% | 简单 | +| 1356. 根据数字二进制下 1 的数目排序 | 583 | 73.0% | 简单 | +| 1360. 日期之间隔几天 | 174 | 50.2% | 简单 | +| 1365. 有多少小于当前数字的数字 | 1167 | 82.4% | 简单 | +| 1370. 上升下降字符串 | 607 | 79.0% | 简单 | +| 1374. 生成每种字符都是奇数个的字符串 | 247 | 74.4% | 简单 | +| 1378. 使用唯一标识码替换员工ID | 71 | 86.8% | 简单 | +| 1380. 矩阵中的幸运数 | 697 | 76.9% | 简单 | +| 1385. 两个数组间的距离值 | 309 | 67.2% | 简单 | +| 1389. 按既定顺序创建目标数组 | 516 | 83.1% | 简单 | +| 1394. 找出数组中的幸运数 | 335 | 66.2% | 简单 | +| 1399. 统计最大组的数目 | 177 | 67.0% | 简单 | +| 1403. 非递增顺序的最小子序列 | 416 | 68.9% | 简单 | +| 1407. 排名靠前的旅行者 | 104 | 68.0% | 简单 | +| 1408. 数组中的字符串匹配 | 234 | 61.8% | 简单 | +| 1413. 逐步求和得到正数的最小值 | 286 | 69.6% | 简单 | +| 1417. 重新格式化字符串 | 214 | 52.2% | 简单 | +| 1421. 净现值查询 | 44 | 72.0% | 简单 | +| 1422. 分割字符串的最大得分 | 237 | 54.2% | 简单 | +| 1426. 数元素 | 63 | 70.7% | 简单 | +| 1427. 字符串的左右移 | 70 | 63.3% | 简单 | +| 1431. 拥有最多糖果的孩子 | 1084 | 84.6% | 简单 | +| 1435. 制作会话柱状图 | 54 | 62.4% | 简单 | +| 1436. 旅行终点站 | 693 | 82.1% | 简单 | +| 1437. 是否所有 1 都至少相隔 k 个元素 | 208 | 57.8% | 简单 | +| 1441. 用栈操作构建数组 | 429 | 65.0% | 简单 | +| 1446. 连续字符 | 713 | 61.0% | 简单 | +| 1450. 在既定时间做作业的学生人数 | 375 | 80.5% | 简单 | +| 1455. 检查单词是否为句中其他单词的前缀 | 252 | 62.7% | 简单 | +| 1460. 通过翻转子数组使两个数组相等 | 366 | 74.0% | 简单 | +| 1464. 数组中两元素的最大乘积 | 458 | 76.3% | 简单 | +| 1469. 寻找所有的独生节点 | 113 | 81.5% | 简单 | +| 1470. 重新排列数组 | 792 | 83.9% | 简单 | +| 1474. 删除链表 M 个节点之后的 N 个节点 | 79 | 71.4% | 简单 | +| 1475. 商品折扣后的最终价格 | 315 | 71.4% | 简单 | +| 1480. 一维数组的动态和 | 1408 | 86.9% | 简单 | +| 1484. 按日期分组销售产品 | 94 | 68.5% | 简单 | +| 1486. 数组异或操作 | 723 | 85.8% | 简单 | +| 1491. 去掉最低工资和最高工资后的工资平均值 | 460 | 64.5% | 简单 | +| 1495. 上月播放的儿童适宜电影 | 46 | 53.7% | 简单 | +| 1496. 判断路径是否相交 | 194 | 53.5% | 简单 | +| 1502. 判断能否形成等差数列 | 417 | 70.9% | 简单 | +| 1507. 转变日期格式 | 154 | 59.0% | 简单 | +| 1511. 消费者下单频率 | 74 | 68.7% | 简单 | +| 1512. 好数对的数目 | 830 | 84.9% | 简单 | +| 1517. 查找拥有有效邮箱的用户 | 47 | 57.2% | 简单 | +| 1518. 换酒问题 | 837 | 70.3% | 简单 | +| 1523. 在区间范围内统计奇数数目 | 397 | 51.3% | 简单 | +| 1527. 患某种疾病的患者 | 95 | 49.0% | 简单 | +| 1528. 重新排列字符串 | 408 | 78.6% | 简单 | +| 1534. 统计好三元组 | 187 | 78.0% | 简单 | +| 1539. 第 k 个缺失的正整数 | 358 | 54.0% | 简单 | +| 1543. 产品名称格式修复 | 51 | 55.2% | 简单 | +| 1544. 整理字符串 | 367 | 55.3% | 简单 | +| 1550. 存在连续三个奇数的数组 | 328 | 65.6% | 简单 | +| 1556. 千位分隔数 | 224 | 56.9% | 简单 | +| 1560. 圆形赛道上经过次数最多的扇区 | 102 | 57.3% | 简单 | +| 1565. 按月统计订单数与顾客数 | 50 | 73.4% | 简单 | +| 1566. 重复至少 K 次且长度为 M 的模式 | 146 | 44.2% | 简单 | +| 1571. 仓库经理 | 59 | 76.8% | 简单 | +| 1572. 矩阵对角线元素的和 | 438 | 80.5% | 简单 | +| 1576. 替换所有的问号 | 591 | 51.5% | 简单 | +| 1581. 进店却未进行过交易的顾客 | 99 | 82.0% | 简单 | +| 1582. 二进制矩阵中的特殊位置 | 147 | 67.2% | 简单 | +| 1587. 银行账户概要 II | 65 | 84.4% | 简单 | +| 1588. 所有奇数长度子数组的和 | 819 | 83.9% | 简单 | +| 1592. 重新排列单词间的空格 | 149 | 44.4% | 简单 | +| 1598. 文件夹操作日志搜集器 | 173 | 67.4% | 简单 | +| 1603. 设计停车系统 | 507 | 84.5% | 简单 | +| 1607. 没有卖出的卖家 | 52 | 53.6% | 简单 | +| 1608. 特殊数组的特征值 | 281 | 61.0% | 简单 | +| 1614. 括号的最大嵌套深度 | 709 | 84.4% | 简单 | +| 1619. 删除某些元素后的数组均值 | 157 | 66.7% | 简单 | +| 1623. 三人国家代表队 | 55 | 78.0% | 简单 | +| 1624. 两个相同字符之间的最长子字符串 | 272 | 61.9% | 简单 | +| 1629. 按键持续时间最长的键 | 401 | 56.0% | 简单 | +| 1633. 各赛事的用户注册率 | 36 | 65.2% | 简单 | +| 1636. 按照频率将数组升序排序 | 237 | 69.7% | 简单 | +| 1640. 能否连接形成数组 | 246 | 64.8% | 简单 | +| 1646. 获取生成数组中的最大值 | 411 | 52.9% | 简单 | +| 1652. 拆炸弹 | 222 | 64.0% | 简单 | +| 1656. 设计有序流 | 113 | 77.8% | 简单 | +| 1661. 每台机器的进程平均运行时间 | 75 | 74.2% | 简单 | +| 1662. 检查两个字符串数组是否相等 | 352 | 81.0% | 简单 | +| 1667. 修复表中的名字 | 91 | 63.7% | 简单 | +| 1668. 最大重复子字符串 | 170 | 44.3% | 简单 | +| 1672. 最富有客户的资产总量 | 867 | 87.7% | 简单 | +| 1677. 发票中的产品金额 | 45 | 36.1% | 简单 | +| 1678. 设计 Goal 解析器 | 386 | 83.3% | 简单 | +| 1683. 无效的推文 | 45 | 90.2% | 简单 | +| 1684. 统计一致字符串的数目 | 427 | 82.5% | 简单 | +| 1688. 比赛中的配对次数 | 576 | 84.3% | 简单 | +| 1693. 每天的领导和合伙人 | 62 | 81.9% | 简单 | +| 1694. 重新格式化电话号码 | 161 | 63.0% | 简单 | +| 1700. 无法吃午餐的学生数量 | 246 | 69.4% | 简单 | +| 1704. 判断字符串的两半是否相似 | 226 | 77.6% | 简单 | +| 1708. 长度为 K 的最大子数组 | 37 | 69.6% | 简单 | +| 1710. 卡车上的最大单元数 | 233 | 69.6% | 简单 | +| 1716. 计算力扣银行的钱 | 681 | 70.2% | 简单 | +| 1720. 解码异或后的数组 | 523 | 86.7% | 简单 | +| 1725. 可以形成最大正方形的矩形数目 | 422 | 83.3% | 简单 | +| 1729. 求关注者的数量 | 41 | 62.9% | 简单 | +| 1731. 每位经理的下属员工数量 | 40 | 45.9% | 简单 | +| 1732. 找到最高海拔 | 257 | 78.5% | 简单 | +| 1736. 替换隐藏数字得到的最晚时间 | 374 | 44.7% | 简单 | +| 1741. 查找每个员工花费的总时间 | 48 | 85.0% | 简单 | +| 1742. 盒子中小球的最大数量 | 156 | 71.1% | 简单 | +| 1748. 唯一元素的和 | 568 | 78.8% | 简单 | +| 1752. 检查数组是否经排序和轮转得到 | 146 | 64.5% | 简单 | +| 1757. 可回收且低脂的产品 | 87 | 89.1% | 简单 | +| 1758. 生成交替二进制字符串的最少操作数 | 139 | 63.8% | 简单 | +| 1763. 最长的美好子字符串 | 263 | 69.0% | 简单 | +| 1768. 交替合并字符串 | 326 | 76.0% | 简单 | +| 1773. 统计匹配检索规则的物品数量 | 235 | 84.3% | 简单 | +| 1777. 每家商店的产品价格 | 73 | 78.7% | 简单 | +| 1779. 找到最近的有相同 X 或 Y 坐标的点 | 205 | 64.8% | 简单 | +| 1784. 检查二进制字符串字段 | 128 | 42.4% | 简单 | +| 1789. 员工的直属部门 | 37 | 71.4% | 简单 | +| 1790. 仅执行一次字符串交换能否使两个字符串相等 | 301 | 57.3% | 简单 | +| 1791. 找出星型图的中心节点 | 459 | 83.9% | 简单 | +| 1795. 每个产品在不同商店的价格 | 60 | 79.3% | 简单 | +| 1796. 字符串中第二大的数字 | 174 | 48.9% | 简单 | +| 1800. 最大升序子数组和 | 201 | 67.4% | 简单 | +| 1805. 字符串中不同整数的数目 | 194 | 46.3% | 简单 | +| 1809. 没有广告的剧集 | 44 | 61.5% | 简单 | +| 1812. 判断国际象棋棋盘中一个格子的颜色 | 267 | 78.7% | 简单 | +| 1816. 截断句子 | 659 | 73.0% | 简单 | +| 1821. 寻找今年具有正收入的客户 | 30 | 90.2% | 简单 | +| 1822. 数组元素积的符号 | 323 | 75.3% | 简单 | +| 1826. 有缺陷的传感器 | 30 | 41.9% | 简单 | +| 1827. 最少操作使数组递增 | 193 | 78.5% | 简单 | +| 1832. 判断句子是否为全字母句 | 278 | 82.2% | 简单 | +| 1837. K 进制表示下的各位数字总和 | 125 | 79.8% | 简单 | +| 1844. 将所有数字用字符替换 | 159 | 79.5% | 简单 | +| 1848. 到目标元素的最小距离 | 129 | 67.5% | 简单 | +| 1853. 转换日期格式 | 26 | 62.2% | 简单 | +| 1854. 人口最多的年份 | 161 | 75.7% | 简单 | +| 1859. 将句子排序 | 209 | 75.1% | 简单 | +| 1863. 找出所有子集的异或总和再求和 | 213 | 86.5% | 简单 | +| 1869. 哪种连续子字符串更长 | 181 | 75.4% | 简单 | +| 1873. 计算特殊奖金 | 112 | 79.6% | 简单 | +| 1876. 长度为三且各字符不同的子字符串 | 156 | 71.5% | 简单 | +| 1880. 检查某单词是否等于两单词之和 | 143 | 76.9% | 简单 | +| 1886. 判断矩阵经轮转后是否一致 | 119 | 58.2% | 简单 | +| 1890. 2020年最后一次登录 | 45 | 73.3% | 简单 | +| 1893. 检查是否区域内所有整数都被覆盖 | 452 | 59.0% | 简单 | +| 1897. 重新分配字符使所有字符串都相等 | 103 | 54.6% | 简单 | +| 1903. 字符串中的最大奇数 | 139 | 62.6% | 简单 | +| 1909. 删除一个元素使数组严格递增 | 107 | 31.3% | 简单 | +| 1913. 两个数对之间的最大乘积差 | 159 | 82.6% | 简单 | +| 1920. 基于排列构建数组 | 196 | 87.5% | 简单 | +| 1925. 统计平方和三元组的数目 | 93 | 69.4% | 简单 | +| 1929. 数组串联 | 223 | 87.3% | 简单 | +| 1933. 判断字符串是否可分解为值均等的子串 | 31 | 49.7% | 简单 | +| 1935. 可以输入的最大单词数 | 154 | 72.1% | 简单 | +| 1939. 主动请求确认消息的用户 | 20 | 60.1% | 简单 | +| 1941. 检查是否所有字符出现次数相同 | 132 | 74.5% | 简单 | +| 1945. 字符串转化后的各位数字之和 | 112 | 65.3% | 简单 | +| 1952. 三除数 | 111 | 54.5% | 简单 | +| 1957. 删除字符使字符串变好 | 80 | 60.7% | 简单 | +| 1961. 检查字符串是否为数组前缀 | 92 | 53.5% | 简单 | +| 1965. 丢失信息的雇员 | 74 | 75.2% | 简单 | +| 1967. 作为子字符串出现在单词中的字符串数目 | 114 | 78.8% | 简单 | +| 1971. 寻找图中是否存在路径 | 80 | 44.1% | 简单 | +| 1974. 使用特殊打字机键入单词的最少时间 | 96 | 72.3% | 简单 | +| 1978. 上级经理已离职的公司员工 | 21 | 52.2% | 简单 | +| 1979. 找出数组的最大公约数 | 174 | 78.3% | 简单 | +| 1984. 学生分数的最小差值 | 474 | 62.9% | 简单 | +| 1990. 统计实验的数量 | 19 | 48.6% | 简单 | +| 1991. 找到数组的中间位置 | 145 | 65.2% | 简单 | +| 1995. 统计特殊四元组 | 245 | 66.3% | 简单 | +| 2000. 反转单词前缀 | 388 | 79.5% | 简单 | +| 2006. 差的绝对值为 K 的数对数目 | 446 | 85.4% | 简单 | +| 2011. 执行操作后的变量值 | 151 | 86.6% | 简单 | +| 2016. 增量元素之间的最大差值 | 458 | 60.2% | 简单 | +| 2022. 将一维数组转变成二维数组 | 424 | 66.7% | 简单 | +| 2026. 低质量的问题 | 26 | 81.0% | 简单 | +| 2027. 转换字符串的最少操作次数 | 92 | 57.4% | 简单 | +| 2032. 至少在两个数组中出现的值 | 150 | 65.8% | 简单 | +| 2037. 使每位学生都有座位的最少移动次数 | 90 | 82.1% | 简单 | +| 2042. 检查句子中的数字是否递增 | 155 | 66.0% | 简单 | +| 2047. 句子中的有效单词数 | 390 | 39.1% | 简单 | +| 2053. 数组中第 K 个独一无二的字符串 | 97 | 72.9% | 简单 | +| 2057. 值相等的最小索引 | 73 | 76.9% | 简单 | +| 2062. 统计字符串中的元音子字符串 | 111 | 61.4% | 简单 | +| 2068. 检查两个字符串是否几乎相等 | 99 | 71.5% | 简单 | +| 2072. 赢得比赛的大学 | 19 | 68.9% | 简单 | +| 2073. 买票需要的时间 | 138 | 62.3% | 简单 | +| 2078. 两栋颜色不同且距离最远的房子 | 131 | 73.6% | 简单 | +| 2082. 富有客户的数量 | 21 | 75.8% | 简单 | +| 2085. 统计出现过一次的公共字符串 | 95 | 72.7% | 简单 | +| 2089. 找出数组排序后的目标下标 | 150 | 81.1% | 简单 | +| 2094. 找出 3 位偶数 | 132 | 55.5% | 简单 | +| 2099. 找到和最大的长度为 K 的子序列 | 119 | 48.5% | 简单 | +| 2103. 环和杆 | 143 | 80.4% | 简单 | +| 2108. 找出数组中的第一个回文字符串 | 136 | 79.2% | 简单 | +| 2114. 句子中的最多单词数 | 139 | 86.0% | 简单 | +| 2119. 反转两次的数字 | 118 | 76.3% | 简单 | +| 2124. 检查是否所有 A 都在 B 之前 | 134 | 70.7% | 简单 | +| 2129. 将标题首字母大写 | 97 | 61.6% | 简单 | +| 2133. 检查是否每一行每一列都包含全部整数 | 114 | 56.4% | 简单 | +| 2138. 将字符串拆分为若干长度为 k 的组 | 107 | 67.3% | 简单 | +| 2144. 打折购买糖果的最小开销 | 104 | 68.3% | 简单 | +| 2148. 元素计数 | 109 | 57.9% | 简单 | +| 2154. 将找到的值乘以 2 | 123 | 74.5% | 简单 | +| 2160. 拆分数位后四位数字的最小和 | 111 | 85.3% | 简单 | +| 2164. 对奇偶下标分别排序 | 94 | 69.8% | 简单 | +| 2169. 得到 0 的操作数 | 88 | 75.9% | 简单 | +| 2176. 统计数组中相等且可以被整除的数对 | 72 | 80.8% | 简单 | +| 2180. 统计各位数字之和为偶数的整数个数 | 96 | 64.9% | 简单 | +| 2185. 统计包含给定前缀的字符串 | 105 | 79.4% | 简单 | +| 2190. 数组中紧跟 key 之后出现最频繁的数字 | 66 | 58.4% | 简单 | +| 2194. Excel 表中某个范围内的单元格 | 94 | 84.9% | 简单 | +| 2200. 找出数组中的所有 K 近邻下标 | 113 | 51.6% | 简单 | +| 2205. The Number of Users That Are Eligible for Discount | 9 | 44.7% | 简单 | +| 2206. 将数组划分成相等数对 | 83 | 76.6% | 简单 | +| 2210. 统计数组中峰和谷的数量 | 106 | 57.7% | 简单 | +| 2215. 找出两数组的不同 | 98 | 66.9% | 简单 | +| 2220. 转换数字的最少位翻转次数 | 88 | 82.8% | 简单 | +| 2224. 转化时间需要的最少操作数 | 108 | 69.1% | 简单 | +| 2229. Check if an Array Is Consecutive | 13 | 69.7% | 简单 | +| 2230. The Users That Are Eligible for Discount | 5 | 53.7% | 简单 | +| 2231. 按奇偶性交换后的最大数字 | 132 | 62.9% | 简单 | +| 2235. 两整数相加 | 25 | 89.1% | 简单 | +| 2236. 判断根结点是否等于子结点之和 | 15 | 86.9% | 简单 | +| 2239. 找到最接近 0 的数字 | 54 | 56.8% | 简单 | +| 2243. 计算字符串的数字和 | 92 | 63.0% | 简单 | +| 2248. 多个数组求交集 | 112 | 67.8% | 简单 | +| 2255. 统计是给定字符串前缀的字符串数目 | 57 | 81.6% | 简单 | +| 2259. 移除指定数字得到的最大结果 | 97 | 48.8% | 简单 | +| LCP 01. 猜数字 | 695 | 84.5% | 简单 | +| LCP 02. 分式化简 | 278 | 69.5% | 简单 | +| LCP 06. 拿硬币 | 740 | 84.0% | 简单 | +| LCP 07. 传递信息 | 537 | 76.4% | 简单 | +| LCP 11. 期望个数统计 | 83 | 70.4% | 简单 | +| LCP 17. 速算机器人 | 302 | 80.0% | 简单 | +| LCP 18. 早餐组合 | 285 | 29.6% | 简单 | +| LCP 22. 黑白方格画 | 200 | 34.1% | 简单 | +| LCP 28. 采购方案 | 240 | 30.5% | 简单 | +| LCP 33. 蓄水 | 114 | 24.8% | 简单 | +| LCP 39. 无人机方阵 | 52 | 53.0% | 简单 | +| LCP 40. 心算挑战 | 99 | 27.8% | 简单 | +| LCP 44. 开幕式焰火 | 105 | 79.5% | 简单 | +| LCP 50. 宝石补给 | 43 | 66.2% | 简单 | +| LCP 51. 烹饪料理 | 61 | 44.9% | 简单 | +| LCP 55. 采集果实 | 25 | 74.1% | 简单 | +| LCS 01. 下载插件 | 174 | 54.6% | 简单 | +| LCS 02. 完成一半题目 | 115 | 65.9% | 简单 | +| 剑指 Offer 03. 数组中重复的数字 | 3512 | 67.9% | 简单 | +| 剑指 Offer 05. 替换空格 | 2653 | 75.9% | 简单 | +| 剑指 Offer 06. 从尾到头打印链表 | 2822 | 75.0% | 简单 | +| 剑指 Offer 09. 用两个栈实现队列 | 2346 | 70.9% | 简单 | +| 剑指 Offer 10- I. 斐波那契数列 | 2316 | 36.2% | 简单 | +| 剑指 Offer 10- II. 青蛙跳台阶问题 | 1693 | 45.4% | 简单 | +| 剑指 Offer 11. 旋转数组的最小数字 | 2120 | 49.2% | 简单 | +| 剑指 Offer 15. 二进制中1的个数 | 1498 | 75.1% | 简单 | +| 剑指 Offer 17. 打印从1到最大的n位数 | 1321 | 77.9% | 简单 | +| 剑指 Offer 18. 删除链表的节点 | 1841 | 60.1% | 简单 | +| 剑指 Offer 21. 调整数组顺序使奇数位于偶数前面 | 2104 | 64.7% | 简单 | +| 剑指 Offer 22. 链表中倒数第k个节点 | 2971 | 80.2% | 简单 | +| 剑指 Offer 24. 反转链表 | 2370 | 74.3% | 简单 | +| 剑指 Offer 25. 合并两个排序的链表 | 1541 | 72.6% | 简单 | +| 剑指 Offer 27. 二叉树的镜像 | 1827 | 79.4% | 简单 | +| 剑指 Offer 28. 对称的二叉树 | 1494 | 57.6% | 简单 | +| 剑指 Offer 29. 顺时针打印矩阵 | 1790 | 43.8% | 简单 | +| 剑指 Offer 30. 包含min函数的栈 | 1541 | 55.2% | 简单 | +| 剑指 Offer 32 - II. 从上到下打印二叉树 II | 1509 | 68.8% | 简单 | +| 剑指 Offer 39. 数组中出现次数超过一半的数字 | 1270 | 69.9% | 简单 | +| 剑指 Offer 40. 最小的k个数 | 2183 | 57.3% | 简单 | +| 剑指 Offer 42. 连续子数组的最大和 | 1879 | 60.7% | 简单 | +| 剑指 Offer 50. 第一个只出现一次的字符 | 1457 | 62.2% | 简单 | +| 剑指 Offer 52. 两个链表的第一个公共节点 | 1294 | 65.5% | 简单 | +| 剑指 Offer 53 - I. 在排序数组中查找数字 I | 2109 | 53.2% | 简单 | +| 剑指 Offer 53 - II. 0～n-1中缺失的数字 | 2007 | 44.7% | 简单 | +| 剑指 Offer 54. 二叉搜索树的第k大节点 | 1514 | 76.3% | 简单 | +| 剑指 Offer 55 - I. 二叉树的深度 | 1545 | 79.2% | 简单 | +| 剑指 Offer 55 - II. 平衡二叉树 | 1196 | 59.5% | 简单 | +| 剑指 Offer 57. 和为s的两个数字 | 1126 | 67.7% | 简单 | +| 剑指 Offer 57 - II. 和为s的连续正数序列 | 2147 | 71.1% | 简单 | +| 剑指 Offer 58 - I. 翻转单词顺序 | 1293 | 44.5% | 简单 | +| 剑指 Offer 58 - II. 左旋转字符串 | 2430 | 86.1% | 简单 | +| 剑指 Offer 61. 扑克牌中的顺子 | 1317 | 46.0% | 简单 | +| 剑指 Offer 62. 圆圈中最后剩下的数字 | 907 | 65.8% | 简单 | +| 剑指 Offer 65. 不用加减乘除做加法 | 667 | 59.3% | 简单 | +| 剑指 Offer 68 - I. 二叉搜索树的最近公共祖先 | 899 | 69.5% | 简单 | +| 剑指 Offer 68 - II. 二叉树的最近公共祖先 | 897 | 70.4% | 简单 | +| 剑指 Offer II 001. 整数除法 | 304 | 21.0% | 简单 | +| 剑指 Offer II 002. 二进制加法 | 313 | 55.2% | 简单 | +| 剑指 Offer II 003. 前 n 个数字二进制中 1 的个数 | 368 | 78.6% | 简单 | +| 剑指 Offer II 006. 排序数组中两个数字之和 | 259 | 64.3% | 简单 | +| 剑指 Offer II 012. 左右两边子数组的和相等 | 236 | 66.7% | 简单 | +| 剑指 Offer II 018. 有效的回文 | 198 | 51.5% | 简单 | +| 剑指 Offer II 019. 最多删除一个字符得到回文 | 191 | 45.8% | 简单 | +| 剑指 Offer II 023. 两个链表的第一个重合节点 | 163 | 69.9% | 简单 | +| 剑指 Offer II 024. 反转链表 | 304 | 75.5% | 简单 | +| 剑指 Offer II 027. 回文链表 | 286 | 61.5% | 简单 | +| 剑指 Offer II 032. 有效的变位词 | 151 | 60.2% | 简单 | +| 剑指 Offer II 034. 外星语言是否排序 | 174 | 55.9% | 简单 | +| 剑指 Offer II 041. 滑动窗口的平均值 | 157 | 77.7% | 简单 | +| 剑指 Offer II 042. 最近请求次数 | 133 | 82.9% | 简单 | +| 剑指 Offer II 052. 展平二叉搜索树 | 160 | 74.6% | 简单 | +| 剑指 Offer II 056. 二叉搜索树中两个节点之和 | 178 | 73.5% | 简单 | +| 剑指 Offer II 059. 数据流的第 K 大数值 | 119 | 63.5% | 简单 | +| 剑指 Offer II 068. 查找插入位置 | 150 | 50.2% | 简单 | +| 剑指 Offer II 069. 山峰数组的顶部 | 476 | 71.1% | 简单 | +| 剑指 Offer II 072. 求平方根 | 149 | 42.0% | 简单 | +| 剑指 Offer II 075. 数组相对排序 | 178 | 70.8% | 简单 | +| 剑指 Offer II 088. 爬楼梯的最少成本 | 163 | 73.7% | 简单 | +| 剑指 Offer II 101. 分割等和子集 | 93 | 49.9% | 简单 | +| 面试题 01.01. 判定字符是否唯一 | 1867 | 71.3% | 简单 | +| 面试题 01.02. 判定是否互为字符重排 | 1338 | 63.7% | 简单 | +| 面试题 01.03. URL化 | 608 | 57.6% | 简单 | +| 面试题 01.04. 回文排列 | 948 | 54.3% | 简单 | +| 面试题 01.06. 字符串压缩 | 1318 | 46.8% | 简单 | +| 面试题 01.09. 字符串轮转 | 520 | 54.7% | 简单 | +| 面试题 02.01. 移除重复节点 | 788 | 67.3% | 简单 | +| 面试题 02.02. 返回倒数第 k 个节点 | 1082 | 78.1% | 简单 | +| 面试题 02.03. 删除中间节点 | 770 | 85.8% | 简单 | +| 面试题 02.06. 回文链表 | 598 | 48.5% | 简单 | +| 面试题 02.07. 链表相交 | 711 | 67.2% | 简单 | +| 面试题 03.01. 三合一 | 242 | 53.1% | 简单 | +| 面试题 03.02. 栈的最小值 | 356 | 61.6% | 简单 | +| 面试题 03.04. 化栈为队 | 394 | 71.4% | 简单 | +| 面试题 03.06. 动物收容所 | 223 | 58.5% | 简单 | +| 面试题 04.02. 最小高度树 | 493 | 78.8% | 简单 | +| 面试题 04.04. 检查平衡性 | 427 | 59.1% | 简单 | +| 面试题 05.01. 插入 | 244 | 50.9% | 简单 | +| 面试题 05.03. 翻转数位 | 288 | 38.2% | 简单 | +| 面试题 05.06. 整数转换 | 278 | 52.2% | 简单 | +| 面试题 05.07. 配对交换 | 257 | 71.0% | 简单 | +| 面试题 08.01. 三步问题 | 561 | 36.5% | 简单 | +| 面试题 08.03. 魔术索引 | 458 | 67.5% | 简单 | +| 面试题 08.06. 汉诺塔问题 | 332 | 65.3% | 简单 | +| 面试题 08.10. 颜色填充 | 272 | 55.8% | 简单 | +| 面试题 10.01. 合并排序的数组 | 2452 | 55.9% | 简单 | +| 面试题 10.05. 稀疏数组搜索 | 299 | 56.2% | 简单 | +| 面试题 16.05. 阶乘尾数 | 144 | 45.6% | 简单 | +| 面试题 16.07. 最大数值 | 342 | 73.3% | 简单 | +| 面试题 16.11. 跳水板 | 624 | 44.1% | 简单 | +| 面试题 16.15. 珠玑妙算 | 291 | 48.7% | 简单 | +| 面试题 16.17. 连续数列 | 436 | 59.5% | 简单 | +| 面试题 17.01. 不用加号的加法 | 201 | 60.5% | 简单 | +| 面试题 17.04. 消失的数字 | 566 | 62.5% | 简单 | +| 面试题 17.10. 主要元素 | 980 | 56.7% | 简单 | +| 面试题 17.12. BiNode | 337 | 63.5% | 简单 | +| 面试题 17.16. 按摩师 | 1210 | 51.4% | 简单 | \ No newline at end of file diff --git a/src/main/java/com/mine/study/hard/hard.md b/src/main/java/com/mine/study/hard/hard.md new file mode 100644 index 0000000..485c864 --- /dev/null +++ b/src/main/java/com/mine/study/hard/hard.md @@ -0,0 +1,559 @@ +# hard 问题目录 +地址：https://leetcode-cn.com/problemset/all/?page=1&difficulty=HARD + +# hard 问题列表 + +| 题目 | 题解 | 通过率 | 难度 | +| ---- | ----- | ------ | ----- | +| 4. 寻找两个正序数组的中位数 | 5190 | 41.4% | 困难 | +| 10. 正则表达式匹配 | 1624 | 31.6% | 困难 | +| 23. 合并K个升序链表 | 3096 | 56.9% | 困难 | +| 25. K 个一组翻转链表 | 2941 | 67.3% | 困难 | +| 30. 串联所有单词的子串 | 832 | 37.0% | 困难 | +| 32. 最长有效括号 | 1719 | 36.4% | 困难 | +| 37. 解数独 | 1162 | 67.4% | 困难 | +| 41. 缺失的第一个正数 | 1754 | 42.6% | 困难 | +| 42. 接雨水 | 3218 | 60.8% | 困难 | +| 44. 通配符匹配 | 702 | 33.2% | 困难 | +| 51. N 皇后 | 2166 | 74.0% | 困难 | +| 52. N皇后 II | 740 | 82.3% | 困难 | +| 60. 排列序列 | 1169 | 53.0% | 困难 | +| 65. 有效数字 | 757 | 27.4% | 困难 | +| 68. 文本左右对齐 | 666 | 52.1% | 困难 | +| 72. 编辑距离 | 2133 | 62.2% | 困难 | +| 76. 最小覆盖子串 | 2203 | 44.0% | 困难 | +| 84. 柱状图中最大的矩形 | 1508 | 44.1% | 困难 | +| 85. 最大矩形 | 920 | 52.9% | 困难 | +| 87. 扰乱字符串 | 369 | 48.1% | 困难 | +| 115. 不同的子序列 | 881 | 51.8% | 困难 | +| 123. 买卖股票的最佳时机 III | 1102 | 55.9% | 困难 | +| 124. 二叉树中的最大路径和 | 1487 | 45.0% | 困难 | +| 126. 单词接龙 II | 413 | 40.5% | 困难 | +| 127. 单词接龙 | 799 | 47.5% | 困难 | +| 132. 分割回文串 II | 513 | 49.4% | 困难 | +| 135. 分发糖果 | 1086 | 49.0% | 困难 | +| 140. 单词拆分 II | 736 | 52.7% | 困难 | +| 149. 直线上最多的点数 | 631 | 36.8% | 困难 | +| 154. 寻找旋转排序数组中的最小值 II | 1079 | 53.0% | 困难 | +| 158. 用 Read4 读取 N 个字符 II | 83 | 59.8% | 困难 | +| 164. 最大间距 | 574 | 60.7% | 困难 | +| 174. 地下城游戏 | 923 | 48.4% | 困难 | +| 185. 部门工资前三高的所有员工 | 785 | 51.2% | 困难 | +| 188. 买卖股票的最佳时机 IV | 962 | 41.3% | 困难 | +| 212. 单词搜索 II | 648 | 45.7% | 困难 | +| 214. 最短回文串 | 368 | 38.1% | 困难 | +| 218. 天际线问题 | 339 | 54.6% | 困难 | +| 224. 基本计算器 | 780 | 41.9% | 困难 | +| 233. 数字 1 的个数 | 498 | 48.2% | 困难 | +| 239. 滑动窗口最大值 | 1870 | 49.9% | 困难 | +| 248. 中心对称数 III | 65 | 48.0% | 困难 | +| 262. 行程和用户 | 461 | 42.4% | 困难 | +| 265. 粉刷房子 II | 220 | 61.9% | 困难 | +| 269. 火星词典 | 144 | 35.2% | 困难 | +| 272. 最接近的二叉搜索树值 II | 99 | 65.8% | 困难 | +| 273. 整数转换英文表示 | 388 | 36.5% | 困难 | +| 282. 给表达式添加运算符 | 184 | 47.9% | 困难 | +| 295. 数据流的中位数 | 624 | 52.7% | 困难 | +| 296. 最佳的碰头地点 | 55 | 62.2% | 困难 | +| 297. 二叉树的序列化与反序列化 | 1009 | 57.4% | 困难 | +| 301. 删除无效的括号 | 459 | 55.1% | 困难 | +| 302. 包含全部黑色像素的最小矩形 | 50 | 66.1% | 困难 | +| 305. 岛屿数量 II | 97 | 40.9% | 困难 | +| 308. 二维区域和检索 - 可变 | 63 | 63.0% | 困难 | +| 312. 戳气球 | 490 | 69.2% | 困难 | +| 315. 计算右侧小于当前元素的个数 | 583 | 42.3% | 困难 | +| 317. 离建筑物最近的距离 | 76 | 47.7% | 困难 | +| 321. 拼接最大数 | 254 | 42.2% | 困难 | +| 327. 区间和的个数 | 253 | 41.5% | 困难 | +| 329. 矩阵中的最长递增路径 | 656 | 50.1% | 困难 | +| 330. 按要求补齐数组 | 164 | 53.0% | 困难 | +| 332. 重新安排行程 | 428 | 46.2% | 困难 | +| 335. 路径交叉 | 153 | 42.9% | 困难 | +| 336. 回文对 | 204 | 39.4% | 困难 | +| 352. 将数据流变为多个不相交区间 | 361 | 67.6% | 困难 | +| 354. 俄罗斯套娃信封问题 | 671 | 42.5% | 困难 | +| 358. K 距离间隔重排字符串 | 66 | 35.6% | 困难 | +| 363. 矩形区域不超过 K 的最大数值和 | 241 | 48.6% | 困难 | +| 381. O(1) 时间插入、删除和获取随机元素 - 允许重复 | 208 | 43.3% | 困难 | +| 391. 完美矩形 | 209 | 46.3% | 困难 | +| 403. 青蛙过河 | 505 | 45.7% | 困难 | +| 407. 接雨水 II | 267 | 57.8% | 困难 | +| 410. 分割数组的最大值 | 415 | 57.8% | 困难 | +| 411. 最短独占单词缩写 | 29 | 49.4% | 困难 | +| 420. 强密码检验器 | 155 | 39.5% | 困难 | +| 425. 单词方块 | 40 | 61.7% | 困难 | +| 428. 序列化和反序列化 N 叉树 | 69 | 66.7% | 困难 | +| 431. 将 N 叉树编码为二叉树 | 37 | 74.3% | 困难 | +| 432. 全 O(1) 的数据结构 | 276 | 47.2% | 困难 | +| 440. 字典序的第K小数字 | 279 | 42.6% | 困难 | +| 446. 等差数列划分 II - 子序列 | 181 | 54.9% | 困难 | +| 458. 可怜的小猪 | 219 | 69.8% | 困难 | +| 460. LFU 缓存 | 510 | 44.0% | 困难 | +| 465. 最优账单平衡 | 27 | 53.7% | 困难 | +| 466. 统计重复个数 | 191 | 37.4% | 困难 | +| 471. 编码最短长度的字符串 | 31 | 60.5% | 困难 | +| 472. 连接词 | 230 | 49.9% | 困难 | +| 479. 最大回文数乘积 | 162 | 62.7% | 困难 | +| 480. 滑动窗口中位数 | 451 | 44.7% | 困难 | +| 483. 最小好进制 | 133 | 59.1% | 困难 | +| 488. 祖玛游戏 | 177 | 51.1% | 困难 | +| 489. 扫地机器人 | 30 | 73.7% | 困难 | +| 493. 翻转对 | 314 | 35.3% | 困难 | +| 499. 迷宫 III | 62 | 39.2% | 困难 | +| 502. IPO | 380 | 44.4% | 困难 | +| 514. 自由之路 | 273 | 50.3% | 困难 | +| 517. 超级洗衣机 | 183 | 51.0% | 困难 | +| 527. 单词缩写 | 34 | 59.0% | 困难 | +| 546. 移除盒子 | 130 | 62.3% | 困难 | +| 548. 将数组分割成和相等的子数组 | 46 | 36.7% | 困难 | +| 552. 学生出勤记录 II | 306 | 57.7% | 困难 | +| 564. 寻找最近的回文数 | 249 | 30.4% | 困难 | +| 568. 最大休假天数 | 30 | 51.1% | 困难 | +| 569. 员工薪水中位数 | 198 | 56.5% | 困难 | +| 571. 给定数字的频率查询中位数 | 118 | 46.8% | 困难 | +| 579. 查询员工的累计薪水 | 162 | 42.1% | 困难 | +| 587. 安装栅栏 | 125 | 62.0% | 困难 | +| 588. 设计内存文件系统 | 41 | 42.5% | 困难 | +| 591. 标签验证器 | 186 | 52.3% | 困难 | +| 600. 不含连续1的非负整数 | 252 | 48.2% | 困难 | +| 601. 体育馆的人流量 | 465 | 49.6% | 困难 | +| 615. 平均工资：部门与公司比较 | 119 | 41.8% | 困难 | +| 618. 学生地理信息报告 | 61 | 62.1% | 困难 | +| 629. K个逆序对数组 | 181 | 51.9% | 困难 | +| 630. 课程表 III | 240 | 46.3% | 困难 | +| 631. 设计 Excel 求和公式 | 38 | 31.1% | 困难 | +| 632. 最小区间 | 272 | 60.1% | 困难 | +| 639. 解码方法 II | 287 | 37.6% | 困难 | +| 642. 设计搜索自动补全系统 | 69 | 55.8% | 困难 | +| 644. 子数组最大平均数 II | 31 | 41.8% | 困难 | +| 656. 金币路径 | 29 | 32.2% | 困难 | +| 660. 移除 9 | 29 | 65.2% | 困难 | +| 664. 奇怪的打印机 | 201 | 65.4% | 困难 | +| 668. 乘法表中第k小的数 | 99 | 52.1% | 困难 | +| 675. 为高尔夫比赛砍树 | 61 | 41.4% | 困难 | +| 679. 24 点游戏 | 318 | 53.9% | 困难 | +| 683. K 个关闭的灯泡 | 67 | 44.8% | 困难 | +| 685. 冗余连接 II | 291 | 42.3% | 困难 | +| 689. 三个无重叠子数组的最大和 | 274 | 56.3% | 困难 | +| 691. 贴纸拼词 | 65 | 46.8% | 困难 | +| 699. 掉落的方块 | 56 | 49.4% | 困难 | +| 710. 黑名单中的随机数 | 185 | 37.9% | 困难 | +| 711. 不同岛屿的数量 II | 31 | 56.6% | 困难 | +| 715. Range 模块 | 66 | 42.6% | 困难 | +| 719. 找出第 k 小的距离对 | 118 | 38.7% | 困难 | +| 726. 原子的数量 | 435 | 55.2% | 困难 | +| 727. 最小窗口子序列 | 64 | 41.0% | 困难 | +| 730. 统计不同回文子序列 | 59 | 50.1% | 困难 | +| 732. 我的日程安排表 III | 72 | 62.8% | 困难 | +| 736. Lisp 语法解析 | 56 | 47.4% | 困难 | +| 741. 摘樱桃 | 60 | 38.4% | 困难 | +| 745. 前缀和后缀搜索 | 71 | 41.0% | 困难 | +| 749. 隔离病毒 | 46 | 50.3% | 困难 | +| 753. 破解保险箱 | 59 | 60.8% | 困难 | +| 757. 设置交集大小至少为2 | 43 | 43.0% | 困难 | +| 759. 员工空闲时间 | 56 | 68.3% | 困难 | +| 761. 特殊的二进制序列 | 39 | 59.6% | 困难 | +| 765. 情侣牵手 | 490 | 66.3% | 困难 | +| 768. 最多能完成排序的块 II | 106 | 51.9% | 困难 | +| 770. 基本计算器 IV | 31 | 57.1% | 困难 | +| 772. 基本计算器 III | 155 | 51.0% | 困难 | +| 773. 滑动谜题 | 385 | 70.7% | 困难 | +| 774. 最小化去加油站的最大距离 | 27 | 61.3% | 困难 | +| 778. 水位上升的泳池中游泳 | 380 | 58.9% | 困难 | +| 780. 到达终点 | 251 | 38.0% | 困难 | +| 782. 变为棋盘 | 37 | 42.5% | 困难 | +| 786. 第 K 个最小的素数分数 | 273 | 67.8% | 困难 | +| 793. 阶乘函数后 K 个零 | 92 | 40.3% | 困难 | +| 798. 得分最高的最小轮调 | 203 | 61.4% | 困难 | +| 801. 使序列递增的最小交换次数 | 109 | 42.8% | 困难 | +| 803. 打砖块 | 138 | 47.7% | 困难 | +| 805. 数组的均值分割 | 58 | 29.8% | 困难 | +| 810. 黑板异或游戏 | 142 | 72.9% | 困难 | +| 815. 公交路线 | 339 | 43.3% | 困难 | +| 818. 赛车 | 49 | 43.9% | 困难 | +| 827. 最大人工岛 | 228 | 39.4% | 困难 | +| 828. 统计子串中的唯一字符 | 70 | 53.5% | 困难 | +| 829. 连续整数求和 | 131 | 37.0% | 困难 | +| 834. 树中距离之和 | 146 | 53.0% | 困难 | +| 839. 相似字符串组 | 294 | 58.0% | 困难 | +| 843. 猜猜这个单词 | 46 | 38.7% | 困难 | +| 847. 访问所有节点的最短路径 | 183 | 67.7% | 困难 | +| 850. 矩形面积 II | 53 | 45.5% | 困难 | +| 854. 相似度为 K 的字符串 | 83 | 36.5% | 困难 | +| 857. 雇佣 K 名工人的最低成本 | 59 | 47.9% | 困难 | +| 862. 和至少为 K 的最短子数组 | 178 | 20.9% | 困难 | +| 864. 获取所有钥匙的最短路径 | 59 | 47.3% | 困难 | +| 871. 最低加油次数 | 160 | 35.5% | 困难 | +| 878. 第 N 个神奇数字 | 74 | 29.3% | 困难 | +| 879. 盈利计划 | 198 | 55.2% | 困难 | +| 882. 细分图中的可到达结点 | 44 | 49.7% | 困难 | +| 887. 鸡蛋掉落 | 407 | 29.7% | 困难 | +| 891. 子序列宽度之和 | 48 | 34.1% | 困难 | +| 895. 最大频率栈 | 130 | 58.4% | 困难 | +| 899. 有序队列 | 56 | 54.3% | 困难 | +| 902. 最大为 N 的数字组合 | 100 | 35.8% | 困难 | +| 903. DI 序列的有效排列 | 49 | 54.8% | 困难 | +| 906. 超级回文数 | 53 | 29.7% | 困难 | +| 913. 猫和老鼠 | 124 | 60.6% | 困难 | +| 920. 播放列表的数量 | 27 | 49.8% | 困难 | +| 924. 尽量减少恶意软件的传播 | 117 | 35.9% | 困难 | +| 927. 三等分 | 81 | 34.6% | 困难 | +| 928. 尽量减少恶意软件的传播 II | 58 | 43.1% | 困难 | +| 936. 戳印序列 | 33 | 40.2% | 困难 | +| 940. 不同的子序列 II | 72 | 42.9% | 困难 | +| 943. 最短超级串 | 53 | 46.1% | 困难 | +| 952. 按公因数计算最大组件大小 | 71 | 36.9% | 困难 | +| 956. 最高的广告牌 | 60 | 44.6% | 困难 | +| 960. 删列造序 III | 42 | 57.5% | 困难 | +| 964. 表示数字的最少运算符 | 32 | 44.5% | 困难 | +| 968. 监控二叉树 | 435 | 51.1% | 困难 | +| 972. 相等的有理数 | 39 | 40.6% | 困难 | +| 975. 奇偶跳 | 63 | 45.7% | 困难 | +| 980. 不同路径 III | 250 | 73.5% | 困难 | +| 982. 按位与为零的三元组 | 40 | 55.9% | 困难 | +| 987. 二叉树的垂序遍历 | 449 | 53.4% | 困难 | +| 992. K 个不同整数的子数组 | 302 | 46.2% | 困难 | +| 995. K 连续位的最小翻转次数 | 263 | 53.4% | 困难 | +| 996. 正方形数组的数目 | 104 | 48.9% | 困难 | +| 1000. 合并石头的最低成本 | 51 | 43.1% | 困难 | +| 1001. 网格照明 | 268 | 45.0% | 困难 | +| 1012. 至少有 1 位重复的数字 | 78 | 35.4% | 困难 | +| 1028. 从先序遍历还原二叉树 | 470 | 73.0% | 困难 | +| 1032. 字符流 | 58 | 42.8% | 困难 | +| 1036. 逃离大迷宫 | 208 | 46.9% | 困难 | +| 1044. 最长重复子串 | 206 | 35.0% | 困难 | +| 1063. 有效子数组的数目 | 51 | 72.4% | 困难 | +| 1067. 范围内的数字计数 | 29 | 44.5% | 困难 | +| 1074. 元素和为目标值的子矩阵数量 | 207 | 67.0% | 困难 | +| 1088. 易混淆数 II | 41 | 46.5% | 困难 | +| 1092. 最短公共超序列 | 63 | 51.0% | 困难 | +| 1095. 山脉数组中查找目标值 | 429 | 37.4% | 困难 | +| 1096. 花括号展开 II | 58 | 55.7% | 困难 | +| 1097. 游戏玩法分析 V | 143 | 52.1% | 困难 | +| 1106. 解析布尔表达式 | 146 | 58.7% | 困难 | +| 1121. 将数组分成几个递增序列 | 20 | 58.0% | 困难 | +| 1125. 最小的必要团队 | 57 | 49.7% | 困难 | +| 1127. 用户购买平台 | 92 | 42.7% | 困难 | +| 1147. 段式回文 | 101 | 56.7% | 困难 | +| 1153. 字符串转化 | 26 | 37.2% | 困难 | +| 1157. 子数组中占绝大多数的元素 | 52 | 33.4% | 困难 | +| 1159. 市场分析 II | 100 | 49.9% | 困难 | +| 1163. 按字典序排在最后的子串 | 114 | 26.9% | 困难 | +| 1168. 水资源分配优化 | 41 | 59.5% | 困难 | +| 1172. 餐盘栈 | 68 | 26.8% | 困难 | +| 1178. 猜字谜 | 188 | 46.4% | 困难 | +| 1183. 矩阵中 1 的最大数量 | 19 | 59.9% | 困难 | +| 1187. 使数组严格递增 | 39 | 45.1% | 困难 | +| 1192. 查找集群内的「关键连接」 | 72 | 51.8% | 困难 | +| 1194. 锦标赛优胜者 | 83 | 51.4% | 困难 | +| 1199. 建造街区的最短时间 | 22 | 45.5% | 困难 | +| 1203. 项目管理 | 155 | 61.7% | 困难 | +| 1206. 设计跳表 | 118 | 61.9% | 困难 | +| 1210. 穿过迷宫的最少移动次数 | 61 | 45.6% | 困难 | +| 1216. 验证回文字符串 III | 45 | 56.2% | 困难 | +| 1220. 统计元音字母序列的数目 | 344 | 60.7% | 困难 | +| 1223. 掷骰子模拟 | 64 | 48.1% | 困难 | +| 1224. 最大相等频率 | 76 | 33.0% | 困难 | +| 1225. 报告系统状态的连续日期 | 97 | 54.1% | 困难 | +| 1231. 分享巧克力 | 77 | 57.4% | 困难 | +| 1235. 规划兼职工作 | 148 | 47.6% | 困难 | +| 1240. 铺瓷砖 | 45 | 49.9% | 困难 | +| 1246. 删除回文子数组 | 47 | 48.9% | 困难 | +| 1250. 检查「好数组」 | 46 | 58.1% | 困难 | +| 1255. 得分最高的单词集合 | 81 | 70.1% | 困难 | +| 1259. 不相交的握手 | 53 | 51.3% | 困难 | +| 1263. 推箱子 | 74 | 42.4% | 困难 | +| 1269. 停在原地的方案数 | 327 | 49.1% | 困难 | +| 1274. 矩形内船只的数目 | 28 | 61.8% | 困难 | +| 1278. 分割回文串 III | 71 | 61.1% | 困难 | +| 1284. 转化为全零矩阵的最少反转次数 | 72 | 67.3% | 困难 | +| 1289. 下降路径最小和 II | 131 | 60.5% | 困难 | +| 1293. 网格中的最短路径 | 147 | 37.2% | 困难 | +| 1298. 你能从盒子里获得的最大糖果数 | 99 | 59.3% | 困难 | +| 1301. 最大得分的路径数目 | 100 | 37.3% | 困难 | +| 1307. 口算难题 | 62 | 33.1% | 困难 | +| 1312. 让字符串成为回文串的最少插入次数 | 184 | 67.6% | 困难 | +| 1316. 不同的循环子字符串 | 71 | 45.4% | 困难 | +| 1320. 二指输入的的最小距离 | 67 | 59.3% | 困难 | +| 1326. 灌溉花园的最少水龙头数目 | 101 | 47.5% | 困难 | +| 1330. 翻转子数组得到最大的数组值 | 35 | 39.9% | 困难 | +| 1335. 工作计划的最低难度 | 68 | 59.4% | 困难 | +| 1336. 每次访问的交易次数 | 63 | 44.6% | 困难 | +| 1340. 跳跃游戏 V | 111 | 58.3% | 困难 | +| 1345. 跳跃游戏 IV | 276 | 46.8% | 困难 | +| 1349. 参加考试的最大学生数 | 109 | 52.3% | 困难 | +| 1354. 多次求和构造目标数组 | 77 | 28.2% | 困难 | +| 1359. 有效的快递序列数目 | 80 | 55.9% | 困难 | +| 1363. 形成三的最大倍数 | 115 | 36.6% | 困难 | +| 1368. 使网格图至少有一条有效路径的最小代价 | 113 | 55.5% | 困难 | +| 1369. 获取最近第二次的活动 | 57 | 60.5% | 困难 | +| 1373. 二叉搜索子树的最大键值和 | 256 | 41.7% | 困难 | +| 1377. T 秒后青蛙的位置 | 144 | 33.0% | 困难 | +| 1383. 最大的团队表现值 | 96 | 33.1% | 困难 | +| 1384. 按年度列出销售总额 | 61 | 56.4% | 困难 | +| 1388. 3n 块披萨 | 64 | 55.3% | 困难 | +| 1392. 最长快乐前缀 | 185 | 42.7% | 困难 | +| 1397. 找到所有好字符串 | 41 | 40.4% | 困难 | +| 1402. 做菜顺序 | 210 | 75.8% | 困难 | +| 1406. 石子游戏 III | 94 | 58.3% | 困难 | +| 1411. 给 N x 3 网格图涂色的方案数 | 150 | 55.7% | 困难 | +| 1412. 查找成绩处于中游的学生 | 85 | 55.1% | 困难 | +| 1416. 恢复数组 | 62 | 41.5% | 困难 | +| 1420. 生成数组 | 51 | 61.2% | 困难 | +| 1425. 带限制的子序列和 | 85 | 45.6% | 困难 | +| 1434. 每个人戴不同帽子的方案数 | 52 | 48.8% | 困难 | +| 1439. 有序矩阵中的第 k 个最小数组和 | 83 | 55.5% | 困难 | +| 1444. 切披萨的方案数 | 70 | 53.4% | 困难 | +| 1449. 数位成本和为目标值的最大数字 | 215 | 62.6% | 困难 | +| 1453. 圆形靶内的最大飞镖数量 | 36 | 37.0% | 困难 | +| 1458. 两个子序列的最大点积 | 100 | 44.9% | 困难 | +| 1463. 摘樱桃 II | 74 | 60.8% | 困难 | +| 1467. 两个盒子中球的颜色数相同的概率 | 53 | 62.8% | 困难 | +| 1473. 粉刷房子 III | 171 | 67.1% | 困难 | +| 1478. 安排邮筒 | 69 | 60.2% | 困难 | +| 1479. 周内每天的销售情况 | 52 | 56.0% | 困难 | +| 1483. 树节点的第 K 个祖先 | 87 | 31.8% | 困难 | +| 1489. 找到最小生成树里的关键边和伪关键边 | 135 | 68.4% | 困难 | +| 1494. 并行课程 II | 45 | 38.1% | 困难 | +| 1499. 满足不等式的最大值 | 74 | 38.5% | 困难 | +| 1505. 最多 K 次交换相邻数位后得到的最小整数 | 78 | 37.0% | 困难 | +| 1510. 石子游戏 IV | 76 | 59.2% | 困难 | +| 1515. 服务中心的最佳位置 | 66 | 34.9% | 困难 | +| 1516. 移动 N 叉树的子树 | 16 | 55.4% | 困难 | +| 1520. 最多的不重叠子字符串 | 75 | 34.1% | 困难 | +| 1521. 找到最接近目标值的函数值 | 59 | 39.8% | 困难 | +| 1526. 形成目标数组的子数组最少增加次数 | 62 | 63.2% | 困难 | +| 1531. 压缩字符串 II | 43 | 35.8% | 困难 | +| 1537. 最大得分 | 107 | 37.4% | 困难 | +| 1542. 找出最长的超赞子字符串 | 56 | 40.4% | 困难 | +| 1547. 切棍子的最小成本 | 79 | 55.1% | 困难 | +| 1548. 图中最相似的路径 | 19 | 68.4% | 困难 | +| 1553. 吃掉 N 个橘子的最少天数 | 135 | 30.8% | 困难 | +| 1563. 石子游戏 V | 70 | 39.0% | 困难 | +| 1568. 使陆地分离的最少天数 | 61 | 45.4% | 困难 | +| 1569. 将子数组重新排序得到同一个二叉查找树的方案数 | 49 | 47.5% | 困难 | +| 1575. 统计所有可行路径 | 84 | 59.3% | 困难 | +| 1579. 保证图可完全遍历 | 308 | 61.9% | 困难 | +| 1585. 检查字符串是否可以通过排序子字符串得到另一个字符串 | 44 | 43.1% | 困难 | +| 1591. 奇怪的打印机 II | 46 | 60.3% | 困难 | +| 1595. 连通两组点的最小成本 | 42 | 49.0% | 困难 | +| 1597. 根据中缀表达式构造二叉表达式树 | 23 | 67.3% | 困难 | +| 1601. 最多可达成的换楼请求数目 | 225 | 61.7% | 困难 | +| 1606. 找到处理最多请求的服务器 | 180 | 48.1% | 困难 | +| 1610. 可见点的最大数目 | 156 | 44.3% | 困难 | +| 1611. 使整数变为 0 的最少操作次数 | 61 | 61.7% | 困难 | +| 1617. 统计子树中城市之间最大距离 | 41 | 62.9% | 困难 | +| 1622. 奇妙序列 | 73 | 16.1% | 困难 | +| 1627. 带阈值的图连通性 | 49 | 39.6% | 困难 | +| 1632. 矩阵转换后的秩 | 36 | 33.2% | 困难 | +| 1635. Hopper 公司查询 I | 41 | 53.6% | 困难 | +| 1639. 通过给定词典构造目标字符串的方案数 | 36 | 41.3% | 困难 | +| 1643. 第 K 条最小指令 | 52 | 46.5% | 困难 | +| 1645. Hopper Company Queries II | 30 | 41.3% | 困难 | +| 1649. 通过指令创建有序数组 | 79 | 48.2% | 困难 | +| 1651. Hopper 公司查询 III | 29 | 66.5% | 困难 | +| 1655. 分配重复整数 | 42 | 39.0% | 困难 | +| 1659. 最大化网格幸福感 | 25 | 42.3% | 困难 | +| 1665. 完成所有任务的最少初始能量 | 93 | 65.8% | 困难 | +| 1671. 得到山形数组的最少删除次数 | 52 | 46.8% | 困难 | +| 1675. 数组的最小偏移量 | 56 | 43.2% | 困难 | +| 1681. 最小不兼容性 | 55 | 40.7% | 困难 | +| 1687. 从仓库到码头运输箱子 | 29 | 43.2% | 困难 | +| 1691. 堆叠长方体的最大高度 | 68 | 49.5% | 困难 | +| 1692. 计算分配糖果的不同方式 | 15 | 65.9% | 困难 | +| 1697. 检查边长度限制的路径是否存在 | 51 | 53.9% | 困难 | +| 1703. 得到连续 K 个 1 的最少相邻交换次数 | 29 | 38.7% | 困难 | +| 1707. 与数组中元素的最大异或值 | 160 | 50.4% | 困难 | +| 1713. 得到子序列的最少操作次数 | 186 | 49.5% | 困难 | +| 1714. 数组中特殊等间距元素的和 | 11 | 57.7% | 困难 | +| 1719. 重构一棵树的方案数 | 91 | 69.8% | 困难 | +| 1723. 完成所有工作的最短时间 | 187 | 50.7% | 困难 | +| 1724. 检查边长度限制的路径是否存在 II | 17 | 55.4% | 困难 | +| 1728. 猫和老鼠 II | 31 | 38.5% | 困难 | +| 1735. 生成乘积数组的方案数 | 31 | 49.5% | 困难 | +| 1739. 放置盒子 | 71 | 48.3% | 困难 | +| 1745. 回文串分割 IV | 80 | 49.0% | 困难 | +| 1751. 最多可以参加的会议数目 II | 54 | 50.3% | 困难 | +| 1755. 最接近目标值的子序列和 | 64 | 42.9% | 困难 | +| 1761. 一个图中连通三元组的最小度数 | 45 | 44.5% | 困难 | +| 1766. 互质树 | 34 | 38.7% | 困难 | +| 1767. 寻找没有被执行的任务对 | 31 | 79.2% | 困难 | +| 1771. 由子序列构造的最长回文串的长度 | 48 | 37.1% | 困难 | +| 1776. 车队 II | 47 | 46.8% | 困难 | +| 1782. 统计点对的数目 | 39 | 31.6% | 困难 | +| 1787. 使所有区间的异或结果为零 | 63 | 65.2% | 困难 | +| 1788. 最大化花园的美观度 | 24 | 63.3% | 困难 | +| 1793. 好子数组的最大分数 | 103 | 42.8% | 困难 | +| 1799. N 次操作后的最大分数和 | 38 | 52.8% | 困难 | +| 1803. 统计异或值在范围内的数对有多少 | 57 | 41.5% | 困难 | +| 1808. 好因子的最大数目 | 50 | 27.4% | 困难 | +| 1815. 得到新鲜甜甜圈的最多组数 | 46 | 30.4% | 困难 | +| 1819. 序列中不同最大公约数的数目 | 37 | 40.0% | 困难 | +| 1825. 求出 MK 平均值 | 61 | 28.9% | 困难 | +| 1830. 使字符串有序的最少操作次数 | 23 | 50.0% | 困难 | +| 1835. 所有数对按位与结果的异或和 | 64 | 52.2% | 困难 | +| 1840. 最高建筑高度 | 53 | 39.4% | 困难 | +| 1842. 下个由相同数字构成的回文串 | 18 | 60.0% | 困难 | +| 1847. 最近的房间 | 50 | 37.3% | 困难 | +| 1851. 包含每个查询的最小区间 | 58 | 41.5% | 困难 | +| 1857. 有向图中最大颜色值 | 43 | 46.7% | 困难 | +| 1862. 向下取整数对和 | 50 | 31.9% | 困难 | +| 1866. 恰有 K 根木棍可以看到的排列数目 | 60 | 61.4% | 困难 | +| 1872. 石子游戏 VIII | 35 | 62.4% | 困难 | +| 1879. 两个数组最小的异或值之和 | 48 | 45.7% | 困难 | +| 1883. 准时抵达会议现场的最小跳过休息次数 | 33 | 38.9% | 困难 | +| 1889. 装包裹的最小浪费空间 | 48 | 27.5% | 困难 | +| 1892. 页面推荐Ⅱ | 25 | 35.6% | 困难 | +| 1896. 反转表达式值的最少操作次数 | 34 | 51.5% | 困难 | +| 1900. 最佳运动员的比拼回合 | 41 | 44.9% | 困难 | +| 1912. 设计电影租借系统 | 62 | 23.7% | 困难 | +| 1916. 统计为蚁群构筑房间的不同顺序 | 19 | 56.2% | 困难 | +| 1917. Leetcodify 好友推荐 | 18 | 33.2% | 困难 | +| 1919. 兴趣相同的朋友 | 29 | 42.0% | 困难 | +| 1923. 最长公共子路径 | 38 | 25.1% | 困难 | +| 1924. 安装栅栏 II | 8 | 37.4% | 困难 | +| 1928. 规定时间内到达终点的最小花费 | 59 | 42.1% | 困难 | +| 1931. 用三种不同颜色为网格涂色 | 69 | 57.2% | 困难 | +| 1932. 合并多棵二叉搜索树 | 41 | 33.3% | 困难 | +| 1938. 查询最大基因差 | 44 | 36.5% | 困难 | +| 1944. 队列中可以看到的人数 | 83 | 60.0% | 困难 | +| 1948. 删除系统中的重复文件夹 | 21 | 50.8% | 困难 | +| 1955. 统计特殊子序列的数目 | 47 | 51.2% | 困难 | +| 1956. 感染 K 种病毒所需的最短时间 | 14 | 36.6% | 困难 | +| 1960. 两个回文子字符串长度的最大乘积 | 25 | 30.4% | 困难 | +| 1964. 找出到每个位置为止最长的有效障碍赛跑路线 | 55 | 40.0% | 困难 | +| 1970. 你能穿过矩阵的最后一天 | 54 | 48.7% | 困难 | +| 1972. 同一天的第一个电话和最后一个电话 | 20 | 46.5% | 困难 | +| 1977. 划分数字的方案数 | 21 | 27.3% | 困难 | +| 1982. 从子集的和还原数组 | 23 | 46.0% | 困难 | +| 1987. 不同的好子序列数目 | 30 | 48.8% | 困难 | +| 1994. 好子集的数目 | 172 | 56.8% | 困难 | +| 1998. 数组的最大公因数排序 | 37 | 43.2% | 困难 | +| 2003. 每棵子树内缺失的最小基因值 | 50 | 40.6% | 困难 | +| 2004. 职员招聘人数 | 20 | 41.9% | 困难 | +| 2005. 斐波那契树的移除子树游戏 | 8 | 53.0% | 困难 | +| 2009. 使数组连续的最少操作数 | 48 | 41.4% | 困难 | +| 2010. 职员招聘人数 II | 17 | 63.9% | 困难 | +| 2014. 重复 K 次的最长子序列 | 27 | 54.1% | 困难 | +| 2019. 解出数学表达式的学生分数 | 39 | 36.1% | 困难 | +| 2025. 分割数组的最多方案数 | 49 | 28.1% | 困难 | +| 2030. 含特定字母的最小子序列 | 48 | 34.6% | 困难 | +| 2035. 将数组分成两个数组并最小化数组和的差 | 50 | 32.3% | 困难 | +| 2040. 两个有序数组的第 K 小乘积 | 25 | 33.0% | 困难 | +| 2045. 到达目的地的第二短时间 | 157 | 53.7% | 困难 | +| 2050. 并行课程 III | 88 | 57.3% | 困难 | +| 2056. 棋盘上有效移动组合的数目 | 17 | 61.1% | 困难 | +| 2060. 同源字符串检测 | 23 | 37.6% | 困难 | +| 2065. 最大化一张图中的路径价值 | 62 | 53.6% | 困难 | +| 2071. 你可以安排的最多任务数目 | 38 | 35.7% | 困难 | +| 2076. 处理含限制条件的好友请求 | 72 | 50.0% | 困难 | +| 2081. k 镜像数字的和 | 70 | 42.0% | 困难 | +| 2088. 统计农场中肥沃金字塔的数目 | 46 | 62.6% | 困难 | +| 2092. 找出知晓秘密的所有专家 | 114 | 27.6% | 困难 | +| 2097. 合法重新排列数对 | 47 | 35.6% | 困难 | +| 2102. 序列顺序查询 | 67 | 53.4% | 困难 | +| 2106. 摘水果 | 82 | 33.0% | 困难 | +| 2111. 使数组 K 递增的最少操作次数 | 86 | 33.2% | 困难 | +| 2117. 一个区间内所有数乘积的缩写 | 18 | 33.7% | 困难 | +| 2118. Build the Equation | 9 | 55.8% | 困难 | +| 2122. 还原原数组 | 58 | 40.7% | 困难 | +| 2123. 使矩阵中的 1 互不相邻的最小操作数 | 5 | 49.2% | 困难 | +| 2127. 参加会议的最多员工数 | 58 | 30.0% | 困难 | +| 2132. 用邮票贴满网格图 | 47 | 25.6% | 困难 | +| 2136. 全部开花的最早一天 | 59 | 63.7% | 困难 | +| 2141. 同时运行 N 台电脑的最长时间 | 66 | 39.7% | 困难 | +| 2143. 在两个数组的区间中选取数字 | 7 | 52.2% | 困难 | +| 2147. 分隔长廊的方案数 | 72 | 39.8% | 困难 | +| 2151. 基于陈述统计最多好人数 | 87 | 48.4% | 困难 | +| 2153. The Number of Passengers in Each Bus II | 4 | 42.9% | 困难 | +| 2157. 字符串分组 | 66 | 29.8% | 困难 | +| 2158. Amount of New Area Painted Each Day | 8 | 51.5% | 困难 | +| 2163. 删除元素后和的最小差值 | 52 | 48.1% | 困难 | +| 2167. 移除所有载有违禁货物车厢所需的最少时间 | 70 | 47.7% | 困难 | +| 2172. 数组的最大与和 | 61 | 47.6% | 困难 | +| 2173. 最多连胜的次数 | 14 | 53.5% | 困难 | +| 2179. 统计数组中好三元组数目 | 61 | 32.6% | 困难 | +| 2183. 统计可以被 K 整除的下标对数目 | 53 | 26.9% | 困难 | +| 2188. 完成比赛的最少时间 | 62 | 42.4% | 困难 | +| 2193. 得到回文串的最少操作次数 | 48 | 47.3% | 困难 | +| 2197. 替换数组中的非互质数 | 83 | 32.9% | 困难 | +| 2199. Finding the Topic of Each Post | 6 | 52.9% | 困难 | +| 2203. 得到要求路径的最小带权子图 | 64 | 36.2% | 困难 | +| 2204. Distance to a Cycle in Undirected Graph | 9 | 81.0% | 困难 | +| 2209. 用地毯覆盖后的最少白色砖块 | 43 | 35.5% | 困难 | +| 2213. 由单个字符重复的最长子字符串 | 67 | 36.1% | 困难 | +| 2218. 从栈中取出 K 个硬币的最大面值和 | 73 | 53.1% | 困难 | +| 2223. 构造字符串的总得分和 | 44 | 33.3% | 困难 | +| 2227. 加密解密字符串 | 77 | 38.5% | 困难 | +| 2234. 花园的最大总美丽值 | 62 | 27.2% | 困难 | +| 2242. 节点序列的最大得分 | 35 | 29.7% | 困难 | +| 2246. 相邻字符不同的最长路径 | 51 | 42.3% | 困难 | +| 2247. Maximum Cost of Trip With K Highways | 8 | 66.3% | 困难 | +| 2251. 花期内花的数目 | 95 | 48.2% | 困难 | +| 2252. Dynamic Pivoting of a Table | 0 | 52.0% | 困难 | +| 2253. Dynamic Unpivoting of a Table | 1 | 60.7% | 困难 | +| 2254. Design Video Sharing Platform | 4 | 65.2% | 困难 | +| 2258. 逃离火灾 | 63 | 33.4% | 困难 | +| 2262. 字符串的总引力 | 96 | 53.6% | 困难 | +| 2263. Make Array Non-decreasing or Non-increasing | 4 | 58.5% | 困难 | +| LCP 04. 覆盖 | 73 | 40.1% | 困难 | +| LCP 05. 发 LeetCoin | 59 | 21.2% | 困难 | +| LCP 09. 最小跳跃次数 | 119 | 29.8% | 困难 | +| LCP 10. 二叉树任务调度 | 41 | 59.4% | 困难 | +| LCP 13. 寻宝 | 88 | 61.0% | 困难 | +| LCP 14. 切分数组 | 50 | 22.5% | 困难 | +| LCP 15. 游乐园的迷宫 | 25 | 59.0% | 困难 | +| LCP 16. 游乐园的游览计划 | 18 | 32.9% | 困难 | +| LCP 20. 快速公交 | 34 | 33.5% | 困难 | +| LCP 21. 追逐游戏 | 31 | 36.1% | 困难 | +| LCP 24. 数字游戏 | 28 | 30.3% | 困难 | +| LCP 25. 古董键盘 | 31 | 36.1% | 困难 | +| LCP 26. 导航装置 | 23 | 36.3% | 困难 | +| LCP 27. 黑盒光线反射 | 28 | 33.7% | 困难 | +| LCP 31. 变换的迷宫 | 40 | 28.3% | 困难 | +| LCP 32. 批量处理任务 | 24 | 44.7% | 困难 | +| LCP 35. 电动车游城市 | 30 | 46.5% | 困难 | +| LCP 36. 最多牌组数 | 23 | 32.7% | 困难 | +| LCP 37. 最小矩形面积 | 26 | 23.3% | 困难 | +| LCP 38. 守卫城堡 | 16 | 63.5% | 困难 | +| LCP 42. 玩具套圈 | 36 | 24.0% | 困难 | +| LCP 43. 十字路口的交通 | 22 | 47.3% | 困难 | +| LCP 47. 入场安检 | 20 | 40.4% | 困难 | +| LCP 48. 无限棋局 | 13 | 22.1% | 困难 | +| LCP 49. 环形闯关游戏 | 16 | 29.2% | 困难 | +| LCP 53. 守护太空城 | 14 | 38.5% | 困难 | +| LCP 54. 夺回据点 | 6 | 31.3% | 困难 | +| LCP 57. 打地鼠 | 31 | 24.1% | 困难 | +| LCP 58. 积木拼接 | 9 | 24.0% | 困难 | +| LCP 59. 搭桥过河 | 5 | 26.4% | 困难 | +| LCP 60. 力扣泡泡龙 | 10 | 13.0% | 困难 | +| 剑指 Offer 19. 正则表达式匹配 | 557 | 38.7% | 困难 | +| 剑指 Offer 37. 序列化二叉树 | 698 | 56.9% | 困难 | +| 剑指 Offer 41. 数据流中的中位数 | 676 | 58.4% | 困难 | +| 剑指 Offer 43. 1～n 整数中 1 出现的次数 | 641 | 49.9% | 困难 | +| 剑指 Offer 51. 数组中的逆序对 | 1128 | 49.1% | 困难 | +| 剑指 Offer 59 - I. 滑动窗口的最大值 | 1453 | 44.7% | 困难 | +| 剑指 Offer II 017. 含有所有字符的最短字符串 | 165 | 50.1% | 困难 | +| 剑指 Offer II 039. 直方图最大矩形面积 | 112 | 50.4% | 困难 | +| 剑指 Offer II 040. 矩阵中最大的矩形 | 115 | 58.3% | 困难 | +| 剑指 Offer II 048. 序列化与反序列化二叉树 | 100 | 67.8% | 困难 | +| 剑指 Offer II 051. 节点之和最大的路径 | 99 | 46.3% | 困难 | +| 剑指 Offer II 078. 合并排序链表 | 159 | 63.6% | 困难 | +| 剑指 Offer II 094. 最少回文分割 | 60 | 58.2% | 困难 | +| 剑指 Offer II 097. 子序列的数目 | 67 | 54.2% | 困难 | +| 剑指 Offer II 108. 单词演变 | 50 | 59.8% | 困难 | +| 剑指 Offer II 112. 最长递增路径 | 71 | 57.3% | 困难 | +| 剑指 Offer II 114. 外星文字典 | 59 | 42.3% | 困难 | +| 剑指 Offer II 117. 相似的字符串 | 56 | 62.5% | 困难 | +| 面试题 04.09. 二叉搜索树序列 | 133 | 48.1% | 困难 | +| 面试题 08.12. 八皇后 | 354 | 76.7% | 困难 | +| 面试题 08.13. 堆箱子 | 109 | 50.7% | 困难 | +| 面试题 16.03. 交点 | 246 | 43.9% | 困难 | +| 面试题 16.08. 整数的英语表示 | 70 | 38.2% | 困难 | +| 面试题 17.06. 2出现的次数 | 129 | 45.9% | 困难 | +| 面试题 17.19. 消失的两个数字 | 216 | 57.9% | 困难 | +| 面试题 17.20. 连续中值 | 89 | 57.3% | 困难 | +| 面试题 17.21. 直方图的水量 | 561 | 63.6% | 困难 | +| 面试题 17.24. 最大子矩阵 | 160 | 53.3% | 困难 | +| 面试题 17.25. 单词矩阵 | 45 | 51.1% | 困难 | +| 面试题 17.26. 稀疏相似度 | 75 | 34.9% | 困难 | \ No newline at end of file diff --git a/src/main/java/com/mine/study/medium/medium.md b/src/main/java/com/mine/study/medium/medium.md new file mode 100644 index 0000000..2c812fc --- /dev/null +++ b/src/main/java/com/mine/study/medium/medium.md @@ -0,0 +1,1397 @@ +# medium 问题目录 +地址：https://leetcode-cn.com/problemset/all/?page=1&difficulty=MEDIUM + +# medium 问题列表 + +| 题目 | 题解 | 通过率 | 难度 | +| ---- | ----- |-------| ----- | +| 2. 两数相加 | 9435 | 41.7% | 中等 | +| 3. 无重复字符的最长子串 | 10287 | 38.7% | 中等 | +| 5. 最长回文子串 | 5524 | 36.6% | 中等 | +| 6. Z 字形变换 | 3592 | 51.9% | 中等 | +| 7. 整数反转 | 6237 | 35.3% | 中等 | +| 8. 字符串转换整数 (atoi) | 3383 | 21.6% | 中等 | +| 11. 盛最多水的容器 | 4078 | 61.4% | 中等 | +| 12. 整数转罗马数字 | 2281 | 66.2% | 中等 | +| 15. 三数之和 | 4348 | 35.4% | 中等 | +| 16. 最接近的三数之和 | 1902 | 45.7% | 中等 | +| 17. 电话号码的字母组合 | 4186 | 57.8% | 中等 | +| 18. 四数之和 | 2096 | 39.3% | 中等 | +| 19. 删除链表的倒数第 N 个结点 | 5702 | 44.0% | 中等 | +| 22. 括号生成 | 3596 | 77.4% | 中等 | +| 24. 两两交换链表中的节点 | 3345 | 70.8% | 中等 | +| 29. 两数相除 | 1270 | 22.1% | 中等 | +| 31. 下一个排列 | 2391 | 37.6% | 中等 | +| 33. 搜索旋转排序数组 | 3453 | 43.5% | 中等 | +| 34. 在排序数组中查找元素的第一个和最后一个位置 | 5037 | 42.2% | 中等 | +| 36. 有效的数独 | 1953 | 63.5% | 中等 | +| 38. 外观数列 | 2854 | 60.0% | 中等 | +| 39. 组合总和 | 2831 | 72.8% | 中等 | +| 40. 组合总和 II | 1967 | 60.8% | 中等 | +| 43. 字符串相乘 | 1494 | 44.8% | 中等 | +| 45. 跳跃游戏 II | 2412 | 44.5% | 中等 | +| 46. 全排列 | 4232 | 78.5% | 中等 | +| 47. 全排列 II | 2091 | 64.6% | 中等 | +| 48. 旋转图像 | 3013 | 74.1% | 中等 | +| 49. 字母异位词分组 | 1836 | 67.3% | 中等 | +| 50. Pow(x, n) | 1685 | 37.8% | 中等 | +| 54. 螺旋矩阵 | 2778 | 48.7% | 中等 | +| 55. 跳跃游戏 | 3593 | 43.5% | 中等 | +| 56. 合并区间 | 3122 | 48.5% | 中等 | +| 57. 插入区间 | 1120 | 41.5% | 中等 | +| 59. 螺旋矩阵 II | 2347 | 76.4% | 中等 | +| 61. 旋转链表 | 2481 | 41.7% | 中等 | +| 62. 不同路径 | 3183 | 67.0% | 中等 | +| 63. 不同路径 II | 2268 | 40.1% | 中等 | +| 64. 最小路径和 | 2665 | 69.2% | 中等 | +| 71. 简化路径 | 1386 | 44.2% | 中等 | +| 73. 矩阵置零 | 1364 | 61.8% | 中等 | +| 74. 搜索二维矩阵 | 2304 | 47.4% | 中等 | +| 75. 颜色分类 | 2603 | 60.1% | 中等 | +| 77. 组合 | 2045 | 77.1% | 中等 | +| 78. 子集 | 3205 | 80.5% | 中等 | +| 79. 单词搜索 | 1937 | 46.2% | 中等 | +| 80. 删除有序数组中的重复项 II | 1570 | 62.0% | 中等 | +| 81. 搜索旋转排序数组 II | 1211 | 41.3% | 中等 | +| 82. 删除排序链表中的重复元素 II | 2204 | 53.3% | 中等 | +| 86. 分隔链表 | 1381 | 63.2% | 中等 | +| 89. 格雷编码 | 780 | 74.6% | 中等 | +| 90. 子集 II | 1678 | 63.5% | 中等 | +| 91. 解码方法 | 1871 | 32.1% | 中等 | +| 92. 反转链表 II | 2778 | 55.3% | 中等 | +| 93. 复原 IP 地址 | 1814 | 56.2% | 中等 | +| 95. 不同的二叉搜索树 II | 807 | 71.9% | 中等 | +| 96. 不同的二叉搜索树 | 1822 | 70.2% | 中等 | +| 97. 交错字符串 | 689 | 45.1% | 中等 | +| 98. 验证二叉搜索树 | 2801 | 36.0% | 中等 | +| 99. 恢复二叉搜索树 | 809 | 60.4% | 中等 | +| 102. 二叉树的层序遍历 | 3400 | 64.7% | 中等 | +| 103. 二叉树的锯齿形层序遍历 | 2020 | 57.3% | 中等 | +| 105. 从前序与中序遍历序列构造二叉树 | 1985 | 71.0% | 中等 | +| 106. 从中序与后序遍历序列构造二叉树 | 1239 | 72.4% | 中等 | +| 107. 二叉树的层序遍历 II | 1618 | 71.2% | 中等 | +| 109. 有序链表转换二叉搜索树 | 912 | 76.2% | 中等 | +| 113. 路径总和 II | 1723 | 63.1% | 中等 | +| 114. 二叉树展开为链表 | 2016 | 72.8% | 中等 | +| 116. 填充每个节点的下一个右侧节点指针 | 1956 | 71.6% | 中等 | +| 117. 填充每个节点的下一个右侧节点指针 II | 1059 | 63.8% | 中等 | +| 120. 三角形最小路径和 | 1997 | 68.6% | 中等 | +| 122. 买卖股票的最佳时机 II | 3505 | 70.3% | 中等 | +| 128. 最长连续序列 | 1681 | 54.9% | 中等 | +| 129. 求根节点到叶节点数字之和 | 1432 | 69.3% | 中等 | +| 130. 被围绕的区域 | 1543 | 45.5% | 中等 | +| 131. 分割回文串 | 1233 | 72.8% | 中等 | +| 133. 克隆图 | 641 | 68.3% | 中等 | +| 134. 加油站 | 1247 | 54.2% | 中等 | +| 137. 只出现一次的数字 II | 908 | 72.1% | 中等 | +| 138. 复制带随机指针的链表 | 1087 | 67.0% | 中等 | +| 139. 单词拆分 | 1755 | 53.0% | 中等 | +| 142. 环形链表 II | 2584 | 56.0% | 中等 | +| 143. 重排链表 | 1413 | 63.7% | 中等 | +| 146. LRU 缓存 | 2361 | 52.7% | 中等 | +| 147. 对链表进行插入排序 | 923 | 68.8% | 中等 | +| 148. 排序链表 | 1673 | 66.5% | 中等 | +| 150. 逆波兰表达式求值 | 1426 | 53.7% | 中等 | +| 151. 颠倒字符串中的单词 | 1990 | 50.2% | 中等 | +| 152. 乘积最大子数组 | 1666 | 42.5% | 中等 | +| 153. 寻找旋转排序数组中的最小值 | 1935 | 56.9% | 中等 | +| 156. 上下翻转二叉树 | 175 | 72.4% | 中等 | +| 159. 至多包含两个不同字符的最长子串 | 263 | 55.4% | 中等 | +| 161. 相隔为 1 的编辑距离 | 131 | 33.9% | 中等 | +| 162. 寻找峰值 | 1476 | 49.5% | 中等 | +| 165. 比较版本号 | 1083 | 52.0% | 中等 | +| 166. 分数到小数 | 440 | 33.3% | 中等 | +| 167. 两数之和 II - 输入有序数组 | 2686 | 58.5% | 中等 | +| 172. 阶乘后的零 | 947 | 48.3% | 中等 | +| 173. 二叉搜索树迭代器 | 763 | 80.9% | 中等 | +| 176. 第二高的薪水 | 1273 | 35.7% | 中等 | +| 177. 第N高的薪水 | 637 | 46.5% | 中等 | +| 178. 分数排名 | 809 | 60.5% | 中等 | +| 179. 最大数 | 1190 | 41.1% | 中等 | +| 180. 连续出现的数字 | 659 | 48.3% | 中等 | +| 184. 部门工资最高的员工 | 837 | 49.3% | 中等 | +| 186. 翻转字符串里的单词 II | 153 | 76.2% | 中等 | +| 187. 重复的DNA序列 | 714 | 52.7% | 中等 | +| 189. 轮转数组 | 2489 | 44.3% | 中等 | +| 192. 统计词频 | 201 | 35.8% | 中等 | +| 194. 转置文件 | 87 | 34.7% | 中等 | +| 198. 打家劫舍 | 3649 | 53.1% | 中等 | +| 199. 二叉树的右视图 | 2119 | 65.5% | 中等 | +| 200. 岛屿数量 | 2864 | 57.7% | 中等 | +| 201. 数字范围按位与 | 414 | 53.4% | 中等 | +| 204. 计数质数 | 857 | 37.5% | 中等 | +| 207. 课程表 | 1324 | 53.9% | 中等 | +| 208. 实现 Trie (前缀树) | 1268 | 71.9% | 中等 | +| 209. 长度最小的子数组 | 2208 | 48.6% | 中等 | +| 210. 课程表 II | 918 | 55.5% | 中等 | +| 211. 添加与搜索单词 - 数据结构设计 | 618 | 50.9% | 中等 | +| 213. 打家劫舍 II | 2129 | 43.7% | 中等 | +| 215. 数组中的第K个最大元素 | 3108 | 64.7% | 中等 | +| 216. 组合总和 III | 1404 | 72.7% | 中等 | +| 220. 存在重复元素 III | 515 | 28.9% | 中等 | +| 221. 最大正方形 | 1290 | 48.8% | 中等 | +| 222. 完全二叉树的节点个数 | 1227 | 79.6% | 中等 | +| 223. 矩形面积 | 567 | 52.9% | 中等 | +| 227. 基本计算器 II | 874 | 43.9% | 中等 | +| 229. 求众数 II | 745 | 53.6% | 中等 | +| 230. 二叉搜索树中第K小的元素 | 1423 | 75.4% | 中等 | +| 236. 二叉树的最近公共祖先 | 1968 | 69.0% | 中等 | +| 238. 除自身以外数组的乘积 | 1201 | 73.4% | 中等 | +| 240. 搜索二维矩阵 II | 1336 | 51.0% | 中等 | +| 241. 为运算表达式设计优先级 | 404 | 73.6% | 中等 | +| 244. 最短单词距离 II | 87 | 57.6% | 中等 | +| 245. 最短单词距离 III | 79 | 58.0% | 中等 | +| 247. 中心对称数 II | 116 | 53.4% | 中等 | +| 249. 移位字符串分组 | 141 | 64.9% | 中等 | +| 250. 统计同值子树 | 111 | 63.3% | 中等 | +| 251. 展开二维向量 | 92 | 55.5% | 中等 | +| 253. 会议室 II | 471 | 51.4% | 中等 | +| 254. 因子的组合 | 111 | 57.2% | 中等 | +| 255. 验证前序遍历序列二叉搜索树 | 85 | 48.6% | 中等 | +| 256. 粉刷房子 | 250 | 66.9% | 中等 | +| 259. 较小的三数之和 | 115 | 55.9% | 中等 | +| 260. 只出现一次的数字 III | 794 | 73.5% | 中等 | +| 261. 以图判树 | 174 | 50.4% | 中等 | +| 264. 丑数 II | 779 | 58.4% | 中等 | +| 267. 回文排列 II | 99 | 45.8% | 中等 | +| 271. 字符串的编码与解码 | 59 | 56.7% | 中等 | +| 274. H 指数 | 643 | 44.2% | 中等 | +| 275. H 指数 II | 475 | 45.8% | 中等 | +| 276. 栅栏涂色 | 164 | 51.4% | 中等 | +| 277. 搜寻名人 | 119 | 57.8% | 中等 | +| 279. 完全平方数 | 1568 | 64.8% | 中等 | +| 280. 摆动排序 | 89 | 68.8% | 中等 | +| 281. 锯齿迭代器 | 90 | 76.2% | 中等 | +| 284. 顶端迭代器 | 232 | 76.8% | 中等 | +| 285. 二叉搜索树中的中序后继 | 151 | 63.9% | 中等 | +| 286. 墙与门 | 196 | 53.1% | 中等 | +| 287. 寻找重复数 | 1560 | 64.9% | 中等 | +| 288. 单词的唯一缩写 | 74 | 47.1% | 中等 | +| 289. 生命游戏 | 946 | 75.5% | 中等 | +| 291. 单词规律 II | 74 | 52.7% | 中等 | +| 294. 翻转游戏 II | 71 | 59.1% | 中等 | +| 298. 二叉树最长连续序列 | 106 | 59.0% | 中等 | +| 299. 猜数字游戏 | 764 | 56.7% | 中等 | +| 300. 最长递增子序列 | 3134 | 53.4% | 中等 | +| 304. 二维区域和检索 - 矩阵不可变 | 886 | 58.6% | 中等 | +| 306. 累加数 | 598 | 38.2% | 中等 | +| 307. 区域和检索 - 数组可修改 | 463 | 50.7% | 中等 | +| 309. 最佳买卖股票时机含冷冻期 | 1377 | 62.9% | 中等 | +| 310. 最小高度树 | 404 | 43.2% | 中等 | +| 311. 稀疏矩阵的乘法 | 66 | 76.3% | 中等 | +| 313. 超级丑数 | 412 | 59.2% | 中等 | +| 314. 二叉树的垂直遍历 | 121 | 55.5% | 中等 | +| 316. 去除重复字母 | 697 | 47.9% | 中等 | +| 318. 最大单词长度乘积 | 533 | 73.8% | 中等 | +| 319. 灯泡开关 | 465 | 57.3% | 中等 | +| 320. 列举单词的全部缩写 | 64 | 69.2% | 中等 | +| 322. 零钱兑换 | 2632 | 45.5% | 中等 | +| 323. 无向图中连通分量的数目 | 212 | 64.6% | 中等 | +| 324. 摆动排序 II | 215 | 38.5% | 中等 | +| 325. 和等于 k 的最长子数组长度 | 146 | 53.4% | 中等 | +| 328. 奇偶链表 | 1281 | 65.4% | 中等 | +| 331. 验证二叉树的前序序列化 | 561 | 48.0% | 中等 | +| 333. 最大 BST 子树 | 114 | 47.7% | 中等 | +| 334. 递增的三元子序列 | 649 | 43.3% | 中等 | +| 337. 打家劫舍 III | 1228 | 60.7% | 中等 | +| 339. 嵌套列表权重和 | 74 | 82.5% | 中等 | +| 340. 至多包含 K 个不同字符的最长子串 | 241 | 50.6% | 中等 | +| 341. 扁平化嵌套列表迭代器 | 566 | 72.6% | 中等 | +| 343. 整数拆分 | 1431 | 61.7% | 中等 | +| 347. 前 K 个高频元素 | 2081 | 62.9% | 中等 | +| 348. 设计井字棋 | 109 | 60.5% | 中等 | +| 351. 安卓系统手势解锁 | 117 | 59.9% | 中等 | +| 353. 贪吃蛇 | 63 | 43.3% | 中等 | +| 355. 设计推特 | 554 | 41.0% | 中等 | +| 356. 直线镜像 | 50 | 35.9% | 中等 | +| 357. 统计各位数字都不同的数字个数 | 846 | 59.8% | 中等 | +| 360. 有序转化数组 | 75 | 61.4% | 中等 | +| 361. 轰炸敌人 | 86 | 57.8% | 中等 | +| 362. 敲击计数器 | 88 | 68.8% | 中等 | +| 364. 加权嵌套序列和 II | 62 | 74.0% | 中等 | +| 365. 水壶问题 | 534 | 38.0% | 中等 | +| 366. 寻找二叉树的叶子节点 | 165 | 78.0% | 中等 | +| 368. 最大整除子集 | 506 | 46.0% | 中等 | +| 369. 给单链表加一 | 169 | 62.7% | 中等 | +| 370. 区间加法 | 169 | 75.1% | 中等 | +| 371. 两整数之和 | 583 | 61.5% | 中等 | +| 372. 超级次方 | 391 | 57.3% | 中等 | +| 373. 查找和最小的 K 对数字 | 466 | 41.7% | 中等 | +| 375. 猜数字大小 II | 287 | 60.7% | 中等 | +| 376. 摆动序列 | 1143 | 47.0% | 中等 | +| 377. 组合总和 Ⅳ | 717 | 52.2% | 中等 | +| 378. 有序矩阵中第 K 小的元素 | 695 | 63.3% | 中等 | +| 379. 电话目录管理系统 | 88 | 62.2% | 中等 | +| 380. O(1) 时间插入、删除和获取随机元素 | 916 | 52.9% | 中等 | +| 382. 链表随机节点 | 361 | 72.1% | 中等 | +| 384. 打乱数组 | 466 | 61.1% | 中等 | +| 385. 迷你语法分析器 | 268 | 55.0% | 中等 | +| 386. 字典序排数 | 597 | 75.1% | 中等 | +| 388. 文件的最长绝对路径 | 464 | 63.9% | 中等 | +| 390. 消除游戏 | 412 | 61.1% | 中等 | +| 393. UTF-8 编码验证 | 433 | 43.9% | 中等 | +| 394. 字符串解码 | 1685 | 56.1% | 中等 | +| 395. 至少有 K 个重复字符的最长子串 | 519 | 52.4% | 中等 | +| 396. 旋转函数 | 529 | 53.6% | 中等 | +| 397. 整数替换 | 612 | 43.0% | 中等 | +| 398. 随机数索引 | 417 | 73.7% | 中等 | +| 399. 除法求值 | 652 | 59.2% | 中等 | +| 400. 第 N 位数字 | 525 | 45.5% | 中等 | +| 402. 移掉 K 位数字 | 750 | 32.4% | 中等 | +| 406. 根据身高重建队列 | 1037 | 74.9% | 中等 | +| 413. 等差数列划分 | 1220 | 69.4% | 中等 | +| 416. 分割等和子集 | 1411 | 51.6% | 中等 | +| 417. 太平洋大西洋水流问题 | 687 | 54.9% | 中等 | +| 418. 屏幕可显示句子的数量 | 44 | 37.6% | 中等 | +| 419. 甲板上的战舰 | 473 | 78.9% | 中等 | +| 421. 数组中两个数的最大异或值 | 352 | 62.0% | 中等 | +| 423. 从英文中重建数字 | 412 | 61.1% | 中等 | +| 424. 替换后的最长重复字符 | 574 | 53.7% | 中等 | +| 426. 将二叉搜索树转化为排序的双向链表 | 158 | 67.9% | 中等 | +| 427. 建立四叉树 | 306 | 71.4% | 中等 | +| 429. N 叉树的层序遍历 | 927 | 71.9% | 中等 | +| 430. 扁平化多级双向链表 | 753 | 59.1% | 中等 | +| 433. 最小基因变化 | 622 | 55.3% | 中等 | +| 435. 无重叠区间 | 1170 | 50.8% | 中等 | +| 436. 寻找右区间 | 213 | 49.4% | 中等 | +| 437. 路径总和 III | 1233 | 56.9% | 中等 | +| 438. 找到字符串中所有字母异位词 | 1488 | 54.5% | 中等 | +| 439. 三元表达式解析器 | 79 | 59.9% | 中等 | +| 442. 数组中重复的数据 | 588 | 71.0% | 中等 | +| 443. 压缩字符串 | 777 | 47.8% | 中等 | +| 444. 序列重建 | 69 | 27.5% | 中等 | +| 445. 两数相加 II | 1125 | 59.6% | 中等 | +| 447. 回旋镖的数量 | 408 | 66.5% | 中等 | +| 449. 序列化和反序列化二叉搜索树 | 178 | 56.6% | 中等 | +| 450. 删除二叉搜索树中的节点 | 1174 | 50.6% | 中等 | +| 451. 根据字符出现频率排序 | 1114 | 71.6% | 中等 | +| 452. 用最少数量的箭引爆气球 | 1108 | 50.6% | 中等 | +| 454. 四数相加 II | 746 | 62.6% | 中等 | +| 456. 132 模式 | 533 | 36.3% | 中等 | +| 457. 环形数组是否存在循环 | 345 | 43.5% | 中等 | +| 462. 最少移动次数使数组元素相等 II | 167 | 61.5% | 中等 | +| 464. 我能赢吗 | 130 | 35.5% | 中等 | +| 467. 环绕字符串中唯一的子字符串 | 136 | 44.8% | 中等 | +| 468. 验证IP地址 | 372 | 25.9% | 中等 | +| 469. 凸多边形 | 24 | 43.3% | 中等 | +| 470. 用 Rand7() 实现 Rand10() | 393 | 55.1% | 中等 | +| 473. 火柴拼正方形 | 246 | 42.2% | 中等 | +| 474. 一和零 | 798 | 62.9% | 中等 | +| 475. 供暖器 | 617 | 40.6% | 中等 | +| 477. 汉明距离总和 | 354 | 60.5% | 中等 | +| 478. 在圆内随机生成点 | 66 | 44.8% | 中等 | +| 481. 神奇字符串 | 134 | 56.5% | 中等 | +| 484. 寻找排列 | 39 | 61.4% | 中等 | +| 486. 预测赢家 | 449 | 59.0% | 中等 | +| 487. 最大连续1的个数 II | 178 | 58.2% | 中等 | +| 490. 迷宫 | 102 | 49.1% | 中等 | +| 491. 递增子序列 | 604 | 53.0% | 中等 | +| 494. 目标和 | 1385 | 49.0% | 中等 | +| 497. 非重叠矩形中的随机点 | 52 | 40.5% | 中等 | +| 498. 对角线遍历 | 606 | 49.8% | 中等 | +| 503. 下一个更大元素 II | 1229 | 65.1% | 中等 | +| 505. 迷宫 II | 89 | 50.0% | 中等 | +| 508. 出现次数最多的子树元素和 | 282 | 68.4% | 中等 | +| 510. 二叉搜索树中的中序后继 II | 66 | 60.4% | 中等 | +| 513. 找树左下角的值 | 911 | 73.1% | 中等 | +| 515. 在每个树行中找最大值 | 630 | 65.6% | 中等 | +| 516. 最长回文子序列 | 820 | 66.4% | 中等 | +| 518. 零钱兑换 II | 916 | 68.2% | 中等 | +| 519. 随机翻转矩阵 | 197 | 46.7% | 中等 | +| 522. 最长特殊序列 II | 143 | 37.2% | 中等 | +| 523. 连续的子数组和 | 674 | 27.9% | 中等 | +| 524. 通过删除字母匹配到字典里最长单词 | 857 | 49.8% | 中等 | +| 525. 连续数组 | 596 | 54.2% | 中等 | +| 526. 优美的排列 | 434 | 73.3% | 中等 | +| 528. 按权重随机选择 | 320 | 48.0% | 中等 | +| 529. 扫雷游戏 | 517 | 64.4% | 中等 | +| 531. 孤独像素 I | 90 | 66.2% | 中等 | +| 532. 数组中的 k-diff 数对 | 333 | 38.5% | 中等 | +| 533. 孤独像素 II | 38 | 52.7% | 中等 | +| 534. 游戏玩法分析 III | 168 | 68.0% | 中等 | +| 535. TinyURL 的加密与解密 | 124 | 84.6% | 中等 | +| 536. 从字符串生成二叉树 | 75 | 54.1% | 中等 | +| 537. 复数乘法 | 622 | 74.9% | 中等 | +| 538. 把二叉搜索树转换为累加树 | 1127 | 73.5% | 中等 | +| 539. 最小时间差 | 607 | 66.5% | 中等 | +| 540. 有序数组中的单一元素 | 934 | 60.9% | 中等 | +| 542. 01 矩阵 | 891 | 46.2% | 中等 | +| 544. 输出比赛匹配对 | 59 | 71.4% | 中等 | +| 545. 二叉树的边界 | 88 | 43.5% | 中等 | +| 547. 省份数量 | 1490 | 62.0% | 中等 | +| 549. 二叉树中最长的连续序列 | 61 | 50.6% | 中等 | +| 550. 游戏玩法分析 IV | 229 | 43.6% | 中等 | +| 553. 最优除法 | 346 | 65.0% | 中等 | +| 554. 砖墙 | 523 | 50.7% | 中等 | +| 555. 分割连接字符串 | 25 | 36.1% | 中等 | +| 556. 下一个更大元素 III | 302 | 33.3% | 中等 | +| 558. 四叉树交集 | 49 | 50.9% | 中等 | +| 560. 和为 K 的子数组 | 1432 | 45.1% | 中等 | +| 562. 矩阵中最长的连续1线段 | 80 | 48.2% | 中等 | +| 565. 数组嵌套 | 182 | 59.7% | 中等 | +| 567. 字符串的排列 | 1720 | 43.8% | 中等 | +| 570. 至少有5名直接下属的经理 | 145 | 65.5% | 中等 | +| 573. 松鼠模拟 | 37 | 65.5% | 中等 | +| 574. 当选者 | 136 | 65.8% | 中等 | +| 576. 出界的路径数 | 326 | 46.9% | 中等 | +| 578. 查询回答率最高的问题 | 152 | 48.0% | 中等 | +| 580. 统计各专业学生人数 | 105 | 52.2% | 中等 | +| 581. 最短无序连续子数组 | 1060 | 41.1% | 中等 | +| 582. 杀掉进程 | 157 | 43.2% | 中等 | +| 583. 两个字符串的删除操作 | 670 | 64.5% | 中等 | +| 585. 2016年的投资 | 138 | 52.8% | 中等 | +| 592. 分数加减运算 | 142 | 52.7% | 中等 | +| 593. 有效的正方形 | 166 | 44.1% | 中等 | +| 602. 好友申请 II ：谁有最多的好友 | 113 | 60.0% | 中等 | +| 608. 树节点 | 166 | 63.7% | 中等 | +| 609. 在系统中查找重复文件 | 126 | 50.1% | 中等 | +| 611. 有效三角形的个数 | 498 | 53.4% | 中等 | +| 612. 平面上的最近距离 | 84 | 65.9% | 中等 | +| 614. 二级关注者 | 91 | 36.1% | 中等 | +| 616. 给字符串添加加粗标签 | 75 | 48.7% | 中等 | +| 621. 任务调度器 | 629 | 58.2% | 中等 | +| 622. 设计循环队列 | 550 | 44.4% | 中等 | +| 623. 在二叉树中增加一行 | 242 | 54.8% | 中等 | +| 624. 数组列表中的最大距离 | 59 | 43.4% | 中等 | +| 625. 最小因式分解 | 57 | 34.6% | 中等 | +| 626. 换座位 | 448 | 68.0% | 中等 | +| 633. 平方数之和 | 887 | 39.0% | 中等 | +| 634. 寻找数组的错位排列 | 23 | 45.5% | 中等 | +| 635. 设计日志存储系统 | 83 | 56.3% | 中等 | +| 636. 函数的独占时间 | 142 | 57.0% | 中等 | +| 638. 大礼包 | 296 | 64.4% | 中等 | +| 640. 求解方程 | 250 | 42.5% | 中等 | +| 641. 设计循环双端队列 | 305 | 52.9% | 中等 | +| 646. 最长数对链 | 257 | 58.2% | 中等 | +| 647. 回文子串 | 1240 | 66.3% | 中等 | +| 648. 单词替换 | 371 | 59.8% | 中等 | +| 649. Dota2 参议院 | 332 | 47.9% | 中等 | +| 650. 只有两个键的键盘 | 709 | 57.0% | 中等 | +| 651. 4键键盘 | 80 | 59.1% | 中等 | +| 652. 寻找重复的子树 | 344 | 58.0% | 中等 | +| 654. 最大二叉树 | 915 | 81.2% | 中等 | +| 655. 输出二叉树 | 189 | 60.3% | 中等 | +| 658. 找到 K 个最接近的元素 | 327 | 45.7% | 中等 | +| 659. 分割数组为连续子序列 | 292 | 54.3% | 中等 | +| 662. 二叉树最大宽度 | 399 | 41.0% | 中等 | +| 663. 均匀树划分 | 47 | 45.8% | 中等 | +| 665. 非递减数列 | 1023 | 27.4% | 中等 | +| 666. 路径总和 IV | 94 | 61.8% | 中等 | +| 667. 优美的排列 II | 141 | 62.2% | 中等 | +| 669. 修剪二叉搜索树 | 458 | 66.7% | 中等 | +| 670. 最大交换 | 368 | 46.0% | 中等 | +| 672. 灯泡开关 Ⅱ | 54 | 54.2% | 中等 | +| 673. 最长递增子序列的个数 | 516 | 44.0% | 中等 | +| 676. 实现一个魔法字典 | 182 | 59.9% | 中等 | +| 677. 键值映射 | 597 | 66.5% | 中等 | +| 678. 有效的括号字符串 | 555 | 38.9% | 中等 | +| 681. 最近时刻 | 80 | 49.8% | 中等 | +| 684. 冗余连接 | 752 | 67.0% | 中等 | +| 686. 重复叠加字符串匹配 | 585 | 40.1% | 中等 | +| 687. 最长同值路径 | 325 | 44.9% | 中等 | +| 688. 骑士在棋盘上的概率 | 358 | 58.3% | 中等 | +| 690. 员工的重要性 | 615 | 65.1% | 中等 | +| 692. 前K个高频单词 | 867 | 57.0% | 中等 | +| 694. 不同岛屿的数量 | 121 | 55.6% | 中等 | +| 695. 岛屿的最大面积 | 1953 | 67.5% | 中等 | +| 698. 划分为k个相等的子集 | 754 | 41.9% | 中等 | +| 701. 二叉搜索树中的插入操作 | 931 | 72.0% | 中等 | +| 702. 搜索长度未知的有序数组 | 100 | 74.3% | 中等 | +| 707. 设计链表 | 739 | 33.5% | 中等 | +| 708. 循环有序列表的插入 | 70 | 36.6% | 中等 | +| 712. 两个字符串的最小ASCII删除和 | 240 | 67.6% | 中等 | +| 713. 乘积小于 K 的子数组 | 692 | 48.6% | 中等 | +| 714. 买卖股票的最佳时机含手续费 | 948 | 73.8% | 中等 | +| 718. 最长重复子数组 | 762 | 56.7% | 中等 | +| 721. 账户合并 | 373 | 47.5% | 中等 | +| 722. 删除注释 | 86 | 32.7% | 中等 | +| 723. 粉碎糖果 | 46 | 73.2% | 中等 | +| 725. 分隔链表 | 678 | 60.6% | 中等 | +| 729. 我的日程安排表 I | 160 | 53.7% | 中等 | +| 731. 我的日程安排表 II | 65 | 50.8% | 中等 | +| 735. 行星碰撞 | 353 | 41.3% | 中等 | +| 737. 句子相似性 II | 88 | 47.3% | 中等 | +| 738. 单调递增的数字 | 721 | 50.0% | 中等 | +| 739. 每日温度 | 1992 | 69.0% | 中等 | +| 740. 删除并获得点数 | 804 | 62.7% | 中等 | +| 742. 二叉树最近的叶节点 | 66 | 49.1% | 中等 | +| 743. 网络延迟时间 | 659 | 54.0% | 中等 | +| 750. 角矩形的数量 | 48 | 72.4% | 中等 | +| 751. IP 到 CIDR | 30 | 48.0% | 中等 | +| 752. 打开转盘锁 | 885 | 53.0% | 中等 | +| 754. 到达终点数字 | 113 | 44.0% | 中等 | +| 755. 倒水 | 36 | 49.4% | 中等 | +| 756. 金字塔转换矩阵 | 86 | 54.9% | 中等 | +| 758. 字符串中的加粗单词 | 76 | 47.5% | 中等 | +| 763. 划分字母区间 | 1219 | 76.6% | 中等 | +| 764. 最大加号标志 | 68 | 49.8% | 中等 | +| 767. 重构字符串 | 531 | 48.0% | 中等 | +| 769. 最多能完成排序的块 | 215 | 58.3% | 中等 | +| 775. 全局倒置与局部倒置 | 96 | 45.9% | 中等 | +| 776. 拆分二叉搜索树 | 41 | 57.7% | 中等 | +| 777. 在LR字符串中交换相邻字符 | 72 | 32.5% | 中等 | +| 779. 第K个语法符号 | 257 | 43.7% | 中等 | +| 781. 森林中的兔子 | 714 | 60.5% | 中等 | +| 784. 字母大小写全排列 | 747 | 69.9% | 中等 | +| 785. 判断二分图 | 946 | 52.9% | 中等 | +| 787. K 站中转内最便宜的航班 | 488 | 38.9% | 中等 | +| 788. 旋转数字 | 209 | 61.2% | 中等 | +| 789. 逃脱阻碍者 | 311 | 68.9% | 中等 | +| 790. 多米诺和托米诺平铺 | 84 | 46.0% | 中等 | +| 791. 自定义字符串排序 | 240 | 69.6% | 中等 | +| 792. 匹配子序列的单词数 | 121 | 47.0% | 中等 | +| 794. 有效的井字游戏 | 470 | 38.9% | 中等 | +| 795. 区间子数组个数 | 111 | 52.9% | 中等 | +| 797. 所有可能的路径 | 1215 | 78.9% | 中等 | +| 799. 香槟塔 | 85 | 42.4% | 中等 | +| 802. 找到最终的安全状态 | 381 | 58.3% | 中等 | +| 807. 保持城市天际线 | 666 | 88.6% | 中等 | +| 808. 分汤 | 46 | 48.4% | 中等 | +| 809. 情感丰富的文字 | 103 | 41.9% | 中等 | +| 811. 子域名访问计数 | 228 | 71.1% | 中等 | +| 813. 最大平均值和的分组 | 104 | 56.1% | 中等 | +| 814. 二叉树剪枝 | 421 | 70.2% | 中等 | +| 816. 模糊坐标 | 77 | 51.4% | 中等 | +| 817. 链表组件 | 194 | 59.4% | 中等 | +| 820. 单词的压缩编码 | 662 | 51.3% | 中等 | +| 822. 翻转卡片游戏 | 49 | 50.7% | 中等 | +| 823. 带因子的二叉树 | 61 | 42.9% | 中等 | +| 825. 适龄的朋友 | 319 | 45.6% | 中等 | +| 826. 安排工作以达到最大收益 | 156 | 39.5% | 中等 | +| 831. 隐藏个人信息 | 90 | 41.4% | 中等 | +| 833. 字符串中的查找与替换 | 94 | 44.3% | 中等 | +| 835. 图像重叠 | 55 | 57.5% | 中等 | +| 837. 新 21 点 | 255 | 39.5% | 中等 | +| 838. 推多米诺 | 511 | 55.4% | 中等 | +| 840. 矩阵中的幻方 | 128 | 36.3% | 中等 | +| 841. 钥匙和房间 | 650 | 66.4% | 中等 | +| 842. 将数组拆分成斐波那契序列 | 340 | 48.6% | 中等 | +| 845. 数组中的最长山脉 | 618 | 42.2% | 中等 | +| 846. 一手顺子 | 486 | 57.2% | 中等 | +| 848. 字母移位 | 123 | 45.4% | 中等 | +| 849. 到最近的人的最大距离 | 223 | 43.2% | 中等 | +| 851. 喧闹和富有 | 293 | 62.8% | 中等 | +| 853. 车队 | 154 | 39.6% | 中等 | +| 855. 考场就座 | 72 | 41.2% | 中等 | +| 856. 括号的分数 | 262 | 63.1% | 中等 | +| 858. 镜面反射 | 57 | 56.3% | 中等 | +| 861. 翻转矩阵后的得分 | 466 | 80.8% | 中等 | +| 863. 二叉树中所有距离为 K 的结点 | 630 | 61.0% | 中等 | +| 865. 具有所有最深节点的最小子树 | 167 | 67.1% | 中等 | +| 866. 回文素数 | 107 | 23.1% | 中等 | +| 869. 重新排序得到 2 的幂 | 485 | 64.0% | 中等 | +| 870. 优势洗牌 | 269 | 45.8% | 中等 | +| 873. 最长的斐波那契子序列的长度 | 151 | 52.7% | 中等 | +| 874. 模拟行走机器人 | 270 | 42.2% | 中等 | +| 875. 爱吃香蕉的珂珂 | 518 | 49.0% | 中等 | +| 877. 石子游戏 | 539 | 76.1% | 中等 | +| 880. 索引处的解码字符串 | 88 | 26.0% | 中等 | +| 881. 救生艇 | 654 | 53.8% | 中等 | +| 885. 螺旋矩阵 III | 89 | 70.0% | 中等 | +| 886. 可能的二分法 | 262 | 47.8% | 中等 | +| 889. 根据前序和后序遍历构造二叉树 | 252 | 67.6% | 中等 | +| 890. 查找和替换模式 | 139 | 73.1% | 中等 | +| 893. 特殊等价字符串组 | 120 | 72.6% | 中等 | +| 894. 所有可能的满二叉树 | 151 | 77.7% | 中等 | +| 898. 子数组按位或操作 | 45 | 35.3% | 中等 | +| 900. RLE 迭代器 | 67 | 50.5% | 中等 | +| 901. 股票价格跨度 | 286 | 55.8% | 中等 | +| 904. 水果成篮 | 582 | 43.9% | 中等 | +| 907. 子数组的最小值之和 | 163 | 33.1% | 中等 | +| 909. 蛇梯棋 | 207 | 45.7% | 中等 | +| 910. 最小差值 II | 87 | 33.5% | 中等 | +| 911. 在线选举 | 332 | 53.9% | 中等 | +| 912. 排序数组 | 1503 | 55.6% | 中等 | +| 915. 分割数组 | 137 | 46.9% | 中等 | +| 916. 单词子集 | 94 | 45.1% | 中等 | +| 918. 环形子数组的最大和 | 380 | 36.9% | 中等 | +| 919. 完全二叉树插入器 | 135 | 65.9% | 中等 | +| 921. 使括号有效的最少添加 | 412 | 74.8% | 中等 | +| 923. 三数之和的多种可能 | 93 | 35.3% | 中等 | +| 926. 将字符串翻转到单调递增 | 180 | 55.7% | 中等 | +| 930. 和相同的二元子数组 | 374 | 54.7% | 中等 | +| 931. 下降路径最小和 | 464 | 67.1% | 中等 | +| 932. 漂亮数组 | 101 | 64.2% | 中等 | +| 934. 最短的桥 | 384 | 47.7% | 中等 | +| 935. 骑士拨号器 | 107 | 49.0% | 中等 | +| 939. 最小面积矩形 | 79 | 46.9% | 中等 | +| 945. 使数组唯一的最小增量 | 566 | 48.3% | 中等 | +| 946. 验证栈序列 | 383 | 63.5% | 中等 | +| 947. 移除最多的同行或同列石头 | 361 | 61.1% | 中等 | +| 948. 令牌放置 | 114 | 39.7% | 中等 | +| 949. 给定数字能组成的最大时间 | 145 | 37.5% | 中等 | +| 950. 按递增顺序显示卡牌 | 183 | 78.2% | 中等 | +| 951. 翻转等价二叉树 | 199 | 66.4% | 中等 | +| 954. 二倍数对数组 | 452 | 38.9% | 中等 | +| 955. 删列造序 II | 70 | 34.2% | 中等 | +| 957. N 天后的牢房 | 154 | 36.4% | 中等 | +| 958. 二叉树的完全性检验 | 335 | 54.3% | 中等 | +| 959. 由斜杠划分区域 | 322 | 74.2% | 中等 | +| 962. 最大宽度坡 | 163 | 45.2% | 中等 | +| 963. 最小面积矩形 II | 37 | 51.0% | 中等 | +| 966. 元音拼写检查器 | 56 | 41.4% | 中等 | +| 967. 连续差相同的数字 | 183 | 48.3% | 中等 | +| 969. 煎饼排序 | 603 | 67.9% | 中等 | +| 970. 强整数 | 138 | 41.2% | 中等 | +| 971. 翻转二叉树以匹配先序遍历 | 130 | 44.7% | 中等 | +| 973. 最接近原点的 K 个点 | 708 | 64.7% | 中等 | +| 974. 和可被 K 整除的子数组 | 441 | 47.1% | 中等 | +| 978. 最长湍流子数组 | 635 | 47.4% | 中等 | +| 979. 在二叉树中分配硬币 | 158 | 71.9% | 中等 | +| 981. 基于时间的键值存储 | 346 | 53.1% | 中等 | +| 983. 最低票价 | 490 | 63.4% | 中等 | +| 984. 不含 AAA 或 BBB 的字符串 | 173 | 42.4% | 中等 | +| 985. 查询后的偶数和 | 200 | 60.3% | 中等 | +| 986. 区间列表的交集 | 417 | 68.3% | 中等 | +| 988. 从叶结点开始的最小字符串 | 140 | 50.4% | 中等 | +| 990. 等式方程的可满足性 | 601 | 51.8% | 中等 | +| 991. 坏了的计算器 | 123 | 52.3% | 中等 | +| 994. 腐烂的橘子 | 1744 | 51.1% | 中等 | +| 998. 最大二叉树 II | 137 | 62.1% | 中等 | +| 1003. 检查替换后的词是否有效 | 213 | 58.1% | 中等 | +| 1004. 最大连续1的个数 III | 872 | 60.1% | 中等 | +| 1006. 笨阶乘 | 626 | 62.7% | 中等 | +| 1007. 行相等的最少多米诺旋转 | 102 | 47.1% | 中等 | +| 1008. 前序遍历构造二叉搜索树 | 285 | 72.1% | 中等 | +| 1010. 总持续时间可被 60 整除的歌曲 | 271 | 45.9% | 中等 | +| 1011. 在 D 天内送达包裹的能力 | 705 | 62.1% | 中等 | +| 1014. 最佳观光组合 | 598 | 56.4% | 中等 | +| 1015. 可被 K 整除的最小整数 | 47 | 36.3% | 中等 | +| 1016. 子串能表示从 1 到 N 数字的二进制串 | 101 | 58.0% | 中等 | +| 1017. 负二进制转换 | 61 | 56.5% | 中等 | +| 1019. 链表中的下一个更大节点 | 344 | 60.5% | 中等 | +| 1020. 飞地的数量 | 605 | 61.1% | 中等 | +| 1023. 驼峰式匹配 | 196 | 56.9% | 中等 | +| 1024. 视频拼接 | 420 | 54.8% | 中等 | +| 1026. 节点与其祖先之间的最大差值 | 210 | 68.2% | 中等 | +| 1027. 最长等差数列 | 150 | 43.4% | 中等 | +| 1029. 两地调度 | 221 | 66.9% | 中等 | +| 1031. 两个非重叠子数组的最大和 | 101 | 58.4% | 中等 | +| 1033. 移动石子直到连续 | 181 | 39.7% | 中等 | +| 1034. 边界着色 | 487 | 55.5% | 中等 | +| 1035. 不相交的线 | 470 | 66.3% | 中等 | +| 1038. 从二叉搜索树到更大和树 | 402 | 80.2% | 中等 | +| 1039. 多边形三角剖分的最低得分 | 70 | 56.7% | 中等 | +| 1040. 移动石子直到连续 II | 33 | 52.3% | 中等 | +| 1041. 困于环中的机器人 | 140 | 49.7% | 中等 | +| 1042. 不邻接植花 | 184 | 54.4% | 中等 | +| 1043. 分隔数组以得到最大和 | 124 | 70.0% | 中等 | +| 1045. 买下所有产品的客户 | 138 | 63.8% | 中等 | +| 1048. 最长字符串链 | 197 | 47.2% | 中等 | +| 1049. 最后一块石头的重量 II | 559 | 67.0% | 中等 | +| 1052. 爱生气的书店老板 | 830 | 58.2% | 中等 | +| 1053. 交换一次的先前排列 | 106 | 46.4% | 中等 | +| 1054. 距离相等的条形码 | 132 | 38.9% | 中等 | +| 1055. 形成字符串的最短路径 | 120 | 60.3% | 中等 | +| 1057. 校园自行车分配 | 48 | 48.8% | 中等 | +| 1058. 最小化舍入误差以满足目标 | 42 | 35.2% | 中等 | +| 1059. 从始点到终点的所有路径 | 42 | 37.5% | 中等 | +| 1060. 有序数组中的缺失元素 | 120 | 53.5% | 中等 | +| 1061. 按字典序排列最小的等效字符串 | 74 | 61.9% | 中等 | +| 1062. 最长重复子串 | 64 | 55.9% | 中等 | +| 1066. 校园自行车分配 II | 52 | 49.1% | 中等 | +| 1070. 产品销售分析 III | 81 | 47.7% | 中等 | +| 1072. 按列翻转得到最大值等行数 | 65 | 59.7% | 中等 | +| 1073. 负二进制数相加 | 60 | 34.7% | 中等 | +| 1077. 项目员工 III | 104 | 72.3% | 中等 | +| 1079. 活字印刷 | 224 | 73.1% | 中等 | +| 1080. 根到叶路径上的不足节点 | 114 | 50.3% | 中等 | +| 1081. 不同字符的最小子序列 | 203 | 58.1% | 中等 | +| 1087. 花括号展开 | 69 | 54.7% | 中等 | +| 1090. 受标签影响的最大值 | 102 | 55.7% | 中等 | +| 1091. 二进制矩阵中的最短路径 | 443 | 38.4% | 中等 | +| 1093. 大样本统计 | 73 | 36.9% | 中等 | +| 1094. 拼车 | 733 | 55.3% | 中等 | +| 1098. 小众书籍 | 115 | 47.6% | 中等 | +| 1100. 长度为 K 的无重复字符子串 | 132 | 70.6% | 中等 | +| 1101. 彼此熟识的最早时间 | 81 | 68.2% | 中等 | +| 1102. 得分最高的路径 | 79 | 38.4% | 中等 | +| 1104. 二叉树寻路 | 714 | 76.0% | 中等 | +| 1105. 填充书架 | 78 | 56.9% | 中等 | +| 1107. 每日新用户统计 | 119 | 41.2% | 中等 | +| 1109. 航班预订统计 | 1062 | 60.7% | 中等 | +| 1110. 删点成林 | 255 | 63.7% | 中等 | +| 1111. 有效括号的嵌套深度 | 417 | 77.0% | 中等 | +| 1112. 每位学生的最高成绩 | 113 | 65.3% | 中等 | +| 1115. 交替打印 FooBar | 546 | 56.3% | 中等 | +| 1116. 打印零与奇偶数 | 409 | 52.9% | 中等 | +| 1117. H2O 生成 | 285 | 52.8% | 中等 | +| 1120. 子树的最大平均值 | 59 | 62.0% | 中等 | +| 1123. 最深叶节点的最近公共祖先 | 131 | 70.8% | 中等 | +| 1124. 表现良好的最长时间段 | 168 | 33.1% | 中等 | +| 1126. 查询活跃业务 | 107 | 68.6% | 中等 | +| 1129. 颜色交替的最短路径 | 165 | 39.2% | 中等 | +| 1130. 叶值的最小代价生成树 | 124 | 63.8% | 中等 | +| 1131. 绝对值表达式的最大值 | 54 | 46.2% | 中等 | +| 1132. 报告的记录 II | 62 | 38.8% | 中等 | +| 1135. 最低成本联通所有城市 | 114 | 56.0% | 中等 | +| 1136. 平行课程 | 74 | 59.3% | 中等 | +| 1138. 字母板上的路径 | 159 | 43.8% | 中等 | +| 1139. 最大的以 1 为边界的正方形 | 171 | 48.6% | 中等 | +| 1140. 石子游戏 II | 109 | 65.7% | 中等 | +| 1143. 最长公共子序列 | 1434 | 64.3% | 中等 | +| 1144. 递减元素使数组呈锯齿状 | 156 | 44.5% | 中等 | +| 1145. 二叉树着色游戏 | 120 | 47.3% | 中等 | +| 1146. 快照数组 | 78 | 30.5% | 中等 | +| 1149. 文章浏览 II | 55 | 44.4% | 中等 | +| 1151. 最少交换次数来组合所有的 1 | 102 | 51.4% | 中等 | +| 1152. 用户网站访问行为分析 | 43 | 39.8% | 中等 | +| 1155. 掷骰子的N种方法 | 166 | 48.9% | 中等 | +| 1156. 单字符重复子串的最大长度 | 132 | 42.9% | 中等 | +| 1158. 市场分析 I | 97 | 55.8% | 中等 | +| 1161. 最大层内元素和 | 206 | 63.1% | 中等 | +| 1162. 地图分析 | 569 | 47.2% | 中等 | +| 1164. 指定日期的产品价格 | 106 | 60.1% | 中等 | +| 1166. 设计文件系统 | 64 | 49.1% | 中等 | +| 1167. 连接棒材的最低费用 | 41 | 47.2% | 中等 | +| 1169. 查询无效交易 | 85 | 32.4% | 中等 | +| 1170. 比较字符串最小字母出现频次 | 243 | 61.8% | 中等 | +| 1171. 从链表中删去总和值为零的连续节点 | 182 | 47.9% | 中等 | +| 1174. 即时食物配送 II | 75 | 62.7% | 中等 | +| 1177. 构建回文串检测 | 108 | 27.7% | 中等 | +| 1181. 前后拼接 | 33 | 37.9% | 中等 | +| 1182. 与目标颜色间的最短距离 | 75 | 44.8% | 中等 | +| 1186. 删除一次得到子数组最大和 | 142 | 40.7% | 中等 | +| 1188. 设计有限阻塞队列 | 77 | 70.2% | 中等 | +| 1190. 反转每对括号间的子串 | 657 | 64.9% | 中等 | +| 1191. K 次串联后最大子数组之和 | 104 | 26.7% | 中等 | +| 1193. 每月交易 I | 89 | 60.6% | 中等 | +| 1195. 交替打印字符串 | 313 | 64.2% | 中等 | +| 1197. 进击的骑士 | 69 | 38.1% | 中等 | +| 1198. 找出所有行中最小公共元素 | 70 | 74.0% | 中等 | +| 1201. 丑数 III | 107 | 25.9% | 中等 | +| 1202. 交换字符串中的元素 | 319 | 50.6% | 中等 | +| 1204. 最后一个能进入电梯的人 | 95 | 73.2% | 中等 | +| 1205. 每月交易II | 94 | 46.4% | 中等 | +| 1208. 尽可能使字符串相等 | 673 | 49.9% | 中等 | +| 1209. 删除字符串中的所有相邻重复项 II | 182 | 51.5% | 中等 | +| 1212. 查询球队积分 | 117 | 51.4% | 中等 | +| 1214. 查找两棵二叉搜索树之和 | 84 | 65.0% | 中等 | +| 1215. 步进数 | 46 | 42.2% | 中等 | +| 1218. 最长定差子序列 | 377 | 51.6% | 中等 | +| 1219. 黄金矿工 | 456 | 69.7% | 中等 | +| 1222. 可以攻击国王的皇后 | 157 | 68.3% | 中等 | +| 1226. 哲学家进餐 | 153 | 59.3% | 中等 | +| 1227. 飞机座位分配概率 | 173 | 66.6% | 中等 | +| 1229. 安排会议日程 | 83 | 44.7% | 中等 | +| 1230. 抛掷硬币 | 90 | 52.4% | 中等 | +| 1233. 删除子文件夹 | 146 | 49.9% | 中等 | +| 1234. 替换子串得到平衡字符串 | 108 | 35.0% | 中等 | +| 1236. 网络爬虫 | 38 | 56.4% | 中等 | +| 1237. 找出给定方程的正整数解 | 156 | 71.4% | 中等 | +| 1238. 循环码排列 | 87 | 66.4% | 中等 | +| 1239. 串联字符串的最大长度 | 405 | 49.0% | 中等 | +| 1242. 多线程网页爬虫 | 23 | 48.0% | 中等 | +| 1244. 力扣排行榜 | 52 | 62.7% | 中等 | +| 1245. 树的直径 | 86 | 51.8% | 中等 | +| 1247. 交换字符使得字符串相同 | 183 | 62.5% | 中等 | +| 1248. 统计「优美子数组」 | 543 | 56.9% | 中等 | +| 1249. 移除无效的括号 | 427 | 58.6% | 中等 | +| 1253. 重构 2 行二进制矩阵 | 91 | 39.8% | 中等 | +| 1254. 统计封闭岛屿的数目 | 414 | 61.8% | 中等 | +| 1256. 加密数字 | 43 | 67.3% | 中等 | +| 1257. 最小公共区域 | 51 | 57.2% | 中等 | +| 1258. 近义词句子 | 61 | 56.5% | 中等 | +| 1261. 在受污染的二叉树中查找元素 | 131 | 73.2% | 中等 | +| 1262. 可被三整除的最大和 | 232 | 52.9% | 中等 | +| 1264. 页面推荐 | 102 | 56.8% | 中等 | +| 1265. 逆序打印不可变链表 | 83 | 91.4% | 中等 | +| 1267. 统计参与通信的服务器 | 166 | 61.0% | 中等 | +| 1268. 搜索推荐系统 | 177 | 58.8% | 中等 | +| 1270. 向公司CEO汇报工作的所有人 | 97 | 80.6% | 中等 | +| 1272. 删除区间 | 38 | 54.3% | 中等 | +| 1273. 删除树节点 | 59 | 55.0% | 中等 | +| 1276. 不浪费原料的汉堡制作方案 | 111 | 50.5% | 中等 | +| 1277. 统计全为 1 的正方形子矩阵 | 274 | 73.3% | 中等 | +| 1282. 用户分组 | 265 | 81.3% | 中等 | +| 1283. 使结果不超过阈值的最小除数 | 128 | 44.4% | 中等 | +| 1285. 找到连续区间的开始和结束数字 | 76 | 81.4% | 中等 | +| 1286. 字母组合迭代器 | 112 | 65.2% | 中等 | +| 1288. 删除被覆盖区间 | 221 | 56.2% | 中等 | +| 1291. 顺次数 | 192 | 52.8% | 中等 | +| 1292. 元素和小于等于阈值的正方形的最大边长 | 123 | 48.6% | 中等 | +| 1296. 划分数组为连续数字的集合 | 151 | 48.3% | 中等 | +| 1297. 子串的最大出现次数 | 106 | 46.5% | 中等 | +| 1300. 转变数组后最接近目标值的数组和 | 399 | 46.4% | 中等 | +| 1302. 层数最深叶子节点的和 | 347 | 82.4% | 中等 | +| 1305. 两棵二叉搜索树中的所有元素 | 631 | 78.2% | 中等 | +| 1306. 跳跃游戏 III | 352 | 58.0% | 中等 | +| 1308. 不同性别每日分数总计 | 74 | 75.2% | 中等 | +| 1310. 子数组异或查询 | 515 | 71.6% | 中等 | +| 1311. 获取你好友已观看的视频 | 95 | 38.8% | 中等 | +| 1314. 矩阵区域和 | 286 | 75.6% | 中等 | +| 1315. 祖父节点值为偶数的节点和 | 312 | 81.3% | 中等 | +| 1318. 或运算的最小翻转次数 | 131 | 66.0% | 中等 | +| 1319. 连通网络的操作次数 | 579 | 61.9% | 中等 | +| 1321. 餐馆营业额变化增长 | 107 | 62.1% | 中等 | +| 1324. 竖直打印单词 | 141 | 58.9% | 中等 | +| 1325. 删除给定值的叶子节点 | 216 | 73.1% | 中等 | +| 1328. 破坏回文串 | 136 | 46.9% | 中等 | +| 1329. 将矩阵按对角线排序 | 188 | 77.0% | 中等 | +| 1333. 餐厅过滤器 | 134 | 55.4% | 中等 | +| 1334. 阈值距离内邻居最少的城市 | 117 | 51.0% | 中等 | +| 1338. 数组大小减半 | 156 | 64.1% | 中等 | +| 1339. 分裂二叉树的最大乘积 | 151 | 40.6% | 中等 | +| 1341. 电影评分 | 58 | 38.7% | 中等 | +| 1343. 大小为 K 且平均值大于等于阈值的子数组数目 | 246 | 55.5% | 中等 | +| 1344. 时钟指针的夹角 | 141 | 60.1% | 中等 | +| 1347. 制造字母异位词的最小步骤数 | 142 | 74.9% | 中等 | +| 1348. 推文计数 | 64 | 32.2% | 中等 | +| 1352. 最后 K 个数的乘积 | 94 | 45.7% | 中等 | +| 1353. 最多可以参加的会议数目 | 178 | 29.0% | 中等 | +| 1355. 活动参与者 | 71 | 66.7% | 中等 | +| 1357. 每隔 n 个顾客打折 | 52 | 53.5% | 中等 | +| 1358. 包含所有三种字符的子字符串数目 | 137 | 51.0% | 中等 | +| 1361. 验证二叉树 | 237 | 39.7% | 中等 | +| 1362. 最接近的因数 | 79 | 53.3% | 中等 | +| 1364. 顾客的可信联系人数量 | 78 | 68.7% | 中等 | +| 1366. 通过投票对团队排名 | 153 | 54.6% | 中等 | +| 1367. 二叉树中的列表 | 284 | 42.8% | 中等 | +| 1371. 每个元音包含偶数次的最长子字符串 | 286 | 58.1% | 中等 | +| 1372. 二叉树中的最长交错路径 | 194 | 52.5% | 中等 | +| 1375. 二进制字符串前缀一致的次数 | 191 | 58.4% | 中等 | +| 1376. 通知所有员工所需的时间 | 212 | 52.9% | 中等 | +| 1379. 找出克隆二叉树中的相同节点 | 187 | 83.9% | 中等 | +| 1381. 设计一个支持增量操作的栈 | 187 | 72.9% | 中等 | +| 1382. 将二叉搜索树变平衡 | 225 | 70.7% | 中等 | +| 1386. 安排电影院座位 | 144 | 32.3% | 中等 | +| 1387. 将整数按权重排序 | 205 | 69.5% | 中等 | +| 1390. 四因数 | 127 | 37.1% | 中等 | +| 1391. 检查网格中是否存在有效路径 | 224 | 40.7% | 中等 | +| 1393. 股票的资本损益 | 89 | 85.1% | 中等 | +| 1395. 统计作战单位数 | 235 | 72.7% | 中等 | +| 1396. 设计地铁系统 | 211 | 40.8% | 中等 | +| 1398. 购买了产品 A 和产品 B 却没有购买产品 C 的顾客 | 85 | 74.9% | 中等 | +| 1400. 构造 K 个回文字符串 | 120 | 61.1% | 中等 | +| 1401. 圆和矩形是否有重叠 | 106 | 42.2% | 中等 | +| 1404. 将二进制表示减到 1 的步骤数 | 170 | 49.9% | 中等 | +| 1405. 最长快乐字符串 | 477 | 64.0% | 中等 | +| 1409. 查询带键的排列 | 157 | 81.0% | 中等 | +| 1410. HTML 实体解析器 | 127 | 47.6% | 中等 | +| 1414. 和为 K 的最少斐波那契数字数目 | 429 | 70.6% | 中等 | +| 1415. 长度为 n 的开心字符串中字典序第 k 小的字符串 | 199 | 68.4% | 中等 | +| 1418. 点菜展示表 | 427 | 73.1% | 中等 | +| 1419. 数青蛙 | 176 | 42.6% | 中等 | +| 1423. 可获得的最大点数 | 574 | 55.6% | 中等 | +| 1424. 对角线遍历 II | 174 | 40.9% | 中等 | +| 1428. 至少有一个 1 的最左端列 | 29 | 60.3% | 中等 | +| 1429. 第一个唯一数字 | 56 | 51.3% | 中等 | +| 1430. 判断给定的序列是否是二叉树从根到叶的路径 | 39 | 56.1% | 中等 | +| 1432. 改变一个整数能得到的最大差值 | 114 | 39.6% | 中等 | +| 1433. 检查一个字符串是否可以打破另一个字符串 | 125 | 64.0% | 中等 | +| 1438. 绝对差不超过限制的最长连续子数组 | 512 | 48.7% | 中等 | +| 1440. 计算布尔表达式的值 | 50 | 70.3% | 中等 | +| 1442. 形成两个异或相等数组的三元组数目 | 387 | 79.2% | 中等 | +| 1443. 收集树上所有苹果的最少时间 | 159 | 41.8% | 中等 | +| 1445. 苹果和桔子 | 68 | 86.2% | 中等 | +| 1447. 最简分数 | 505 | 67.8% | 中等 | +| 1448. 统计二叉树中好节点的数目 | 224 | 71.7% | 中等 | +| 1451. 重新排列句子中的单词 | 176 | 53.1% | 中等 | +| 1452. 收藏清单 | 101 | 50.7% | 中等 | +| 1454. 活跃用户 | 99 | 39.7% | 中等 | +| 1456. 定长子串中元音的最大数目 | 267 | 53.0% | 中等 | +| 1457. 二叉树中的伪回文路径 | 156 | 62.6% | 中等 | +| 1459. 矩形面积 | 55 | 61.2% | 中等 | +| 1461. 检查一个字符串是否包含所有长度为 K 的二进制子串 | 98 | 51.0% | 中等 | +| 1462. 课程表 IV | 172 | 44.5% | 中等 | +| 1465. 切割后面积最大的蛋糕 | 90 | 31.9% | 中等 | +| 1466. 重新规划路线 | 160 | 48.9% | 中等 | +| 1468. 计算税后工资 | 59 | 69.9% | 中等 | +| 1471. 数组中的 k 个最强值 | 120 | 54.9% | 中等 | +| 1472. 设计浏览器历史记录 | 180 | 61.7% | 中等 | +| 1476. 子矩形查询 | 128 | 86.4% | 中等 | +| 1477. 找两个和为目标值且不重叠的子数组 | 116 | 29.8% | 中等 | +| 1481. 不同整数的最少数目 | 166 | 52.3% | 中等 | +| 1482. 制作 m 束花所需的最少天数 | 446 | 59.0% | 中等 | +| 1485. 克隆含随机指针的二叉树 | 32 | 79.3% | 中等 | +| 1487. 保证文件名唯一 | 116 | 32.0% | 中等 | +| 1488. 避免洪水泛滥 | 134 | 25.0% | 中等 | +| 1490. 克隆 N 叉树 | 35 | 83.6% | 中等 | +| 1492. n 的第 k 个因子 | 115 | 62.9% | 中等 | +| 1493. 删掉一个元素以后全为 1 的最长子数组 | 204 | 58.3% | 中等 | +| 1497. 检查数组对是否可以被 k 整除 | 125 | 39.8% | 中等 | +| 1498. 满足条件的子序列数目 | 96 | 34.7% | 中等 | +| 1500. 设计文件分享系统 | 40 | 29.4% | 中等 | +| 1501. 可以放心投资的国家 | 78 | 60.3% | 中等 | +| 1503. 所有蚂蚁掉下来前的最后一刻 | 97 | 52.2% | 中等 | +| 1504. 统计全 1 子矩形 | 147 | 60.9% | 中等 | +| 1506. 找到 N 叉树的根节点 | 20 | 82.0% | 中等 | +| 1508. 子数组和排序后的区间和 | 76 | 55.8% | 中等 | +| 1509. 三次操作后最大值与最小值的最小差 | 105 | 55.3% | 中等 | +| 1513. 仅含 1 的子串数 | 177 | 38.6% | 中等 | +| 1514. 概率最大的路径 | 187 | 36.5% | 中等 | +| 1519. 子树中标签相同的节点数 | 132 | 31.0% | 中等 | +| 1522. N 叉树的直径 | 47 | 71.3% | 中等 | +| 1524. 和为奇数的子数组数目 | 122 | 44.1% | 中等 | +| 1525. 字符串的好分割数目 | 125 | 66.0% | 中等 | +| 1529. 最少的后缀翻转次数 | 151 | 69.7% | 中等 | +| 1530. 好叶子节点对的数量 | 169 | 57.6% | 中等 | +| 1532. 最近的三笔订单 | 63 | 62.3% | 中等 | +| 1533. 找到最大整数的索引 | 29 | 58.7% | 中等 | +| 1535. 找出数组游戏的赢家 | 198 | 45.8% | 中等 | +| 1536. 排布二进制网格的最少交换次数 | 87 | 44.7% | 中等 | +| 1538. 找出隐藏数组中出现次数最多的元素 | 10 | 56.2% | 中等 | +| 1540. K 次操作转变字符串 | 94 | 32.1% | 中等 | +| 1541. 平衡括号字符串的最少插入次数 | 139 | 48.1% | 中等 | +| 1545. 找出第 N 个二进制字符串中的第 K 位 | 109 | 55.7% | 中等 | +| 1546. 和为目标值且不重叠的非空子数组的最大数目 | 93 | 42.7% | 中等 | +| 1549. 每件商品的最新订单 | 67 | 67.4% | 中等 | +| 1551. 使数组中所有元素相等的最小操作数 | 181 | 81.9% | 中等 | +| 1552. 两球之间的磁力 | 154 | 52.8% | 中等 | +| 1554. 只有一个不同字符的字符串 | 27 | 66.0% | 中等 | +| 1555. 银行账户概要 | 65 | 44.3% | 中等 | +| 1557. 可以到达所有点的最少点数目 | 168 | 79.7% | 中等 | +| 1558. 得到目标数组的最少函数调用次数 | 80 | 62.5% | 中等 | +| 1559. 二维网格图中探测环 | 82 | 38.3% | 中等 | +| 1561. 你可以获得的最大硬币数目 | 205 | 77.9% | 中等 | +| 1562. 查找大小为 M 的最新分组 | 104 | 32.4% | 中等 | +| 1564. 把箱子放进仓库里 I | 35 | 56.0% | 中等 | +| 1567. 乘积为正数的最长子数组长度 | 361 | 42.0% | 中等 | +| 1570. 两个稀疏向量的点积 | 46 | 88.8% | 中等 | +| 1573. 分割字符串的方案数 | 72 | 30.3% | 中等 | +| 1574. 删除最短的子数组使剩余数组有序 | 118 | 34.5% | 中等 | +| 1577. 数的平方等于两数乘积的方法数 | 91 | 33.2% | 中等 | +| 1578. 使绳子变成彩色的最短时间 | 231 | 59.0% | 中等 | +| 1580. 把箱子放进仓库里 II | 24 | 59.0% | 中等 | +| 1583. 统计不开心的朋友 | 247 | 68.5% | 中等 | +| 1584. 连接所有点的最小费用 | 441 | 66.1% | 中等 | +| 1586. 二叉搜索树迭代器 II | 29 | 61.7% | 中等 | +| 1589. 所有排列中的最大和 | 72 | 30.5% | 中等 | +| 1590. 使数组和能被 P 整除 | 65 | 27.6% | 中等 | +| 1593. 拆分字符串使唯一子字符串的数目最大 | 110 | 55.3% | 中等 | +| 1594. 矩阵的最大非负积 | 109 | 32.1% | 中等 | +| 1596. 每位顾客最经常订购的商品 | 53 | 75.4% | 中等 | +| 1599. 经营摩天轮的最大利润 | 77 | 42.4% | 中等 | +| 1600. 王位继承顺序 | 222 | 67.0% | 中等 | +| 1602. 找到二叉树中最近的右侧节点 | 47 | 74.7% | 中等 | +| 1604. 警告一小时内使用相同员工卡大于等于三次的人 | 81 | 41.8% | 中等 | +| 1605. 给定行和列的和求可行矩阵 | 85 | 74.7% | 中等 | +| 1609. 奇偶树 | 441 | 59.1% | 中等 | +| 1612. 检查两棵二叉表达式树是否等价 | 28 | 73.5% | 中等 | +| 1613. 找到遗失的ID | 43 | 72.9% | 中等 | +| 1615. 最大网络秩 | 85 | 54.1% | 中等 | +| 1616. 分割两个字符串得到回文串 | 106 | 27.9% | 中等 | +| 1618. 找出适应屏幕的最大字号 | 21 | 60.2% | 中等 | +| 1620. 网络信号最好的坐标 | 52 | 37.1% | 中等 | +| 1621. 大小为 K 的不重叠线段的数目 | 39 | 45.4% | 中等 | +| 1625. 执行操作后字典序最小的字符串 | 72 | 55.0% | 中等 | +| 1626. 无矛盾的最佳球队 | 97 | 39.9% | 中等 | +| 1628. 设计带解析函数的表达式树 | 22 | 82.3% | 中等 | +| 1630. 等差子数组 | 160 | 76.0% | 中等 | +| 1631. 最小体力消耗路径 | 352 | 49.9% | 中等 | +| 1634. 求两个多项式链表的和 | 38 | 57.0% | 中等 | +| 1637. 两点之间不包含任何点的最宽垂直面积 | 99 | 80.9% | 中等 | +| 1638. 统计只差一个字符的子串数目 | 61 | 71.8% | 中等 | +| 1641. 统计字典序元音字符串的数目 | 311 | 77.4% | 中等 | +| 1642. 可以到达的最远建筑 | 126 | 45.0% | 中等 | +| 1644. 二叉树的最近公共祖先 II | 37 | 54.7% | 中等 | +| 1647. 字符频次唯一的最小删除次数 | 139 | 52.9% | 中等 | +| 1648. 销售价值减少的颜色球 | 114 | 29.1% | 中等 | +| 1650. 二叉树的最近公共祖先 III | 46 | 80.0% | 中等 | +| 1653. 使字符串平衡的最少删除次数 | 111 | 52.9% | 中等 | +| 1654. 到家的最少跳跃次数 | 76 | 29.9% | 中等 | +| 1657. 确定两个字符串是否接近 | 91 | 46.6% | 中等 | +| 1658. 将 x 减到 0 的最小操作数 | 182 | 31.4% | 中等 | +| 1660. 纠正二叉树 | 29 | 74.5% | 中等 | +| 1663. 具有给定数值的最小字符串 | 146 | 57.4% | 中等 | +| 1664. 生成平衡数组的方案数 | 123 | 55.4% | 中等 | +| 1666. 改变二叉树的根节点 | 17 | 65.2% | 中等 | +| 1669. 合并两个链表 | 308 | 75.4% | 中等 | +| 1670. 设计前中后队列 | 104 | 52.8% | 中等 | +| 1673. 找出最具竞争力的子序列 | 195 | 37.0% | 中等 | +| 1674. 使数组互补的最少操作次数 | 61 | 38.8% | 中等 | +| 1676. 二叉树的最近公共祖先 IV | 38 | 79.0% | 中等 | +| 1679. K 和数对的最大数目 | 139 | 51.0% | 中等 | +| 1680. 连接连续二进制数字 | 81 | 47.8% | 中等 | +| 1682. 最长回文子序列 II | 28 | 55.3% | 中等 | +| 1685. 有序数组中差绝对值之和 | 114 | 63.6% | 中等 | +| 1686. 石子游戏 VI | 56 | 48.3% | 中等 | +| 1689. 十-二进制数的最少数目 | 234 | 86.4% | 中等 | +| 1690. 石子游戏 VII | 113 | 53.7% | 中等 | +| 1695. 删除子数组的最大得分 | 173 | 49.6% | 中等 | +| 1696. 跳跃游戏 VI | 138 | 39.6% | 中等 | +| 1698. 字符串的不同子字符串个数 | 23 | 51.6% | 中等 | +| 1699. 两人之间的通话次数 | 58 | 77.9% | 中等 | +| 1701. 平均等待时间 | 107 | 61.3% | 中等 | +| 1702. 修改后的最大二进制字符串 | 70 | 48.0% | 中等 | +| 1705. 吃苹果的最大数目 | 354 | 45.3% | 中等 | +| 1706. 球会落何处 | 601 | 69.3% | 中等 | +| 1709. 访问日期之间最大的空档期 | 50 | 72.7% | 中等 | +| 1711. 大餐计数 | 366 | 35.9% | 中等 | +| 1712. 将数组分成三个子数组的方案数 | 129 | 27.1% | 中等 | +| 1715. 苹果和橘子的个数 | 43 | 72.1% | 中等 | +| 1717. 删除子字符串的最大得分 | 60 | 44.4% | 中等 | +| 1718. 构建字典序最大的可行序列 | 58 | 50.2% | 中等 | +| 1721. 交换链表中的节点 | 221 | 63.8% | 中等 | +| 1722. 执行交换操作后的最小汉明距离 | 124 | 50.9% | 中等 | +| 1726. 同积元组 | 126 | 50.0% | 中等 | +| 1727. 重新排列后的最大子矩阵 | 84 | 58.0% | 中等 | +| 1730. 获取食物的最短路径 | 30 | 50.5% | 中等 | +| 1733. 需要教语言的最少人数 | 65 | 47.2% | 中等 | +| 1734. 解码异或后的排列 | 372 | 72.3% | 中等 | +| 1737. 满足三条件之一需改变的最少字符数 | 109 | 33.6% | 中等 | +| 1738. 找出第 K 大的异或坐标值 | 401 | 65.3% | 中等 | +| 1740. 找到二叉树中的距离 | 38 | 66.8% | 中等 | +| 1743. 从相邻元素对还原数组 | 339 | 69.6% | 中等 | +| 1744. 你能在你最喜欢的那天吃到你最喜欢的糖果吗？ | 373 | 36.2% | 中等 | +| 1746. 经过一次操作后的最大子数组和 | 63 | 59.5% | 中等 | +| 1747. 应该被禁止的 Leetflex 账户 | 45 | 68.0% | 中等 | +| 1749. 任意子数组和的绝对值的最大值 | 109 | 53.7% | 中等 | +| 1750. 删除字符串两端相同字符后的最短长度 | 96 | 44.8% | 中等 | +| 1753. 移除石子的最大得分 | 154 | 63.2% | 中等 | +| 1754. 构造字典序最大的合并字符串 | 97 | 43.1% | 中等 | +| 1756. 设计最近使用（MRU）队列 | 20 | 81.7% | 中等 | +| 1759. 统计同构子字符串的数目 | 108 | 44.0% | 中等 | +| 1760. 袋子里最少数目的球 | 109 | 56.5% | 中等 | +| 1762. 能看到海景的建筑物 | 37 | 70.7% | 中等 | +| 1764. 通过连接另一个数组的子数组得到一个数组 | 71 | 47.5% | 中等 | +| 1765. 地图中的最高点 | 308 | 66.5% | 中等 | +| 1769. 移动所有球到每个盒子所需的最小操作数 | 212 | 85.4% | 中等 | +| 1770. 执行乘法运算的最大分数 | 114 | 37.9% | 中等 | +| 1772. 按受欢迎程度排列功能 | 16 | 48.1% | 中等 | +| 1774. 最接近目标价格的甜点成本 | 103 | 53.7% | 中等 | +| 1775. 通过最少操作次数使数组的和相等 | 107 | 48.4% | 中等 | +| 1778. 未知网格中的最短路径 | 15 | 51.9% | 中等 | +| 1780. 判断一个数字是否可以表示成三的幂的和 | 132 | 67.2% | 中等 | +| 1781. 所有子字符串美丽值之和 | 69 | 53.8% | 中等 | +| 1783. 大满贯数量 | 39 | 80.6% | 中等 | +| 1785. 构成特定和需要添加的最少元素 | 71 | 35.8% | 中等 | +| 1786. 从第一个节点出发到最后一个节点的受限路径数 | 107 | 34.9% | 中等 | +| 1792. 最大平均通过率 | 115 | 51.0% | 中等 | +| 1794. 统计距离最小的子串对个数 | 11 | 54.5% | 中等 | +| 1797. 设计一个验证系统 | 111 | 57.4% | 中等 | +| 1798. 你能构造出连续值的最大数目 | 58 | 53.9% | 中等 | +| 1801. 积压订单中的订单总数 | 125 | 39.1% | 中等 | +| 1802. 有界数组中指定下标处的最大值 | 129 | 27.3% | 中等 | +| 1804. 实现 Trie （前缀树） II | 48 | 55.6% | 中等 | +| 1806. 还原排列的最少操作步数 | 88 | 66.4% | 中等 | +| 1807. 替换字符串中的括号内容 | 101 | 59.0% | 中等 | +| 1810. 隐藏网格下的最小消耗路径 | 8 | 61.9% | 中等 | +| 1811. 寻找面试候选人 | 42 | 64.6% | 中等 | +| 1813. 句子相似性 III | 93 | 48.3% | 中等 | +| 1814. 统计一个数组中好对子的数目 | 97 | 35.7% | 中等 | +| 1817. 查找用户活跃分钟数 | 116 | 70.0% | 中等 | +| 1818. 绝对差值和 | 359 | 37.3% | 中等 | +| 1820. 最多邀请的个数 | 15 | 45.3% | 中等 | +| 1823. 找出游戏的获胜者 | 481 | 79.0% | 中等 | +| 1824. 最少侧跳次数 | 170 | 64.7% | 中等 | +| 1828. 统计一个圆中点的数目 | 144 | 86.6% | 中等 | +| 1829. 每个查询的最大异或值 | 91 | 70.0% | 中等 | +| 1831. 每天的最大交易 | 36 | 76.7% | 中等 | +| 1833. 雪糕的最大数量 | 410 | 68.2% | 中等 | +| 1834. 单线程 CPU | 147 | 36.3% | 中等 | +| 1836. 从未排序的链表中移除重复元素 | 46 | 73.3% | 中等 | +| 1838. 最高频元素的频数 | 336 | 42.8% | 中等 | +| 1839. 所有元音按顺序排布的最长子字符串 | 158 | 54.6% | 中等 | +| 1841. 联赛信息统计 | 44 | 52.8% | 中等 | +| 1843. 可疑银行账户 | 36 | 47.1% | 中等 | +| 1845. 座位预约管理系统 | 105 | 48.8% | 中等 | +| 1846. 减小和重新排列数组后的最大元素 | 387 | 63.2% | 中等 | +| 1849. 将字符串拆分为递减的连续值 | 125 | 32.8% | 中等 | +| 1850. 邻位交换的最小次数 | 54 | 61.2% | 中等 | +| 1852. 每个子数组的数字种类数 | 14 | 55.5% | 中等 | +| 1855. 下标对中的最大距离 | 157 | 63.7% | 中等 | +| 1856. 子数组最小乘积的最大值 | 95 | 35.6% | 中等 | +| 1858. 包含所有前缀的最长单词 | 31 | 64.7% | 中等 | +| 1860. 增长的内存泄露 | 94 | 76.4% | 中等 | +| 1861. 旋转盒子 | 87 | 63.0% | 中等 | +| 1864. 构成交替字符串需要的最小交换次数 | 120 | 39.4% | 中等 | +| 1865. 找出和为指定值的下标对 | 71 | 50.6% | 中等 | +| 1867. 最大数量高于平均水平的订单 | 28 | 72.0% | 中等 | +| 1868. 两个行程编码数组的积 | 30 | 54.0% | 中等 | +| 1870. 准时到达的列车最小时速 | 92 | 44.0% | 中等 | +| 1871. 跳跃游戏 VII | 143 | 28.1% | 中等 | +| 1874. 两个数组的最小乘积和 | 28 | 86.0% | 中等 | +| 1875. 将工资相同的雇员分组 | 32 | 65.7% | 中等 | +| 1877. 数组中最大数对和的最小值 | 434 | 81.4% | 中等 | +| 1878. 矩阵中最大的三个菱形和 | 61 | 43.8% | 中等 | +| 1881. 插入后的最大值 | 76 | 36.4% | 中等 | +| 1882. 使用服务器处理任务 | 127 | 28.7% | 中等 | +| 1884. 鸡蛋掉落-两枚鸡蛋 | 71 | 69.0% | 中等 | +| 1885. 统计数对 | 22 | 56.2% | 中等 | +| 1887. 使数组元素相等的减少操作次数 | 84 | 64.7% | 中等 | +| 1888. 使二进制字符串字符交替的最少反转次数 | 73 | 33.5% | 中等 | +| 1891. 割绳子 | 34 | 40.7% | 中等 | +| 1894. 找到需要补充粉笔的学生编号 | 549 | 45.8% | 中等 | +| 1895. 最大的幻方 | 45 | 54.3% | 中等 | +| 1898. 可移除字符的最大数目 | 82 | 33.8% | 中等 | +| 1899. 合并若干三元组以形成目标三元组 | 49 | 63.6% | 中等 | +| 1901. 找出顶峰元素 II | 78 | 59.4% | 中等 | +| 1902. 给定二叉搜索树的插入顺序求深度 | 7 | 48.4% | 中等 | +| 1904. 你完成的完整对局数 | 87 | 30.1% | 中等 | +| 1905. 统计子岛屿 | 232 | 64.7% | 中等 | +| 1906. 查询差绝对值的最小值 | 59 | 42.6% | 中等 | +| 1907. 按分类统计薪水 | 32 | 60.3% | 中等 | +| 1908. Nim 游戏 II | 13 | 62.8% | 中等 | +| 1910. 删除一个字符串中所有出现的给定子字符串 | 89 | 66.5% | 中等 | +| 1911. 最大子序列交替和 | 89 | 57.2% | 中等 | +| 1914. 循环轮转矩阵 | 78 | 45.1% | 中等 | +| 1915. 最美子字符串的数目 | 63 | 40.4% | 中等 | +| 1918. 第 K 小的子数组和· | 7 | 48.3% | 中等 | +| 1921. 消灭怪物的最大数量 | 107 | 35.5% | 中等 | +| 1922. 统计好数字的数目 | 86 | 36.3% | 中等 | +| 1926. 迷宫中离入口最近的出口 | 112 | 37.6% | 中等 | +| 1927. 求和游戏 | 45 | 42.1% | 中等 | +| 1930. 长度为 3 的不同回文子序列 | 111 | 49.1% | 中等 | +| 1934. 确认率 | 26 | 73.2% | 中等 | +| 1936. 新增的最少台阶数 | 78 | 45.6% | 中等 | +| 1937. 扣分后的最大得分 | 69 | 26.2% | 中等 | +| 1940. 排序数组之间的最长公共子序列 | 33 | 75.3% | 中等 | +| 1942. 最小未被占据椅子的编号 | 83 | 40.5% | 中等 | +| 1943. 描述绘画结果 | 61 | 42.1% | 中等 | +| 1946. 子字符串突变后可能得到的最大整数 | 87 | 31.2% | 中等 | +| 1947. 最大兼容性评分和 | 100 | 55.7% | 中等 | +| 1949. 坚定的友谊 | 20 | 55.8% | 中等 | +| 1950. 所有子数组最小值中的最大值 | 9 | 53.0% | 中等 | +| 1951. 查询具有最多共同关注者的所有两两结对组 | 25 | 70.6% | 中等 | +| 1953. 你可以工作的最大周数 | 90 | 34.4% | 中等 | +| 1954. 收集足够苹果的最小花园周长 | 76 | 48.7% | 中等 | +| 1958. 检查操作是否合法 | 50 | 43.0% | 中等 | +| 1959. K 次调整数组大小浪费的最小总空间 | 37 | 43.3% | 中等 | +| 1962. 移除石子使总数最小 | 91 | 45.2% | 中等 | +| 1963. 使字符串平衡的最小交换次数 | 69 | 62.7% | 中等 | +| 1966. 未排序数组中的可被二分搜索的数 | 8 | 62.6% | 中等 | +| 1968. 构造元素不等于两相邻元素平均值的数组 | 78 | 37.4% | 中等 | +| 1969. 数组元素的最小非零乘积 | 50 | 28.9% | 中等 | +| 1973. 值等于子节点值之和的节点数量 | 12 | 61.3% | 中等 | +| 1975. 最大方阵和 | 54 | 39.9% | 中等 | +| 1976. 到达目的地的方案数 | 64 | 32.3% | 中等 | +| 1980. 找出不同的二进制字符串 | 124 | 59.2% | 中等 | +| 1981. 最小化目标值与所选元素的差 | 92 | 31.3% | 中等 | +| 1983. 范围和相等的最宽索引对 | 5 | 52.5% | 中等 | +| 1985. 找出数组中的第 K 大整数 | 113 | 41.7% | 中等 | +| 1986. 完成任务的最少工作时间段 | 84 | 29.8% | 中等 | +| 1988. 找出每所学校的最低分数要求 | 27 | 67.1% | 中等 | +| 1989. Maximum Number of People That Can Be Caught in Tag | 6 | 55.0% | 中等 | +| 1992. 找到所有的农场组 | 85 | 59.6% | 中等 | +| 1993. 树上的操作 | 55 | 38.8% | 中等 | +| 1996. 游戏中弱角色的数量 | 277 | 41.4% | 中等 | +| 1997. 访问完所有房间的第一天 | 44 | 34.2% | 中等 | +| 1999. 最小的仅由两个数组成的倍数 | 11 | 46.1% | 中等 | +| 2001. 可互换矩形的组数 | 141 | 37.2% | 中等 | +| 2002. 两个回文子序列长度的最大乘积 | 100 | 59.4% | 中等 | +| 2007. 从双倍数组中还原原数组 | 94 | 32.9% | 中等 | +| 2008. 出租车的最大盈利 | 60 | 43.9% | 中等 | +| 2012. 数组美丽值求和 | 88 | 37.3% | 中等 | +| 2013. 检测正方形 | 229 | 56.5% | 中等 | +| 2015. 每段建筑物的平均高度 | 10 | 57.7% | 中等 | +| 2017. 网格游戏 | 113 | 36.9% | 中等 | +| 2018. 判断单词是否能放入填字游戏内 | 55 | 41.7% | 中等 | +| 2020. 无流量的帐户数 | 20 | 72.6% | 中等 | +| 2021. 街上最亮的位置 | 17 | 59.0% | 中等 | +| 2023. 连接后等于目标字符串的字符串对 | 76 | 73.6% | 中等 | +| 2024. 考试的最大困扰度 | 390 | 57.3% | 中等 | +| 2028. 找出缺失的观测数据 | 381 | 50.7% | 中等 | +| 2029. 石子游戏 IX | 196 | 47.2% | 中等 | +| 2031. 1 比 0 多的子数组个数 | 15 | 55.5% | 中等 | +| 2033. 获取单值网格的最小操作数 | 101 | 40.8% | 中等 | +| 2034. 股票价格波动 | 221 | 46.8% | 中等 | +| 2036. 最大交替子数组和 | 16 | 41.7% | 中等 | +| 2038. 如果相邻两个颜色均相同则删除当前颜色 | 441 | 63.7% | 中等 | +| 2039. 网络空闲的时刻 | 177 | 55.8% | 中等 | +| 2041. 面试中被录取的候选人 | 20 | 74.0% | 中等 | +| 2043. 简易银行系统 | 283 | 67.5% | 中等 | +| 2044. 统计按位或能得到最大值的子集数目 | 366 | 81.9% | 中等 | +| 2046. 给按照绝对值排序的链表排序 | 24 | 67.4% | 中等 | +| 2048. 下一个更大的数值平衡数 | 101 | 43.0% | 中等 | +| 2049. 统计最高分的节点数目 | 297 | 51.7% | 中等 | +| 2051. The Category of Each Member in the Store | 14 | 67.5% | 中等 | +| 2052. 将句子分隔成行的最低成本 | 14 | 46.5% | 中等 | +| 2054. 两个最好的不重叠活动 | 68 | 35.4% | 中等 | +| 2055. 蜡烛之间的盘子 | 412 | 43.3% | 中等 | +| 2058. 找出临界点之间的最小和最大距离 | 84 | 56.5% | 中等 | +| 2059. 转化数字的最小运算数 | 101 | 44.5% | 中等 | +| 2061. 扫地机器人清扫过的空间个数 | 15 | 49.9% | 中等 | +| 2063. 所有子字符串中的元音 | 110 | 50.0% | 中等 | +| 2064. 分配给商店的最多商品的最小值 | 83 | 42.8% | 中等 | +| 2066. 账户余额 | 20 | 80.2% | 中等 | +| 2067. Number of Equal Count Substrings | 9 | 50.2% | 中等 | +| 2069. 模拟行走机器人 II | 95 | 20.6% | 中等 | +| 2070. 每一个查询的最大美丽值 | 94 | 43.5% | 中等 | +| 2074. 反转偶数长度组的节点 | 129 | 43.2% | 中等 | +| 2075. 解码斜向换位密码 | 69 | 46.2% | 中等 | +| 2077. Paths in Maze That Lead to Same Room | 6 | 56.1% | 中等 | +| 2079. 给植物浇水 | 123 | 77.9% | 中等 | +| 2080. 区间内查询数字的频率 | 153 | 29.2% | 中等 | +| 2083. 求以相同字母开头和结尾的子串总数 | 14 | 62.0% | 中等 | +| 2084. 为订单类型为 0 的客户删除类型为 1 的订单 | 26 | 82.9% | 中等 | +| 2086. 从房屋收集雨水需要的最少水桶数 | 77 | 45.4% | 中等 | +| 2087. 网格图中机器人回家的最小代价 | 65 | 48.3% | 中等 | +| 2090. 半径为 k 的子数组平均值 | 97 | 35.9% | 中等 | +| 2091. 从数组中移除最大值和最小值 | 124 | 56.8% | 中等 | +| 2093. Minimum Cost to Reach City With Discounts | 9 | 65.5% | 中等 | +| 2095. 删除链表的中间节点 | 125 | 58.6% | 中等 | +| 2096. 从二叉树一个节点到另一个节点每一步的方向 | 167 | 42.2% | 中等 | +| 2098. 长度为 K 的最大偶数和子序列 | 8 | 42.6% | 中等 | +| 2100. 适合打劫银行的日子 | 403 | 48.6% | 中等 | +| 2101. 引爆最多的炸弹 | 78 | 38.6% | 中等 | +| 2104. 子数组范围和 | 338 | 62.7% | 中等 | +| 2105. 给植物浇水 II | 88 | 54.5% | 中等 | +| 2107. 分享 K 个糖果后独特口味的数量 | 9 | 47.2% | 中等 | +| 2109. 向字符串添加空格 | 97 | 61.2% | 中等 | +| 2110. 股票平滑下跌阶段的数目 | 128 | 51.8% | 中等 | +| 2112. The Airport With the Most Traffic | 12 | 72.7% | 中等 | +| 2113. 查询删除和添加元素后的数组 | 9 | 70.8% | 中等 | +| 2115. 从给定原材料中找到所有可以做出的菜 | 88 | 38.6% | 中等 | +| 2116. 判断一个括号字符串是否有效 | 51 | 30.2% | 中等 | +| 2120. 执行所有后缀指令 | 90 | 82.4% | 中等 | +| 2121. 相同元素的间隔之和 | 135 | 36.5% | 中等 | +| 2125. 银行中的激光束数量 | 95 | 83.9% | 中等 | +| 2126. 摧毁小行星 | 86 | 48.5% | 中等 | +| 2128. 通过翻转行或列来去除所有的 1 | 7 | 72.0% | 中等 | +| 2130. 链表最大孪生和 | 84 | 82.9% | 中等 | +| 2131. 连接两字母单词得到的最长回文串 | 92 | 38.3% | 中等 | +| 2134. 最少交换次数来组合所有的 1 II | 150 | 47.1% | 中等 | +| 2135. 统计追加字母可以获得的单词数 | 87 | 34.2% | 中等 | +| 2137. 通过倒水操作让所有的水桶所含水量相等 | 9 | 62.3% | 中等 | +| 2139. 得到目标值的最少行动次数 | 136 | 50.6% | 中等 | +| 2140. 解决智力问题 | 138 | 41.4% | 中等 | +| 2142. The Number of Passengers in Each Bus I | 11 | 54.0% | 中等 | +| 2145. 统计隐藏数组数目 | 101 | 34.1% | 中等 | +| 2146. 价格范围内最高排名的 K 样物品 | 84 | 38.8% | 中等 | +| 2149. 按符号重排数组 | 92 | 81.0% | 中等 | +| 2150. 找出数组中的所有孤独数字 | 85 | 60.3% | 中等 | +| 2152. 穿过所有点的所需最少直线数量 | 12 | 50.5% | 中等 | +| 2155. 分组得分最高的所有下标 | 100 | 64.0% | 中等 | +| 2156. 查找给定哈希值的子串 | 78 | 24.1% | 中等 | +| 2159. Order Two Columns Independently | 7 | 63.1% | 中等 | +| 2161. 根据给定数字划分数组 | 87 | 85.0% | 中等 | +| 2162. 设置时间的最少代价 | 73 | 32.2% | 中等 | +| 2165. 重排数字的最小值 | 114 | 55.1% | 中等 | +| 2166. 设计位集 | 142 | 29.2% | 中等 | +| 2168. 每个数字的频率都相同的独特子字符串的数量 | 7 | 62.0% | 中等 | +| 2170. 使数组变成交替数组的最少操作数 | 136 | 29.3% | 中等 | +| 2171. 拿出最少数目的魔法豆 | 159 | 39.1% | 中等 | +| 2174. Remove All Ones With Row and Column Flips II | 8 | 68.8% | 中等 | +| 2175. The Change in Global Rankings | 7 | 56.1% | 中等 | +| 2177. 找到和为给定整数的三个连续整数 | 57 | 69.1% | 中等 | +| 2178. 拆分成最多数目的正偶数之和 | 91 | 55.3% | 中等 | +| 2181. 合并零之间的节点 | 124 | 86.1% | 中等 | +| 2182. 构造限制重复的字符串 | 129 | 47.8% | 中等 | +| 2184. Number of Ways to Build Sturdy Brick Wall | 9 | 49.8% | 中等 | +| 2186. 使两字符串互为字母异位词的最少步骤数 | 97 | 71.6% | 中等 | +| 2187. 完成旅途的最少时间 | 128 | 26.1% | 中等 | +| 2189. Number of Ways to Build House of Cards | 10 | 55.7% | 中等 | +| 2191. 将杂乱无章的数字排序 | 99 | 41.6% | 中等 | +| 2192. 有向无环图中一个节点的所有祖先 | 90 | 41.6% | 中等 | +| 2195. 向数组中追加 K 个整数 | 199 | 23.0% | 中等 | +| 2196. 根据描述创建二叉树 | 122 | 73.2% | 中等 | +| 2198. Number of Single Divisor Triplets | 6 | 64.6% | 中等 | +| 2201. 统计可以提取的工件 | 113 | 48.1% | 中等 | +| 2202. K 次操作后最大化顶端元素 | 133 | 20.3% | 中等 | +| 2207. 字符串中最多数目的子字符串 | 88 | 29.6% | 中等 | +| 2208. 将数组和减半的最少操作次数 | 81 | 38.8% | 中等 | +| 2211. 统计道路上的碰撞次数 | 127 | 38.6% | 中等 | +| 2212. 射箭比赛中的最大得分 | 149 | 46.6% | 中等 | +| 2214. Minimum Health to Beat Game | 6 | 56.1% | 中等 | +| 2216. 美化数组的最少删除数 | 148 | 46.9% | 中等 | +| 2217. 找到指定长度的回文数 | 143 | 32.1% | 中等 | +| 2219. Maximum Sum Score of Array | 8 | 77.1% | 中等 | +| 2221. 数组的三角和 | 65 | 80.1% | 中等 | +| 2222. 选择建筑的方案数 | 108 | 46.9% | 中等 | +| 2225. 找出输掉零场或一场比赛的玩家 | 90 | 62.7% | 中等 | +| 2226. 每个小孩最多能分到多少糖果 | 144 | 32.2% | 中等 | +| 2228. Users With Two Purchases Within Seven Days | 7 | 53.1% | 中等 | +| 2232. 向表达式添加括号后的最小结果 | 116 | 60.8% | 中等 | +| 2233. K 次增加后的最大乘积 | 144 | 35.4% | 中等 | +| 2237. Count Positions on Street With Required Brightness | 6 | 78.7% | 中等 | +| 2238. Number of Times a Driver Was a Passenger | 6 | 73.1% | 中等 | +| 2240. 买钢笔和铅笔的方案数 | 51 | 56.9% | 中等 | +| 2241. 设计一个 ATM 机器 | 53 | 34.0% | 中等 | +| 2244. 完成所有任务需要的最少轮数 | 122 | 54.9% | 中等 | +| 2245. 转角路径的乘积中最多能有几个尾随零 | 85 | 33.6% | 中等 | +| 2249. 统计圆内格点数目 | 101 | 51.4% | 中等 | +| 2256. 最小平均差 | 60 | 35.4% | 中等 | +| 2257. 统计网格图中没有被保卫的格子数 | 89 | 50.0% | 中等 | +| 2260. 必须拿起的最小连续卡牌数 | 113 | 49.5% | 中等 | +| 2261. 含最多 K 个可整除元素的子数组 | 103 | 51.2% | 中等 | +| 6043. 统计包含每个点的矩形数目 | 102 | 32.6% | 中等 | +| LCP 03. 机器人大冒险 | 202 | 22.7% | 中等 | +| LCP 08. 剧情触发时间 | 114 | 30.8% | 中等 | +| LCP 12. 小张刷题计划 | 128 | 42.5% | 中等 | +| LCP 19. 秋叶收藏集 | 219 | 51.8% | 中等 | +| LCP 23. 魔术排列 | 58 | 34.9% | 中等 | +| LCP 29. 乐团站位 | 162 | 20.8% | 中等 | +| LCP 30. 魔塔游戏 | 125 | 37.0% | 中等 | +| LCP 34. 二叉树染色 | 76 | 53.3% | 中等 | +| LCP 41. 黑白翻转棋 | 37 | 46.4% | 中等 | +| LCP 45. 自行车炫技赛场 | 35 | 23.5% | 中等 | +| LCP 46. 志愿者调配 | 31 | 43.1% | 中等 | +| LCP 52. 二叉搜索树染色 | 67 | 23.0% | 中等 | +| LCP 56. 信物传送 | 38 | 34.7% | 中等 | +| LCS 03. 主题空间 | 73 | 40.8% | 中等 | +| 剑指 Offer 04. 二维数组中的查找 | 2770 | 40.1% | 中等 | +| 剑指 Offer 07. 重建二叉树 | 1774 | 70.3% | 中等 | +| 剑指 Offer 12. 矩阵中的路径 | 1495 | 45.3% | 中等 | +| 剑指 Offer 13. 机器人的运动范围 | 2154 | 53.3% | 中等 | +| 剑指 Offer 14- I. 剪绳子 | 1665 | 57.3% | 中等 | +| 剑指 Offer 14- II. 剪绳子 II | 616 | 31.7% | 中等 | +| 剑指 Offer 16. 数值的整数次方 | 1008 | 34.5% | 中等 | +| 剑指 Offer 20. 表示数值的字符串 | 1145 | 25.1% | 中等 | +| 剑指 Offer 26. 树的子结构 | 1644 | 46.7% | 中等 | +| 剑指 Offer 31. 栈的压入、弹出序列 | 1253 | 62.0% | 中等 | +| 剑指 Offer 32 - I. 从上到下打印二叉树 | 1354 | 63.8% | 中等 | +| 剑指 Offer 32 - III. 从上到下打印二叉树 III | 1635 | 58.7% | 中等 | +| 剑指 Offer 33. 二叉搜索树的后序遍历序列 | 1292 | 56.1% | 中等 | +| 剑指 Offer 34. 二叉树中和为某一值的路径 | 1175 | 58.5% | 中等 | +| 剑指 Offer 35. 复杂链表的复制 | 1316 | 71.6% | 中等 | +| 剑指 Offer 36. 二叉搜索树与双向链表 | 1278 | 65.3% | 中等 | +| 剑指 Offer 38. 字符串的排列 | 1348 | 58.0% | 中等 | +| 剑指 Offer 44. 数字序列中某一位的数字 | 623 | 42.6% | 中等 | +| 剑指 Offer 45. 把数组排成最小的数 | 1139 | 55.6% | 中等 | +| 剑指 Offer 46. 把数字翻译成字符串 | 1884 | 52.3% | 中等 | +| 剑指 Offer 47. 礼物的最大价值 | 1354 | 69.1% | 中等 | +| 剑指 Offer 48. 最长不含重复字符的子字符串 | 1429 | 46.4% | 中等 | +| 剑指 Offer 49. 丑数 | 673 | 65.3% | 中等 | +| 剑指 Offer 56 - I. 数组中数字出现的次数 | 1274 | 69.3% | 中等 | +| 剑指 Offer 56 - II. 数组中数字出现的次数 II | 868 | 80.5% | 中等 | +| 剑指 Offer 59 - II. 队列的最大值 | 1218 | 47.7% | 中等 | +| 剑指 Offer 60. n个骰子的点数 | 761 | 57.3% | 中等 | +| 剑指 Offer 63. 股票的最大利润 | 1286 | 63.5% | 中等 | +| 剑指 Offer 64. 求1+2+…+n | 1537 | 85.9% | 中等 | +| 剑指 Offer 66. 构建乘积数组 | 746 | 60.0% | 中等 | +| 剑指 Offer 67. 把字符串转换成整数 | 745 | 29.1% | 中等 | +| 剑指 Offer II 004. 只出现一次的数字 | 278 | 70.9% | 中等 | +| 剑指 Offer II 005. 单词长度的最大乘积 | 243 | 70.9% | 中等 | +| 剑指 Offer II 007. 数组中和为 0 的三个数 | 209 | 44.3% | 中等 | +| 剑指 Offer II 008. 和大于等于 target 的最短子数组 | 264 | 48.9% | 中等 | +| 剑指 Offer II 009. 乘积小于 K 的子数组 | 234 | 53.7% | 中等 | +| 剑指 Offer II 010. 和为 k 的子数组 | 219 | 43.5% | 中等 | +| 剑指 Offer II 011. 0 和 1 个数相同的子数组 | 195 | 55.6% | 中等 | +| 剑指 Offer II 013. 二维子矩阵的和 | 162 | 66.1% | 中等 | +| 剑指 Offer II 014. 字符串中的变位词 | 194 | 51.3% | 中等 | +| 剑指 Offer II 015. 字符串中的所有变位词 | 168 | 61.9% | 中等 | +| 剑指 Offer II 016. 不含重复字符的最长子字符串 | 240 | 47.6% | 中等 | +| 剑指 Offer II 020. 回文子字符串的个数 | 181 | 71.8% | 中等 | +| 剑指 Offer II 021. 删除链表的倒数第 n 个结点 | 268 | 52.7% | 中等 | +| 剑指 Offer II 022. 链表中环的入口节点 | 208 | 55.1% | 中等 | +| 剑指 Offer II 025. 链表中的两数相加 | 236 | 59.4% | 中等 | +| 剑指 Offer II 026. 重排链表 | 210 | 66.2% | 中等 | +| 剑指 Offer II 028. 展平多级双向链表 | 186 | 60.9% | 中等 | +| 剑指 Offer II 029. 排序的循环链表 | 226 | 30.5% | 中等 | +| 剑指 Offer II 030. 插入、删除和随机访问都是 O(1) 的容器 | 95 | 54.3% | 中等 | +| 剑指 Offer II 031. 最近最少使用缓存 | 130 | 54.0% | 中等 | +| 剑指 Offer II 033. 变位词组 | 144 | 75.1% | 中等 | +| 剑指 Offer II 035. 最小时间差 | 128 | 66.9% | 中等 | +| 剑指 Offer II 036. 后缀表达式 | 171 | 56.5% | 中等 | +| 剑指 Offer II 037. 小行星碰撞 | 206 | 44.3% | 中等 | +| 剑指 Offer II 038. 每日温度 | 186 | 77.2% | 中等 | +| 剑指 Offer II 043. 往完全二叉树添加节点 | 156 | 62.3% | 中等 | +| 剑指 Offer II 044. 二叉树每层的最大值 | 186 | 63.2% | 中等 | +| 剑指 Offer II 045. 二叉树最底层最左边的值 | 210 | 79.8% | 中等 | +| 剑指 Offer II 046. 二叉树的右侧视图 | 187 | 71.7% | 中等 | +| 剑指 Offer II 047. 二叉树剪枝 | 187 | 68.6% | 中等 | +| 剑指 Offer II 049. 从根节点到叶节点的路径数字之和 | 171 | 74.6% | 中等 | +| 剑指 Offer II 050. 向下的路径节点之和 | 125 | 60.3% | 中等 | +| 剑指 Offer II 053. 二叉搜索树中的中序后继 | 166 | 63.3% | 中等 | +| 剑指 Offer II 054. 所有大于等于节点的值之和 | 160 | 85.6% | 中等 | +| 剑指 Offer II 055. 二叉搜索树迭代器 | 122 | 86.5% | 中等 | +| 剑指 Offer II 057. 值和下标之差都在给定的范围内 | 76 | 34.9% | 中等 | +| 剑指 Offer II 058. 日程表 | 92 | 61.3% | 中等 | +| 剑指 Offer II 060. 出现频率最高的 k 个数字 | 153 | 69.4% | 中等 | +| 剑指 Offer II 061. 和最小的 k 个数对 | 111 | 54.3% | 中等 | +| 剑指 Offer II 062. 实现前缀树 | 115 | 76.9% | 中等 | +| 剑指 Offer II 063. 替换单词 | 151 | 70.6% | 中等 | +| 剑指 Offer II 064. 神奇的字典 | 103 | 61.3% | 中等 | +| 剑指 Offer II 065. 最短的单词编码 | 100 | 63.7% | 中等 | +| 剑指 Offer II 066. 单词之和 | 135 | 65.1% | 中等 | +| 剑指 Offer II 067. 最大的异或 | 78 | 65.7% | 中等 | +| 剑指 Offer II 070. 排序数组中只出现一次的数字 | 148 | 64.2% | 中等 | +| 剑指 Offer II 071. 按权重生成随机数 | 67 | 50.1% | 中等 | +| 剑指 Offer II 073. 狒狒吃香蕉 | 115 | 52.6% | 中等 | +| 剑指 Offer II 074. 合并区间 | 126 | 57.2% | 中等 | +| 剑指 Offer II 076. 数组中的第 k 大的数字 | 170 | 67.8% | 中等 | +| 剑指 Offer II 077. 链表排序 | 213 | 60.7% | 中等 | +| 剑指 Offer II 079. 所有子集 | 187 | 85.7% | 中等 | +| 剑指 Offer II 080. 含有 k 个元素的组合 | 116 | 83.2% | 中等 | +| 剑指 Offer II 081. 允许重复选择元素的组合 | 155 | 80.2% | 中等 | +| 剑指 Offer II 082. 含有重复元素集合的组合 | 123 | 65.7% | 中等 | +| 剑指 Offer II 083. 没有重复元素集合的全排列 | 153 | 85.9% | 中等 | +| 剑指 Offer II 084. 含有重复元素集合的全排列 | 111 | 69.1% | 中等 | +| 剑指 Offer II 085. 生成匹配的括号 | 175 | 85.2% | 中等 | +| 剑指 Offer II 086. 分割回文子字符串 | 106 | 75.3% | 中等 | +| 剑指 Offer II 087. 复原 IP | 122 | 62.6% | 中等 | +| 剑指 Offer II 089. 房屋偷盗 | 110 | 60.9% | 中等 | +| 剑指 Offer II 090. 环形房屋偷盗 | 90 | 48.9% | 中等 | +| 剑指 Offer II 091. 粉刷房子 | 180 | 77.1% | 中等 | +| 剑指 Offer II 092. 翻转字符 | 133 | 66.8% | 中等 | +| 剑指 Offer II 093. 最长斐波那契数列 | 70 | 58.3% | 中等 | +| 剑指 Offer II 095. 最长公共子序列 | 143 | 66.0% | 中等 | +| 剑指 Offer II 096. 字符串交织 | 70 | 47.3% | 中等 | +| 剑指 Offer II 098. 路径的数目 | 126 | 76.6% | 中等 | +| 剑指 Offer II 099. 最小路径之和 | 121 | 72.6% | 中等 | +| 剑指 Offer II 100. 三角形中最小路径之和 | 117 | 76.0% | 中等 | +| 剑指 Offer II 102. 加减的目标值 | 74 | 57.9% | 中等 | +| 剑指 Offer II 103. 最少的硬币数目 | 93 | 50.7% | 中等 | +| 剑指 Offer II 104. 排列的数目 | 59 | 58.6% | 中等 | +| 剑指 Offer II 105. 岛屿的最大面积 | 149 | 70.0% | 中等 | +| 剑指 Offer II 106. 二分图 | 81 | 54.9% | 中等 | +| 剑指 Offer II 107. 矩阵中的距离 | 60 | 52.7% | 中等 | +| 剑指 Offer II 109. 开密码锁 | 66 | 57.8% | 中等 | +| 剑指 Offer II 110. 所有路径 | 119 | 80.5% | 中等 | +| 剑指 Offer II 111. 计算除法 | 65 | 66.5% | 中等 | +| 剑指 Offer II 113. 课程顺序 | 79 | 57.2% | 中等 | +| 剑指 Offer II 115. 重建序列 | 63 | 30.3% | 中等 | +| 剑指 Offer II 116. 省份数量 | 142 | 67.2% | 中等 | +| 剑指 Offer II 118. 多余的边 | 80 | 69.8% | 中等 | +| 剑指 Offer II 119. 最长连续序列 | 113 | 49.3% | 中等 | +| 面试题 01.05. 一次编辑 | 710 | 32.5% | 中等 | +| 面试题 01.07. 旋转矩阵 | 1089 | 74.2% | 中等 | +| 面试题 01.08. 零矩阵 | 597 | 62.1% | 中等 | +| 面试题 02.04. 分割链表 | 461 | 63.7% | 中等 | +| 面试题 02.05. 链表求和 | 644 | 46.7% | 中等 | +| 面试题 02.08. 环路检测 | 347 | 54.1% | 中等 | +| 面试题 03.03. 堆盘子 | 179 | 38.6% | 中等 | +| 面试题 03.05. 栈排序 | 264 | 53.9% | 中等 | +| 面试题 04.01. 节点间通路 | 315 | 53.5% | 中等 | +| 面试题 04.03. 特定深度节点链表 | 623 | 80.4% | 中等 | +| 面试题 04.05. 合法二叉搜索树 | 388 | 35.3% | 中等 | +| 面试题 04.06. 后继者 | 310 | 59.1% | 中等 | +| 面试题 04.08. 首个共同祖先 | 224 | 71.5% | 中等 | +| 面试题 04.10. 检查子树 | 316 | 71.4% | 中等 | +| 面试题 04.12. 求和路径 | 306 | 48.6% | 中等 | +| 面试题 05.02. 二进制数转字符串 | 160 | 70.7% | 中等 | +| 面试题 05.04. 下一个数 | 165 | 36.5% | 中等 | +| 面试题 05.08. 绘制直线 | 96 | 54.7% | 中等 | +| 面试题 08.02. 迷路的机器人 | 249 | 36.2% | 中等 | +| 面试题 08.04. 幂集 | 393 | 82.1% | 中等 | +| 面试题 08.05. 递归乘法 | 614 | 67.2% | 中等 | +| 面试题 08.07. 无重复字符串的排列组合 | 378 | 81.4% | 中等 | +| 面试题 08.08. 有重复字符串的排列组合 | 296 | 71.0% | 中等 | +| 面试题 08.09. 括号 | 430 | 81.5% | 中等 | +| 面试题 08.11. 硬币 | 348 | 49.5% | 中等 | +| 面试题 08.14. 布尔运算 | 89 | 53.3% | 中等 | +| 面试题 10.02. 变位词组 | 450 | 74.0% | 中等 | +| 面试题 10.03. 搜索旋转数组 | 253 | 39.1% | 中等 | +| 面试题 10.09. 排序矩阵查找 | 198 | 45.4% | 中等 | +| 面试题 10.10. 数字流的秩 | 120 | 61.9% | 中等 | +| 面试题 10.11. 峰与谷 | 134 | 66.2% | 中等 | +| 面试题 16.01. 交换数字 | 473 | 82.5% | 中等 | +| 面试题 16.02. 单词频率 | 239 | 76.8% | 中等 | +| 面试题 16.04. 井字游戏 | 183 | 46.4% | 中等 | +| 面试题 16.06. 最小差 | 239 | 42.9% | 中等 | +| 面试题 16.09. 运算 | 47 | 55.3% | 中等 | +| 面试题 16.10. 生存人数 | 227 | 68.1% | 中等 | +| 面试题 16.13. 平分正方形 | 68 | 43.4% | 中等 | +| 面试题 16.14. 最佳直线 | 73 | 56.1% | 中等 | +| 面试题 16.16. 部分排序 | 271 | 45.9% | 中等 | +| 面试题 16.18. 模式匹配 | 330 | 34.2% | 中等 | +| 面试题 16.19. 水域大小 | 424 | 62.1% | 中等 | +| 面试题 16.20. T9键盘 | 210 | 71.9% | 中等 | +| 面试题 16.21. 交换和 | 216 | 47.1% | 中等 | +| 面试题 16.22. 兰顿蚂蚁 | 69 | 58.1% | 中等 | +| 面试题 16.24. 数对和 | 198 | 47.6% | 中等 | +| 面试题 16.25. LRU 缓存 | 318 | 54.8% | 中等 | +| 面试题 16.26. 计算器 | 252 | 39.4% | 中等 | +| 面试题 17.05. 字母与数字 | 112 | 39.6% | 中等 | +| 面试题 17.07. 婴儿名字 | 240 | 41.3% | 中等 | +| 面试题 17.08. 马戏团人塔 | 135 | 27.6% | 中等 | +| 面试题 17.09. 第 k 个数 | 178 | 55.0% | 中等 | +| 面试题 17.11. 单词距离 | 307 | 68.5% | 中等 | +| 面试题 17.13. 恢复空格 | 290 | 55.3% | 中等 | +| 面试题 17.14. 最小K个数 | 832 | 59.4% | 中等 | +| 面试题 17.15. 最长单词 | 149 | 40.5% | 中等 | +| 面试题 17.17. 多次搜索 | 219 | 45.0% | 中等 | +| 面试题 17.18. 最短超串 | 146 | 44.4% | 中等 | +| 面试题 17.22. 单词转换 | 176 | 38.8% | 中等 | +| 面试题 17.23. 最大黑方阵 | 130 | 37.6% | 中等 | \ No newline at end of file diff --git a/src/main/java/com/mine/study/offer/m03.java b/src/main/java/com/mine/study/offer/m03.java new file mode 100644 index 0000000..53790fb --- /dev/null +++ b/src/main/java/com/mine/study/offer/m03.java @@ -0,0 +1,31 @@ +package com.mine.study.offer; + +/** + * @author:Sun Hongwei + * @2020/2/25 下午4:51 + * File Description：数组中重复的数字：在一个长度为 n 的数组 nums 里的所有数字都在 + * 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。 + * 请找出数组中任意一个重复的数字。 + * + * + * 如果没有重复数字，那么正常排序后，数字i应该在下标为i的位置，所以思路是重头扫描数组， + * 遇到下标为i的数字如果不是i的话，（假设为m),那么我们就拿与下标m的数字交换。 + * 在交换过程中，如果有重复的数字发生，那么终止返回ture + * + */ +public class m03 { + public int findRepeatNumber(int[] nums) { + int temp; + for(int i=0;i stack=new Stack<>(); + while(head!=null){ + stack.push(head.val); + // System.out.println(head.val); + head=head.next; + } + int[] ans=new int[stack.size()]; + int i=0; + while(!stack.empty()){ + // System.out.println(stack.peek()); + ans[i++]=stack.pop(); + } + return ans; + + } +} diff --git a/src/main/java/com/mine/study/offer/m09.java b/src/main/java/com/mine/study/offer/m09.java new file mode 100644 index 0000000..0db71b4 --- /dev/null +++ b/src/main/java/com/mine/study/offer/m09.java @@ -0,0 +1,39 @@ +package com.mine.study.offer; + +import java.util.Stack; + +/** + * @author:Sun Hongwei + * @2020/2/27 下午10:32 + * File Description：用两个栈实现队列: 用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 ) + * + * + *删除队头元素： 若stack2为空，把stack1中的元素全部取出压入到stack2中即可 + */ +public class m09 { + class CQueue { + private Stack stack1; //stack1用于储存元素 + private Stack stack2; //stack2用于辅助，操作删除队头元素 + + public CQueue() { + stack1=new Stack(); + stack2=new Stack(); + } + + public void appendTail(int value) { + stack1.push(value); + } + + public int deleteHead() { + if(stack1.isEmpty() && stack2.isEmpty()){ + return -1; + } + if(stack2.isEmpty()){ + while (!stack1.isEmpty()){ + stack2.push(stack1.pop()); + } + } + return stack2.pop(); + } + } +} diff --git a/src/main/java/com/mine/study/offer/m13.java b/src/main/java/com/mine/study/offer/m13.java new file mode 100644 index 0000000..bcde7e5 --- /dev/null +++ b/src/main/java/com/mine/study/offer/m13.java @@ -0,0 +1,41 @@ +package com.mine.study.offer; + +/** + * @author:Sun Hongwei + * @2020/2/28 上午9:53 + * File Description：机器人的运动范围:地上有一个m行n列的方格，从坐标[0,0]到坐标[m-1,n-1]。 + * 一个机器人从坐标[0, 0]的格子开始移动，它每次可以向左、右、上、下移动一格（不能移动到方格外）， + * 也不能进入行坐标和列坐标的数位之和大于k的格子。 + * + * + * 深度优先遍历DFS + */ +public class m13 { + private int m,n,k,count=0; + private boolean[][] visited; + public int movingCount(int m, int n, int k) { + this.visited=new boolean[m][n]; //访问标志位 + this.m=m; + this.k=k; + this.n=n; + dfs(0,0); + return count; + } + public void dfs(int i,int j){ + if(i<0 || i>=m || j<0 || j>=n || visited[i][j]==true){ + return; + }//遇到边界 + + if((i%10+i/10)+(j%10+j/10)>k){ + return; //数位之和超过预定值 + } + visited[i][j]=true; + count++; + + //遍历下一格 + dfs(i-1,j); + dfs(i+1,j); + dfs(i,j-1); + dfs(i,j+1); + } +} diff --git a/src/main/java/com/mine/study/offer/m17.java b/src/main/java/com/mine/study/offer/m17.java new file mode 100644 index 0000000..d935563 --- /dev/null +++ b/src/main/java/com/mine/study/offer/m17.java @@ -0,0 +1,19 @@ +package com.mine.study.offer; + +/** + * @author:Sun Hongwei + * @2020/2/29 下午6:08 + * File Description：输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。 + * 比如输入 3，则打印出 1、2、3 一直到最大的 3 位数 999。 + * + */ +public class m17 { + public int[] printNumbers(int n) { + int num=(int)Math.pow(10,n)-1; + int[] ans=new int[num]; + for(int i=0;i=0 && nums[right]%2==0){ + right--; + } + if(left>right) break; + temp=nums[left]; + nums[left]=nums[right]; + nums[right]=temp; + } + return nums; + } +} diff --git a/src/main/java/com/mine/study/offer/m26.java b/src/main/java/com/mine/study/offer/m26.java new file mode 100644 index 0000000..58d3779 --- /dev/null +++ b/src/main/java/com/mine/study/offer/m26.java @@ -0,0 +1,30 @@ +package com.mine.study.offer; + +import com.mine.study.TreeNode; + +import java.util.Date; + +/** + * @author:Sun Hongwei + * @2020/2/28 下午6:58 + * File Description： 树的子结构: 输入两棵二叉树A和B，判断B是不是A的子结构。 + * (约定空树不是任意一个树的子结构) , B是A的子结构， 即 A中有出现和B相同的结构和节点值。 + * + * + * DFS+递归 + */ +public class m26 { + public boolean isSubStructure(TreeNode A, TreeNode B) { + if(A==null || B==null) return false; + //递归遍历，只要B是A，A的左子树或者右子树的子结构即可 + return DFS(A,B) || isSubStructure(A.left,B) || isSubStructure(A.right,B); + + } + public boolean DFS(TreeNode A,TreeNode B){ + if(B==null) return true; //B全部遍历完了，说明B是A的子结构 + if(A==null) return false; //B没有结束的情况下，A先结束了，所以B不是A的子结构 + + return A.val==B.val && DFS(A.left,B.left) && DFS(A.right,B.right); + + } +} diff --git a/src/main/java/com/mine/study/offer/m32_1.java b/src/main/java/com/mine/study/offer/m32_1.java new file mode 100644 index 0000000..3b1c3fb --- /dev/null +++ b/src/main/java/com/mine/study/offer/m32_1.java @@ -0,0 +1,47 @@ +package com.mine.study.offer; + +import com.mine.study.TreeNode; + +import java.util.ArrayList; +import java.util.LinkedList; +import java.util.List; +import java.util.Queue; + +/** + * @author:Sun Hongwei + * @2020/2/27 下午11:23 + * File Description：从上到下打印二叉树:从上到下打印出二叉树的每个节点， + * 同一层的节点按照从左到右的顺序打印。 + * + * BFS:用队列实现 + */ +public class m32_1 { + public int[] levelOrder(TreeNode root) { + if(root==null){ + return new int[0]; + } + List ans=new ArrayList<>(); //因为节点数未知，先用arraylist存储 + Queue queue=new LinkedList<>(); + queue.add(root); + //用队列实现BFS + while (!queue.isEmpty()){ + int size=queue.size(); + for (int i=0;i ans; + private char[] ss; + private int[] visited; //标记访问位 + private int length; //原字符串长度 + public String[] permutation(String s) { + ss=s.toCharArray(); //原字符串转化为字符串数组 + //现将字符串数组内字符排序 + Arrays.sort(ss); + length=s.length(); + visited=new int[length]; + ans=new ArrayList(); + backtrack(new StringBuilder()); //回溯入口 + results=new String[ans.size()]; + for(int i=0;i0 && ss[i]==ss[i-1] && visited[i-1]==0){ + continue; + } + visited[i]=1; + temp.append(ss[i]); + backtrack(temp); + visited[i]=0; + temp.delete(temp.length()-1,temp.length()); + } + } + +} diff --git a/src/main/java/com/mine/study/offer/m40.java b/src/main/java/com/mine/study/offer/m40.java new file mode 100644 index 0000000..331d96b --- /dev/null +++ b/src/main/java/com/mine/study/offer/m40.java @@ -0,0 +1,36 @@ +package com.mine.study.offer; + +import java.util.PriorityQueue; +import java.util.Queue; + +/** + * @author:Sun Hongwei + * @2020/2/28 上午2:29 + * File Description：最小的k个数:输入整数数组 arr ，找出其中最小的 k 个数。 + * 例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。 + * + * + * Java中PirorityQueue以堆为基础 + */ +public class m40 { + public int[] getLeastNumbers(int[] arr, int k) { + if(k==0) return new int[0]; + Queue q=new PriorityQueue((a,b)->b-a); + for(int a:arr){ + if(q.size()a){ + q.remove(); + q.add(a); + } + } + + int[] result=new int[k]; + int num=0; + while(q.size()>0){ + result[num++]=q.remove(); + } + return result; + + } +} diff --git a/src/main/java/com/mine/study/offer/m45.java b/src/main/java/com/mine/study/offer/m45.java new file mode 100644 index 0000000..4462d20 --- /dev/null +++ b/src/main/java/com/mine/study/offer/m45.java @@ -0,0 +1,30 @@ +package com.mine.study.offer; + +import java.util.ArrayList; +import java.util.List; + +/** + * @author:Sun Hongwei + * @2020/2/28 下午3:56 + * File Description：把数组排成最小的数: 输入一个正整数数组，把数组里所有数字拼接起来排成一个数， + * 打印能拼接出的所有数字中最小的一个。 + * + * 本质上就是排序题，根据字符串a+b和b+a的大小来排序 + * 这里用到了sort函数里套用compareTo + * + */ +public class m45 { + public String minNumber(int[] nums) { + List str=new ArrayList(); + //转换为String数组 + for(int n:nums){ + str.add(String.valueOf(n)); + } + str.sort((s1,s2)->(s1+s2).compareTo(s2+s1)); + StringBuilder stringBuilder=new StringBuilder(); + for(String s:str){ + stringBuilder.append(s); + } + return stringBuilder.toString(); + } +} diff --git a/src/main/java/com/mine/study/offer/m46.java b/src/main/java/com/mine/study/offer/m46.java new file mode 100644 index 0000000..62982f9 --- /dev/null +++ b/src/main/java/com/mine/study/offer/m46.java @@ -0,0 +1,37 @@ +package com.mine.study.offer; + +/** + * @author:Sun Hongwei + * @2020/2/28 下午6:27 + * File Description：把数字翻译成字符串:给定一个数字，我们按照如下规则把它翻译为字符串：0 翻译成 “a” ， + * 1 翻译成 “b”，……，11 翻译成 “l”，……，25 翻译成 “z”。一个数字可能有多个翻译。 + * 请编程实现一个函数，用来计算一个数字有多少种不同的翻译方法。 + * + * + * + *动态规划：若第i位和第i-1位组成的数字小于26且大于等于10，那么dp[i]=dp[i-1]+dp[i-2] + * 否则dp[i]=dp[i-1] + */ +public class m46 { + public int translateNum(int num) { + char[] numc=String.valueOf(num).toCharArray(); + int[] dp=new int[numc.length]; + if(numc.length==1) return 1; + //确定动态转移方程前两位 + dp[0]=1; + if((numc[0]-'0')*10+numc[1]-'0'<26){ + dp[1]=2; + }else{ + dp[1]=1; + } + for(int i=2;i=10){ //某一位是0的情况也需要考虑 + dp[i]=dp[i-1]+dp[i-2]; + }else{ + dp[i]=dp[i-1]; + } + } + return dp[numc.length-1]; + } +} diff --git a/src/main/java/com/mine/study/offer/m47.java b/src/main/java/com/mine/study/offer/m47.java new file mode 100644 index 0000000..e72c34c --- /dev/null +++ b/src/main/java/com/mine/study/offer/m47.java @@ -0,0 +1,29 @@ +package com.mine.study.offer; + +/** + * @author:Sun Hongwei + * @2020/2/27 下午7:50 + * File Description：礼物的最大价值:在一个 m*n 的棋盘的每一格都放有一个礼物， + * 每个礼物都有一定的价值（价值大于 0）。你可以从棋盘的左上角开始拿格子里的礼物， + * 并每次向右或者向下移动一格、直到到达棋盘的右下角。给定一个棋盘及其上面的礼物的价值， + * 请计算你最多能拿到多少价值的礼物？ + * + * 动态规划：状态转移方程：dp[i][j]=max(dp[i-1][j],dp[i][j-1])+grid[i][j]; + * + */ +public class m47 { + public int maxValue(int[][] grid) { + for(int i=1;itarget){ + right=mid-1; + }else if(nums[mid] nodes=new ArrayList<>(); + private int k; + public int kthLargest(TreeNode root, int k) { + this.k=k; + inorder(root); + return nodes.get(k-1); + } + + private void inorder(TreeNode root){ + if(root.right!=null) inorder(root.right); + nodes.add(root.val); + if(nodes.size()==k) return; + if(root.left!=null) inorder(root.left); + } +} diff --git a/src/main/java/com/mine/study/offer/m56_1.java b/src/main/java/com/mine/study/offer/m56_1.java new file mode 100644 index 0000000..f6e4394 --- /dev/null +++ b/src/main/java/com/mine/study/offer/m56_1.java @@ -0,0 +1,35 @@ +package com.mine.study.offer; + +/** + * @author:Sun Hongwei + * @2020/2/25 下午9:08 + * File Description：数组中数字出现的次数:一个整型数组 nums 里除两个数字之外，其他数字都出现了两次。 + * 请写程序找出这两个只出现一次的数字。要求时间复杂度是O(n)，空间复杂度是O(1)。 + * + * + * !异或处理：相同的数字异或后，结果为0，不相同的数字处理后，结果不为0 + * + * 1. 先把所有数字异或处理，找出结果不为1的那一位 + * 2. 按照那一位是0或者是1，把结果分为两组（这样两个答案一定都在不同组） + * 3. 对每一组单独异或处理，找到每组的那个数 + * + */ +public class m56_1 { + public int[] singleNumbers(int[] nums) { + int ans=0; + int[] result=new int[2]; + for(int i:nums){ + ans=ans^i; + } + int lastOne = ans & -ans; //求出结果是1的最后1位，其他位是0 + //将数组分为两组 + for(int i:nums){ + if((i&lastOne)==0){ + result[0]^=i; + }else{ + result[1]^=i; + } + } + return result; + } +} diff --git a/src/main/java/com/mine/study/offer/m56_2.java b/src/main/java/com/mine/study/offer/m56_2.java new file mode 100644 index 0000000..c3395d4 --- /dev/null +++ b/src/main/java/com/mine/study/offer/m56_2.java @@ -0,0 +1,28 @@ +package com.mine.study.offer; + +/** + * @author:Sun Hongwei + * @2020/2/25 下午10:07 + * File Description：数组中数字出现的次数 II:在一个数组 nums 中除一个数字只出现一次之外，其他数字都出现了三次。 + * 请找出那个只出现一次的数字。 + * + * + * 所有数转化成二进制按位相加，出现三次的数相加之和每位都是三的倍数，取余数后即为只出现一次的数 + */ +public class m56_2 { + public int singleNumber(int[] nums) { + int ans=0; + for(int i=0;i<32;i++) { + int count=0; //count用于计算每一位的和 + for(int n:nums){ + if(((1<0){ //取第i位的值 + count++; + } + } + if(count%3==1){ + ans+=(1<target){ + j--; + }else if(nums[i]+nums[j]s.length()) return s; + chars=s.toCharArray(); + //翻转 + reverse(0,n-1); + reverse(n,s.length()-1); + reverse(0,s.length()-1); + + return new String(chars); + } + private void reverse(int i,int j){ + char t; + while(i=i-1){ //j-d0 && nums[i]-nums[i-1]>1 && nums[i-1]!=0) { + if (nums[i]-nums[i-1]-1>count) { //如果0不够替代中间的差值，返回false + return false; + }else { + count-=(nums[i]-nums[i-1]-1); + } + }else if(i>0 && nums[i]==nums[i-1]){ //如果遇到重复不为0的牌，直接返回false + return false; + } + } + return true; + } +} diff --git a/src/main/java/com/mine/study/offer/m62.java b/src/main/java/com/mine/study/offer/m62.java new file mode 100644 index 0000000..a397f16 --- /dev/null +++ b/src/main/java/com/mine/study/offer/m62.java @@ -0,0 +1,22 @@ +package com.mine.study.offer; + +/** + * @author:Sun Hongwei + * @2020/2/25 下午6:01 + * File Description：圆圈中最后剩下的数字:0,1,...,n-1这n个数字排成一个圆圈， + * 从数字0开始，每次从这个圆圈里删除第m个数字。求出这个圆圈里剩下的最后一个数字。 + * + * + */ +public class m62 { + public int lastRemaining(int n, int m) { + if(n<1 || m<1){ + return -1; + } + int ans=0; + for(int i=2;i<=n;i++){ + ans=(ans+m)%i; + } + return ans; + } +} diff --git a/src/main/java/com/mine/study/offer/m64.java b/src/main/java/com/mine/study/offer/m64.java new file mode 100644 index 0000000..b5e9d43 --- /dev/null +++ b/src/main/java/com/mine/study/offer/m64.java @@ -0,0 +1,16 @@ +package com.mine.study.offer; + +/** + * @author:Sun Hongwei + * @2020/2/25 下午5:47 + * File Description： 求1+2+…+n:求 1+2+...+n ， + * 要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C） + * + * + * 递归 + */ +public class m64 { + public int sumNums(int n) { + return n==1?1:sumNums(n-1)+n; + } +} diff --git a/src/main/java/com/mine/study/offer/m65.java b/src/main/java/com/mine/study/offer/m65.java new file mode 100644 index 0000000..0b49109 --- /dev/null +++ b/src/main/java/com/mine/study/offer/m65.java @@ -0,0 +1,21 @@ +package com.mine.study.offer; + +/** + * @author:Sun Hongwei + * @2020/2/28 上午10:29 + * File Description：不用加减乘除做加法 + * + * + * 位运算 + */ +public class m65 { + public int add(int a, int b) { + int sum=0; + while(b!=0){ + sum=a^b; //异或:表示求各位数字之和，不考虑进位 + b=(a&b)<<1; //与运算，再向右移一位，表示求进位 + a=sum; + } + return sum; + } +} diff --git a/src/main/java/com/mine/study/offer/m66.java b/src/main/java/com/mine/study/offer/m66.java new file mode 100644 index 0000000..304d57a --- /dev/null +++ b/src/main/java/com/mine/study/offer/m66.java @@ -0,0 +1,29 @@ +package com.mine.study.offer; + +/** + * @author:Sun Hongwei + * @2020/2/28 上午1:17 + * File Description：构建乘积数组: 给定一个数组 A[0,1,…,n-1]，请构建一个数组 B[0,1,…,n-1]， + * 其中 B 中的元素 B[i]=A[0]×A[1]×…×A[i-1]×A[i+1]×…×A[n-1]。不能使用除法。 + * + * + * 将每个最终答案分成left*right两部分来看，分别从左和从右遍历两遍计算即可 + * + */ +public class m66 { + public int[] constructArr(int[] a) { + int[] result=new int[a.length]; + int left=1,right=1; + //求left + for(int i=0;i=0;i--){ + result[i]*=right; + right*=a[i]; + } + return result; + } +} diff --git a/src/main/java/com/mine/study/sql/demo1179 b/src/main/java/com/mine/study/sql/demo1179 new file mode 100644 index 0000000..483f4ee --- /dev/null +++ b/src/main/java/com/mine/study/sql/demo1179 @@ -0,0 +1,68 @@ +demo1179 + +部门表 Department： + ++---------------+---------+ +| Column Name | Type | ++---------------+---------+ +| id | int | +| revenue | int | +| month | varchar | ++---------------+---------+ +(id, month) 是表的联合主键。 +这个表格有关于每个部门每月收入的信息。 +月份（month）可以取下列值 ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]。 +  + +编写一个 SQL 查询来重新格式化表，使得新的表中有一个部门 id 列和一些对应 每个月 的收入（revenue）列。 + +查询结果格式如下面的示例所示： + +Department 表： ++------+---------+-------+ +| id | revenue | month | ++------+---------+-------+ +| 1 | 8000 | Jan | +| 2 | 9000 | Jan | +| 3 | 10000 | Feb | +| 1 | 7000 | Feb | +| 1 | 6000 | Mar | ++------+---------+-------+ + +查询得到的结果表： ++------+-------------+-------------+-------------+-----+-------------+ +| id | Jan_Revenue | Feb_Revenue | Mar_Revenue | ... | Dec_Revenue | ++------+-------------+-------------+-------------+-----+-------------+ +| 1 | 8000 | 7000 | 6000 | ... | null | +| 2 | 9000 | null | null | ... | null | +| 3 | null | 10000 | null | ... | null | ++------+-------------+-------------+-------------+-----+-------------+ + +_______________________________________________________________ + +1.用case...when...then... END 筛选月份： +2.用sum()/group id统计： sum用来将id相同的统计到一起 + +SELECT id, + +SUM(CASE month WHEN 'Jan' THEN revenue END) Jan_Revenue, +SUM(CASE month WHEN 'Feb' THEN revenue END) Feb_Revenue, +SUM(CASE month WHEN 'Mar' THEN revenue END) Mar_Revenue, +SUM(CASE month WHEN 'Apr' THEN revenue END) Apr_Revenue, +SUM(CASE month WHEN 'May' THEN revenue END) May_Revenue, +SUM(CASE month WHEN 'Jun' THEN revenue END) Jun_Revenue, +SUM(CASE month WHEN 'Jul' THEN revenue END) Jul_Revenue, +SUM(CASE month WHEN 'Aug' THEN revenue END) Aug_Revenue, +SUM(CASE month WHEN 'Sep' THEN revenue END) Sep_Revenue, +SUM(CASE month WHEN 'Oct' THEN revenue END) Oct_Revenue, +SUM(CASE month WHEN 'Nov' THEN revenue END) Nov_Revenue, +SUM(CASE month WHEN 'Dec' THEN revenue END) Dec_Revenue + +FROM Department +GROUP BY id; + + + + + + diff --git a/src/main/java/com/mine/study/sql/demo175 b/src/main/java/com/mine/study/sql/demo175 new file mode 100644 index 0000000..f57d039 --- /dev/null +++ b/src/main/java/com/mine/study/sql/demo175 @@ -0,0 +1,38 @@ +demo175 + +表1: Person + ++-------------+---------+ +| 列名 | 类型 | ++-------------+---------+ +| PersonId | int | +| FirstName | varchar | +| LastName | varchar | ++-------------+---------+ +PersonId 是上表主键 +表2: Address + ++-------------+---------+ +| 列名 | 类型 | ++-------------+---------+ +| AddressId | int | +| PersonId | int | +| City | varchar | +| State | varchar | ++-------------+---------+ +AddressId 是上表主键 + +编写一个 SQL 查询，满足条件：无论 person 是否有地址信息，都需要基于上述两表提供 person 的以下信息： +FirstName, LastName, City, State + + +_______________________________________________________________ + + + +连接时保证一表存在，用left(right) join ... on... + +SELECT Person.FirstName,Person.LastName,Address.City,Address.State +FROM Person +LEFT JOIN Address +ON Person.PersonId=Address.PersonId; \ No newline at end of file diff --git a/src/main/java/com/mine/study/sql/demo176 b/src/main/java/com/mine/study/sql/demo176 new file mode 100644 index 0000000..9440e7c --- /dev/null +++ b/src/main/java/com/mine/study/sql/demo176 @@ -0,0 +1,33 @@ +demo176 + +编写一个 SQL 查询，获取 Employee 表中第二高的薪水（Salary） 。 + ++----+--------+ +| Id | Salary | ++----+--------+ +| 1 | 100 | +| 2 | 200 | +| 3 | 300 | ++----+--------+ +例如上述 Employee 表，SQL查询应该返回 200 作为第二高的薪水。如果不存在第二高的薪水，那么查询应返回 null。 + ++---------------------+ +| SecondHighestSalary | ++---------------------+ +| 200 | ++---------------------+ + +_______________________________________________________________ +(1) select * from table limit 2,1; 含义是跳过2条取出1条数据 +(2) select * from table limit 2 offset 1; 含义是从第1条（不包括）数据开始取出2条数据 + + + +SELECT +IFNULL +( + (SELECT distinct(Salary) FROM Employee + ORDER BY Salary DESC + LIMIT 1 offset 1) +,null) +as SecondHighestSalary; \ No newline at end of file diff --git a/src/main/java/com/mine/study/sql/demo177 b/src/main/java/com/mine/study/sql/demo177 new file mode 100644 index 0000000..08529f2 --- /dev/null +++ b/src/main/java/com/mine/study/sql/demo177 @@ -0,0 +1,38 @@ +demo177 + +编写一个 SQL 查询，获取 Employee 表中第 n 高的薪水（Salary）。 + ++----+--------+ +| Id | Salary | ++----+--------+ +| 1 | 100 | +| 2 | 200 | +| 3 | 300 | ++----+--------+ +例如上述 Employee 表，n = 2 时，应返回第二高的薪水 200。如果不存在第 n 高的薪水，那么查询应返回 null。 + ++------------------------+ +| getNthHighestSalary(2) | ++------------------------+ +| 200 | ++------------------------+ + +_______________________________________________________________ +先判断n的大小，取第n个时用limit n-1,1 //跳过n-1个数后，取第n个 + + + +CREATE FUNCTION getNthHighestSalary(N INT) RETURNS INT +BEGIN + SET N=N-1; + RETURN( + SELECT IFNULL( + ( + SELECT DISTINCT(Salary) + FROM Employee + ORDER BY Salary DESC + LIMIT N,1 + ) + ,null) as getNthHighestSalary + ); +END \ No newline at end of file diff --git a/src/main/java/com/mine/study/sql/demo178 b/src/main/java/com/mine/study/sql/demo178 new file mode 100644 index 0000000..7d30387 --- /dev/null +++ b/src/main/java/com/mine/study/sql/demo178 @@ -0,0 +1,35 @@ +demo178 + +编写一个 SQL 查询来实现分数排名。如果两个分数相同，则两个分数排名（Rank）相同。请注意，平分后的下一个名次应该是下一个连续的整数值。换句话说，名次之间不应该有“间隔”。 + ++----+-------+ +| Id | Score | ++----+-------+ +| 1 | 3.50 | +| 2 | 3.65 | +| 3 | 4.00 | +| 4 | 3.85 | +| 5 | 4.00 | +| 6 | 3.65 | ++----+-------+ +例如，根据上述给定的 Scores 表，你的查询应该返回（按分数从高到低排列）： + ++-------+------+ +| Score | Rank | ++-------+------+ +| 4.00 | 1 | +| 4.00 | 1 | +| 3.85 | 2 | +| 3.65 | 3 | +| 3.65 | 3 | +| 3.50 | 4 | ++-------+------+ + +_______________________________________________________________ +先拆成两表，对于a表中的每一个分数score，找出b表中有多少个大于或等于该分数的不同的分数，然后按降序排列 + +SELECT a.Score as Score, + (SELECT COUNT(distinct b.Score) from Scores b where b.Score>=a.Score)as Rank +FROM Scores a +ORDER BY Rank ASC; + diff --git a/src/main/java/com/mine/study/sql/demo180 b/src/main/java/com/mine/study/sql/demo180 new file mode 100644 index 0000000..fe45313 --- /dev/null +++ b/src/main/java/com/mine/study/sql/demo180 @@ -0,0 +1,32 @@ +demo180 + +编写一个 SQL 查询，查找所有至少连续出现三次的数字。 + ++----+-----+ +| Id | Num | ++----+-----+ +| 1 | 1 | +| 2 | 1 | +| 3 | 1 | +| 4 | 2 | +| 5 | 1 | +| 6 | 2 | +| 7 | 2 | ++----+-----+ +例如，给定上面的 Logs 表， 1 是唯一连续出现至少三次的数字。 + ++-----------------+ +| ConsecutiveNums | ++-----------------+ +| 1 | ++-----------------+ + +_______________________________________________________________ + +比较连续三次的情况，等于构建三张相同的表进行比较：(并用DISTINCT保证结果不重复) + +SELECT DISTINCT Num as ConsecutiveNums +FROM Logs A,Logs B,Logs C +WHERE + A.Id=B.Id-1 AND A.Num=B.Num +AND A.Id=C.Id-2 AND A.Num=C.Num; \ No newline at end of file diff --git a/src/main/java/com/mine/study/sql/demo181 b/src/main/java/com/mine/study/sql/demo181 new file mode 100644 index 0000000..7447e47 --- /dev/null +++ b/src/main/java/com/mine/study/sql/demo181 @@ -0,0 +1,34 @@ +demo181 + +Employee 表包含所有员工，他们的经理也属于员工。每个员工都有一个 Id，此外还有一列对应员工的经理的 Id。 + ++----+-------+--------+-----------+ +| Id | Name | Salary | ManagerId | ++----+-------+--------+-----------+ +| 1 | Joe | 70000 | 3 | +| 2 | Henry | 80000 | 4 | +| 3 | Sam | 60000 | NULL | +| 4 | Max | 90000 | NULL | ++----+-------+--------+-----------+ +给定 Employee 表，编写一个 SQL 查询，该查询可以获取收入超过他们经理的员工的姓名。在上面的表格中，Joe 是唯一一个收入超过他的经理的员工。 + ++----------+ +| Employee | ++----------+ +| Joe | ++----------+ + +_______________________________________________________________ + +1.拆成两个表再用ManagerId=Id整合一起时比较Salary + +SELECT A.Name as Employee +FROM Employee as A,Employee as B +WHERE A.ManagerId=B.Id +AND A.Salary>B.Salary; + +2.用JOIN...ON整合一起 +SELECT A.Name as Employee +FROM Employee as A JOIN Employee as B + ON A.ManagerId=B.Id + AND A.Salary>B.Salary; \ No newline at end of file diff --git a/src/main/java/com/mine/study/sql/demo182 b/src/main/java/com/mine/study/sql/demo182 new file mode 100644 index 0000000..be191f9 --- /dev/null +++ b/src/main/java/com/mine/study/sql/demo182 @@ -0,0 +1,40 @@ +demo182 + +#编写一个 SQL 查询，查找 Person 表中所有重复的电子邮箱。 ++----+---------+ +| Id | Email | ++----+---------+ +| 1 | a@b.com | +| 2 | c@d.com | +| 3 | a@b.com | ++----+---------+ + +根据以上输入，你的查询应返回以下结果： + ++---------+ +| Email | ++---------+ +| a@b.com | ++---------+ +说明：所有电子邮箱都是小写字母。 +_______________________________________________________________ + +1.group by和临时表 +SELECT Email From +( + SELECT Email,count(Email) as num + FROM Person + GROUP BY Email +)as NewPerson +WHERE num>1; + + +2.group by和 Having +//在 SQL 中增加 HAVING 子句原因是，WHERE 关键字无法与聚合函数一起使用。 +HAVING 子句可以筛选分组后的各组数据。 + + +SELECT Email +FROM Person +GROUP BY Email +HAVING COUNT(Email)>1; diff --git a/src/main/java/com/mine/study/sql/demo183 b/src/main/java/com/mine/study/sql/demo183 new file mode 100644 index 0000000..2d00148 --- /dev/null +++ b/src/main/java/com/mine/study/sql/demo183 @@ -0,0 +1,60 @@ +demo183 + +某网站包含两个表，Customers 表和 Orders 表。编写一个 SQL 查询，找出所有从不订购任何东西的客户。 + +Customers 表： + ++----+-------+ +| Id | Name | ++----+-------+ +| 1 | Joe | +| 2 | Henry | +| 3 | Sam | +| 4 | Max | ++----+-------+ +Orders 表： + ++----+------------+ +| Id | CustomerId | ++----+------------+ +| 1 | 3 | +| 2 | 1 | ++----+------------+ +例如给定上述表格，你的查询应返回： + ++-----------+ +| Customers | ++-----------+ +| Henry | +| Max | ++-----------+ + +_______________________________________________________________ + + +1.NOT IN: + +SELECT Customers.Name as Customers +FROM Customers +WHERE Customers.Id +NOT IN +( + SELECT CustomerId FROM Orders +); + + + +2.LEFT JOIN: +左连接(以左表为核心): 从左表（table1）返回所有的行，即使右表（table2）中没有匹配。如果右表中没有匹配，则结果为 NULL。 + +SELECT Customers.Name as Customers +FROM Customers +LEFT JOIN Orders +ON Customers.Id=Orders.CustomerId +WHERE Orders.CustomerId is null; + + + + + + diff --git a/src/main/java/com/mine/study/sql/demo184 b/src/main/java/com/mine/study/sql/demo184 new file mode 100644 index 0000000..527aac7 --- /dev/null +++ b/src/main/java/com/mine/study/sql/demo184 @@ -0,0 +1,47 @@ +demo184 + +Employee 表包含所有员工信息，每个员工有其对应的 Id, salary 和 department Id。 + ++----+-------+--------+--------------+ +| Id | Name | Salary | DepartmentId | ++----+-------+--------+--------------+ +| 1 | Joe | 70000 | 1 | +| 2 | Henry | 80000 | 2 | +| 3 | Sam | 60000 | 2 | +| 4 | Max | 90000 | 1 | ++----+-------+--------+--------------+ +Department 表包含公司所有部门的信息。 + ++----+----------+ +| Id | Name | ++----+----------+ +| 1 | IT | +| 2 | Sales | ++----+----------+ +编写一个 SQL 查询，找出每个部门工资最高的员工。例如，根据上述给定的表格，Max 在 IT 部门有最高工资，Henry 在 Sales 部门有最高工资。 + ++------------+----------+--------+ +| Department | Employee | Salary | ++------------+----------+--------+ +| IT | Max | 90000 | +| Sales | Henry | 80000 | ++------------+----------+--------+ + +_______________________________________________________________ + +1.先用group by整合DepartmentId，找出每个DepartmentId中最大的Salary +2.结果和Department 表 join连接 + +SELECT Department.Name as Department, + Employee.Name as Employee, + Employee.Salary as Salary +FROM Employee JOIN Department + ON Employee.DepartmentId=Department.Id +WHERE +( //用group by找出最大工资 + (DepartmentId,Salary) in( + SELECT DepartmentId,MAX(Salary) + FROM Employee + GROUP BY DepartmentId + ) +); diff --git a/src/main/java/com/mine/study/sql/demo185 b/src/main/java/com/mine/study/sql/demo185 new file mode 100644 index 0000000..ba32e98 --- /dev/null +++ b/src/main/java/com/mine/study/sql/demo185 @@ -0,0 +1,63 @@ +demo185 + +Employee 表包含所有员工信息，每个员工有其对应的工号 Id，姓名 Name，工资 Salary 和部门编号 DepartmentId 。 + ++----+-------+--------+--------------+ +| Id | Name | Salary | DepartmentId| ++----+-------+--------+--------------+ +| 1 | Joe | 85000 | 1 | +| 2 | Henry | 80000 | 2 | +| 3 | Sam | 60000 | 2 | +| 4 | Max | 90000 | 1 | +| 5 | Janet | 69000 | 1 | +| 6 | Randy | 85000 | 1 | +| 7 | Will | 70000 | 1 | ++----+-------+--------+--------------+ +Department 表包含公司所有部门的信息。 + ++----+----------+ +| Id | Name | ++----+----------+ +| 1 | IT | +| 2 | Sales | ++----+----------+ +编写一个 SQL 查询，找出每个部门获得前三高工资的所有员工。例如，根据上述给定的表，查询结果应返回： + ++------------+----------+--------+ +| Department | Employee | Salary | ++------------+----------+--------+ +| IT | Max | 90000 | +| IT | Randy | 85000 | +| IT | Joe | 85000 | +| IT | Will | 70000 | +| Sales | Henry | 80000 | +| Sales | Sam | 60000 | ++------------+----------+--------+ + +_______________________________________________________________ + +1.先用count(distinct)>3的方法统计出各部门里没有超过三个salary比自己钱多的employee: +(拆成两表比较) + +SELECT e1.salary +FROM Employee e1 +WHERE ( + SELECT COUNT(DISTINCT e2.salary) + FROM Employee e2 + WHERE e1.salaryp2.Id; + +改成删除即可： + +DELETE p1 +FROM Person p1,Person p2 +WHERE p1.Email = p2.Email +AND p1.Id > p2.Id; + +2.Group by 和 not in //先把每种Email用group by统计出来，保留每种最小的id,然后删除(not in)的记录 +DELETE FROM Person +WHERE Id not in +( + SELECT p.minid + FROM + ( + SELECT min(Id) as minid + FROM Person + GROUP BY Email + ) + as p + ) +); diff --git a/src/main/java/com/mine/study/sql/demo197 b/src/main/java/com/mine/study/sql/demo197 new file mode 100644 index 0000000..6173c05 --- /dev/null +++ b/src/main/java/com/mine/study/sql/demo197 @@ -0,0 +1,31 @@ +demo197 + +给定一个 Weather 表，编写一个 SQL 查询，来查找与之前（昨天的）日期相比温度更高的所有日期的 Id。 + ++---------+------------------+------------------+ +| Id(INT) | RecordDate(DATE) | Temperature(INT) | ++---------+------------------+------------------+ +| 1 | 2015-01-01 | 10 | +| 2 | 2015-01-02 | 25 | +| 3 | 2015-01-03 | 20 | +| 4 | 2015-01-04 | 30 | ++---------+------------------+------------------+ +例如，根据上述给定的 Weather 表格，返回如下 Id: + ++----+ +| Id | ++----+ +| 2 | +| 4 | ++----+ + +_______________________________________________________________ + +1.比较日期格式数据,用 DATEDIFF 函数: DATEDIFF(日期1, 日期2)：得到的结果是日期1与日期2相差的天数。 +2.把表自身拆成两个表进行比较 + +SELECT A.Id as Id +From Weather as A + JOIN Weather as B + On DATEDIFF(A.DATE,B.DATE)=1 + AND a.Temperature>B.Temperature; diff --git a/src/main/java/com/mine/study/sql/demo595 b/src/main/java/com/mine/study/sql/demo595 new file mode 100644 index 0000000..59d9750 --- /dev/null +++ b/src/main/java/com/mine/study/sql/demo595 @@ -0,0 +1,44 @@ +demo595 + +这里有张 World 表 + ++-----------------+------------+------------+--------------+---------------+ +| name | continent | area | population | gdp | ++-----------------+------------+------------+--------------+---------------+ +| Afghanistan | Asia | 652230 | 25500100 | 20343000 | +| Albania | Europe | 28748 | 2831741 | 12960000 | +| Algeria | Africa | 2381741 | 37100000 | 188681000 | +| Andorra | Europe | 468 | 78115 | 3712000 | +| Angola | Africa | 1246700 | 20609294 | 100990000 | ++-----------------+------------+------------+--------------+---------------+ +如果一个国家的面积超过300万平方公里，或者人口超过2500万，那么这个国家就是大国家。 + +编写一个SQL查询，输出表中所有大国家的名称、人口和面积。 + +例如，根据上表，我们应该输出: + ++--------------+-------------+--------------+ +| name | population | area | ++--------------+-------------+--------------+ +| Afghanistan | 25500100 | 652230 | +| Algeria | 37100000 | 2381741 | ++--------------+-------------+--------------+ + +_______________________________________________________________ +1.最基本的方法，用OR + +SELECT name,population,area +FROM World +WHERE population>=25000000 +OR area>3000000; + +2.用Union合并两表: + +SELECT name,population,area +FROM World +WHERE population>=25000000 +UNION +SELECT name,population,area +FROM World +WHERE area>3000000; + diff --git a/src/main/java/com/mine/study/sql/demo596 b/src/main/java/com/mine/study/sql/demo596 new file mode 100644 index 0000000..2f4bd20 --- /dev/null +++ b/src/main/java/com/mine/study/sql/demo596 @@ -0,0 +1,62 @@ +demo596 + +有一个courses 表 ，有: student (学生) 和 class (课程)。 + +请列出所有超过或等于5名学生的课。 + +例如,表: + ++---------+------------+ +| student | class | ++---------+------------+ +| A | Math | +| B | English | +| C | Math | +| D | Biology | +| E | Math | +| F | Computer | +| G | Math | +| H | Math | +| I | Math | ++---------+------------+ +应该输出: + ++---------+ +| class | ++---------+ +| Math | ++---------+ +Note: +学生在每个课中不应被重复计算。 + +_______________________________________________________________ +用distinct 防止学生被重复计算 + + +1.用Having筛选： +SELECT class +FROM courses +GROUP BY class +HAVING COUNT(DISTINCT student)>=5; + +2.构建临时表： +SELECT class +FROM +( //临时表 + SELECT class,COUNT(DISTINCT student) as num + FROM courses + GROUP BY class +)as classnum +WHERE num>1; + + + + + + + + + + + + diff --git a/src/main/java/com/mine/study/sql/demo601 b/src/main/java/com/mine/study/sql/demo601 new file mode 100644 index 0000000..287d0d5 --- /dev/null +++ b/src/main/java/com/mine/study/sql/demo601 @@ -0,0 +1,52 @@ +demo601 + +X 市建了一个新的体育馆，每日人流量信息被记录在这三列信息中：序号 (id)、日期 (visit_date)、 人流量 (people)。 + +请编写一个查询语句，找出人流量的高峰期。高峰期时，至少连续三行记录中的人流量不少于100。 + +例如，表 stadium： + ++------+------------+-----------+ +| id | visit_date | people | ++------+------------+-----------+ +| 1 | 2017-01-01 | 10 | +| 2 | 2017-01-02 | 109 | +| 3 | 2017-01-03 | 150 | +| 4 | 2017-01-04 | 99 | +| 5 | 2017-01-05 | 145 | +| 6 | 2017-01-06 | 1455 | +| 7 | 2017-01-07 | 199 | +| 8 | 2017-01-08 | 188 | ++------+------------+-----------+ +对于上面的示例数据，输出为： + ++------+------------+-----------+ +| id | visit_date | people | ++------+------------+-----------+ +| 5 | 2017-01-05 | 145 | +| 6 | 2017-01-06 | 1455 | +| 7 | 2017-01-07 | 199 | +| 8 | 2017-01-08 | 188 | ++------+------------+-----------+ + +_______________________________________________________________ + + +1.因为是连续三天，需要把原表拆成三张表来比较 +SELECT DISTINCT t1.* +FROM stadium t1,stadium t2,stadium t3 +WHERE t1.people>=100 AND t2.people>=100 AND t3.people>=100 + +AND( + (t2.id=t1.id-1 AND t3.id=t2.id-1) //t1第三天 + OR (t1.id=t2.id-1 AND t3.id=t1.id-1) //t1第二天 + OR (t2.id=t3.id-1 AND t1.id=t2.id-1) //t1第一天 +) +// 2.考虑t1可能是第一天或者第二天 +ORDER BY t1.id; + + + + + + diff --git a/src/main/java/com/mine/study/sql/demo620 b/src/main/java/com/mine/study/sql/demo620 new file mode 100644 index 0000000..deaaa56 --- /dev/null +++ b/src/main/java/com/mine/study/sql/demo620 @@ -0,0 +1,36 @@ +demo620 + +某城市开了一家新的电影院，吸引了很多人过来看电影。该电影院特别注意用户体验，专门有个 LED显示板做电影推荐，上面公布着影评和相关电影描述。 + +作为该电影院的信息部主管，您需要编写一个 SQL查询，找出所有影片描述为非 boring (不无聊) 的并且 id 为奇数 的影片，结果请按等级 rating 排列。 + +例如，下表 cinema: + ++---------+-----------+--------------+-----------+ +| id | movie | description | rating | ++---------+-----------+--------------+-----------+ +| 1 | War | great 3D | 8.9 | +| 2 | Science | fiction | 8.5 | +| 3 | irish | boring | 6.2 | +| 4 | Ice song | Fantacy | 8.6 | +| 5 | House card| Interesting| 9.1 | ++---------+-----------+--------------+-----------+ +对于上面的例子，则正确的输出是为： + ++---------+-----------+--------------+-----------+ +| id | movie | description | rating | ++---------+-----------+--------------+-----------+ +| 5 | House card| Interesting| 9.1 | +| 1 | War | great 3D | 8.9 | ++---------+-----------+--------------+-----------+ + +_______________________________________________________________ + + +奇数： mod(id,2)=1 +降序： ORDER BY DESC + +SELECT * +FROM cinema +WHERE mod(id,2)=1 and description!="boring" +ORDER BY rating DESC; \ No newline at end of file diff --git a/src/main/java/com/mine/study/sql/demo626 b/src/main/java/com/mine/study/sql/demo626 new file mode 100644 index 0000000..b9f1cd3 --- /dev/null +++ b/src/main/java/com/mine/study/sql/demo626 @@ -0,0 +1,44 @@ +demo626 + +小美是一所中学的信息科技老师，她有一张 seat 座位表，平时用来储存学生名字和与他们相对应的座位 id。 +其中纵列的 id 是连续递增的 +小美想改变相邻俩学生的座位。 + +示例： + ++---------+---------+ +| id | student | ++---------+---------+ +| 1 | Abbot | +| 2 | Doris | +| 3 | Emerson | +| 4 | Green | +| 5 | Jeames | ++---------+---------+ +假如数据输入的是上表，则输出结果如下： + ++---------+---------+ +| id | student | ++---------+---------+ +| 1 | Doris | +| 2 | Abbot | +| 3 | Green | +| 4 | Emerson | +| 5 | Jeames | ++---------+---------+ +注意： + +如果学生人数是奇数，则不需要改变最后一个同学的座位。 +用case...when... 分析id的奇偶性作出调整 + + +SELECT ( + CASE + WHEN mod(id,2)=1 AND id=counts THEN id + WHEN mod(id,2)=1 And id!=counts THEN id+1 + ELSE id-1 + END + )as id,student +FROM seat,(SELECT COUNT(*) as counts FROM seat) as seat_counts +ORDER BY id ASC; + diff --git a/src/main/java/com/mine/study/sql/demo627 b/src/main/java/com/mine/study/sql/demo627 new file mode 100644 index 0000000..0b62ff9 --- /dev/null +++ b/src/main/java/com/mine/study/sql/demo627 @@ -0,0 +1,41 @@ +demo627 + +给定一个 salary 表，如下所示，有 m = 男性 和 f = 女性 的值。交换所有的 f 和 m 值（例如，将所有 f 值更改为 m，反之亦然）。要求只使用一个更新（Update）语句，并且没有中间的临时表。 + +注意，您必只能写一个 Update 语句，请不要编写任何 Select 语句。 + +例如： + +| id | name | sex | salary | +|----|------|-----|--------| +| 1 | A | m | 2500 | +| 2 | B | f | 1500 | +| 3 | C | m | 5500 | +| 4 | D | f | 500 | +运行你所编写的更新语句之后，将会得到以下表: + +| id | name | sex | salary | +|----|------|-----|--------| +| 1 | A | f | 2500 | +| 2 | B | m | 1500 | +| 3 | C | f | 5500 | +| 4 | D | m | 500 | + +_______________________________________________________________ + + +1.case...when... + +UPDATE salary +SET + sex=CASE sex + WHEN 'm' THEN 'f' + ELSE 'm' + END; + + +2.ASCII互转 !!! +UPDATE salary +SET + sex = char(ascii('m') + ascii('f') - ascii(sex)); +//变换前后总和一样 diff --git a/src/main/resources/logback.xml b/src/main/resources/logback.xml new file mode 100644 index 0000000..3035e6c --- /dev/null +++ b/src/main/resources/logback.xml @@ -0,0 +1,28 @@ + + + + + + %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n + + + + + + %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n + utf-8 + + log/output.log + + log/output.log.%i + + + 1MB + + + + + + + + \ No newline at end of file diff --git a/src/test/java/com/mine/study/AppTest.java b/src/test/java/com/mine/study/AppTest.java new file mode 100644 index 0000000..f351539 --- /dev/null +++ b/src/test/java/com/mine/study/AppTest.java @@ -0,0 +1,118 @@ +package com.mine.study; + + +import java.io.*; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; + +public class AppTest { + public static void main(String[] args) throws IOException { + mdTable(); + } + + public static void mdTable() throws IOException { + File myFile = new File("src/main/java/com/mine/study/medium/medium.md"); + + if (myFile.isFile() && myFile.exists()) { + + InputStreamReader reader = new InputStreamReader(Files.newInputStream(myFile.toPath()), StandardCharsets.UTF_8); + BufferedReader buf = new BufferedReader(reader); + + StringBuilder sb = new StringBuilder(); + PrintWriter pw = null; + //记录替换所在的行 + int rowLine = 0; + //换行符 + String enter = System.getProperty("line.separator"); + + String line = null; + StringBuilder mergeLine = null; + int idx = 0; + while ((line = buf.readLine()) != null) { + rowLine++; + + if (line.contains(". ")) { + idx = 0; + mergeLine = new StringBuilder(enter + "| " + line); + } else if ((line.startsWith(" ") || line.startsWith(" ") || line.startsWith(" ") || line.startsWith(" ")) && mergeLine != null) { + idx++; + mergeLine.append(" | ").append(line); + }else { + sb.append(line).append(enter); + } + + //数据暂存在 StringBuilder 中 + if (idx == 3) { + sb.append(mergeLine).append(" | "); + } + } + + buf.close(); + reader.close(); + + // 修改原文件 + pw = new PrintWriter(new FileWriter(myFile), true); + pw.print(sb); + pw.flush(); + pw.close(); + + } else { + System.out.println("找不到指定的文件"); + } + } + + public static void addTab() throws IOException { + File myFile = new File("src/main/java/com/mine/study/hard/hard.md"); + + if (myFile.isFile() && myFile.exists()) { + + InputStreamReader reader = new InputStreamReader(Files.newInputStream(myFile.toPath()), StandardCharsets.UTF_8); + BufferedReader buf = new BufferedReader(reader); + + StringBuilder sb = new StringBuilder(); + PrintWriter pw = null; + //记录替换所在的行 + int rowLine = 0; + //换行符 + String enter = System.getProperty("line.separator"); + + String line = null; + while ((line = buf.readLine()) != null) { + rowLine++; + + if (line.contains(". ")) { + System.out.println(line); + } else if (!line.startsWith(" ") && rowLine > 10) { + System.out.println(line + " //需要修改"); + line = " " + line; + } else { + System.out.println("不需要修改"); + } + + //数据暂存在 StringBuilder 中 + if (rowLine == 1) { + sb.append(line); + } else { + sb.append(enter).append(line); + } + } + + buf.close(); + reader.close(); + + // 写入新的文件 + // BufferedOutputStream out = new BufferedOutputStream(Files.newOutputStream(Paths.get("data/out.json"))); + // out.flush(); + // out.close(); + + // 修改原文件 + pw = new PrintWriter(new FileWriter(myFile), true); + pw.print(sb); + pw.flush(); + pw.close(); + + } else { + System.out.println("找不到指定的文件"); + } + } +} diff --git a/src/test/java/com/mine/study/test.txt b/src/test/java/com/mine/study/test.txt new file mode 100644 index 0000000..42e4c06 --- /dev/null +++ b/src/test/java/com/mine/study/test.txt @@ -0,0 +1,697 @@ +# easy 问题目录 +地址：https://leetcode-cn.com/problemset/all/?page=1&difficulty=EASY + +# 列表 +题目 +题解 +通过率 +难度 + + +| 1. 两数之和 | 17600 | 52.5% | 简单 | +| 9. 回文数 | 6414 | 57.3% | 简单 | +| 13. 罗马数字转整数 | 5099 | 62.5% | 简单 | +| 14. 最长公共前缀 | 5107 | 42.3% | 简单 | +| 20. 有效的括号 | 7339 | 44.6% | 简单 | +| 21. 合并两个有序链表 | 5115 | 66.6% | 简单 | +| 26. 删除有序数组中的重复项 | 5956 | 54.0% | 简单 | +| 27. 移除元素 | 5493 | 59.4% | 简单 | +| 28. 实现 strStr() | 4329 | 40.5% | 简单 | +| 35. 搜索插入位置 | 5516 | 45.3% | 简单 | +| 53. 最大子数组和 | 5247 | 54.9% | 简单 | +| 58. 最后一个单词的长度 | 3374 | 40.1% | 简单 | +| 66. 加一 | 4347 | 45.9% | 简单 | +| 67. 二进制求和 | 2232 | 53.9% | 简单 | +| 69. x 的平方根 | 2659 | 38.8% | 简单 | +| 70. 爬楼梯 | 4808 | 53.7% | 简单 | +| 83. 删除排序链表中的重复元素 | 2617 | 53.6% | 简单 | +| 88. 合并两个有序数组 | 4439 | 52.3% | 简单 | +| 94. 二叉树的中序遍历 | 3186 | 75.8% | 简单 | +| 100. 相同的树 | 2438 | 59.7% | 简单 | +| 101. 对称二叉树 | 3139 | 57.6% | 简单 | +| 104. 二叉树的最大深度 | 3457 | 77.0% | 简单 | +| 108. 将有序数组转换为二叉搜索树 | 1566 | 76.7% | 简单 | +| 110. 平衡二叉树 | 1952 | 57.0% | 简单 | +| 111. 二叉树的最小深度 | 2786 | 50.3% | 简单 | +| 112. 路径总和 | 2328 | 53.2% | 简单 | +| 118. 杨辉三角 | 2401 | 74.8% | 简单 | +| 119. 杨辉三角 II | 1608 | 68.3% | 简单 | +| 121. 买卖股票的最佳时机 | 4632 | 57.8% | 简单 | +| 125. 验证回文串 | 2282 | 46.9% | 简单 | +| 136. 只出现一次的数字 | 3086 | 72.2% | 简单 | +| 141. 环形链表 | 3740 | 51.4% | 简单 | +| 144. 二叉树的前序遍历 | 2540 | 71.0% | 简单 | +| 145. 二叉树的后序遍历 | 2064 | 75.8% | 简单 | +| 155. 最小栈 | 2058 | 58.1% | 简单 | +| 157. 用 Read4 读取 N 个字符 | 106 | 54.2% | 简单 | +| 160. 相交链表 | 2765 | 62.7% | 简单 | +| 163. 缺失的区间 | 201 | 34.5% | 简单 | +| 168. Excel表列名称 | 918 | 43.6% | 简单 | +| 169. 多数元素 | 2846 | 66.7% | 简单 | +| 170. 两数之和 III - 数据结构设计 | 124 | 42.9% | 简单 | +| 171. Excel 表列序号 | 1103 | 71.6% | 简单 | +| 175. 组合两个表 | 1763 | 73.6% | 简单 | +| 181. 超过经理收入的员工 | 856 | 69.2% | 简单 | +| 182. 查找重复的电子邮箱 | 766 | 79.3% | 简单 | +| 183. 从不订购的客户 | 751 | 67.1% | 简单 | +| 190. 颠倒二进制位 | 1055 | 71.0% | 简单 | +| 191. 位1的个数 | 1595 | 75.8% | 简单 | +| 193. 有效电话号码 | 163 | 33.2% | 简单 | +| 195. 第十行 | 167 | 43.9% | 简单 | +| 196. 删除重复的电子邮箱 | 530 | 67.1% | 简单 | +| 197. 上升的温度 | 676 | 53.4% | 简单 | +| 202. 快乐数 | 1926 | 62.7% | 简单 | +| 203. 移除链表元素 | 2327 | 53.4% | 简单 | +| 205. 同构字符串 | 1068 | 49.9% | 简单 | +| 206. 反转链表 | 9109 | 72.9% | 简单 | +| 217. 存在重复元素 | 2603 | 55.6% | 简单 | +| 219. 存在重复元素 II | 1480 | 44.4% | 简单 | +| 225. 用队列实现栈 | 5076 | 67.6% | 简单 | +| 226. 翻转二叉树 | 2904 | 79.1% | 简单 | +| 228. 汇总区间 | 805 | 56.7% | 简单 | +| 231. 2 的幂 | 1627 | 50.4% | 简单 | +| 232. 用栈实现队列 | 1732 | 68.9% | 简单 | +| 234. 回文链表 | 2664 | 51.5% | 简单 | +| 235. 二叉搜索树的最近公共祖先 | 1338 | 67.2% | 简单 | +| 237. 删除链表中的节点 | 1503 | 85.9% | 简单 | +| 242. 有效的字母异位词 | 2380 | 65.3% | 简单 | +| 243. 最短单词距离 | 145 | 66.1% | 简单 | +| 246. 中心对称数 | 142 | 47.8% | 简单 | +| 252. 会议室 | 195 | 57.1% | 简单 | +| 257. 二叉树的所有路径 | 1429 | 69.6% | 简单 | +| 258. 各位相加 | 1152 | 71.0% | 简单 | +| 263. 丑数 | 962 | 51.2% | 简单 | +| 266. 回文排列 | 134 | 69.1% | 简单 | +| 268. 丢失的数字 | 1753 | 65.7% | 简单 | +| 270. 最接近的二叉搜索树值 | 165 | 57.4% | 简单 | +| 278. 第一个错误的版本 | 1796 | 45.2% | 简单 | +| 283. 移动零 | 4620 | 63.9% | 简单 | +| 290. 单词规律 | 1352 | 45.3% | 简单 | +| 292. Nim 游戏 | 883 | 70.7% | 简单 | +| 293. 翻转游戏 | 102 | 71.9% | 简单 | +| 303. 区域和检索 - 数组不可变 | 1333 | 74.7% | 简单 | +| 326. 3 的幂 | 714 | 50.6% | 简单 | +| 338. 比特位计数 | 1734 | 78.7% | 简单 | +| 342. 4的幂 | 903 | 52.1% | 简单 | +| 344. 反转字符串 | 2729 | 78.5% | 简单 | +| 345. 反转字符串中的元音字母 | 1188 | 54.2% | 简单 | +| 346. 数据流中的移动平均值 | 169 | 71.7% | 简单 | +| 349. 两个数组的交集 | 2053 | 74.1% | 简单 | +| 350. 两个数组的交集 II | 2033 | 56.1% | 简单 | +| 359. 日志速率限制器 | 82 | 74.0% | 简单 | +| 367. 有效的完全平方数 | 1195 | 44.8% | 简单 | +| 374. 猜数字大小 | 741 | 52.1% | 简单 | +| 383. 赎金信 | 1625 | 64.3% | 简单 | +| 387. 字符串中的第一个唯一字符 | 1623 | 54.8% | 简单 | +| 389. 找不同 | 1273 | 68.4% | 简单 | +| 392. 判断子序列 | 1977 | 52.1% | 简单 | +| 401. 二进制手表 | 742 | 61.8% | 简单 | +| 404. 左叶子之和 | 1527 | 60.5% | 简单 | +| 405. 数字转换为十六进制数 | 526 | 55.7% | 简单 | +| 408. 有效单词缩写 | 96 | 34.6% | 简单 | +| 409. 最长回文串 | 1625 | 55.6% | 简单 | +| 412. Fizz Buzz | 692 | 71.3% | 简单 | +| 414. 第三大的数 | 1348 | 39.4% | 简单 | +| 415. 字符串相加 | 1374 | 54.8% | 简单 | +| 422. 有效的单词方块 | 68 | 43.5% | 简单 | +| 434. 字符串中的单词数 | 991 | 39.7% | 简单 | +| 441. 排列硬币 | 875 | 45.8% | 简单 | +| 448. 找到所有数组中消失的数字 | 1417 | 65.5% | 简单 | +| 453. 最小操作次数使数组元素相等 | 743 | 61.3% | 简单 | +| 455. 分发饼干 | 1679 | 57.2% | 简单 | +| 459. 重复的子字符串 | 872 | 50.8% | 简单 | +| 461. 汉明距离 | 1655 | 81.6% | 简单 | +| 463. 岛屿的周长 | 1124 | 70.2% | 简单 | +| 476. 数字的补数 | 939 | 71.0% | 简单 | +| 482. 密钥格式化 | 487 | 47.0% | 简单 | +| 485. 最大连续 1 的个数 | 1216 | 61.0% | 简单 | +| 492. 构造矩形 | 466 | 60.7% | 简单 | +| 495. 提莫攻击 | 1030 | 60.3% | 简单 | +| 496. 下一个更大元素 I | 1758 | 71.1% | 简单 | +| 500. 键盘行 | 845 | 74.4% | 简单 | +| 501. 二叉搜索树中的众数 | 749 | 53.1% | 简单 | +| 504. 七进制数 | 741 | 52.1% | 简单 | +| 506. 相对名次 | 809 | 65.3% | 简单 | +| 507. 完美数 | 471 | 49.0% | 简单 | +| 509. 斐波那契数 | 2379 | 66.6% | 简单 | +| 511. 游戏玩法分析 I | 176 | 72.7% | 简单 | +| 512. 游戏玩法分析 II | 183 | 54.0% | 简单 | +| 520. 检测大写字母 | 1127 | 57.4% | 简单 | +| 521. 最长特殊序列 Ⅰ | 508 | 73.8% | 简单 | +| 530. 二叉搜索树的最小绝对差 | 830 | 62.8% | 简单 | +| 541. 反转字符串 II | 1067 | 59.5% | 简单 | +| 543. 二叉树的直径 | 1580 | 56.9% | 简单 | +| 551. 学生出勤记录 I | 838 | 56.8% | 简单 | +| 557. 反转字符串中的单词 III | 1974 | 74.2% | 简单 | +| 559. N 叉树的最大深度 | 888 | 74.4% | 简单 | +| 561. 数组拆分 I | 891 | 78.0% | 简单 | +| 563. 二叉树的坡度 | 658 | 65.6% | 简单 | +| 566. 重塑矩阵 | 964 | 66.6% | 简单 | +| 572. 另一棵树的子树 | 1010 | 47.5% | 简单 | +| 575. 分糖果 | 892 | 71.0% | 简单 | +| 577. 员工奖金 | 117 | 69.4% | 简单 | +| 584. 寻找用户推荐人 | 151 | 72.1% | 简单 | +| 586. 订单最多的客户 | 141 | 73.3% | 简单 | +| 589. N 叉树的前序遍历 | 935 | 76.1% | 简单 | +| 590. N 叉树的后序遍历 | 802 | 77.9% | 简单 | +| 594. 最长和谐子序列 | 594 | 56.5% | 简单 | +| 595. 大的国家 | 328 | 74.1% | 简单 | +| 596. 超过5名学生的课 | 366 | 45.8% | 简单 | +| 597. 好友申请 I：总体通过率 | 102 | 44.2% | 简单 | +| 598. 范围求和 II | 527 | 57.2% | 简单 | +| 599. 两个列表的最小索引总和 | 648 | 57.2% | 简单 | +| 603. 连续空余座位 | 163 | 65.0% | 简单 | +| 604. 迭代压缩字符串 | 74 | 38.0% | 简单 | +| 605. 种花问题 | 1491 | 32.9% | 简单 | +| 606. 根据二叉树创建字符串 | 660 | 63.1% | 简单 | +| 607. 销售员 | 151 | 67.8% | 简单 | +| 610. 判断三角形 | 94 | 65.0% | 简单 | +| 613. 直线上的最近距离 | 103 | 80.6% | 简单 | +| 617. 合并二叉树 | 1780 | 78.9% | 简单 | +| 619. 只出现一次的最大数字 | 105 | 45.9% | 简单 | +| 620. 有趣的电影 | 380 | 77.2% | 简单 | +| 627. 变更性别 | 450 | 81.5% | 简单 | +| 628. 三个数的最大乘积 | 882 | 52.4% | 简单 | +| 637. 二叉树的层平均值 | 834 | 69.4% | 简单 | +| 643. 子数组最大平均数 I | 704 | 44.4% | 简单 | +| 645. 错误的集合 | 813 | 41.9% | 简单 | +| 653. 两数之和 IV - 输入 BST | 809 | 63.0% | 简单 | +| 657. 机器人能否返回原点 | 695 | 78.4% | 简单 | +| 661. 图片平滑器 | 495 | 64.5% | 简单 | +| 671. 二叉树中第二小的节点 | 760 | 48.3% | 简单 | +| 674. 最长连续递增序列 | 1000 | 52.5% | 简单 | +| 680. 验证回文字符串 Ⅱ | 997 | 40.1% | 简单 | +| 682. 棒球比赛 | 873 | 72.2% | 简单 | +| 693. 交替位二进制数 | 742 | 65.4% | 简单 | +| 696. 计数二进制子串 | 540 | 63.7% | 简单 | +| 697. 数组的度 | 941 | 60.1% | 简单 | +| 700. 二叉搜索树中的搜索 | 1188 | 77.4% | 简单 | +| 703. 数据流中的第 K 大元素 | 668 | 52.0% | 简单 | +| 704. 二分查找 | 2966 | 54.4% | 简单 | +| 705. 设计哈希集合 | 515 | 63.9% | 简单 | +| 706. 设计哈希映射 | 489 | 63.9% | 简单 | +| 709. 转换成小写字母 | 784 | 77.3% | 简单 | +| 716. 最大栈 | 97 | 47.2% | 简单 | +| 717. 1 比特与 2 比特字符 | 747 | 55.4% | 简单 | +| 720. 词典中最长的单词 | 631 | 51.9% | 简单 | +| 724. 寻找数组的中心下标 | 1048 | 48.6% | 简单 | +| 728. 自除数 | 656 | 78.8% | 简单 | +| 733. 图像渲染 | 924 | 58.1% | 简单 | +| 734. 句子相似性 | 48 | 47.6% | 简单 | +| 744. 寻找比目标字母大的最小字母 | 756 | 49.5% | 简单 | +| 746. 使用最小花费爬楼梯 | 1803 | 61.7% | 简单 | +| 747. 至少是其他数字两倍的最大数 | 833 | 45.8% | 简单 | +| 748. 最短补全词 | 509 | 67.8% | 简单 | +| 760. 找出变位映射 | 108 | 83.6% | 简单 | +| 762. 二进制表示中质数个计算置位 | 447 | 75.7% | 简单 | +| 766. 托普利茨矩阵 | 692 | 70.5% | 简单 | +| 771. 宝石与石头 | 1249 | 85.2% | 简单 | +| 783. 二叉搜索树节点最小距离 | 741 | 59.8% | 简单 | +| 796. 旋转字符串 | 749 | 63.0% | 简单 | +| 800. 相似 RGB 颜色 | 45 | 70.8% | 简单 | +| 804. 唯一摩尔斯密码词 | 751 | 82.2% | 简单 | +| 806. 写字符串需要的行数 | 580 | 69.1% | 简单 | +| 812. 最大三角形面积 | 124 | 63.1% | 简单 | +| 819. 最常见的单词 | 617 | 46.4% | 简单 | +| 821. 字符的最短距离 | 897 | 73.3% | 简单 | +| 824. 山羊拉丁文 | 675 | 65.3% | 简单 | +| 830. 较大分组的位置 | 620 | 54.3% | 简单 | +| 832. 翻转图像 | 1012 | 79.5% | 简单 | +| 836. 矩形重叠 | 709 | 48.4% | 简单 | +| 844. 比较含退格的字符串 | 1353 | 49.4% | 简单 | +| 852. 山脉数组的峰顶索引 | 889 | 70.3% | 简单 | +| 859. 亲密字符串 | 790 | 34.5% | 简单 | +| 860. 柠檬水找零 | 972 | 58.5% | 简单 | +| 867. 转置矩阵 | 802 | 66.7% | 简单 | +| 868. 二进制间距 | 636 | 69.5% | 简单 | +| 872. 叶子相似的树 | 784 | 65.2% | 简单 | +| 876. 链表的中间结点 | 2451 | 70.7% | 简单 | +| 883. 三维形体投影面积 | 519 | 76.6% | 简单 | +| 884. 两句话中的不常见单词 | 537 | 72.0% | 简单 | +| 888. 公平的糖果交换 | 511 | 64.0% | 简单 | +| 892. 三维形体的表面积 | 711 | 63.9% | 简单 | +| 896. 单调数列 | 809 | 58.0% | 简单 | +| 897. 递增顺序搜索树 | 798 | 74.2% | 简单 | +| 905. 按奇偶排序数组 | 1272 | 71.3% | 简单 | +| 908. 最小差值 I | 512 | 74.3% | 简单 | +| 914. 卡牌分组 | 666 | 38.6% | 简单 | +| 917. 仅仅反转字母 | 946 | 60.2% | 简单 | +| 922. 按奇偶排序数组 II | 920 | 71.3% | 简单 | +| 925. 长按键入 | 727 | 38.3% | 简单 | +| 929. 独特的电子邮件地址 | 261 | 64.6% | 简单 | +| 933. 最近的请求次数 | 699 | 77.1% | 简单 | +| 937. 重新排列日志文件 | 445 | 64.0% | 简单 | +| 938. 二叉搜索树的范围和 | 892 | 82.1% | 简单 | +| 941. 有效的山脉数组 | 674 | 39.3% | 简单 | +| 942. 增减字符串匹配 | 263 | 73.4% | 简单 | +| 944. 删列造序 | 209 | 68.4% | 简单 | +| 953. 验证外星语词典 | 254 | 55.4% | 简单 | +| 961. 在长度 2N 的数组中找出重复 N 次的元素 | 356 | 67.7% | 简单 | +| 965. 单值二叉树 | 484 | 68.7% | 简单 | +| 976. 三角形的最大周长 | 657 | 58.8% | 简单 | +| 977. 有序数组的平方 | 2237 | 69.0% | 简单 | +| 989. 数组形式的整数加法 | 677 | 46.9% | 简单 | +| 993. 二叉树的堂兄弟节点 | 896 | 55.6% | 简单 | +| 997. 找到小镇的法官 | 747 | 53.0% | 简单 | +| 999. 可以被一步捕获的棋子数 | 593 | 69.2% | 简单 | +| 1002. 查找共用字符 | 684 | 72.2% | 简单 | +| 1005. K 次取反后最大化的数组和 | 1157 | 51.6% | 简单 | +| 1009. 十进制整数的反码 | 270 | 59.0% | 简单 | +| 1013. 将数组分成和相等的三个部分 | 970 | 39.2% | 简单 | +| 1018. 可被 5 整除的二进制前缀 | 405 | 51.4% | 简单 | +| 1021. 删除最外层的括号 | 731 | 78.5% | 简单 | +| 1022. 从根到叶的二进制数之和 | 333 | 71.3% | 简单 | +| 1025. 除数博弈 | 711 | 70.8% | 简单 | +| 1030. 距离顺序排列矩阵单元格 | 471 | 70.9% | 简单 | +| 1037. 有效的回旋镖 | 156 | 43.8% | 简单 | +| 1046. 最后一块石头的重量 | 1022 | 65.8% | 简单 | +| 1047. 删除字符串中的所有相邻重复项 | 1216 | 72.6% | 简单 | +| 1050. 合作过至少三次的演员和导演 | 90 | 77.0% | 简单 | +| 1051. 高度检查器 | 420 | 75.9% | 简单 | +| 1056. 易混淆数 | 78 | 42.5% | 简单 | +| 1064. 不动点 | 84 | 64.8% | 简单 | +| 1065. 字符串的索引对 | 88 | 55.5% | 简单 | +| 1068. 产品销售分析 I | 80 | 86.6% | 简单 | +| 1069. 产品销售分析 II | 70 | 81.6% | 简单 | +| 1071. 字符串的最大公因子 | 699 | 58.7% | 简单 | +| 1075. 项目员工 I | 91 | 69.6% | 简单 | +| 1076. 项目员工II | 105 | 49.1% | 简单 | +| 1078. Bigram 分词 | 458 | 65.7% | 简单 | +| 1082. 销售分析 I | 118 | 76.3% | 简单 | +| 1083. 销售分析 II | 125 | 52.8% | 简单 | +| 1084. 销售分析III | 148 | 55.0% | 简单 | +| 1085. 最小元素各数位之和 | 90 | 77.4% | 简单 | +| 1086. 前五科的均分 | 96 | 68.1% | 简单 | +| 1089. 复写零 | 345 | 58.2% | 简单 | +| 1099. 小于 K 的两数之和 | 116 | 59.6% | 简单 | +| 1103. 分糖果 II | 1152 | 63.8% | 简单 | +| 1108. IP 地址无效化 | 748 | 83.8% | 简单 | +| 1113. 报告的记录 | 61 | 53.5% | 简单 | +| 1114. 按序打印 | 656 | 65.3% | 简单 | +| 1118. 一月有多少天 | 55 | 63.9% | 简单 | +| 1119. 删去字符串中的元音 | 163 | 86.8% | 简单 | +| 1122. 数组的相对排序 | 967 | 70.8% | 简单 | +| 1128. 等价多米诺骨牌对的数量 | 499 | 54.3% | 简单 | +| 1133. 最大唯一数 | 77 | 64.9% | 简单 | +| 1134. 阿姆斯特朗数 | 61 | 77.3% | 简单 | +| 1137. 第 N 个泰波那契数 | 1185 | 60.8% | 简单 | +| 1141. 查询近30天活跃用户数 | 110 | 49.2% | 简单 | +| 1142. 过去30天的用户活动 II | 58 | 37.3% | 简单 | +| 1148. 文章浏览 I | 67 | 71.5% | 简单 | +| 1150. 检查一个数是否在数组中占绝大多数 | 101 | 59.8% | 简单 | +| 1154. 一年中的第几天 | 551 | 64.2% | 简单 | +| 1160. 拼写单词 | 956 | 68.5% | 简单 | +| 1165. 单行键盘 | 132 | 83.5% | 简单 | +| 1173. 即时食物配送 I | 97 | 75.4% | 简单 | +| 1175. 质数排列 | 151 | 49.2% | 简单 | +| 1176. 健身计划评估 | 77 | 46.9% | 简单 | +| 1179. 重新格式化部门表 | 224 | 64.1% | 简单 | +| 1180. 统计只含单一字母的子串 | 84 | 77.7% | 简单 | +| 1184. 公交站间的距离 | 307 | 58.4% | 简单 | +| 1185. 一周中的第几天 | 484 | 62.6% | 简单 | +| 1189. “气球” 的最大数量 | 726 | 68.7% | 简单 | +| 1196. 最多可以买到的苹果数量 | 68 | 68.2% | 简单 | +| 1200. 最小绝对差 | 300 | 68.1% | 简单 | +| 1207. 独一无二的出现次数 | 892 | 72.9% | 简单 | +| 1211. 查询结果的质量和占比 | 77 | 66.4% | 简单 | +| 1213. 三个有序数组的交集 | 157 | 78.1% | 简单 | +| 1217. 玩筹码 | 414 | 70.0% | 简单 | +| 1221. 分割平衡字符串 | 1202 | 84.4% | 简单 | +| 1228. 等差数列中缺失的数字 | 64 | 53.7% | 简单 | +| 1232. 缀点成线 | 482 | 46.4% | 简单 | +| 1241. 每个帖子的评论数 | 75 | 59.4% | 简单 | +| 1243. 数组变换 | 67 | 53.4% | 简单 | +| 1251. 平均售价 | 120 | 77.1% | 简单 | +| 1252. 奇数值单元格的数目 | 352 | 74.7% | 简单 | +| 1260. 二维网格迁移 | 292 | 60.7% | 简单 | +| 1266. 访问所有点的最小时间 | 483 | 82.6% | 简单 | +| 1271. 十六进制魔术数字 | 49 | 51.1% | 简单 | +| 1275. 找出井字棋的获胜者 | 189 | 54.7% | 简单 | +| 1279. 红绿灯路口 | 21 | 63.1% | 简单 | +| 1280. 学生们参加各科测试的次数 | 87 | 49.9% | 简单 | +| 1281. 整数的各位积和之差 | 740 | 83.3% | 简单 | +| 1287. 有序数组中出现次数超过25%的元素 | 259 | 60.0% | 简单 | +| 1290. 二进制链表转整数 | 835 | 80.8% | 简单 | +| 1294. 不同国家的天气类型 | 97 | 65.3% | 简单 | +| 1295. 统计位数为偶数的数字 | 690 | 80.6% | 简单 | +| 1299. 将每个元素替换为右侧最大元素 | 485 | 78.8% | 简单 | +| 1303. 求团队人数 | 116 | 82.4% | 简单 | +| 1304. 和为零的N个唯一整数 | 422 | 71.7% | 简单 | +| 1309. 解码字母到整数映射 | 376 | 76.3% | 简单 | +| 1313. 解压缩编码列表 | 585 | 83.2% | 简单 | +| 1317. 将整数转换为两个无零整数的和 | 220 | 61.8% | 简单 | +| 1322. 广告效果 | 74 | 59.3% | 简单 | +| 1323. 6 和 9 组成的最大数字 | 546 | 75.3% | 简单 | +| 1327. 列出指定时间段内所有的下单产品 | 68 | 68.9% | 简单 | +| 1331. 数组序号转换 | 257 | 53.0% | 简单 | +| 1332. 删除回文子序列 | 333 | 78.0% | 简单 | +| 1337. 矩阵中战斗力最弱的 K 行 | 750 | 69.2% | 简单 | +| 1342. 将数字变成 0 的操作次数 | 938 | 82.5% | 简单 | +| 1346. 检查整数及其两倍数是否存在 | 363 | 43.0% | 简单 | +| 1350. 院系无效的学生 | 95 | 85.0% | 简单 | +| 1351. 统计有序矩阵中的负数 | 634 | 75.3% | 简单 | +| 1356. 根据数字二进制下 1 的数目排序 | 583 | 73.0% | 简单 | +| 1360. 日期之间隔几天 | 174 | 50.2% | 简单 | +| 1365. 有多少小于当前数字的数字 | 1167 | 82.4% | 简单 | +| 1370. 上升下降字符串 | 607 | 79.0% | 简单 | +| 1374. 生成每种字符都是奇数个的字符串 | 247 | 74.4% | 简单 | +| 1378. 使用唯一标识码替换员工ID | 71 | 86.8% | 简单 | +| 1380. 矩阵中的幸运数 | 697 | 76.9% | 简单 | +| 1385. 两个数组间的距离值 | 309 | 67.2% | 简单 | +| 1389. 按既定顺序创建目标数组 | 516 | 83.1% | 简单 | +| 1394. 找出数组中的幸运数 | 335 | 66.2% | 简单 | +| 1399. 统计最大组的数目 | 177 | 67.0% | 简单 | +| 1403. 非递增顺序的最小子序列 | 416 | 68.9% | 简单 | +| 1407. 排名靠前的旅行者 | 104 | 68.0% | 简单 | +| 1408. 数组中的字符串匹配 | 234 | 61.8% | 简单 | +| 1413. 逐步求和得到正数的最小值 | 286 | 69.6% | 简单 | +| 1417. 重新格式化字符串 | 214 | 52.2% | 简单 | +| 1421. 净现值查询 | 44 | 72.0% | 简单 | +| 1422. 分割字符串的最大得分 | 237 | 54.2% | 简单 | +| 1426. 数元素 | 63 | 70.7% | 简单 | +| 1427. 字符串的左右移 | 70 | 63.3% | 简单 | +| 1431. 拥有最多糖果的孩子 | 1084 | 84.6% | 简单 | +| 1435. 制作会话柱状图 | 54 | 62.4% | 简单 | +| 1436. 旅行终点站 | 693 | 82.1% | 简单 | +| 1437. 是否所有 1 都至少相隔 k 个元素 | 208 | 57.8% | 简单 | +| 1441. 用栈操作构建数组 | 429 | 65.0% | 简单 | +| 1446. 连续字符 | 713 | 61.0% | 简单 | +| 1450. 在既定时间做作业的学生人数 | 375 | 80.5% | 简单 | +| 1455. 检查单词是否为句中其他单词的前缀 | 252 | 62.7% | 简单 | +| 1460. 通过翻转子数组使两个数组相等 | 366 | 74.0% | 简单 | +| 1464. 数组中两元素的最大乘积 | 458 | 76.3% | 简单 | +| 1469. 寻找所有的独生节点 | 113 | 81.5% | 简单 | +| 1470. 重新排列数组 | 792 | 83.9% | 简单 | +| 1474. 删除链表 M 个节点之后的 N 个节点 | 79 | 71.4% | 简单 | +| 1475. 商品折扣后的最终价格 | 315 | 71.4% | 简单 | +| 1480. 一维数组的动态和 | 1408 | 86.9% | 简单 | +| 1484. 按日期分组销售产品 | 94 | 68.5% | 简单 | +| 1486. 数组异或操作 | 723 | 85.8% | 简单 | +| 1491. 去掉最低工资和最高工资后的工资平均值 | 460 | 64.5% | 简单 | +| 1495. 上月播放的儿童适宜电影 | 46 | 53.7% | 简单 | +| 1496. 判断路径是否相交 | 194 | 53.5% | 简单 | +| 1502. 判断能否形成等差数列 | 417 | 70.9% | 简单 | +| 1507. 转变日期格式 | 154 | 59.0% | 简单 | +| 1511. 消费者下单频率 | 74 | 68.7% | 简单 | +| 1512. 好数对的数目 | 830 | 84.9% | 简单 | +| 1517. 查找拥有有效邮箱的用户 | 47 | 57.2% | 简单 | +| 1518. 换酒问题 | 837 | 70.3% | 简单 | +| 1523. 在区间范围内统计奇数数目 | 397 | 51.3% | 简单 | +| 1527. 患某种疾病的患者 | 95 | 49.0% | 简单 | +| 1528. 重新排列字符串 | 408 | 78.6% | 简单 | +| 1534. 统计好三元组 | 187 | 78.0% | 简单 | +| 1539. 第 k 个缺失的正整数 | 358 | 54.0% | 简单 | +| 1543. 产品名称格式修复 | 51 | 55.2% | 简单 | +| 1544. 整理字符串 | 367 | 55.3% | 简单 | +| 1550. 存在连续三个奇数的数组 | 328 | 65.6% | 简单 | +| 1556. 千位分隔数 | 224 | 56.9% | 简单 | +| 1560. 圆形赛道上经过次数最多的扇区 | 102 | 57.3% | 简单 | +| 1565. 按月统计订单数与顾客数 | 50 | 73.4% | 简单 | +| 1566. 重复至少 K 次且长度为 M 的模式 | 146 | 44.2% | 简单 | +| 1571. 仓库经理 | 59 | 76.8% | 简单 | +| 1572. 矩阵对角线元素的和 | 438 | 80.5% | 简单 | +| 1576. 替换所有的问号 | 591 | 51.5% | 简单 | +| 1581. 进店却未进行过交易的顾客 | 99 | 82.0% | 简单 | +| 1582. 二进制矩阵中的特殊位置 | 147 | 67.2% | 简单 | +| 1587. 银行账户概要 II | 65 | 84.4% | 简单 | +| 1588. 所有奇数长度子数组的和 | 819 | 83.9% | 简单 | +| 1592. 重新排列单词间的空格 | 149 | 44.4% | 简单 | +| 1598. 文件夹操作日志搜集器 | 173 | 67.4% | 简单 | +| 1603. 设计停车系统 | 507 | 84.5% | 简单 | +| 1607. 没有卖出的卖家 | 52 | 53.6% | 简单 | +| 1608. 特殊数组的特征值 | 281 | 61.0% | 简单 | +| 1614. 括号的最大嵌套深度 | 709 | 84.4% | 简单 | +| 1619. 删除某些元素后的数组均值 | 157 | 66.7% | 简单 | +| 1623. 三人国家代表队 | 55 | 78.0% | 简单 | +| 1624. 两个相同字符之间的最长子字符串 | 272 | 61.9% | 简单 | +| 1629. 按键持续时间最长的键 | 401 | 56.0% | 简单 | +| 1633. 各赛事的用户注册率 | 36 | 65.2% | 简单 | +| 1636. 按照频率将数组升序排序 | 237 | 69.7% | 简单 | +| 1640. 能否连接形成数组 | 246 | 64.8% | 简单 | +| 1646. 获取生成数组中的最大值 | 411 | 52.9% | 简单 | +| 1652. 拆炸弹 | 222 | 64.0% | 简单 | +| 1656. 设计有序流 | 113 | 77.8% | 简单 | +| 1661. 每台机器的进程平均运行时间 | 75 | 74.2% | 简单 | +| 1662. 检查两个字符串数组是否相等 | 352 | 81.0% | 简单 | +| 1667. 修复表中的名字 | 91 | 63.7% | 简单 | +| 1668. 最大重复子字符串 | 170 | 44.3% | 简单 | +| 1672. 最富有客户的资产总量 | 867 | 87.7% | 简单 | +| 1677. 发票中的产品金额 | 45 | 36.1% | 简单 | +| 1678. 设计 Goal 解析器 | 386 | 83.3% | 简单 | +| 1683. 无效的推文 | 45 | 90.2% | 简单 | +| 1684. 统计一致字符串的数目 | 427 | 82.5% | 简单 | +| 1688. 比赛中的配对次数 | 576 | 84.3% | 简单 | +| 1693. 每天的领导和合伙人 | 62 | 81.9% | 简单 | +| 1694. 重新格式化电话号码 | 161 | 63.0% | 简单 | +| 1700. 无法吃午餐的学生数量 | 246 | 69.4% | 简单 | +| 1704. 判断字符串的两半是否相似 | 226 | 77.6% | 简单 | +| 1708. 长度为 K 的最大子数组 | 37 | 69.6% | 简单 | +| 1710. 卡车上的最大单元数 | 233 | 69.6% | 简单 | +| 1716. 计算力扣银行的钱 | 681 | 70.2% | 简单 | +| 1720. 解码异或后的数组 | 523 | 86.7% | 简单 | +| 1725. 可以形成最大正方形的矩形数目 | 422 | 83.3% | 简单 | +| 1729. 求关注者的数量 | 41 | 62.9% | 简单 | +| 1731. 每位经理的下属员工数量 | 40 | 45.9% | 简单 | +| 1732. 找到最高海拔 | 257 | 78.5% | 简单 | +| 1736. 替换隐藏数字得到的最晚时间 | 374 | 44.7% | 简单 | +| 1741. 查找每个员工花费的总时间 | 48 | 85.0% | 简单 | +| 1742. 盒子中小球的最大数量 | 156 | 71.1% | 简单 | +| 1748. 唯一元素的和 | 568 | 78.8% | 简单 | +| 1752. 检查数组是否经排序和轮转得到 | 146 | 64.5% | 简单 | +| 1757. 可回收且低脂的产品 | 87 | 89.1% | 简单 | +| 1758. 生成交替二进制字符串的最少操作数 | 139 | 63.8% | 简单 | +| 1763. 最长的美好子字符串 | 263 | 69.0% | 简单 | +| 1768. 交替合并字符串 | 326 | 76.0% | 简单 | +| 1773. 统计匹配检索规则的物品数量 | 235 | 84.3% | 简单 | +| 1777. 每家商店的产品价格 | 73 | 78.7% | 简单 | +| 1779. 找到最近的有相同 X 或 Y 坐标的点 | 205 | 64.8% | 简单 | +| 1784. 检查二进制字符串字段 | 128 | 42.4% | 简单 | +| 1789. 员工的直属部门 | 37 | 71.4% | 简单 | +| 1790. 仅执行一次字符串交换能否使两个字符串相等 | 301 | 57.3% | 简单 | +| 1791. 找出星型图的中心节点 | 459 | 83.9% | 简单 | +| 1795. 每个产品在不同商店的价格 | 60 | 79.3% | 简单 | +| 1796. 字符串中第二大的数字 | 174 | 48.9% | 简单 | +| 1800. 最大升序子数组和 | 201 | 67.4% | 简单 | +| 1805. 字符串中不同整数的数目 | 194 | 46.3% | 简单 | +| 1809. 没有广告的剧集 | 44 | 61.5% | 简单 | +| 1812. 判断国际象棋棋盘中一个格子的颜色 | 267 | 78.7% | 简单 | +| 1816. 截断句子 | 659 | 73.0% | 简单 | +| 1821. 寻找今年具有正收入的客户 | 30 | 90.2% | 简单 | +| 1822. 数组元素积的符号 | 323 | 75.3% | 简单 | +| 1826. 有缺陷的传感器 | 30 | 41.9% | 简单 | +| 1827. 最少操作使数组递增 | 193 | 78.5% | 简单 | +| 1832. 判断句子是否为全字母句 | 278 | 82.2% | 简单 | +| 1837. K 进制表示下的各位数字总和 | 125 | 79.8% | 简单 | +| 1844. 将所有数字用字符替换 | 159 | 79.5% | 简单 | +| 1848. 到目标元素的最小距离 | 129 | 67.5% | 简单 | +| 1853. 转换日期格式 | 26 | 62.2% | 简单 | +| 1854. 人口最多的年份 | 161 | 75.7% | 简单 | +| 1859. 将句子排序 | 209 | 75.1% | 简单 | +| 1863. 找出所有子集的异或总和再求和 | 213 | 86.5% | 简单 | +| 1869. 哪种连续子字符串更长 | 181 | 75.4% | 简单 | +| 1873. 计算特殊奖金 | 112 | 79.6% | 简单 | +| 1876. 长度为三且各字符不同的子字符串 | 156 | 71.5% | 简单 | +| 1880. 检查某单词是否等于两单词之和 | 143 | 76.9% | 简单 | +| 1886. 判断矩阵经轮转后是否一致 | 119 | 58.2% | 简单 | +| 1890. 2020年最后一次登录 | 45 | 73.3% | 简单 | +| 1893. 检查是否区域内所有整数都被覆盖 | 452 | 59.0% | 简单 | +| 1897. 重新分配字符使所有字符串都相等 | 103 | 54.6% | 简单 | +| 1903. 字符串中的最大奇数 | 139 | 62.6% | 简单 | +| 1909. 删除一个元素使数组严格递增 | 107 | 31.3% | 简单 | +| 1913. 两个数对之间的最大乘积差 | 159 | 82.6% | 简单 | +| 1920. 基于排列构建数组 | 196 | 87.5% | 简单 | +| 1925. 统计平方和三元组的数目 | 93 | 69.4% | 简单 | +| 1929. 数组串联 | 223 | 87.3% | 简单 | +| 1933. 判断字符串是否可分解为值均等的子串 | 31 | 49.7% | 简单 | +| 1935. 可以输入的最大单词数 | 154 | 72.1% | 简单 | +| 1939. 主动请求确认消息的用户 | 20 | 60.1% | 简单 | +| 1941. 检查是否所有字符出现次数相同 | 132 | 74.5% | 简单 | +| 1945. 字符串转化后的各位数字之和 | 112 | 65.3% | 简单 | +| 1952. 三除数 | 111 | 54.5% | 简单 | +| 1957. 删除字符使字符串变好 | 80 | 60.7% | 简单 | +| 1961. 检查字符串是否为数组前缀 | 92 | 53.5% | 简单 | +| 1965. 丢失信息的雇员 | 74 | 75.2% | 简单 | +| 1967. 作为子字符串出现在单词中的字符串数目 | 114 | 78.8% | 简单 | +| 1971. 寻找图中是否存在路径 | 80 | 44.1% | 简单 | +| 1974. 使用特殊打字机键入单词的最少时间 | 96 | 72.3% | 简单 | +| 1978. 上级经理已离职的公司员工 | 21 | 52.2% | 简单 | +| 1979. 找出数组的最大公约数 | 174 | 78.3% | 简单 | +| 1984. 学生分数的最小差值 | 474 | 62.9% | 简单 | +| 1990. 统计实验的数量 | 19 | 48.6% | 简单 | +| 1991. 找到数组的中间位置 | 145 | 65.2% | 简单 | +| 1995. 统计特殊四元组 | 245 | 66.3% | 简单 | +| 2000. 反转单词前缀 | 388 | 79.5% | 简单 | +| 2006. 差的绝对值为 K 的数对数目 | 446 | 85.4% | 简单 | +| 2011. 执行操作后的变量值 | 151 | 86.6% | 简单 | +| 2016. 增量元素之间的最大差值 | 458 | 60.2% | 简单 | +| 2022. 将一维数组转变成二维数组 | 424 | 66.7% | 简单 | +| 2026. 低质量的问题 | 26 | 81.0% | 简单 | +| 2027. 转换字符串的最少操作次数 | 92 | 57.4% | 简单 | +| 2032. 至少在两个数组中出现的值 | 150 | 65.8% | 简单 | +| 2037. 使每位学生都有座位的最少移动次数 | 90 | 82.1% | 简单 | +| 2042. 检查句子中的数字是否递增 | 155 | 66.0% | 简单 | +| 2047. 句子中的有效单词数 | 390 | 39.1% | 简单 | +| 2053. 数组中第 K 个独一无二的字符串 | 97 | 72.9% | 简单 | +| 2057. 值相等的最小索引 | 73 | 76.9% | 简单 | +| 2062. 统计字符串中的元音子字符串 | 111 | 61.4% | 简单 | +| 2068. 检查两个字符串是否几乎相等 | 99 | 71.5% | 简单 | +| 2072. 赢得比赛的大学 | 19 | 68.9% | 简单 | +| 2073. 买票需要的时间 | 138 | 62.3% | 简单 | +| 2078. 两栋颜色不同且距离最远的房子 | 131 | 73.6% | 简单 | +| 2082. 富有客户的数量 | 21 | 75.8% | 简单 | +| 2085. 统计出现过一次的公共字符串 | 95 | 72.7% | 简单 | +| 2089. 找出数组排序后的目标下标 | 150 | 81.1% | 简单 | +| 2094. 找出 3 位偶数 | 132 | 55.5% | 简单 | +| 2099. 找到和最大的长度为 K 的子序列 | 119 | 48.5% | 简单 | +| 2103. 环和杆 | 143 | 80.4% | 简单 | +| 2108. 找出数组中的第一个回文字符串 | 136 | 79.2% | 简单 | +| 2114. 句子中的最多单词数 | 139 | 86.0% | 简单 | +| 2119. 反转两次的数字 | 118 | 76.3% | 简单 | +| 2124. 检查是否所有 A 都在 B 之前 | 134 | 70.7% | 简单 | +| 2129. 将标题首字母大写 | 97 | 61.6% | 简单 | +| 2133. 检查是否每一行每一列都包含全部整数 | 114 | 56.4% | 简单 | +| 2138. 将字符串拆分为若干长度为 k 的组 | 107 | 67.3% | 简单 | +| 2144. 打折购买糖果的最小开销 | 104 | 68.3% | 简单 | +| 2148. 元素计数 | 109 | 57.9% | 简单 | +| 2154. 将找到的值乘以 2 | 123 | 74.5% | 简单 | +| 2160. 拆分数位后四位数字的最小和 | 111 | 85.3% | 简单 | +| 2164. 对奇偶下标分别排序 | 94 | 69.8% | 简单 | +| 2169. 得到 0 的操作数 | 88 | 75.9% | 简单 | +| 2176. 统计数组中相等且可以被整除的数对 | 72 | 80.8% | 简单 | +| 2180. 统计各位数字之和为偶数的整数个数 | 96 | 64.9% | 简单 | +| 2185. 统计包含给定前缀的字符串 | 105 | 79.4% | 简单 | +| 2190. 数组中紧跟 key 之后出现最频繁的数字 | 66 | 58.4% | 简单 | +| 2194. Excel 表中某个范围内的单元格 | 94 | 84.9% | 简单 | +| 2200. 找出数组中的所有 K 近邻下标 | 113 | 51.6% | 简单 | +| 2205. The Number of Users That Are Eligible for Discount | 9 | 44.7% | 简单 | +| 2206. 将数组划分成相等数对 | 83 | 76.6% | 简单 | +| 2210. 统计数组中峰和谷的数量 | 106 | 57.7% | 简单 | +| 2215. 找出两数组的不同 | 98 | 66.9% | 简单 | +| 2220. 转换数字的最少位翻转次数 | 88 | 82.8% | 简单 | +| 2224. 转化时间需要的最少操作数 | 108 | 69.1% | 简单 | +| 2229. Check if an Array Is Consecutive | 13 | 69.7% | 简单 | +| 2230. The Users That Are Eligible for Discount | 5 | 53.7% | 简单 | +| 2231. 按奇偶性交换后的最大数字 | 132 | 62.9% | 简单 | +| 2235. 两整数相加 | 25 | 89.1% | 简单 | +| 2236. 判断根结点是否等于子结点之和 | 15 | 86.9% | 简单 | +| 2239. 找到最接近 0 的数字 | 54 | 56.8% | 简单 | +| 2243. 计算字符串的数字和 | 92 | 63.0% | 简单 | +| 2248. 多个数组求交集 | 112 | 67.8% | 简单 | +| 2255. 统计是给定字符串前缀的字符串数目 | 57 | 81.6% | 简单 | +| 2259. 移除指定数字得到的最大结果 | 97 | 48.8% | 简单 | +| LCP 01. 猜数字 | 695 | 84.5% | 简单 | +| LCP 02. 分式化简 | 278 | 69.5% | 简单 | +| LCP 06. 拿硬币 | 740 | 84.0% | 简单 | +| LCP 07. 传递信息 | 537 | 76.4% | 简单 | +| LCP 11. 期望个数统计 | 83 | 70.4% | 简单 | +| LCP 17. 速算机器人 | 302 | 80.0% | 简单 | +| LCP 18. 早餐组合 | 285 | 29.6% | 简单 | +| LCP 22. 黑白方格画 | 200 | 34.1% | 简单 | +| LCP 28. 采购方案 | 240 | 30.5% | 简单 | +| LCP 33. 蓄水 | 114 | 24.8% | 简单 | +| LCP 39. 无人机方阵 | 52 | 53.0% | 简单 | +| LCP 40. 心算挑战 | 99 | 27.8% | 简单 | +| LCP 44. 开幕式焰火 | 105 | 79.5% | 简单 | +| LCP 50. 宝石补给 | 43 | 66.2% | 简单 | +| LCP 51. 烹饪料理 | 61 | 44.9% | 简单 | +| LCP 55. 采集果实 | 25 | 74.1% | 简单 | +| LCS 01. 下载插件 | 174 | 54.6% | 简单 | +| LCS 02. 完成一半题目 | 115 | 65.9% | 简单 | +| 剑指 Offer 03. 数组中重复的数字 | 3512 | 67.9% | 简单 | +| 剑指 Offer 05. 替换空格 | 2653 | 75.9% | 简单 | +| 剑指 Offer 06. 从尾到头打印链表 | 2822 | 75.0% | 简单 | +| 剑指 Offer 09. 用两个栈实现队列 | 2346 | 70.9% | 简单 | +| 剑指 Offer 10- I. 斐波那契数列 | 2316 | 36.2% | 简单 | +| 剑指 Offer 10- II. 青蛙跳台阶问题 | 1693 | 45.4% | 简单 | +| 剑指 Offer 11. 旋转数组的最小数字 | 2120 | 49.2% | 简单 | +| 剑指 Offer 15. 二进制中1的个数 | 1498 | 75.1% | 简单 | +| 剑指 Offer 17. 打印从1到最大的n位数 | 1321 | 77.9% | 简单 | +| 剑指 Offer 18. 删除链表的节点 | 1841 | 60.1% | 简单 | +| 剑指 Offer 21. 调整数组顺序使奇数位于偶数前面 | 2104 | 64.7% | 简单 | +| 剑指 Offer 22. 链表中倒数第k个节点 | 2971 | 80.2% | 简单 | +| 剑指 Offer 24. 反转链表 | 2370 | 74.3% | 简单 | +| 剑指 Offer 25. 合并两个排序的链表 | 1541 | 72.6% | 简单 | +| 剑指 Offer 27. 二叉树的镜像 | 1827 | 79.4% | 简单 | +| 剑指 Offer 28. 对称的二叉树 | 1494 | 57.6% | 简单 | +| 剑指 Offer 29. 顺时针打印矩阵 | 1790 | 43.8% | 简单 | +| 剑指 Offer 30. 包含min函数的栈 | 1541 | 55.2% | 简单 | +| 剑指 Offer 32 - II. 从上到下打印二叉树 II | 1509 | 68.8% | 简单 | +| 剑指 Offer 39. 数组中出现次数超过一半的数字 | 1270 | 69.9% | 简单 | +| 剑指 Offer 40. 最小的k个数 | 2183 | 57.3% | 简单 | +| 剑指 Offer 42. 连续子数组的最大和 | 1879 | 60.7% | 简单 | +| 剑指 Offer 50. 第一个只出现一次的字符 | 1457 | 62.2% | 简单 | +| 剑指 Offer 52. 两个链表的第一个公共节点 | 1294 | 65.5% | 简单 | +| 剑指 Offer 53 - I. 在排序数组中查找数字 I | 2109 | 53.2% | 简单 | +| 剑指 Offer 53 - II. 0～n-1中缺失的数字 | 2007 | 44.7% | 简单 | +| 剑指 Offer 54. 二叉搜索树的第k大节点 | 1514 | 76.3% | 简单 | +| 剑指 Offer 55 - I. 二叉树的深度 | 1545 | 79.2% | 简单 | +| 剑指 Offer 55 - II. 平衡二叉树 | 1196 | 59.5% | 简单 | +| 剑指 Offer 57. 和为s的两个数字 | 1126 | 67.7% | 简单 | +| 剑指 Offer 57 - II. 和为s的连续正数序列 | 2147 | 71.1% | 简单 | +| 剑指 Offer 58 - I. 翻转单词顺序 | 1293 | 44.5% | 简单 | +| 剑指 Offer 58 - II. 左旋转字符串 | 2430 | 86.1% | 简单 | +| 剑指 Offer 61. 扑克牌中的顺子 | 1317 | 46.0% | 简单 | +| 剑指 Offer 62. 圆圈中最后剩下的数字 | 907 | 65.8% | 简单 | +| 剑指 Offer 65. 不用加减乘除做加法 | 667 | 59.3% | 简单 | +| 剑指 Offer 68 - I. 二叉搜索树的最近公共祖先 | 899 | 69.5% | 简单 | +| 剑指 Offer 68 - II. 二叉树的最近公共祖先 | 897 | 70.4% | 简单 | +| 剑指 Offer II 001. 整数除法 | 304 | 21.0% | 简单 | +| 剑指 Offer II 002. 二进制加法 | 313 | 55.2% | 简单 | +| 剑指 Offer II 003. 前 n 个数字二进制中 1 的个数 | 368 | 78.6% | 简单 | +| 剑指 Offer II 006. 排序数组中两个数字之和 | 259 | 64.3% | 简单 | +| 剑指 Offer II 012. 左右两边子数组的和相等 | 236 | 66.7% | 简单 | +| 剑指 Offer II 018. 有效的回文 | 198 | 51.5% | 简单 | +| 剑指 Offer II 019. 最多删除一个字符得到回文 | 191 | 45.8% | 简单 | +| 剑指 Offer II 023. 两个链表的第一个重合节点 | 163 | 69.9% | 简单 | +| 剑指 Offer II 024. 反转链表 | 304 | 75.5% | 简单 | +| 剑指 Offer II 027. 回文链表 | 286 | 61.5% | 简单 | +| 剑指 Offer II 032. 有效的变位词 | 151 | 60.2% | 简单 | +| 剑指 Offer II 034. 外星语言是否排序 | 174 | 55.9% | 简单 | +| 剑指 Offer II 041. 滑动窗口的平均值 | 157 | 77.7% | 简单 | +| 剑指 Offer II 042. 最近请求次数 | 133 | 82.9% | 简单 | +| 剑指 Offer II 052. 展平二叉搜索树 | 160 | 74.6% | 简单 | +| 剑指 Offer II 056. 二叉搜索树中两个节点之和 | 178 | 73.5% | 简单 | +| 剑指 Offer II 059. 数据流的第 K 大数值 | 119 | 63.5% | 简单 | +| 剑指 Offer II 068. 查找插入位置 | 150 | 50.2% | 简单 | +| 剑指 Offer II 069. 山峰数组的顶部 | 476 | 71.1% | 简单 | +| 剑指 Offer II 072. 求平方根 | 149 | 42.0% | 简单 | +| 剑指 Offer II 075. 数组相对排序 | 178 | 70.8% | 简单 | +| 剑指 Offer II 088. 爬楼梯的最少成本 | 163 | 73.7% | 简单 | +| 剑指 Offer II 101. 分割等和子集 | 93 | 49.9% | 简单 | +| 面试题 01.01. 判定字符是否唯一 | 1867 | 71.3% | 简单 | +| 面试题 01.02. 判定是否互为字符重排 | 1338 | 63.7% | 简单 | +| 面试题 01.03. URL化 | 608 | 57.6% | 简单 | +| 面试题 01.04. 回文排列 | 948 | 54.3% | 简单 | +| 面试题 01.06. 字符串压缩 | 1318 | 46.8% | 简单 | +| 面试题 01.09. 字符串轮转 | 520 | 54.7% | 简单 | +| 面试题 02.01. 移除重复节点 | 788 | 67.3% | 简单 | +| 面试题 02.02. 返回倒数第 k 个节点 | 1082 | 78.1% | 简单 | +| 面试题 02.03. 删除中间节点 | 770 | 85.8% | 简单 | +| 面试题 02.06. 回文链表 | 598 | 48.5% | 简单 | +| 面试题 02.07. 链表相交 | 711 | 67.2% | 简单 | +| 面试题 03.01. 三合一 | 242 | 53.1% | 简单 | +| 面试题 03.02. 栈的最小值 | 356 | 61.6% | 简单 | +| 面试题 03.04. 化栈为队 | 394 | 71.4% | 简单 | +| 面试题 03.06. 动物收容所 | 223 | 58.5% | 简单 | +| 面试题 04.02. 最小高度树 | 493 | 78.8% | 简单 | +| 面试题 04.04. 检查平衡性 | 427 | 59.1% | 简单 | +| 面试题 05.01. 插入 | 244 | 50.9% | 简单 | +| 面试题 05.03. 翻转数位 | 288 | 38.2% | 简单 | +| 面试题 05.06. 整数转换 | 278 | 52.2% | 简单 | +| 面试题 05.07. 配对交换 | 257 | 71.0% | 简单 | +| 面试题 08.01. 三步问题 | 561 | 36.5% | 简单 | +| 面试题 08.03. 魔术索引 | 458 | 67.5% | 简单 | +| 面试题 08.06. 汉诺塔问题 | 332 | 65.3% | 简单 | +| 面试题 08.10. 颜色填充 | 272 | 55.8% | 简单 | +| 面试题 10.01. 合并排序的数组 | 2452 | 55.9% | 简单 | +| 面试题 10.05. 稀疏数组搜索 | 299 | 56.2% | 简单 | +| 面试题 16.05. 阶乘尾数 | 144 | 45.6% | 简单 | +| 面试题 16.07. 最大数值 | 342 | 73.3% | 简单 | +| 面试题 16.11. 跳水板 | 624 | 44.1% | 简单 | +| 面试题 16.15. 珠玑妙算 | 291 | 48.7% | 简单 | +| 面试题 16.17. 连续数列 | 436 | 59.5% | 简单 | +| 面试题 17.01. 不用加号的加法 | 201 | 60.5% | 简单 | +| 面试题 17.04. 消失的数字 | 566 | 62.5% | 简单 | +| 面试题 17.10. 主要元素 | 980 | 56.7% | 简单 | +| 面试题 17.12. BiNode | 337 | 63.5% | 简单 | +| 面试题 17.16. 按摩师 | 1210 | 51.4% | 简单 | \ No newline at end of file pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy