【LeetCode】刷题工具_leetcode editor

Idea插件 之 LeetCode Editor

文档

LeetCode Editor插件中文官网：https://github.com/shuzijun/leetcode-editor/blob/master/README_ZH.md

获取

配置（第一次安装需要先配置）

官网描述：

自己配置：

官方给的下图中第5、6步一个模板：https://github.com/shuzijun/leetcode-editor/blob/master/doc/CustomCode_ZH.md

我设置的文件名：

P${question.frontendQuestionId}_${question.title}/Main
1

文件模板：

package leetcode.editor.cn.P${question.frontendQuestionId}_${question.title};
public class Main{
    public static void main(String[] args) {
        Solution solution = new Solution();
       
    }
}
${question.code}
1
2
3
4
5
6
7
8

图示：

然后点这里选题：

工具类：

ListNode :

public class ListNode {
    public int val;
    public ListNode next;
    public ListNode() {}
    public ListNode(int val) { this.val = val; }
    public ListNode(int val, ListNode next) { this.val = val; this.next = next; }
}
1
2
3
4
5
6
7

TreeNode

public class TreeNode {
    public int val;
    public TreeNode left;
    public TreeNode right;
    public TreeNode() {}
    public TreeNode(int val) { this.val = val; }
    public TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

自定义工具类：

力扣上刷题，想复制它的测试案例，直接在本地测试？不妨复制这个工具类

import com.alibaba.fastjson.JSONObject;
import com.ljy.commons.ListNode;
import com.ljy.commons.TreeNode;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.*;

public class LeetCodeUtil {

    /**
     * 根据数组生成链表
     *
     * @param arr
     * @return
     */
    public static ListNode getListNode(int[] arr) {
        ListNode listNode = new ListNode(arr[0]);
        ListNode head = listNode;
        for (int i = 1; i < arr.length; i++) {
            ListNode node = new ListNode(arr[i]);
            listNode.next = node;
            listNode = node;
        }
        listNode.next = null;
        return head;
    }

    /**
     * 打印链表
     *
     * @param node
     */
    public static void printListNode(ListNode node) {
        while (node != null) {
            String result = node.next == null ? node.val + "" : node.val + " --> ";
            node = node.next;
            System.out.print(result);
        }
    }

    /**
     * 根据数组生成二叉树
     *
     * @param arr
     * @return
     */
    public static TreeNode getTreeNode(Integer[] arr) {
        return getTreeNode(arr, 0);
    }

    /**
     * 根据数组生成二叉树
     *
     * @param data
     * @return
     */
    public static TreeNode getTreeNode(String data) {
        String[] strArr = string2stringArray(data)[0];
        Integer[] integerArr = new Integer[strArr.length];
        for (int i = 0; i < strArr.length; i++) {
            integerArr[i] = "null".equals(strArr[i]) ? null : Integer.parseInt(strArr[i]);
        }
        return getTreeNode(integerArr);
    }

    //层次法生成二叉树
    private static TreeNode getTreeNode(Integer[] arr, int index) {
        TreeNode node = null;
        if (index < arr.length) {
            if (arr[index] != null) {
                node = new TreeNode(arr[index]);

                node.left = getTreeNode(arr, 2 * index + 1);
                node.right = getTreeNode(arr, 2 * index + 2);
            }
        }
        return node;
    }

    //层次遍历
    public static void printTreeNode(TreeNode treeNode) {
        System.out.println("注:/、\\分别表示左子树、右子树");
        LinkedList<TreeNode> linkedList = new LinkedList<>();
        linkedList.add(treeNode);
        while (true) {
            if (linkedList == null || linkedList.size() == 0) break;
            //输出
            for (TreeNode t2 : linkedList) {
                System.out.print(String.format("%4s", t2.val));
            }
            System.out.println();
            //用于画线
            for (TreeNode t2 : linkedList) {
                StringBuilder sb = new StringBuilder();
                if (t2.left != null)
                    sb.append("/");
                if (t2.right != null)
                    sb.append("\\");
                System.out.print(String.format("%4s", sb.toString()));
            }
            System.out.println();
            //下一层
            linkedList = printTreeNode(linkedList);
        }
    }

    //根据i层获得i+1层
    private static LinkedList<TreeNode> printTreeNode(LinkedList<TreeNode> linkedList) {
        LinkedList<TreeNode> l2 = new LinkedList<>();
        if (linkedList == null || linkedList.size() == 0) {
            return null;
        }
        for (TreeNode t : linkedList) {
            if (t.left != null)
                l2.add(t.left);
            if (t.right != null)
                l2.add(t.right);
        }
        return l2;
    }

    /**
     * 对二叉树的节点排序并打印
     *
     * @param root
     */
    public static void printSortTreeNode(TreeNode root) {
        List list = new ArrayList();
        preOrder(root, list);
        Collections.sort(list);
        System.out.println(list);
    }

    /**
     * 二叉树先序遍历(非递归)
     *
     * @param root
     */
    private static void preOrder(TreeNode root, List list) {
        Stack<TreeNode> stack = new Stack<>();
        while (true) {
            while (root != null) {
                list.add(root.val);
                stack.push(root);
                root = root.left;
            }
            if (stack.isEmpty()) break;
            root = stack.pop();
            root = root.right;
        }
    }

    /**
     * 打印数组
     *
     * @param arr
     */
    public static void printArr(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + (i == arr.length - 1 ? "" : ","));
        }
    }

    public static void quickSort(int[] arr) {
        quickSort(arr, 0, arr.length - 1);
    }

    /**
     * 快排
     *
     * @param arr
     * @param leftIndex
     * @param rightIndex
     */
    public static void quickSort(int[] arr, int leftIndex, int rightIndex) {
        if (leftIndex >= rightIndex) {
            return;
        }
        int left = leftIndex;
        int right = rightIndex;
        //待排序的第一个元素作为基准值
        int key = arr[left];
        //从左右两边交替扫描，直到left = right
        while (left < right) {
            while (right > left && arr[right] >= key) {
                //从右往左扫描，找到第一个比基准值小的元素
                right--;
            }
            //找到这种元素将arr[right]放入arr[left]中
            arr[left] = arr[right];
            while (left < right && arr[left] <= key) {
                //从左往右扫描，找到第一个比基准值大的元素
                left++;
            }
            //找到这种元素将arr[left]放入arr[right]中
            arr[right] = arr[left];
        }
        //基准值归位
        arr[left] = key;
        //对基准值左边的元素进行递归排序
        quickSort(arr, leftIndex, left - 1);
        //对基准值右边的元素进行递归排序。
        quickSort(arr, right + 1, rightIndex);
    }

    /**
     * 字符串转二维数组
     *
     * @param s 例如：[[1,0],[99,97]]
     * @return 二维数组
     */
    public static int[][] string2intArray(String s) {
        String[][] strings = string2stringArray(s);
        int[][] res = new int[strings.length][strings[0].length];
        String[] tmp;
        for (int i = 0; i < strings.length; i++) {
            tmp = strings[i];
            for (int j = 0; j < tmp.length; j++) {
                res[i][j] = Integer.parseInt(tmp[j]);
            }
        }
        return res;
    }
    /**
     * 字符串转二维数组
     *
     * @param s 例如：[[1,0],[99,97]]
     * @return 二维数组的第0个
     */
    public static int[] string2intArray0(String s){
        return string2intArray(s)[0];
    }

    /**
     * 字符串转二维数组。默认每一行数据个数相同
     *
     * @param s 例如：[["1","0"],["99","97"]]
     * @return 二维数组
     */
    public static String[][] string2stringArray(String s) {
        return string2stringArray(s,true);
    }

    /**
     * 字符串转二维数组。isSameLength = true 表示每一行数据个数相同
     * @param s 例如：[["1","0"],["99","97"]]
     * @param isSameLength 每一行的元素个数是否相同
     * @return
     */
    public static String[][] string2stringArray(String s, boolean isSameLength) {
        // [[1,0],[99,97]]
        //去掉首尾的[]
        s = s.substring(s.indexOf("[") + 1, s.lastIndexOf("]"));

        //去掉所有的双引号
        s = s.replaceAll("\"", "");
        //使用,分隔 ==> [1,0]
        String[] row = s.split("],\\[");

        //每一行右相同个数的元素
        if (isSameLength){
            String[][] res = new String[row.length][];
            int colCount = row[0].split(",").length;
            for (int i = 0; i < row.length; i++) {
                res[i] = new String[colCount];
                String[] col = row[i].replace("[", "").replace("]", "").split(",");
                System.arraycopy(col, 0, res[i], 0, col.length);
            }

            return res;
        }else {
            String[][] res = new String[row.length][];
            for (int i = 0; i < row.length; i++) {
               res[i] = row[i].replace("[", "").replace("]", "").split(",");
            }
            return res;
        }
    }

    /**
     * 模拟力扣中的执行方法：
     * 例如：
     * ["MyLinkedList","addAtHead","addAtTail","addAtIndex","get","deleteAtIndex","get"]
     * [[],[1],[3],[1,2],[1],[1],[1]]
     *
     * @param obj 执行哪个对象的方法？
     * @param method  方法的集合，例如：["MyLinkedList","addAtHead","addAtTail","addAtIndex","get","deleteAtIndex","get"]
     * @param param 参数的集合，例如：[[],[1],[3],[1,2],[1],[1],[1]]
     * @return 依次执行所有方法后的obj
     * @throws Exception
     */
    public static Object invoke(Object obj, String method, String param) throws Exception {
        //["Trie","insert","search","search","startsWith","insert","search"]
        // [[],["apple"],["apple"],["app"],["app"],["app"],["app"]]

        String[] ms = string2stringArray(method)[0];
        String[][] ps = string2stringArray(param, false);
        //ps中空字符串转null
        for (int i = 0; i < ps.length; i++) {
            ps[i] = ps[i].length == 1 && ps[i][0].length() == 0 ? null : ps[i];
        }

        Class<?> objClass = obj.getClass();
        for (int i = 0; i < ms.length; i++) {
            String mi = ms[i];
            //如果以大写字母开头，则调用构造器
            int len = ps[i] == null ? 0 : ps[i].length;
            if (mi.charAt(0) <= 'Z') {
                for (Constructor<?> constructor : objClass.getConstructors()) {
                    int parameterCount = constructor.getParameterCount();
                    if (parameterCount == len) {
                        System.out.println("==>构造器:" + constructor.getName() +
                                Arrays.toString(ps[i])
                                        .replace("[", "(").replace("]", ")")
                        );
                        constructor.setAccessible(true);
                        obj = constructor.newInstance(ps[i]);
                        break;
                    }
                }
            } else {
                //调用方法，传参数
                Method[] methods = objClass.getMethods();

                for (Method md : methods) {
                    //参数个数
                    int parameterCount = md.getParameterCount();
                    //参数名一致，参数个数一致，很可能就是这个方法
                    if (md.getName().equals(mi) && parameterCount == len) {
                        md.setAccessible(true);
                        //转化String数组类型的参数到我们想要的类型：
                        Class<?>[] pts = md.getParameterTypes();
                        Object[] psObj = new Object[pts.length];
                        for (int k = 0; k < pts.length; k++) {
                            psObj[k] = cast(pts[k], ps[i][k]);
                        }

                        System.out.println("==> 方法:" + md.getName() + "" +
                                Arrays.toString(ps[i])
                                        .replace("[", "(").replace("]", ")"));
                        //真正的开始执行方法：
                        Object res = md.invoke(obj, psObj);
                        System.out.println("<== " + res);
                        break;
                    }
                }
            }
        }

        return obj;
    }

    /**
     * 将字符串s转换为指定的class类型
     * @param clzz
     * @param s
     * 依赖于fastjson，可在pom中引入：
     *          <dependency>
     *             <groupId>com.alibaba</groupId>
     *             <artifactId>fastjson</artifactId>
     *             <version>1.2.75</version>
     *         </dependency>
     * @return
     */
    private static Object cast(Class<?> clzz, String s) {
        String jsonString = JSONObject.toJSONString(s);
        return JSONObject.parseObject(jsonString, clzz);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371