精华内容
下载资源
问答
  • 2020-06-24 11:18:37

    完整代码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();
        }
    }
    
    更多相关内容
  • 实写构造函数leetcode leetcode在线练习,这是一个算法设计套路,可以帮助开发者挖掘潜力,提高生产力,将推动开发者每天投入到应对测验中。 如何加入 找到合适的位置 您的工作区可能位于leetcode/src/username/ ...
  • leetcode-代码测试模板

    2021-06-23 11:41:55
    代码提交前的测试模板 #include <iostream> #include <utility> #include <string> #include <cstring> #include <vector> #include <map> #include <set> #include <...

    代码提交前的测试模板
    准备工作:
    创建 input.txt 放测试数据
    创建 expect.txt 放预期结果

    例题:https://leetcode-cn.com/problems/longest-increasing-path-in-a-matrix/
    input.txt
    3 3
    9 9 4
    6 6 8
    2 1 1

    expect.txt
    4

    编译命令
    g++ main.cpp -std=c++17 -Wall -DTEST

    输出结果
    在这里插入图片描述

    几个常见问题

    1、 怎么改成 ide 调试

    *  将// #define TEST的注释去掉
    *  将 dir 改成绝对路径
    

    2、输入输出的时候

    	用户 out 代替 cout, in 代替 cin
    

    3、writeToFile 函数使用

    * 作用是将输出写入到 output.txt 文件
    * 支持内置对象 写单行
    * 支持stl 容器, 每个容器的内容会写入单行并用单个空格隔间最后换行,比如
    	 1.   vector<int> dd{1, 2, 3} 
    	     写入的格式为:1 2 3\n
    	 2.   vector<vector<int>> dd{{1, 2, 3}, {4, 5, 6},{7, 8, 9}}
    	     写入格式的为:1 2 3 4 5 6 7 8 9
    
    #include <iostream>
    #include <utility>
    #include <string>
    #include <cstring>
    #include <vector>
    #include <map>
    #include <set>
    #include <stack>
    #include <queue>
    #include <unordered_map>
    #include <unordered_set>
    #include <algorithm>
    #include <numeric>
    
    #include <fstream>
    
    using namespace std;
    
    // 直接调试去掉下面的注释, 然后把 dir改成绝对路径
    // #define TEST
    
    #ifdef TEST
    // 修改这里可以改成绝对路径用 ide 直接调试
    string dir = "./";
    string inputFile = dir + "input.txt";
    string outputFile = dir + "output.txt";
    string expectFile = dir + "expect.txt";
    
    ifstream in(inputFile);
    ofstream out(outputFile);
    
    ifstream output(outputFile);
    ifstream expect(expectFile);
    
    string emptyStr = "nullptr";
    
    template<typename T, typename ...Args>
    auto has_begin(int) -> decltype(declval<T>().begin(declval<Args>...), true_type{});
    
    template<typename T, typename ...Args>
    false_type has_begin(...);
    
    template<typename T, typename ...Args>
    using beginable = typename std::is_same<decltype(has_begin<T>(0)), true_type>::type;
    
    
    // 用于实现了 operator<<的对象
    template<typename Obj, typename = typename enable_if<
            !is_same<
                    true_type,
                    beginable<
                            typename decay<Obj>::type
                    >
            >::value
    >::type
    >
    auto writeToFile(Obj &&r, bool end = true) -> decltype(void(out.operator<<(r))) {
        out << r << " ";
        if (end) {
            out << endl;
        }
    }
    
    // 容器都有 begin 方法
    template<typename Container>
    auto writeToFile(Container &&c, bool end = true) -> decltype(void(c.begin())) {
        for (auto&& v : c) {
            writeToFile(v, false);
        }
        if (end) {
            out << endl;
        }
    }
    
    // 用于数值退化成指针的情况
    template<typename Arr, size_t N>
    void writeToFile(Arr &&r, int n) {
        for (int i = 0; i < n; ++i) {
            out << r[n] << " ";
        }
        out << endl;
    }
    
    #else
    istream &in = cin;
    ostream &out = cout;
    // 加速
    ios::sync_with_stdio(false);
    in.tie(0);
    out.tie(0);
    #endif
    
    
    class Prepare {
    public:
        Prepare() {
            prepare();
        }
    
        static void prepare() {
    #ifdef TEST
            if (!in.is_open()) {
                cout << "empty input file" << endl;
                exit(-1);
            }
            if (!expect.is_open()) {
                cout << "empty expect file" << endl;
                exit(-1);
            }
    #endif
        }
    };
    
    class Check {
    public:
        ~Check() {
            // compare
    #ifdef TEST
            for (int i = 1; !output.eof(); ++i) {
                if (output.eof()) {
                    break;
                }
                string l, r;
                getline(output, l);
                getline(expect, r);
                while(!l.empty() && l.back() == ' ') {
                    l.pop_back();
                }
                while(!r.empty() && r.back() == ' ') {
                    r.pop_back();
                }
                if (l.empty() && r.empty()) {
                    break;
                }
                if (l == emptyStr) {
                    break;
                }
                if (l == r) {
                    cout << "case: " << i << " pass" << endl;
                } else if (l != r) {
                    cout << "case: " << i << "wrong " << "output[" << l << "], while expect[" << r << "]" << endl;
                    continue;
                }
            }
    #endif
        }
    };
    
    static Prepare pre;
    static Check check;
    
    
    ///    ===============提交的业务代码=============================
    
    /*
     * @lc app=leetcode.cn id=329 lang=cpp
     *
     * [329] 矩阵中的最长递增路径
     */
    
    // @lc code=start
    class Solution {
    public:
        int dx[4] = {0, -1, 0, 1};
        int dy[4] = {-1, 0, 1, 0};
    
        int dfs(int x, int y, vector<vector<int>>& dp, const vector<vector<int>>& matrix) {
            if (dp[x][y]) {
                return dp[x][y];
            }
            int res = 1;
            for (int k = 0; k < 4; ++k) {
                int nx = x + dx[k];
                int ny = y + dy[k];
                if (nx < 0 || nx >= dp.size() || ny < 0 || ny >= dp[nx].size() || matrix[x][y] <= matrix[nx][ny]) {
                    continue;
                }
                int now = dfs(nx, ny, dp, matrix);
                res = max(res, now + 1);
            }
            return dp[x][y] = res;
        }
    
        int longestIncreasingPath(vector<vector<int>>& matrix) {
            vector<vector<int>> dp(matrix.size(), vector<int>(matrix[0].size()));
            int res = 0;
            for (int i = 0; i < matrix.size(); ++i) {
                for (int j = 0; j < matrix[i].size(); ++j) {
                    if (!dp[i][j]) {
                        res = max(res, dfs(i, j, dp, matrix));
                    }
                }
            }
            return res;
        }
    };
    // @lc code=end
    
    #ifdef TEST
    
    ///  ===============测试代码=============================
    
    
    
    int main() {
        // 自定义读取输入  规定输入边界
        int m, n;
        while (in >> m >> n) {
            vector<vector<int>> matrix(m, vector<int>(n));
            for(int i = 0; i < m; i++) {
                for (int j = 0; j < n; j++) {
                    in >> matrix[i][j];
                }
            }
            //
            auto ans = Solution{}.longestIncreasingPath(matrix);
            // 输出结果到 out
            // 如
            writeToFile(ans);
        }
    }
    #endif
    
    
    
    
    展开全文
  • 力扣的测试题 数组 1.删除排序数组中的重复项 给定一个排序数组,你需要在 原地 删除重复出现的元素,使得每个元素只出现一次,返回移除后数组的新长度。 不要使用额外的数组空间,你必须在 原地 修改输入数组 并在...
  • 这是测试结果,是正确的提交结果却是-1 ...刷题刷着刷着发现有时候测试运行的结果和提交的结果不一样,然后我尝试着吧全局声明的哈希表移到函数里面去,就可以了 --------> ——题目出自力扣第387题 ...

    这是测试结果,是正确的测试提交结果却是-1
    提交
    刷题刷着刷着发现有时候测试运行的结果和提交的结果不一样,然后我尝试着吧全局声明的哈希表移到函数里面去,就可以了
    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述
    ——题目出自力扣第387题

    展开全文
  • 编写leetcode测试用例所用的辅助函数

    千次阅读 多人点赞 2015-01-31 17:10:31
    在做leetcode题目(https://oj.leetcode.com/problemset/algorithms/)的时候,我们总要自己写测试用例,常常要生成vector, list, tree,我将这些常用操作封装了一下,方便大家使用

             在做leetcode题目(https://oj.leetcode.com/problemset/algorithms/)的时候,我们总要自己写测试用例,常常要生成vector, list, tree,我将这些常用操作封装了一下,方便大家使用

     tool.h

    //tool.h
    #ifndef TOOL_H_
    #define TOOL_H_
    
    #include <iostream>
    #include <vector>
    #include <cstdarg>
    #include <string>
    using namespace std;
    
    #include "windows.h"
    
    struct ListNode
    {
        int val;
        ListNode *next;
        ListNode(int x) : val(x), next(NULL) {}
    };
    
    struct TreeNode {
        int val;
        TreeNode *left;
        TreeNode *right;
        TreeNode(int x=0) : val(x), left(NULL), right(NULL) {}
    };
    
    void ArrayPrint(int arr[], int count);
    
    vector<int> IntVectorCreate(int count, ...);
    void IntVectorPrint(const vector<int> &vec);
    void IntVector2DPrint(const vector<vector<int>> &vec);
    
    vector<string> StringVectorCreate(int count, ...);
    void StringVectorPrint(const vector<string> &vec);
    
    TreeNode *TreeCreate(int count, ...);
    void TreePrint(TreeNode *root);
    
    ListNode *ListCreate(int count, ...);
    void ListPrint(ListNode *head);
    
    #endif
    tool.cpp
    //tool.cpp
    #include "tool.h"
    
    void ListPrint(ListNode *head)
    {
        ListNode *node = head;
        while (node)
        {
            cout << node->val << " -> ";
            node = node->next;
        }
        cout << endl;
    }
    
    ListNode *ListCreate(int count, ...)
    {
        va_list argptr;
        va_start(argptr, count);
    
        ListNode *head, *curr;
        int num = va_arg(argptr, int);
        head = new ListNode(num);
        curr = head;
        for (int i = 1; i < count; i++)
        {
            num = va_arg(argptr, int);
            ListNode *temp = new ListNode(num);
            curr->next = temp;
            curr = temp;
        }
        va_end(argptr);
        return head;
    }
    
    
    
    
    void ArrayPrint(int arr[], int count)
    {
        for (int i = 0; i < count; i++)
            cout << arr[i] << " , ";
        cout << endl;
    }
    
    void IntVectorPrint(const vector<int> &vec)
    {
        for (size_t i = 0; i < vec.size(); i++)
            cout << vec[i] << " , ";
        cout << endl;
    }
    
    void IntVector2DPrint(const vector<vector<int>> &vec)
    {
        printf("[\n");
        for (size_t i = 0; i < vec.size(); i++)
        {
            printf("[ ");
            for (size_t j = 0; j < vec[i].size(); j++)
                printf("%d, ", vec[i][j]);
            printf(" ]\n");
        }
        printf("]\n");
    }
    
    void StringVectorPrint(const vector<string> &vec)
    {
        cout << "------------------------------------" << endl;
        for (size_t i = 0; i < vec.size(); i++)
            cout << vec[i] << "_" << endl;
        cout << "------------------------------------" << endl;
    }
    
    //
    
    vector<int> IntVectorCreate(int count, ...)
    {
        vector<int> result;
        va_list argptr;
        va_start(argptr, count);
        
        for(int i=0; i<count; i++) 
        {
            int num = va_arg(argptr, int);
            result.push_back(num);
        }
        va_end(argptr);
        return result;
    }
    
    vector<string> StringVectorCreate(int count, ...)
    {
        vector<string> result;
        va_list argptr;
        va_start(argptr, count);
    
        for (int i = 0; i < count; i++)
        {
            char *str = va_arg(argptr, char*);
            result.push_back(str);
        }
        va_end(argptr);
        return result;
    }
    
    //
    
    TreeNode *TreeCreate(int count, ...)
    {
        va_list argptr;
        va_start(argptr, count);
    
        TreeNode **treeArr = new TreeNode*[count];
        for (int i = 0; i < count; i++)
        {
            int num = va_arg(argptr, int);
            if (INT_MAX == num)
                treeArr[i] = NULL;
            else
                treeArr[i] = new TreeNode(num);
        }
    
        int curr = 1;
        for (int i = 0; i<count; i++)
        {
            if( !treeArr[i] )
                continue;
     
            if( curr < count )
                treeArr[i]->left = treeArr[curr++];
            if (curr < count)
                treeArr[i]->right = treeArr[curr++];
        }
        
        va_end(argptr);
        return treeArr[0];
    }
    
    
    void SubTreePrint(TreeNode *node, int level)
    {
        if ( !node )
            return;
    
        SubTreePrint(node->right, level + 1);
        for (int i = 0; i < level; i++)
            printf("    ");
        printf("%04d\n", node->val);
        SubTreePrint(node->left, level + 1);
    }
    
    void TreePrint(TreeNode *root)
    {
        cout << "------------------------------------" << endl;
        SubTreePrint(root, 0);
        cout << "------------------------------------" << endl;
    }

    array, vector, list这几个结构的Create和Print很简单,就不多解释了

    PS: XXXCreate函数的第一个参数总是元素的个数

    int main()
    {
        int arr[] = { 1, 2, 3, 4, 5 };
        ArrayPrint(arr, 5);
    
        vector<int> ivec = IntVectorCreate(5, 1, 2, 3, 4, 5);
        IntVectorPrint(ivec);
    
        vector<string> svec = StringVectorCreate(5, "11", "22", "33", "44", "55");
        StringVectorPrint(svec);
    
        ListNode *node = ListCreate(5, 1, 2, 3, 4, 5);
        ListPrint(node);
    
        getchar();
        return 0;
    }


    tree的情况比较复杂,详细解释一下

    假设一棵树如下:


    那么leetcode上的表示是:{1,2,3,#,#,4,#,#,5}

    代码是这个样子的:(#用INT_MAX代替)

        TreeNode *tree = TreeCreate(9, 1, 2, 3, INT_MAX, INT_MAX, 4, INT_MAX, INT_MAX, 5);
        TreePrint(tree);

    打印出来之后,就是这个样子的


    一切搞定

    展开全文
  • 知识梳理 刷题步骤 阅读题目 参考示例 思考数据范围 根据题意, 实现函数的功能 本地数据测试 提交 过啦! 函数 函数是将一个经常实用的功能, 封装为一个简单的调用方法, 从而达到高效的代码复用的方法. 函数具有 高效...
  • LeetCode刷题攻略:详细介绍LeetCode刷题的各种常用技巧和注意点
  • 在刷leetcode题目的时候,我总结了一些编写测试用例的辅助函数,用于方便地生成和输出array, vector, list, tree, 希望对大家有帮助 二:API说明 1. 通用数据结构 //链表结点 struct ListNode { int val; ListNode...
  • LeetCode——旋转函数

    2022-04-22 22:20:17
    在大家刷LeetCode时,一定刷过旋转数组这道题,有兴趣的伙伴可以试着刷一刷,链接如下:
  • 封装了一个测试函数, 允许你批量测试 提供构造Tree的函数, 将数组转为二叉树 :package: 安装 使用git下载仓库并使用npm安装相关依赖, 我个人更推荐你使用 Yarn 安装相关依赖. git clone git@github....
  • 举个例子: 这个是提交后返回的结果 这个是本地测试结果 原因在于把大数组开到了函数内,只需要把大数组从函数中拿出去就好了。
  • 项目使用 Bazel 构建的 C++ 刷题项目,通过几个简单步骤即可完成编译、测试,提供工具用于代码格式化、覆盖率报告、持续集成,还有额外的工具函数辅助创建测试用例。 如果你正使用 C++ 刷 LeetCode,但苦于每次写完...
  • 补充:本方法从最终原理上并不比普通的对子序列从前向后比较高效(因为原理是相同的),但针对力扣的测试用例速度提升蛮大的) 原文: 除了蛮力算法和KMP算法,也可以采用对子序列从后向前比较的方式,代码如下 ...
  • C++实现 leetcode做题,用于本地调试生成测试用例(即树)
  • Python函数:定义函数函数参数 Python类与模块:类构造、类实例化、模块介绍、模块加载和使用 Python基础测验 完成上面的基础学习后,可以在下面的题目中小试牛刀: 第二阶段 - 入门LeetCode(1月24日-2月9日) 学习...
  • 您只需将lines_per_input设置为您需要的文本文件中的多行,并且对于脚手架main函数中的每个循环,使用input()函数来获取下一项。 满足您所有企业需求的漂亮打印解决方案 在main.py文件中,您还可以设置要打印的解决...
  • 示例 2: 输入:words = ["leetcode","et","code"] 输出:["et","code"] 解释:"et" 和 "code" 都是 "leetcode" 的子字符串。 示例 3: 输入:words = ["blue","green","bu"] 输出:[] 提示: 1 [i].length [i] 仅...
  • 文章目录想做这件事的起因想实现的效果main函数中如果换题测试只需要改一个地方比较方便放多个测试用例设计接口需要用到的转换完整的接口代码 想做这件事的起因 其实说来惭愧,昨天在刷题的时候,一道题反复提交N次...
  • leetcode中国 Scala 中的 Leetcode 解决方案 这个项目的创建有几个目的 首先是推广语言及其解决问题的函数式方法,Scala 具有表现力,简洁而被低估太多。 其次,让我们承认在一小时的技术面试中cannot判断另一个人的...
  • 如果是线上题目,写完之后,不要立即提交,自己检查并借助一些测试用例测试几遍代码 四,面试的三种形式 1.电话面试 有些面试官会打电话过来预约电话面试的时间,也有些面试官喜欢突然袭击,一个电话过来就开始面试...
  • LeetCode如何构建链表和树的测试用例

    千次阅读 多人点赞 2020-02-14 20:59:44
    平时在刷leetcode题目中的链表和树,难免会出现调试不方便的问题。因为习惯了IDEA中debug来进行错误分析,所以本文将实现leetcode刷题中链表和数在IDEA中的调试。 链表 直接上代码。 public static class ListNode...
  • 自动生成测试数据的函数: random() 测试程序: main() 核心函数: 和LeetCode上面的模板函数同名 其他: 功能参见注解说明 注意:为了可以在测试程序里调用进行测试,因此所有函数都用的static修饰 题目1 这一部分...
  • 应编写主类以调用这些函数并进行测试。 LinkedListCycleII.java 给定一个链表,返回循环开始的节点。 如果没有循环,则返回null。 跟进:不使用额外空间你能解决吗? 单数.java 给定一个整数数组,每个元素出现两次...
  • 4.考虑将在不同对象上的相同操作提炼为子函数 5.c++链表操作复习 Longest Substring Without Repeating Characters: 1.map内部根据键值红黑树排序,一开始以为根据插入时间排序导致错误 2.情况分为最长子串在字符串...
  • 每个题的代码放在src中,在main.cpp设置prob_num的值,prob_num为题目编号,然后运行测试函数即可,例如需要运行题1,在main.cpp中设置prob_num=1即可: #include #include "src/P0000_Solutions.h" using ...
  • LeetCode问题 项目 我喜欢每天(希望)进行编程问题,以便对语言有更好的了解,并乐于学习如何解决各种问题。 我决定将这些问题仅作为标头进行处理,只是为了没有每个问题的.h和.cpp文件。 由于每个问题只是一个...
  • LeetCode算法零基础】1. 两数之和 visual studio 2022 测试用例版本
  • leetcode 分类 leetcode leetcode刷题记录,按照难度分类 每个题一个cpp文件,leetcode测试集通过 每个cpp文件的main函数实现对一个测试用例的测试,g++编译通过(c++11)
  • 方便本地开发测试,专注于实现提交函数,初版完善有限见量

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,229
精华内容 5,691
关键字:

leetcode测试时的函数