手撕代码之数组

最新推荐文章于 2023-06-25 14:05:30 发布
最新推荐文章于 2023-06-25 14:05:30 发布
阅读量721 收藏 5
点赞数 1
分类专栏： # 手撕代码 文章标签： 数组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/daaikuaichuan/article/details/89335770
版权

文章目录

一、二维数组中的查找（leetcode 240）

在这里插入图片描述
  思路：如果当前元素大于目标值，则向左移动列，如果当前元素小于目标值，则向下移动行。

class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        if (matrix.empty())
            return false;
        int col_len = matrix[0].size(), row_len = matrix.size();
        int row = 0, col = col_len - 1;
        // 循环条件为行和列的作用范围
        while (row < row_len && col >= 0){
            if (matrix[row][col] == target)
                return true;
            // 如果当前元素大于目标值，则向左移动列
            else if (matrix[row][col] > target)
                col--;
            // 如果当前元素小于目标值，则向下移动行
            else
                row++;
        }
        return false;
    }
};

二、旋转数组的最小数字（leetcode 153）

在这里插入图片描述
  思路：二分查找，如果中间位置的值比左边元素大，则更新左边元素位置为中间位置，否则更新右边元素位置为中间位置。

class Solution {
public:
    int findMin(vector<int>& nums) {
        int low = 0, high = nums.size()-1, mid = 0;
        while (nums[low] > nums[high]){
            if (high - low == 1){
                mid = high;
                break;
            }
            mid = low + (high - low) / 2;
            // 二分查找，如果中间位置的值比左边元素大，则更新左边元素位置为中间位置
            // 否则更新右边元素位置为中间位置
            if (nums[mid] > nums[low])
                low = mid;
            else
                high = mid;
        }
        return nums[mid];
    }
};

三、旋转数组中的查找（leetcode 33）

在这里插入图片描述
  思路：
在这里插入图片描述
对于[0,1,2,3,4,5,6,7]而言，如红色标出所示，如果nums[mid]<nums[right]，即中间的数小于最右边的数，那么mid（包括mid）右边的数是有序的，如果中间的数大于最右边的数，那么mid（包括mid）左边的数是有序的。那我们每次都可以折半查找。

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0, right = nums.size()-1;
        while (left <= right){
            int mid = left + (right - left) / 2;
            if (nums[mid] == target)
                return mid;
            // 如果中间数比右边数小，则右半边是有序的
            if (nums[mid] < nums[right]){
            	// 如果target在右半边范围内，则进行二分查找
                if (nums[mid] < target && target <= nums[right])
                    left = mid + 1;
                // 如果target不在右边范围，则缩小查找区间
                else
                    right = mid - 1;
            }
            // 否则左半边是有序的
            else{
            	// 如果target在左半边范围内，则进行二分查找
                if (nums[left] <= target && target < nums[mid])
                    right = mid - 1;
                // 如果target不在左边范围，则缩小查找区间
                else
                    left = mid + 1;
            }
        }
        return -1;
    }
};

四、数组中出现次数超过一半的数字（leetcode 169）

在这里插入图片描述
  思路：题目中要找的数字出现的次数超过数组长度的一半，也就是说它出现的次数比其他所有数字出现的次数的和还要多。因此我们可以考虑在遍历数组的时候保存两个值：一个是数组中的一个数字，一个是次数。
  第一个数字作为士兵，防守阵地(cnt = 1)；
  遇到相同的元素，cnt++；
  如果cnt == 0时，选取新的下标值对应的元素作为防守阵地的士兵；
  遇到不同的元素（即为敌人），同归于尽，cnt–；
  最后留在阵地上的士兵，可能是主元素。

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        int result = nums[0], count = 1, len = nums.size();
        for(int i = 1; i < len; ++i)
        {
            if(nums[i] == result)
                count++;
            else if(count == 0)
            {
                result = nums[i];
                count = 1;
            }
            else
                count --;
        }
        return result;
    }
};

五、把数组排成最大的数（leetcode 179）

在这里插入图片描述
  思路：重新定义排序规则，两个数字m和n能够拼接成mn和nm，如果mn大于nm，则m应该排在n前面；如果mn小于nm，则m应该排在n后面。

class Solution {
public:
    string largestNumber(vector<int>& nums) {
        vector<string> vec_str;
        for (auto num : nums)
            vec_str.push_back(to_string(num));
        sort(vec_str.begin(), vec_str.end(), [](const string & str1, const string & str2)->bool{
            return str1 + str2 > str2 + str1;
        });
        string res;
        for (auto str : vec_str)
            res.append(str);
        if (res[0] == '0')
            return "0";
        return res;
    }
};

六、数组中只出现一次的数字（leetcode 136）

在这里插入图片描述
  思路：利用异或的基本性质（相同为0，相异为1，与0异或等于本身），以及交换律和结合律。

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int res = nums[0], sz = nums.size();
        for (int i = 1; i < sz; ++i){
            res ^= nums[i];
        }
        return res;
    }
};

七、排序数组中查找某一个数第一次和最后一次出现的位置（leetcode 34）

在这里插入图片描述
  思路：二分查找的变式，注意边界条件。

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int low = lower_bound(nums, target);
        int high = upper_bound(nums, target);
        if (nums.empty() || nums[low] != target)
            return vector<int>{-1, -1};
        else
            return vector<int>{low, high};
    }
    // 查找第一次出现的位置
    int lower_bound(vector<int>& nums, int target){
        int low = 0, high = nums.size() - 1;
        while (low < high){
            int mid = low + (high - low) / 2;
            if (nums[mid] >= target)
                high = mid;
            else
                low = mid + 1;
        }
        return low;
    }
    // 查找最后一次出现的位置
    int upper_bound(vector<int>& nums, int target){
        int low = 0, high = nums.size() - 1;
        while (low <= high){
            int mid = low + (high - low) / 2;
            if (nums[mid] <= target)
                low = mid + 1;
            else
                high = mid - 1;
        }
        return high;
    }
};

八、寻找数组中的重复元素（leetcode 287）

在这里插入图片描述
  思路：用哈希表存储每一个元素出现的次数。

class Solution {
public:
    int findDuplicate(vector<int>& nums) {
        int res;
        unordered_map<int, int> ump;
        for (auto num : nums){
            ump[num]++;
            if (ump[num] > 1){
                res = num;
                break;
            }
        }
        return res;
    }
};

九、顺时针打印矩阵（leetcode 54）

在这里插入图片描述
  思路：用四个变量记录下边界，然后分析打印每一步的前提条件。
在这里插入图片描述

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        vector<int> res;
        if (matrix.empty())
            return res;
        // 用四个变量记录下边界
        int top = 0, btm = matrix.size()-1, left = 0, right = matrix[0].size()-1;
        while (left <= right && top <= btm){
            // 打印第一步不需要条件
            for (int j = left; j <= right; ++j){
                res.push_back(matrix[top][j]);
            }
            // 打印第二步的前提条件是(top<btm)
            if (top < btm){
                for (int i = top+1; i <= btm; ++i){
                    res.push_back(matrix[i][right]);
                }    
            }
            // 打印第三步的前提条件是(top<btm && left<right)
            if (top < btm && left < right){
                for (int j = right-1; j >= left; --j){
                    res.push_back(matrix[btm][j]);
                }                    
            }
            // 打印第四步的前提条件是(top+1<btm&&left<right)
            if (left < right && top+1 < btm){
                for (int i = btm-1; i >= top+1; --i){
                    res.push_back(matrix[i][left]);
                }
            }
            ++top, ++left, --btm, --right;
        }
        return res;
    }
};

十、数组中第K大的数（leetcode 215）

在这里插入图片描述
  思路：基于快排的思想，比较k和mid的位置关系，每次只需要利用一个区间即可。
在这里插入图片描述

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        quick_sort(nums, 0, nums.size()-1, k);
        return nums[nums.size() - k];
    }
    void quick_sort(vector<int>& nums, int low, int high, int k){
        if (low < high){
            int mid = partition(nums, low, high);
            // 比较k和mid的位置关系，每次只需要利用一个区间即可
            if (mid > nums.size() - k)
                quick_sort(nums, 0, mid - 1, k);
            else if (mid < nums.size() - k)
                quick_sort(nums, mid + 1, high, k);
            else
                return;
        }
    }
    // 根据枢纽元划分左右区间
    int partition(vector<int>& nums, int low, int high){
        int pivot = nums[low], mid = low;
        for (int i = low + 1; i <= high; ++i)
            if (nums[i] <= pivot)
                swap(nums[i], nums[++mid]);
        swap(nums[low], nums[mid]);
        return mid;
    }
};

十一、数据流中的中位数（leetcode 295）

在这里插入图片描述
  思路：基于最大堆和最小堆来实现，新元素先加入到最大堆，然后将最大堆的堆顶元素加入最小堆中并弹出，这样保证了最小堆的堆顶元素永远大于最大堆的堆顶元素。如果最小堆的元素个数大于最大堆的元素个数，则继续弹出和加入操作，保证最大堆的元素个数始终与最小堆的元素个数相差不超过1。
在这里插入图片描述

class MedianFinder {
public:
    priority_queue<int, vector<int>, less<int>> large; // 定义最大堆
    priority_queue<int, vector<int>, greater<int>> small; // 定义最小堆
    MedianFinder() { }
    
    void addNum(int num) {
        // 保证最小堆的堆顶元素永远大于最大堆的堆顶元素
        large.push(num);
        small.push(large.top());
        large.pop();
        if (small.size() > large.size()){
            // 保证最大堆的堆顶元素永远小于最小堆的堆顶元素
            large.push(small.top());
            small.pop(); 
        }
    }
    
    double findMedian() {
        return large.size() > small.size() ? 
        		large.top() : 0.5 * (small.top() + large.top());
    }
};

十二、接雨水问题（leetcode 42）

在这里插入图片描述
  思路：保存一个左指针left，右指针right，以及左指针遍历的最大值maxleft以及右指针遍历的最大值maxright。如果当前高度小于maxleft，说明有坑，需要补全，对于right也是一样，但是要保持height[left] < height[right]，目的是找到最高点。

class Solution {
public:
    int trap(vector<int>& height) {
        if (height.size() == 0) return 0;
        int left = 0, right = height.size() - 1, maxleft = 0, maxright = 0, res = 0;
        while (left < right) {
            if (height[left] < height[right]){
                maxleft = max(maxleft, height[left]);
                res += maxleft - height[left];
                left++;
            } else {
                maxright = max(maxright, height[right]);
                res += maxright - height[right];
                right--;                
            }
        }
        return res;
    }
};

十三、求两个数组的交集（leetcode 350）

在这里插入图片描述
  思路：用哈希表记录下较长的数组中的每个元素及其出现的次数，遍历较短长度的数组，如果能找到则递减计数。

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        vector<int> res;
        if (nums1.size() < nums2.size()) 
            swap(nums1, nums2);
        unordered_map<int, int> mp;
        // 用哈希表记录下较长的数组中的每个元素及其出现的次数
        for (int i = 0; i < nums1.size(); ++i)
            mp[nums1[i]]++;
        for (auto num : nums2){ 
            if (mp.find(num) != mp.end() && mp[num] > 0){
                res.push_back(num);
                mp[num]--;
            }
        }
        return res;
    }
};

十四、二维数组的最长递增序列（leetcode 329）

在这里插入图片描述
  思路：深度优先搜索+记忆化搜索，具体方法如下：从起点开始遍历矩阵，递归寻找其最长递增路径。定义辅助数组record，用于记录已经搜索过的矩阵元素的数据，如record[x][y]存储了从坐标(x, y)出发的最长递增路径长度。之后，进行深度优先搜索。逐一检查某个元素的四个方向，并继续从所有可能出现最长路径的方向上进行搜索。 当遇到record[x][y]已算出的情况，直接返回record[x][y]，减少运算量。

class Solution {
public:
    // record[x][y]存储了从坐标(x, y)出发的最长递增路径长度。
    int dfs(vector<vector<int>>& matrix, vector<vector<int>>& record, int x, int y, int lastval) {
        if (x < 0 || y < 0 || x >= matrix.size() || y >= matrix[0].size()) return 0;
        if (matrix[x][y] > lastval) {
            // 路线已算出，直接返回结果
            if (record[x][y] != 0) return record[x][y];
            // 向四周搜索
            int left = dfs(matrix, record, x + 1, y, matrix[x][y]) + 1;
            int right = dfs(matrix, record, x - 1, y, matrix[x][y]) + 1;
            int top = dfs(matrix, record, x, y + 1, matrix[x][y]) + 1;
            int bottom = dfs(matrix, record, x, y - 1, matrix[x][y]) + 1;
            record[x][y] = max(left, max(right, max(top, bottom)));
            return record[x][y];
        }
        return 0;
    }
    int longestIncreasingPath(vector<vector<int>>& matrix) {
        if (matrix.size() == 0) return 0;
        int res = 0;
        vector<vector<int>> record(matrix.size(), vector<int>(matrix[0].size(), 0));
        for (int i = 0; i < matrix.size(); ++i) {
            for (int j = 0; j < matrix[0].size(); ++j) {
                res = max(res, dfs(matrix, record, i, j, -1));
            }
        }
        return res;
    }
};

十五、两个排序数组找第K大的数（leetcode 4）

在这里插入图片描述
  思路：比较这两个数组的第 K/2 小的数字的大小，如果第一个数组的第 K/2 个数字较小的话，那么说明我们要找的数字肯定不在 nums1 中的前 K/2 个数字，所以我们可以将其淘汰，将 nums1 的起始位置向后移动 K/2 个，并且此时的K也自减去 K/2，调用递归。
在这里插入图片描述

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int m = nums1.size(), n = nums2.size();
        return (findKth(nums1, nums2, (m + n + 1) / 2) + findKth(nums1, nums2, (m + n + 2) / 2)) / 2.0;
    }
    int findKth(vector<int> nums1, vector<int> nums2, int k) {
        if (nums1.empty()) return nums2[k - 1];
        if (nums2.empty()) return nums1[k - 1];
        if (k == 1) return min(nums1[0], nums2[0]);
        int i = min((int)nums1.size(), k / 2), j = min((int)nums2.size(), k / 2);
        if (nums1[i - 1] > nums2[j - 1]) {
            return findKth(nums1, vector<int>(nums2.begin() + j, nums2.end()), k - j);
        } else {
            return findKth(vector<int>(nums1.begin() + i, nums1.end()), nums2, k - i);
        }
        return 0;
    }
};

十六、调整数组使所有奇数位于偶数前面（剑指offer）

在这里插入图片描述
  思路：解法一是利用冒泡排序的方法，遇到前偶后奇就交换；解法二是空间换时间的做法，先摘取再合并。

// 解法一
class Solution {
public:
    void reOrderArray(vector<int> &array) {
        // 类似冒泡算法，前偶后奇数就交换
        for (int i = 0; i < array.size(); ++i) {
            for (int j = array.size()-1; j > i; --j) {
                if (array[j] % 2 == 1 && array[j-1] % 2 == 0)
                    swap(array[j], array[j-1]);
            }
        }
    }
};

// 解法二
class Solution {
public:
    void reOrderArray(vector<int> &array) {
        vector<int> res;
        for(int i = 0; i < array.size(); i++)
        {
            if(array[i] % 2 == 1)
                res.push_back(array[i]);
        }
        for(int i = 0; i < array.size(); i++)
        {
            if(array[i] % 2 == 0)
                res.push_back(array[i]);
        }
        array.swap(res);
    }
};

十七、二维矩阵顺时针旋转90度（leetcode 48）

在这里插入图片描述
  思路：先求转置，再把每一行反转。

class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        /*
        * 先求转置再反转每一行
        */
        int sz = matrix.size();
        for (int i = 0; i < sz; ++i){
            for (int j = i+1; j < sz; ++j)
                swap(matrix[i][j], matrix[j][i]);
            reverse(matrix[i].begin(), matrix[i].end());
        }
        return;
    }
};

十八、包含重复元素的数组全排列

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

set<vector<int>> ans; //用set去重

void fun(vector<int> &vec, int start, int len)
{
	// 当start==arr.length-1时，说明子序列的长度为1，就不用再往下划分子序列了
	if (start == len)
		ans.insert(vec);
	for (int i = start; i < len; i++)
	{
		swap(vec[start], vec[i]);
		fun(vec, start + 1, len);
		swap(vec[start], vec[i]);
	}
}

vector<vector<int>> Permutation(vector<int> vec) {
	vector<vector<int>> vecout;
	if (!vec.empty())
	{
		fun(vec, 0, vec.size());
		for (auto tmp : ans)
			vecout.push_back(tmp);
	}
	return vecout;
}

int main() {
	vector<vector<int>> res = Permutation({ 1, 2, 3 });
	for (int i = 0; i < res.size(); ++i) {
		for (int j = 0; j < res[0].size(); ++j) {
			cout << res[i][j] << " ";
		}
		cout << endl;
	}
	system("pause");
	return 0;
}
~青萍之末~
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
2024年华为OD面试手撕代码真题-​两整数之和​
面试高手的博客
06-19 88
2024年华为OD面试手撕代码真题-​两整数之和​，这是一道频率超高的面试题，已经有多个学员反馈面试遇到了，大家一定要好好做
2023华为OD面试手撕代码经验分享
热门推荐
MISAYAONE的博客
05-17 2万+
华为OD 面试手撕代码经验分享
「Java数据结构」：手撕二维数组和稀疏数组相互转换。
yzh2776680982的博客
07-12 1100
目录一、稀疏数组1、什么是稀疏数组2、图示 ​3、稀疏数组的表达方式二、二维数组→稀疏数组 第一步：创建二维数组第二步：创建稀疏数组，并赋值第三步：遍历二维数组并赋值给稀疏数组完整代码三、 稀疏数组→二维数组第一步：创建新的二维数组第二步：循环遍历并赋值完整代码...
华为二面手撕代码leetcode中等难度链表题
u012425770的博客
09-23 1万+
华为上合面试二面手撕代码，给一个链表和一个数，将链表分为两部分，左边部分小于x，右边部分大于或等于x，保证两部分中节点的相对顺序与之前一致。 比如： Input: head = 1->4->3->2->5->2, x = 3 Output: 1->2->2->4->3->5 这题我四个月前AC过，做得很大意当时没细想就AC了。由于手写和面......
华为od项目
我的博客简介
08-03 8854
本来以为到这里就算挂了的。5.19 三面，面试官问的比较底层，大多数问题都答出来了，但不是很完美，有一个没答出来的是：错误处理机制errorCaptured、errorHandler，毕竟我实在没用过，接下来就是一道算法题，当时面试官问我有没有刷过leetcode，我说刷了600道题，然后他就让我共享桌面，让我搜一道没做过的题目，给了一个题号是一道简单题，（ 2243. 计算字符串的数字和 ），七八分钟直接就用递归做出来了，然后面试官看了一下解答思路，就针对我的答案挑我的编码规范的问题，我只能欣然接受呗。.
校招面试手撕代码.zip
11-14
《校招面试手撕代码》是一份专门为大学毕业生准备的面试资源，主要涵盖了编程面试中的核心问题和解题策略。这份资料以"CodingInterviewChinese2-master"为项目名称，暗示了其是某个代码库的主分支，可能包含了多个子...
手撕代码1
08-08
下面是使用数组实现栈的示例代码： ```java public class Stack { // 存数据的数组 int[] data; // 栈的最大长度 private int size; // 栈顶的位置 private int top; // 栈的构造函数 public Stack(int ...
杭电笔试代码模板参考
01-21
手撕代码是指在没有现成框架或者库支持的情况下，从零开始编写核心算法，这对程序员的编程功底有较高要求。这不仅涉及编程语言的基本语法，还包括对算法的深入理解和灵活应用，例如动态规划、贪心算法、分治策略等。...
互联网面试手写代码常见题总结.docx
09-09
本文涵盖了互联网面试中常见的代码编写题目，总共 68 道题目，涵盖了链表、数组、树、图、排序算法、动态规划、递归、循环队列、堆、栈、队列、红黑树、B 树、遍历方式、最短路径算法、堆排序、LRU 算法、二分查找、...
CV总复习--计算机基础与手撕代码篇.zip
09-27
数据类型和数据结构是编程的基础，如整型、浮点型、字符串、数组、链表、栈、队列、树和图等。理解它们的特性和操作，能帮助我们更有效地组织和处理数据。在CV中，矩阵运算和图像表示（例如像素数组）尤为重要，因此...
华为手撕代码c语言题目,想去面试？这10道最高频的手撕代码题都会了吗？
weixin_31186111的博客
05-24 2292
原标题：想去面试？这10道最高频的手撕代码题都会了吗？来源：Python与算法之美ID：Python_Ai_Road作者：梁云1991想去看机会？下面这10道最高频的手撕代码面试题都会了吗？相信我，彻底掌握以下这10道题的解法，你顺利做出手撕代码面试题目的概率至少不低于50%。1，快速排序题目形式：手写一下快速排序算法。题目难度：中等。出现概率：约50%。手写快排绝对是手撕代码面试题中的百兽之王，...
2021年华为OD面试总结
suwuzs的博客
01-21 8730
文章目录写在前面面试总体流程简历筛选线上机考综合评测业务面试背景调查和HR面试主管面试 写在前面 笔者211重点大学本科，毕业近5年；因为之前不是学python的，是近两年入了编程教培行业，所以慢慢接触到的python。然后21年下半年10月后，准备重回技术岗，就开始了漫长的求职面试之旅。 项目经验：主要来自学校比赛和校园项目（而且也是偏向硬件）； 所以大家看到的我的博客专栏； python编程基础（精讲） 数据结构与算法（python） 算是笔者在学习python，准备面试的过程中，慢慢积累的学习笔记
常见手撕代码题汇总！
磊哥聊Java
06-25 1470
面试就看 www.javacn.site 内容贼全随着 Java 技术的发展，以及从业人员专业知识的不断提升，面试的难度也水涨船高越来越难了，所以八股也要与时俱进不断更新，这就是本篇文章诞生的目的之一。我凭借自身的面试和被面试的经验，以及人工查阅并整理了牛某今年最新的 200 篇面经，总结了这篇文章，所以希望大家不要吝啬手中免费的赞，给作者点一波赞，谢谢了。整理的部分面经展示：一、最常见手撕代码题...
手撕代码
sinat_14819779的博客
04-24 1582
1、用c语言编写一个函数用来删除字符串中的空格并返回空格个数（不允许开辟空间） int deletespace(char *str, char *res) { int count = 0; int i = 0; while(*str != '\0'){ if (*str != ' ') { res[i++] = *str; } else { count++; } str++; } res[i + 1] = '\0'; return count; } int ma
嵌入式程序员手撕代码
Ztt19990421的博客
05-26 692
/12. ((((A)&0xff000000)>>24) | (((A)&0x000000ff)8) | (((A)&0x00ff)
Python 华为面试手撕代码 + 八股文，机器学习参数调节，损失函数，激活函数，线程、进程和协程
L_goodboy的博客
05-30 4784
Python 华为面试手撕代码 + 八股文，机器学习参数调节，损失函数，激活函数，线程、进程和协程
字节跳动程序媛教你如何刷算法题：面试手撕代码我就没怕过
Stay Hungry Stay Foolish 求知若饥 虚心若愚
02-11 1万+
本人上一次刷题还是大一的C语言期末考试……但是面试中算法考核截止上岸前一直保持着100%正确率的光辉记录。 本文将给你指明一条刷题的决胜指南。并从算法的重要性、题库的选择以及刷题的三大步骤分别进行讲解，彻底解决你所有关于面试算法所有的困扰。
手撕代码怎么破
CURD工程师
11-19 7046
       基础知识的知识点在前面介绍过了，涉及到的内容，都会在后面同步，今天我们主要来聊聊面试过程中的手撕代码环节。关于手撕代码，公司不同，要求不同，但是有一点是很显然的，那就是即使你写不出来可运行的代码，也得有清晰的思路，绝大部分公司则要求写出完整的代码，而代码能力和基础知识不同，不是短时间能够恶补的，更不是可以死记硬背的...
华为手撕代码java
最新发布
01-04
华为手撕代码java是指在面试或技术交流过程中，面试官会给出几道具体的java编程问题，要求面试者用手撕代码的方式进行解答。这种方式的面试考察了面试者对java语言的熟练程度和编程能力，也考察了其对算法和数据结构...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

~青萍之末~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值