手撕代码+++！！！

最新推荐文章于 2025-07-21 21:43:44 发布
原创 最新推荐文章于 2025-07-21 21:43:44 发布 · 2.2k 阅读 · 14 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#链表 #二叉树

手撕

数组

1. 两数之和

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        //建立一个unordred_map,key是nums[i],value 是i
        //遍历表，找到target-nums[i]，并且不是自身。
        unordered_map<int,int> hashtable;
        for(int i = 0; i < nums.size(); i++)
        {
            hashtable[nums[i]] = i;
        }
        for(int i = 0; i < nums.size(); i++)
        {
            if(hashtable.find(target-nums[i]) != hashtable.end() && hashtable[target - nums[i]] != i)
            {
                return {i, hashtable[target - nums[i]]};
            }
        }
        return {};

    }
};

2. 第k大

class Finder {
public:
    int findKth(vector<int> a, int n, int K) {
        // write code here
        //快排+二分，递归调用
        QuickSort(a, n , K , 0, n-1);
    }
    
    int QuickSort(vector<int>& a, int n, int K, int start, int end)
    {
        int base = a[start];
        int i = start;
        int j = end;
        int res = 0; 
        while(i < j)
        {
            while(i < j && a[j] >= base)
            {
                j--;
            }
            while(i < j && a[i] <= base)
            {
                i++;
            }
            if(i < j)
            {
                swap(a[i],a[j]);
            }
        }
        swap(a[start],a[j]);
        
        if(n - j == K) {return a[j];}
        
        else if(n - j > K) {res=  QuickSort(a,n,K,j + 1, end);}
        else if(n - j < K) {res =  QuickSort(a,n,K,start,j-1);}
        return res;
    }
};

int main()
{
	int a[5] = { 1,2,7,8,5 };
	int k = 3;
	quickFindMaxK(a, 0, 4, k);
	for (int i = 0; i < k; i++)
		cout << a[i] << " ";
	cout << endl;

}

3. 出现次数topk

：建立一个小顶堆，然后遍历「出现次数数组」：
如果堆的元素个数小于 kk，就可以直接插入堆中。
如果堆的元素个数等于 kk，则检查堆顶与当前出现次数的大小。如果堆顶更大，说明至少有 kk 个数字的出现次数比当前值大，故舍弃当前值；否则，就弹出堆顶，并将当前值插入堆中。
遍历完成后，堆中的元素就代表了「出现次数数组」中前 kk 大的值


class Solution {
public:
    static bool cmp(pair<int, int>& m, pair<int, int>& n) {
        return m.second > n.second;
    }

    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int, int> occurrences;
        for (auto& v : nums) {
            occurrences[v]++;
        }

        // pair 的第一个元素代表数组的值，第二个元素代表了该值出现的次数
        priority_queue<pair<int, int>, vector<pair<int, int>>, decltype(&cmp)> q(cmp);
        for (auto& [num, count] : occurrences) {
            if (q.size() == k) {
                if (q.top().second < count) {
                    q.pop();
                    q.emplace(num, count);
                }
            } else {
                q.emplace(num, count);
            }
        }
        vector<int> ret;
        while (!q.empty()) {
            ret.emplace_back(q.top().first);
            q.pop();
        }
        return ret;
    }
};

4. 合并两有序数组

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        //1. 扩大数组为m+n，指针p从后往前遍历
        //2. 分别从后往前遍历俩数组，大的替换p
        //3. 循环条件，p>= 0;
        int p = m + n -1;
        int p1 = m -1;
        int p2 = n -1;
        while(p >= 0)
        {
            if(p1 < 0)
            {
                nums1[p] = nums2[p2];
                p2--;
            }
            else if(p2 <0)
            {
                nums1[p] == nums1[p1];
                p1--;
            }
            else if(nums1[p1] <= nums2[p2])
            {
                nums1[p] = nums2[p2];
                p2--;
            }
            else
            {
                nums1[p] = nums1[p1];
                p1--;
            }
            p--;
        }
    }
};

5. 移除元素

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        if(nums.size()==0)
        {
            return 0;
        }
        int right = nums.size() - 1;
        for(int i = 0; i <= right; i++)
        {
            while(right >= 0 && nums[right] == val)
            {
                right--;
            }
            if(nums[i] == val && i < right)
            {
                nums[i] = nums[right];
                nums[right] = val;
            }
           
        }
        return right + 1;
    }
};

6. 数组的交集

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        map <int,int> m;
        vector<int> v;
        for(auto e : nums2)
        {
            m[e]++;
        }

       
        for(auto e : nums1)
        {
            if(m[e] > 0)
            {
                m[e] = 0;
                v.push_back(e);
            }
        }
        return v;

    }
};

7. 旋转数组的最小数字

class Solution {
public:
    int minNumberInRotateArray(vector<int> rotateArray) {
        if(rotateArray.size() == 0)
        {
            return 0;
        }
        int first = 0, last = rotateArray.size() - 1;
        
        while(first < last)
        {
            int mid = first + ((last - first)>>1);
            if(rotateArray[first] < rotateArray[last])
            {
                return rotateArray[first];
            }
            else{
                if(rotateArray[mid] > rotateArray[last])
                {
                    first = mid + 1;
                }else{
                    if(rotateArray[mid] <= rotateArray[last])
                    {
                        last = mid;
                    }
                    
                }
            }
        }
        return rotateArray[first];
    }
};

8.变态跳台阶

class Solution {
public:
    int jumpFloorII(int number) {
        if(number == 0 || number == 1) return number;
        int a = 1,b;
        for(int i = 2;i <= number; i++)
        {
            b = a << 1;
            a = b;
        }
        return b;

    }
};

9. 二进制1的个数

class Solution {
public:
     int  NumberOf1(int n) {
         int count = 0;
         while(n!= 0)
         {
             count++;
             n = n & (n-1);
         }
         return count;
         
     }
     
};

10. 三数之和为0


#include<iostream>
#include<vector>
#include<algorithm>
 
using namespace std;
 
class Solution {
public:
vector<vector<int> > threeSum(vector<int> &num) 
	{
		vector<int> tmp(3);
		vector<vector<int> > rs;
		sort(num.begin(), num.end());
 
		for (int i = 0; i < num.size(); i++)
		{
			for (int j = i+1, k = num.size()-1; j < k; )
			{
				if (num[i]+num[j]+num[k] < 0) j++;
				else if (num[i]+num[j]+num[k] >0) k--;
				else
				{
					tmp[0] = num[i]; 
					tmp[1] = num[j]; 
					tmp[2] = num[k];
					rs.push_back(tmp);
					j++, k--;
					while (j<k && num[j] == num[j-1]) j++;
					while (j<k && num[k] == num[k+1]) k--;
				}
			}
			while (i<num.size() && num[i] == num[i+1]) i++;
		}
		return rs;
	}
	
int main() 
{
	vector<vector<int> > vt;
	int a[] = {-2,13,-5,-4,-7,8,0,-9,6,7,0,-4,2,1,-2,4};
	int len = sizeof(a)/sizeof(int);
	vector<int> t(a, a+len);
	Solution solu;
	vt = solu.threeSum(t);
	for (auto x:vt)
	{
		cout<<"(";
		for (auto y:x)
			cout<<y<<"\t";
		cout<<")"<<endl;
	}
	cout<<endl;
 
	system("pause");
	return 0;
}

11. 前K大

#include<iostream>
#include<algorithm>
#define N 100010
using namespace std;
 
 
 
void swap(int &a, int &b)
{
	int temp = a;
	a = b;
	b = temp;
}
 
void quicksort(int a[], int s, int e, int k)
{
	// s 是数组的开始，e是数组的最后一个元素，k要求的前k个最大值
	int m = a[s];
	if (s >= e)
		return;
	int i = s, j = e;
	while (i != j)
	{
		while (j > i&&a[j] >= m)
		{
			j--;
		}
		swap(a[i], a[j]);
		while (j > i&&a[i] <= m)
		{
			i++;
		}
		swap(a[i], a[j]);
	}
	//quicksort(a, s, i - 1);
	//quicksort(a, i + 1, e);
	if ((e - j) == k)
	{
		// 如果已经有k个数在key的右边，则目标完成
		return;
	}
	else if ((e - j) > k)
	{
		// 对右边的从j到e的数进行操作
		quicksort(a, j, e, k);
	}
	else
	{
		// 对从s到j的数
		quicksort(a, s, j, e - j - k);
	}
 
}
 
int main()
{
	int n, k;
	int a[N];
	scanf("%d", &n);
	for (int i = 0; i < n; i++)
		scanf("%d", &a[i]);
	scanf("%d", &k);
	quicksort(a, 0, n - 1, k);
	sort(a+n-k, a + n);
	for (int i = n-1; i >= n-k; i--)
	{
		printf("%d\n", a[i]);
	}
	return 0;
}

链表

1. 反转链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode *cur = NULL;
        ListNode *pre = head;

        while(pre != NULL)
        {
            ListNode *t = pre -> next;
            pre -> next = cur;
            cur = pre;
            pre = t;
        }
        return cur;

    }
};

2. 删除倒数第k个结点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        //新建一个前继结点；
        //快指针先走n步，再同时走，直到末尾-》next不为空，可以定位到删除元素的前一个结点
        ListNode*  dummy = new ListNode(0);
        dummy -> next = head;
        ListNode* fast = dummy, *slow = dummy;
        while(n--)
        {
            if(fast!= nullptr)
            {
                fast = fast -> next;
            }
            
        }
        while(fast->next != nullptr)
        {
            fast = fast -> next;
            slow = slow -> next;
        }
        slow -> next = slow -> next -> next;
        return dummy-> next;

    }
};

3. 合并两个有序链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        //迭代方式；
        //1. 新建一个链表头，初始化一个哨兵结点。
        //2. 循环条件：两个链表都不为空； 比较两个链表结点大小，将小的结点链接在新节点后。
        //3. 当一个链表为空时，将剩余链表结点链接。
        ListNode* head = new ListNode(-1);
        ListNode* prev = head;
        while(l1 != nullptr && l2 != nullptr)
        {
            if(l1 -> val <= l2 -> val)
            {
                prev -> next = l1;
                l1 = l1 -> next;
            }
            else
            {
                prev -> next = l2;
                l2  = l2 -> next;
            }
            prev = prev-> next;
        }
        if(l1 == nullptr) prev -> next = l2;
        else if(l2 == nullptr) prev -> next = l1;
        return head -> next;
    }
};

4. 旋转链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) {
        if(head == NULL) {return NULL;}
        ListNode* left = head, *right = head;
        int n = 0;
        ListNode* p = head;
        while(p)
        {
            p = p -> next;
            n++;
        }
        k %= n;
        while(k--)
        {
            if(right != NULL)
            {
                right = right -> next;
            }
            
        }
        while(right->next != NULL)
        {
            right = right -> next;
            left = left -> next;
        }
        right -> next = head;
        head = left -> next;
        left -> next = NULL;
        return head;
        
    }
};

5. 移除链表元素

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode *dummy = new ListNode(0);
        dummy->next = head;
        ListNode *pre = dummy, *cur = head;

        while(cur != NULL)
        {
            if(cur -> val == val)
            {
                pre -> next = cur -> next;
                cur = cur -> next;
            }else
            {
                cur = cur -> next;
                pre = pre -> next;
            }
        }
        return dummy -> next;
    }
};

字符串

1. 有效括号

class Solution {
public:
    bool isValid(string s) {
        stack<char> st;
        for(int i = 0; i < s.size(); i++)
        {
            switch(s[i])
            {
                case '(':
                    st.push('(');
                    break;
                case '[':
                    st.push('[');
                    break;
                case '{':
                    st.push('{');
                    break;
                case ')':
                    if(st.empty()) return false;
                    else if(st.top() == '(')
                    {
                        st.pop();
                    }
                    else{return false;}
                    break;
                case ']':
                    if(st.empty()) return false;
                    else if(st.top() == '[')
                    {
                        st.pop();
                    }
                    else{return false;}
                    break;
                case '}':
                    if(st.empty()) return false;
                    else if(st.top() == '{')
                    {
                        st.pop();
                    }
                    else{return false;}
                    break;
            }
        }
        if(st.empty()) return true;
        else return false;

    }
};

2. 字符串相加

class Solution {
public:
    string addStrings(string num1, string num2) {
        int str1 = num1.size() -1;
        int str2 = num2.size() -1;
        string ans;
        int result = 0, add = 0;
        int x = 0, y = 0;
        while(str1 >= 0 || str2 >= 0 || add != 0)
        {
            if(str1 >= 0)
            {
                x = num1[str1] - '0';
            }
            else{
                x = 0;
            }
            if(str2 >= 0)
            {
                y = num2[str2] - '0';
            }
            else{
                y = 0;
            }
            result = x + y + add;
            ans.push_back('0' + result % 10);
            add = result / 10;
            str1--;
            str2--;
        }
        reverse(ans.begin(), ans.end());
        return ans;
    }
};

3.只反转单词

class Solution {
public:
    string reverseWords(string s) {
        if(s.size() == 0)
        {
            return s;
        }
        int n = s.size();
        int front = 0; int back = 0;
        for(int i = 0; i < n - 1; i++)
        {
            if(s[back] != ' ')
            {
                back++;
            }
            else
            {
                reverse(s.begin() + front, s.begin() + back);
                front = back + 1;
                back = front;
            }
        }
        back++;
        reverse(s.begin() + front, s.begin() + back);
        return s;

    }
};

4. 倒置字符串

#include<iostream>
#include<string>
#include<algorithm>
using namespace std;

int main()
{
    string s;
    getline(cin,s);
    
    reverse(s.begin(),s.end());
    int len = s.size();
    int front = 0, back = 0;
    for(int i =0; i < len - 1; i++)
    {
        if(s[i] != ' ')
        {
            back++;
        }
        else{
            reverse(s.begin()+front,s.begin()+back);
            front = back + 1;
            back = front;
        }
       
    }
     back++;
     reverse(s.begin()+front,s.begin()+back);
    cout<<s<<endl;
    return 0;
}

5.替换空格

class Solution {
public:
	void replaceSpace(char *str,int length) {
        if(str == nullptr || length < 0)
        {
            return;
        }
        int count = 0;
        for(int i = 0; i < length; i++)
        {
            if(str[i] == ' ')
            {
                count++;
            }
        }
        if(count == 0)
        {
            return;
        }
        int new_length = length + count*2;
        for(int i = length; i >= 0; i--)
        {
            if(str[i] != ' ')
            {
                str[new_length] = str[i];
                new_length--;
            }else{
                str[new_length--] = '0';
                str[new_length--] = '2';
                str[new_length--] = '%';
            }
         
        }
    }
};

6. 最长不重复子串

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
       //滑动窗口思想
       //哈希表存放字符出现的次数，
       //左右双指针，右指针增加找到符合不重复字符的窗口，左指针增加改变窗口大小来回
       //循环条件：出现重复元素
       unordered_map<char,int> window;
       int left = 0, right = 0;
       int res = 0;
       int n = s.size();
       while(right < n)
       {
           char c1 = s[right];
           window[c1]++;
           right++;
           while(window[c1] > 1)
           {
               char c2 = s[left];
               window[c2]--;
               left++;
           }
           res = max(res,right - left);
       }
       
       return res;

    }
};

二叉树

1. 二叉树的中序遍历

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        stack<TreeNode*> s;
        vector<int> v;
        TreeNode* rt = root;
        while(rt || s.size())
        {
            while(rt)
            {
                s.push(rt);
                rt = rt -> left;
            }
            rt = s.top();
            s.pop();
            v.push_back(rt -> val);
            rt = rt -> right;
        }
        return v;
        
    }
};

2. 平衡二叉树

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int height(TreeNode* root)
    {
        if(root == NULL)
        {
            return 0;
        }
        else 
            return max(height(root -> right), height(root -> left)) + 1;
    }
    bool isBalanced(TreeNode* root) {
        if(root == NULL)
        {
            return true;
        }
        else
        {
            return abs(height(root -> right) - height(root -> left)) <= 1 && isBalanced(root -> left) && isBalanced(root -> right);
        } 
    }
};

3. 重建二叉树

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
        if(pre.size() == 0 || vin.size() == 0)
        {
            return NULL;
        }
        TreeNode* head = new TreeNode(pre[0]);
        vector<int> pre_left, pre_right, vin_left, vin_right;
        int vinlen = vin.size();
        int temp = 0;
        for(int i = 0;i < vinlen; i++)
        {
            if(vin[i] == pre[0])
            {
                temp = i;
                break;
            }
        }
        for(int i = 0; i < temp ; i++)
        {
            pre_left.push_back(pre[i+1]);
            vin_left.push_back(vin[i]);
        }
        for(int i = temp+1; i < vinlen; i++)
        {
            pre_right.push_back(pre[i]);
            vin_right.push_back(vin[i]);
        }
        head ->left = reConstructBinaryTree(pre_left, vin_left);
        head ->right = reConstructBinaryTree(pre_right, vin_right);
        return head;

    }
};

两个栈实现队列

class Solution
{
public:
    void push(int node) {
        stack1.push(node);
        
    }

    int pop() {
        if(stack2.empty())
        {
            while(!stack1.empty())
            {
                stack2.push(stack1.top());
                stack1.pop();
            }
        }
        int ret = stack2.top();
        stack2.pop();
        return ret;
    }

private:
    stack<int> stack1;
    stack<int> stack2;
};
2025华为OD面试手撕代码真题目录
MISAYAONE的博客
04-28 8万+
一般面试的时候每一轮技术面都会出一到两个手撕代码题，这些题的特点就是，非常短小，易于理解。不可能会再出阅读理解一样的机试题的。但是这些题目也非常注意基本功，很注意细节的处理，一般都是easy+medium题目。但是大家一定要注意，因为大部分面试官上面一开始就会让你做题，直接看你所有的做题过程（防止有人水平一般，机试就网上找的答案的蒙混过关），手撕代码题会给你后面的面试定一个基调。
【华为OD技术面试手撕真题】86、排序链表 | 手撕真题+思路参考+代码解析（C & C++ & Java & Python & JS）
KJ.JK
11-18 5465
【华为OD技术面试手撕真题】86、排序链表 | 手撕真题+思路参考+代码解析（C & C++ & Java & Python & JS） 华为od机试，华为od机试真题，华为od机试E卷，华为odE卷，华为od机试真题E卷，华为OD，华为OD机试，华为OD机试真题，华为od机考，华为od机试D卷，华为od机试真题D卷，华为od手撕代码，华为od，华为od机试C卷，华为od e卷，华为2024e卷，od机试，2024E卷，华为OD机试E卷，什么是华为od，华为od介绍，全面了解华为od，2024华为od，如何
面试手撕代码整理
09-29
自己整理的在面试时可能出现的手撕代码题目，例如求一个数的平方根，反转链表，辗转相除法求最大公约数等，希望能提供一些帮助
手撕代码汇总
yanlei980827的博客
05-02 764
文章目录1. 计数器2. 分频器3. 状态机  3.1 Moore状态机  3.2 Mealy状态机4. 序列检测器  4.1 状态机描述  4.2 移位寄存器5. 序列生成器6. 伪随机码发生器7. 异步复位，同步释放8. 超前进位加法器9. FIR滤波器 1. 计数器   计数器 2. 分频器   分频器 3. 状态机   3.1 Moore状态机   3.2 Mealy状态机 4. 序列检测器   4.1 状态机描述     状态机描述_序列检测器     next_state另一种写法     这
嵌入式程序员手撕代码
Ztt19990421的博客
05-26 1437
/12. ((((A)&0xff000000)>>24) | (((A)&0x000000ff)8) | (((A)&0x00ff)
手撕代码
bryant_zhang的博客
09-09 384
1、快速排序 讲解链接 当基准数选择最左边的数字时，那么就应该先从右边开始搜索；当基准数选择最右边的数字时，那么就应该先从左边开始搜索。不论是从小到大排序还是从大到小排序！快速排序的最差时间复杂度是O(N2)，平均时间复杂度为O(NlogN)。 void QuickSort(vector<int>& vec, int left, int right) { if (left >= right) return; int l = left, r = right; int bas
华为手撕代码+剑指offer总结 （python+c语言）
qq_42219077的博客
09-25 8499
文章目录1.华为手撕代码总结1.1排序问题1.2链表求和1.3树的前中后序遍历（递归/循环写法）1.4树的链表化1.5给一个初始饮料瓶数，三个空瓶换一瓶，可以赊一瓶，求最后能喝几瓶1.6岛屿最大面积问题1.7自己面试手撕的5道算法题2.剑指offer2.1 二维数组查找中的查找2.2 替换空格2.3 从尾到头打印链表2.4 重建二叉树2.5用两个栈实现队列2.6旋转数组的最小数2.7斐波那契数列 ...
精选资源
【酒酒】数字IC手撕代码总结.docx
04-07
**示例代码（C语言）：** ```c #include #include int main() { int i, j, k; for (i = 2; i ; i++) { k = sqrt(i); for (j = 2; j ; j++) { if (i % j == 0) break; } if (j > k) printf("%d ", i); // ...
手撕代码_C语言手撕_C++_手撕代码c++_
10-01
在IT行业中，编程面试往往包含了“手撕代码”这一环节，即面试者需要现场编写代码来解决特定问题。本资源“手撕代码_C语言手撕_C++_手撕代码c++_”聚焦于C语言和C++的面试题，特别关注如何使用两个队列来实现堆栈的...
手撕代码的步骤
weixin_41746688的博客
03-09 1181
手撕代码的步骤(以手写代码表示new的过程为例) 一、明确代码目标 可以先将函数的调用/测试用例写出来，帮助自己梳理代码的输入、输出以及代码逻辑。本体的代码逻辑如下 function Test(name) { this.name = name this.city = '南京' } function createNew(clas, ...args) { //此处需补充 } let my = createNew(Test, 'lxy') 通过上述调用可发现，createNew()传入的两个参数分别为构造
手撕代码全集
weixin_44739750的博客
04-30 516
1.数组问题 2.字符串问题 一级目录 一级目录 一级目录 一级目录 一级目录 一级目录 一级目录
手撕代码全集（数组）
weixin_44739750的博客
07-01 356
数组 数组的最大子数组的和 public static int getMaxSum(int[] num){ if(num == null || num.length == 0) throw new IllegalArgumentException("数组中必须有数据"); int max = Integer.MIN_VALUE; int curMax = 0...
程序员的基本功-手撕代码
csdn565973850的博客
05-24 790
手撕代码是什么
C语言----手撕代码
最新发布
qq_50663389的博客
07-21 299
如有问题，欢迎大家批评指正！
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值