完整代码github地址

LeetCode自定义的数据结构

public class UtilDS {
	public static class ListNode {
		public int val;
		public ListNode next;

		public ListNode(int x) {
			val = x;
		}
	}

	public static class TreeNode {
		public int val;
		public TreeNode left;
		public TreeNode right;

		public TreeNode(int x) {
			val = x;
		}
	}
	

}

生成方法

首先是工厂

public interface TestHelperFactory<T> {
    T produce(String s);
}

前言：代码写的挺随意的，当初写的时候都是赶着赶紧测试。。。只要实现了这个功能就好。不保证边际用例和最高效率

但使用应该是拿来就能用。就我测试过的题而言，这些够用了

二维char工厂

public class CharArr_Two_Factory implements TestHelperFactory<char[][]> {
    @Override
    public char[][] produce(String s) {
        s = s.replace("\"", "");
        int n = s.length();
        Stack<Character> s1 = new Stack<Character>();
        Stack<Character> s2 = new Stack<Character>();
        Queue<char[]> queue = new LinkedList<char[]>();
        int m = n;
        for (int i = 0; i < n; ++i) {
            char c = s.charAt(i);
            if (c == ',')
                continue;
            if (c != ']') {
                s1.add(c);
            } else {
                while (!s1.isEmpty()) {
                    char c1 = s1.pop();
                    if (c1 != '[') {
                        s2.add(c1);
                    }
                }
                int size = s2.size();
                if (size == 0) {
                    continue;
                }
                m = size;
                char[] cArr = new char[size];
                for (int j = 0; j < m; ++j) {
                    cArr[j] = s2.pop();
                }
                queue.add(cArr);
            }
        }
        int qSize = queue.size();
        char[][] res = new char[qSize][m];
        for (int i = 0; i < qSize; ++i) {
            char[] temp = queue.poll();
            res[i] = temp;
        }
        return res;
    }

一维数组工厂

public class IntArr_One_Factory implements TestHelperFactory<int[]> {

    @Override
    public int[] produce(String s) {
        String temp1 = s.replace("[", "");
        String temp2 = temp1.replace("]", "");
        if(temp2.length()==0){
            return new int[0];
        }
        String[] s2 = temp2.split(",");
        int n = s2.length;
        int[] res = new int[n];
        for (int i = 0; i < n; ++i) {
            res[i] = Integer.parseInt(s2[i]);
        }
        return res;
    }
}

二维数组工厂

public class IntArr_Two_Factory implements TestHelperFactory<int[][]> {
    @Override
    public int[][] produce(String s) {
        Queue<int[]> queue = new LinkedList<int[]>();
        s = s.substring(0, s.length() - 1);
        s = s.substring(1, s.length());
        int maxM = 0;
        TestHelperFactory<int[]> factory = new IntArr_One_Factory();
        while (s.length() > 0) {
            int b = s.indexOf("[");
            int e = s.indexOf("]");
            String temp = s.substring(b, e + 1);
            int[] intArr = factory.produce(temp);
            maxM = Math.max(intArr.length, maxM);
            queue.add(intArr);
            s = s.substring(e + 1, s.length());
        }
        int m = maxM;
        int n = queue.size();
        int[][] res = new int[n][m];
        for (int i = 0; i < n; ++i) {
            res[i] = queue.poll();
        }
        return res;
    }
}

List工厂

public class List_Int_Factory implements TestHelperFactory<List<Integer>> {
    @Override
    public List<Integer> produce(String s) {
        TestHelperFactory<int[]> factory = new IntArr_One_Factory();
        int[] intArr = factory.produce(s);
        return initialList(intArr);
    }

    public List<Integer> initialList(int[] arr) {
        int n = arr.length;
        List<Integer> res = new ArrayList<Integer>();
        for (int i = 0; i < n; i++) {
            res.add(arr[i]);
        }
        return res;
    }
}

public class List_List_Int_Factory implements TestHelperFactory<List<List<Integer>>> {
    @Override
    public List<List<Integer>> produce(String s) {
        TestHelperFactory<int[][]> factory = new IntArr_Two_Factory();
        int[][] intArr = factory.produce(s);
        return initialList(intArr);
    }

    private List<List<Integer>> initialList(int[][] arr) {
        List<List<Integer>> res = new ArrayList<>();
        int n = arr.length;
        List_Int_Factory factory = new List_Int_Factory();
        for (int i = 0; i < n; ++i) {
            int[] temp = arr[i];
            List<Integer> l = factory.initialList(temp);
            res.add(l);
        }
        return res;
    }
}

一维字符串

public class StringArr_Factory implements TestHelperFactory<String[]> {

    @Override
    public String[] produce(String s) {
        String temp1 = s.replace("\"", "");
        String temp2 = temp1.replace("[", "");
        String temp3 = temp2.replace("]", "");
        String[] res = temp3.split(",");
        return res;
    }
}

TreeNode工厂

public class TreeNode_Factory implements TestHelperFactory<TreeNode> {

    @Override
    public TreeNode produce(String s) {
        s = s.replace("[", "");
        s = s.replace("]", "");
        String[] sArr = s.split(",");
        int n = sArr.length;
        Queue<TreeNode> qTree = new LinkedList<TreeNode>();
        TreeNode headNode = new TreeNode(Integer.parseInt(sArr[0]));
        qTree.add(headNode);
        int i = 1;
        while (i < n) {
            TreeNode tempNode = qTree.poll();
            TreeNode left = null;
            String tempString = sArr[i];
            if (!tempString.equals("null")) {
                try {
                    int temp = Integer.parseInt(tempString);
                    left = new TreeNode(temp);
                    tempNode.left = left;
                } catch (Exception e) {
                    // TODO: handle exception
                }
            }

            i++;
            if (i == n) {
                break;
            }
            TreeNode right = null;
            tempString = sArr[i];
            if (!tempString.equals("null")) {
                try {
                    int temp = Integer.parseInt(tempString);
                    right = new TreeNode(temp);
                    tempNode.right = right;
                } catch (Exception e) {
                    // TODO: handle exception
                }
            }

            i++;
            qTree.add(left);
            qTree.add(right);
        }
        return headNode;
    }
}

关于测试框架的设计思路可以看我的另一篇文章：
手动搭建一个LeetCode的测试框架——让你的刷题之路更省时间

我们可以定义一个工厂选择器

public class FactorySelector {

    private String intArr_One_Class;//一维数组的class
    private String String_Class;
    private String intArr_Two_Class;
    private String charArr_Two_Class;
    private String list_Int_Class;
    private String list_List_Int_ClassTypeName;
    private String treeNode_ClassTypeName;

    public FactorySelector() {
        intArr_One_Class = ClassHelper.getIntArr_One_ClassTypeName();
        String_Class = ClassHelper.getString_ClassTypeName();
        intArr_Two_Class = ClassHelper.getIntArr_Two_ClassTypeName();
        charArr_Two_Class = ClassHelper.getCharArr_Two_ClassTypeName();
        list_Int_Class = ClassHelper.getList_Int_ClassTypeName();
        list_List_Int_ClassTypeName = ClassHelper.getList_List_Int_ClassTypeName();
        treeNode_ClassTypeName = ClassHelper.getTreeNode_ClassTypeName();
    }

    public TestHelperFactory getFactory(String classType) {
        if (classType.equals(intArr_One_Class)) {
            return new IntArr_One_Factory();
        }
        if (classType.equals(intArr_Two_Class)) {
            return new IntArr_Two_Factory();
        }

        if (classType.equals(String_Class)) {
            return new StringArr_Factory();
        }

        if (classType.equals(charArr_Two_Class)) {
            return new CharArr_Two_Factory();
        }

        if (classType.equals(list_Int_Class)) {
            return new List_Int_Factory();
        }
        if (classType.equals(list_List_Int_ClassTypeName)) {
            return new List_List_Int_Factory();
        }

        if (classType.equals(treeNode_ClassTypeName)) {
            return new TreeNode_Factory();
        }
        return null;
    }


}

这里的ClassHelper代码如下

public class ClassHelper {
    //https://blog.csdn.net/u011082160/article/details/101025884

    public static String getInterfaceTName(Object o, int typeIndex, int typeArgumentsIndex) {
        Type[] types = o.getClass().getGenericInterfaces();
        ParameterizedType parameterizedType = (ParameterizedType) types[typeIndex];
        Type type = parameterizedType.getActualTypeArguments()[typeArgumentsIndex];
        return type.getTypeName();
    }

    public static Class<?> getFinalInterfaceT(Object o, int typeIndex, int typeArgumentsIndex) {
        Type[] types = o.getClass().getGenericInterfaces();
        ParameterizedType parameterizedType = (ParameterizedType) types[typeIndex];
        Type type = parameterizedType.getActualTypeArguments()[typeArgumentsIndex];
        return checkType(type, typeArgumentsIndex);
    }

    public static String getClassName(Object o, int index) {
        Type type = o.getClass().getGenericSuperclass();
        ParameterizedType parameterizedType = (ParameterizedType) type;
        Type actType = parameterizedType.getActualTypeArguments()[index];
        return actType.getTypeName();
    }

    public static Class<?> getFinalClassT(Object o, int index) {
        Type type = o.getClass().getGenericSuperclass();
        if (type instanceof ParameterizedType) {
            ParameterizedType parameterizedType = (ParameterizedType) type;
            Type actType = parameterizedType.getActualTypeArguments()[index];
            return checkType(actType, index);
        } else {
            String className = type == null ? "null" : type.getClass().getName();
            throw new IllegalArgumentException("Expected a Class, ParameterizedType"
                    + ", but <" + type + "> is of type " + className);
        }
    }

    private static Class<?> checkType(Type type, int index) {
        if (type instanceof Class<?>) {
            return (Class<?>) type;
        } else if (type instanceof ParameterizedType) {
            ParameterizedType pt = (ParameterizedType) type;
            Type t = pt.getActualTypeArguments()[index];
            return checkType(t, index);
        } else {
            String className = type == null ? "null" : type.getClass().getName();
            throw new IllegalArgumentException("Expected a Class, ParameterizedType"
                    + ", but <" + type + "> is of type " + className);
        }
    }

    public static String getIntArr_One_ClassTypeName() {
        int[] arrOne = new int[0];
        Class<?> arrClass = arrOne.getClass();
        return arrClass.getTypeName();
    }

    public static String getIntArr_Two_ClassTypeName() {
        int[][] ints = new int[0][0];
        Class<?> intsClass = ints.getClass();
        return intsClass.getTypeName();
    }

    public static String getString_ClassTypeName() {
        String s = new String();
        Class<?> sClass = s.getClass();
        return sClass.getTypeName();
    }

    public static String getCharArr_Two_ClassTypeName() {
        char[][] chars = new char[0][];
        Class<?> charsClass = chars.getClass();
        return charsClass.getTypeName();
    }

    public static String getList_Int_ClassTypeName() {
        return "java.util.List<java.lang.Integer>";
    }

    public static String getList_List_Int_ClassTypeName(){
        return "java.util.List<java.util.List<java.lang.Integer>>";
    }

    public static String getTreeNode_ClassTypeName(){
        TreeNode node = new TreeNode(0);
        Class<?> charsClass = node.getClass();
        return charsClass.getTypeName();
    }
}