leetcode刷题工具

前言

自己把leetcode的一些基础知识对应的题目总结下来放在了gitee上，希望对大家有帮助。
另外自己写了一些方便大家使用自己的IDE进行调试的工具，也放在了下面。

• 算法知识对应题目列表
• leetcode数据转换工具

工具

由于使用leetcode直接写代码，调试的时候总是需要排队，所以个人还是比较喜欢使用IDE进行编码的。但是由于leetcode的数据的格式不能直接复制粘贴，所以写了一些工具进行转化。

字符串转化成数组

• 把字符串转化成列表(String类型和int类型)
• 把字符串转化成一维和二维数组(String和int类型)。

由于leetcode中最常见的就是String和int类型的二维数组。所以写一个转换，方便输入数据的时候进行直接复制粘贴，不用在手动转换了。

package leetcode.utils;

import java.util.ArrayList;
import java.util.List;

/*
*
*   leetcode中的数组转换成实际的数组
*
* 1. 算法过程
* 2. 如何设计着个代码？ 是否要让idx成为全局变量，并且是静态的
* 3. 辅助函数changeToList是否应该使用static
*
* 很多设计上面的问题
* 1. 如何返回数组，而不是List, 转化成1维，2维，还是其他维。
* 2. 返回的怎么是Integer类型的，最后一维
*
* */
public class ChangeToArrayOrList {
    private static int idx;
    private ChangeToArrayOrList() {}  // 不提供构对象，只提供方法
    @SuppressWarnings("unchecked")
    private static List changeToIntList(char[] chars) {
        List list = new ArrayList();
        if (chars[idx] == '[') {
            while(idx < chars.length && chars[idx] == '[') {
                idx++;                             // 去掉左括号
                List nlist = changeToIntList(chars);
                list.add(nlist);
                while(idx < chars.length && (chars[idx] == ']' || chars[idx] == ','))
                    idx++;                             // 去掉逗号和右括号
            }
        } else {                                        // 字母
            while(idx < chars.length && Character.isDigit(chars[idx])) {
                StringBuilder b = new StringBuilder();
                while(Character.isDigit(chars[idx])) {
                    b.append(chars[idx]);
                    idx++;
                }
                list.add(Integer.valueOf(b.toString()));
                idx++;                          // 逗号和右括号去掉
            }
        }
        return list;
    }
    @SuppressWarnings("unchecked")
    private static List changeToStringList(char[] chars) {
        List list = new ArrayList();
        if (chars[idx] == '[') {
            while(idx < chars.length && chars[idx] == '[') {
                idx++;                             // 去掉左括号
                List nlist = changeToStringList(chars);
                list.add(nlist);

                while(idx < chars.length && (chars[idx] == ']' || chars[idx] == ','))
                    idx++;                             // 去掉逗号和右括号
            }
        } else {                                    // 字符串
            while(idx < chars.length && (Character.isLetter(chars[idx]) || chars[idx] == '\"')) {
                StringBuilder b = new StringBuilder();
                while(Character.isLetter(chars[idx]) || chars[idx] == '\"') {
                    b.append(chars[idx]);
                    idx++;
                }
                list.add(b.toString());
                idx++;                          // 逗号和右括号去掉
            }
        }
        return list;
    }

    /*
    *
    *   转化成int类型的列表
    *   1. 保证必须是列表类型的字符串
    *   1.1 一定含有[]结构，并且是关闭的
    *   1.2 一定是以 ']'结尾代表，而不是以 ','结尾
    *   1.3 其中的变量一定是int类型而不是String类型
    *
    * */
    public static List changeToIntList(String s) {
        s = s.replace(" ", "");
        idx = 0;

        // 这里需要先验证是否符合上面两条数据，如果不符合直接返回
        if (s.length() == 0)
        {
            throw new RuntimeException("不是正确的数组类型啊，亲");
        }

        List list = changeToIntList(s.toCharArray());
        return (List)list.get(0);
    }

    public static List changeToStringList(String s) {
        s = s.replace(" ", "");
        idx = 0;

        // 这里需要先验证是否符合上面两条数据，如果不符合直接返回
        if (s.length() == 0)
        {
            throw new RuntimeException("不是正确的数组类型啊，亲");
        }
        List list = changeToStringList(s.toCharArray());
        return (List)list.get(0);
    }



    public static int [] changTo1DIntArray(String s) {
        s = s.replace(" ", "");
        List list = changeToIntList(s);
        if (list == null) {
            throw new RuntimeException("必须保证是一维数组啊，亲");
        }
        int [] ans = new int[list.size()];
        for (int i = 0; i < list.size(); i++) {
            ans[i] = (Integer) list.get(i);
        }
        return ans;
    }

    /*
    *
    *   转换成int类型的二维数组
    *
    * 1. 保证每一维的大小相同
    * 2. 保证一定是二维的
    * 3. 保证不为空
    * */

    public static int[][] changeTo2DIntArray(String s) {
        s = s.replace(" ", "");
        List list = changeToIntList(s);
        if (list == null || list.size() == 0) {
            throw new RuntimeException("必须保证是二维数组啊，亲");
        }
        List list1 = (List)list.get(0);
        int m = list1.size(), n = list.size();
        int[][] ans = new int[n][m];
        for (int i = 0; i < n; i++) {
            list1 = (List)list.get(i);

            if (list1.size() > m) {
                throw new RuntimeException("数组越界了啊，亲，必须保证维度相同啊");
            }
            for (int j = 0; j < m; j++) {
                ans[i][j] = (Integer) list1.get(j);
            }
        }
        return ans;
    }

    public static String[] changeTo1DString(String s) {
        s = s.replace(" ", "");
        List list = changeToStringList(s);
        if (list == null) {
            throw new RuntimeException("必须保证是一维数组啊，亲");
        }
        String[] ans = new String[list.size()];
        for (int i = 0; i < list.size(); i++) {
            ans[i] = (String) list.get(i);
        }
        return ans;
    }
    public static String[][] changTo2DString(String s) {
        s = s.replace(" ", "");
        List list = changeToStringList(s);
        if (list == null || list.size() == 0) {
            throw new RuntimeException("必须保证是二维数组啊，亲");
        }
        List list1 = (List)list.get(0);
        int m = list1.size(), n = list.size();
        String[][] ans = new String[n][m];
        for (int i = 0; i < n; i++) {
            list1 = (List)list.get(i);

            if (list1.size() != m) {
                throw new RuntimeException("数组越界了啊，亲，必须保证维度相同啊");
            }
            for (int j = 0; j < m; j++) {
                ans[i][j] = (String) list1.get(j);
            }
        }
        return ans;
    }


    public static void main(String[] args) {

        String s = "[[\"fda\"],[\"dsfa\"]]";
        List list = changeToStringList(s);
        System.out.println(list);

        s = "[[1,1],[2,2],[2,0],[2,4],[3,3],[4,2]]";
        list = changeToIntList(s);
        System.out.println(s);
        int[][]arrs = changeTo2DIntArray(s);
        PrintArrays.print2DIntArray(arrs);


        s = "[13,43,42,1]";
        int[] arr = changTo1DIntArray(s);

        System.out.println();

        s = "[\"mass\",\"as\",\"hero\",\"superhero\"]";
        String[] sArr = changeTo1DString(s);
        PrintArrays.print1DObjArray(sArr);

        s = "[[\"mass\",\"as\"],[\"hero\",\"superhero\"]]";
        String[][] sArrs = changTo2DString(s);
        PrintArrays.print2DObjArray(sArrs);
    }
}

数组的输出

每次调试的时候，输出一、二维数组，都是一个巨大的负担。
并且Java中数组转化成list还需要强制转换或者使用流操作，特别不爽，还是自己写一个打印的比较爽。

package leetcode.utils;

/*
*
*   对数组的输出
* */
public class PrintArrays {

    private PrintArrays() {}

    public static void print2DIntArray(int[][] arr) {
        if (arr.length == 0) {
            System.out.println("[]");
            return ;
        }
        int n = arr.length, m = arr[0].length;
        System.out.print('[');
        for (int i = 0; i < n; i++) {
            System.out.print('[');
            for (int j = 0; j < m; j++) {
                System.out.print(arr[i][j]);
                if (j != m - 1) System.out.print(',');
                else System.out.print(']');
            }
            if (i != n - 1) System.out.print(',');
            else System.out.println(']');
        }
    }
    public static void print1DIntArray(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
            if (i != arr.length - 1) System.out.print(",");
            else System.out.println("]");
        }
    }

    public static void print1DObjArray(Object[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
            if (i != arr.length - 1) System.out.print(",");
            else System.out.println("]");
        }
    }

    public static void print2DObjArray(Object[][] arr) {
        if (arr.length == 0) {
            throw new RuntimeException("必须是二维数组啊，亲人");
        }
        int n = arr.length, m = arr[0].length;
        System.out.print('[');
        for (int i = 0; i < n; i++) {
            System.out.print('[');
            for (int j = 0; j < m; j++) {
                System.out.print(arr[i][j]);
                if (j != m - 1) System.out.print(',');
                else System.out.print(']');
            }
            if (i != n - 1) System.out.print(',');
            else System.out.println(']');
        }
    }


    public static void main(String[] args) {
        int[][] nums = {{323,432},{42,42}};
        print2DIntArray(nums);
        int[] num = {123,434};
        print1DIntArray(num);
    }
}

树的操作

暂定

链表的操作

妈妈再也不用担心我没法调试列表了。

• 链表的创建
• 链表的遍历
• 链表的反转

package leetcode.utils;

import com.sun.istack.internal.NotNull;
import leetcode.everyDay.April.Exercise25;

import java.util.List;

public class ListNode {
    int val;
    ListNode next;

    ListNode() {
    }

    ListNode(int val) {
        this.val = val;
    }

    ListNode(int val,ListNode next) {
        this.val = val;
        this.next = next;
    }

    private static ListNode createList(int[]list) {

        ListNode head = new ListNode();
        ListNode p = head;
        for (int x: list) {
            p.next = new ListNode(x);
            p = p.next;
        }
        return head.next;
    }

    public static void travelList(@NotNull ListNode h) {
        ListNode p = h;
        System.out.print("[");
        while(p.next != null) {
            System.out.print(p.val + ",");
            p = p.next;
        }
        System.out.println(p.val + "]");
    }
    public ListNode reverseList(ListNode l) {
        ListNode head = new ListNode();
        ListNode p = l;
        while(p != null) {
            ListNode t = p;
            p = p.next;
            t.next = head.next;
            head.next = t;
        }
        return head.next;
    }

    public static void main(String[] args) {
        int[]list = {1,2,3,3,4,4,5};
        ListNode h = createList(list);
        travelList(h);
    }
}

点赞点赞