0
  • 聊天消息
  • 系统消息
  • 评论与回复
登录后你可以
  • 下载海量资料
  • 学习在线课程
  • 观看威廉希尔官方网站 视频
  • 写文章/发帖/加入社区
会员中心
创作中心

完善资料让更多小伙伴认识你,还能领取20积分哦,立即完善>

3天内不再提示

腾讯常考的十道算法题

算法与数据结构 来源:捡田螺的小男孩 作者:算法与数据结构 2022-03-28 10:25 次阅读

前言

大家好,我是捡田螺的小男孩。收集了腾讯常考的十道算法题(真题)。在金三银四,希望对大家有帮助呀。

  1. 重排链表
  2. 最长递增子序列
  3. 环形链表
  4. 反转链表
  5. 最长回文子串
  6. 全排列
  7. LRU 缓存
  8. 合并K个升序链表
  9. 无重复字符的最长子串
  10. 删除链表的倒数第 N 个结点

1. 重排链表

给定一个单链表 L 的头节点 head ,单链表 L 表示为:

L0→L1→…→Ln-1→Ln

请将其重新排列后变为:

L0→Ln→L1→Ln-1→L2→Ln-2→…

输入:

head=[1,2,3,4]

输出:

[1,4,2,3]

思路:

如果是数组就好了,哈哈,因为数组可以直接通过下标访问,很容易就可以解答这道题了。但是这是链表。链表不支持下标访问,我们没办法随机访问到链表任意位置的元素,怎么办呢?

我们可以先遍历一下,用数组把链表的元素按顺序存储起来呀,然后就可以把它当做数组这么访问来用了对吧,最后重建下链表即可啦。

ArrayList的底层就是数组,我们先用它存储链表就好,如下:

Listlist=newArrayList();
ListNodenode=head;
while(node!=null){
list.add(node);
node=node.next;
}

有了一个数组结构的链表后,如何重建链表呢?回头多看示例两眼,很容易就发小规律啦:先排第1个,再排倒数第1个,接着排第2个,紧接着倒数第2个。显然这个规律很明显,代码也比较好实现:

inti=0;
intj=list.size()-1;
while(iif(i==j){
break;
}
list.get(j).next=list.get(i);
j--;
}
//大家画个图就很清晰知道为什么需要这行了,哈哈
list.get(i).next=null;

完整实现代码如下:

classSolution{
publicvoidreorderList(ListNodehead){
if(head==null){
return;
}
Listlist=newArrayList();
ListNodenode=head;
while(node!=null){
list.add(node);
node=node.next;
}
inti=0,j=list.size()-1;
while(i< j) {
            list.get(i).next = list.get(j);
            i++;
            if(i==j){
break;
}
list.get(j).next=list.get(i);
j--;
}
list.get(i).next=null;
}
}

2. 最长递增子序列

给你一个整数数组 nums ,找到其中最长严格递增子序列的长度。

实例1:

输入:nums =[10,9,2,5,3,7,101,18]
输出:4
解释:最长递增子序列是[2,3,7,101],因此长度为 4 。

实例2:

输入:nums =[0,1,0,3,2,3]
输出:4

思路:

这道题是求最值问题,可以使用动态规划解决。动态规划的解题整体思路就是:

  1. 穷举分析
  2. 分析找规律,拆分子问题
  3. 确定边界
  4. 确定最优子结构
  5. 写出状态转移方程

2.1 穷举分析

动态规划的核心思想包括拆分子问题,记住过往,减少重复计算。所以我们在思考原问题:数组num[i]的最长递增子序列长度时,可以思考下相关子问题,比如原问题是否跟子问题num[i-1]的最长递增子序列长度有关呢?

自底向上的穷举过程:

  • 当nums只有一个元素10时,最长递增子序列是[10],长度是1.
  • 当nums需要加入一个元素9时,最长递增子序列是[10]或者[9],长度是1。
  • 当nums再加入一个元素2时,最长递增子序列是[10]或者[9]或者[2],长度是1。
  • 当nums再加入一个元素5时,最长递增子序列是[2,5],长度是2。
  • 当nums再加入一个元素3时,最长递增子序列是[2,5]或者[2,3],长度是2。
  • 当nums再加入一个元素7时,,最长递增子序列是[2,5,7]或者[2,3,7],长度是3。
  • 当nums再加入一个元素101时,最长递增子序列是[2,5,7,101]或者[2,3,7,101],长度是4。
  • 当nums再加入一个元素18时,最长递增子序列是[2,5,7,101]或者[2,3,7,101]或者[2,5,7,18]或者[2,3,7,18],长度是4。
  • 当nums再加入一个元素7时,最长递增子序列是[2,5,7,101]或者[2,3,7,101]或者[2,5,7,18]或者[2,3,7,18],长度是4.

2.2 分析找规律,拆分子问题

通过上面分析,我们可以发现一个规律:

如果新加入一个元素nums[i], 最长递增子序列要么是以nums[i]结尾的递增子序列,要么就是nums[i-1]的最长递增子序列。看到这个,是不是很开心,nums[i]的最长递增子序列已经跟子问题nums[i-1]的最长递增子序列有关联了。

原问题数组nums[i]的最长递增子序列 = 子问题数组nums[i-1]的最长递增子序列/nums[i]结尾的最长递增子序列

是不是感觉成功了一半呢?但是如何把nums[i]结尾的递增子序列也转化为对应的子问题呢?要是nums[i]结尾的递增子序列也跟nums[i-1]的最长递增子序列有关就好了。又或者nums[i]结尾的最长递增子序列,跟前面子问题num[j](0=结尾的最长递增子序列有关就好了,带着这个想法,我们又回头看看穷举的过程:

2e7ef6ec-ae3c-11ec-aa7f-dac502259ad0.png

nums[i]的最长递增子序列,不就是从以数组num[i]每个元素结尾的最长子序列集合,取元素最多(也就是长度最长)那个嘛,所以原问题,我们转化成求出以数组nums每个元素结尾的最长子序列集合,再取最大值嘛。哈哈,想到这,我们就可以用dp[i]表示以num[i]这个数结尾的最长递增子序列的长度啦,然后再来看看其中的规律:

2e98d6ca-ae3c-11ec-aa7f-dac502259ad0.png

其实,nums[i]结尾的自增子序列,只要找到比nums[i]小的子序列,加上nums[i]就可以啦。显然,可能形成多种新的子序列,我们选最长那个,就是dp[i]的值啦

  • nums[3]=5,以5结尾的最长子序列就是[2,5],因为从数组下标0到3遍历,只找到了子序列[2]比5小,所以就是[2]+[5]啦,即dp[4]=2
  • nums[4]=3,以3结尾的最长子序列就是[2,3],因为从数组下标0到4遍历,只找到了子序列[2]比3小,所以就是[2]+[3]啦,即dp[4]=2
  • nums[5]=7,以7结尾的最长子序列就是[2,5,7]和[2,3,7],因为从数组下标0到5遍历,找到2,5和3都比7小,所以就有[2,7],[5,7],[3,7],[2,5,7]和[2,3,7]这些子序列,最长子序列就是[2,5,7]和[2,3,7],它俩不就是以5结尾和3结尾的最长递增子序列+[7]来的嘛!所以,dp[5]=3 =dp[3]+1=dp[4]+1。

很显然有这个规律:一个以nums[i]结尾的数组nums

  • 如果存在j属于区间[0,i-1],并且num[i]>num[j]的话,则有:dp(i) =max(dp(j))+1。

2.3 确定边界

当nums数组只有一个元素时,最长递增子序列的长度dp(1)=1,当nums数组有两个元素时,dp(2) =2或者1, 因此边界就是dp(1)=1。

2.4 确定最优子结构

从2.2 穷举分析找规律,我们可以得出,以下的最优结构:

dp(i)=max(dp(j))+1,存在j属于区间[0,i-1],并且num[i]>num[j]。

max(dp(j)) 就是最优子结构。

2.5 写出状态转移方程

通过前面分析,我们就可以得出状态转移方程啦:

2ea9361e-ae3c-11ec-aa7f-dac502259ad0.png

所以数组nums[i]的最长递增子序列就是:

最长递增子序列=max(dp[i])

完整代码实现如下

classSolution{
publicintlengthOfLIS(int[]nums){
if(nums.length==0){
return0;
}
int[]dp=newint[nums.length];
//初始化就是边界情况
dp[0]=1;
intmaxans=1;
//自底向上遍历
for(inti=1;i< nums.length; i++) {
            dp[i] = 1;
            //从下标0到i遍历
            for(intj=0;j< i; j++) {
                //找到前面比nums[i]小的数nums[j],即有dp[i]= dp[j]+1
                if(nums[j]< nums[i]) {
                    //因为会有多个小于nums[i]的数,也就是会存在多种组合了嘛,我们就取最大放到dp[i]
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
            //求出dp[i]后,dp最大那个就是nums的最长递增子序列啦
            maxans = Math.max(maxans, dp[i]);
        }
        returnmaxans;
}
}

3. 环形链表

给定一个链表的头节点head ,返回链表开始入环的第一个节点。如果链表无环,则返回 null。

实例:

2ebe1e80-ae3c-11ec-aa7f-dac502259ad0.png
输入:head =[3,2,0,-4], pos = 1
输出:返回索引为 1 的链表节点
解释:链表中有一个环,其尾部连接到第二个节点。

如果判断链表是否有环,我们可以使用快慢指针,快指针是慢指针速度的两倍,当两个指针相遇时,即表示有环。

booleanhasCycle(ListNodehead){

ListNodeslow=head;
ListNodefast=head;
while(fast!=null&&fast.next!=null){
fast=fast.next.next;
slow=slow.next;
if(fast==slow){
returntrue;
}
}
returnfalse;
}

我们可以很容易就判断有环,但是如何返回入环的第一个节点呢?我们来画个图分析一波:

2ecc87b8-ae3c-11ec-aa7f-dac502259ad0.png

假设起点为A,入环点为B,快慢指针相遇点为C,慢指针走到相遇点为k步,B到C的距离为m。设环型周长为X。因为快指针速度是慢指针的2倍。则有:

K-m+X+m=2K=快指针走的举例

所以周长X = K。相遇后,快指针到继续往前走,走到入环点B,刚好距离是X-m = K-m。而起点到B节点,距离也是K-m。因此,快慢指针相遇后,慢指针回到起点,这时候快慢指针一样的速度走,相遇时,就是入环点啦,是不是无巧不成书呀,哈哈哈。

完整代码如下:

publicclassSolution{
publicListNodedetectCycle(ListNodehead){
if(head==null){
returnnull;
}
ListNodefast=head;
ListNodeslow=head;
while(fast!=null&&fast.next!=null){
fast=fast.next.next;
slow=slow.next;
//快慢指针相等表示有环
if(slow==fast){
//回到起点一起相同速度走
while(head!=fast){
head=head.next;
fast=fast.next;
}
returnhead;
}

}
returnnull;
}
}

4. 反转链表

给你单链表的头节点 head ,请你反转链表,并返回反转后的链表。

2eddbb14-ae3c-11ec-aa7f-dac502259ad0.png
输入:head =[1,2,3,4,5]
输出:[5,4,3,2,1]

完整代码如下:

classSolution{
publicListNodereverseList(ListNodehead){

ListNodeprev=null;
ListNodenext=head;
ListNodecurr=head;

while(curr!=null){
next=curr.next;
curr.next=prev;
prev=curr;
curr=next;
}

returnprev;
}
}

之前图解过这道题,大家可以看下哈:

看一遍就理解,图解单链表反转

5. 最长回文子串

给你一个字符串 s,找到 s 中最长的回文子串。

实例1:

输入:s ="babad"
输出:"bab"
解释:"aba"同样是符合题意的答案。

这道题可以使用中心扩展法实现,从中间开始向两边扩散来判断回文串。

for0<= i < len(s):
    找到以 s[i] 为中心的回文串
    更新答案

但是回文串可能是长度可能是奇数,也可能是偶数,因此需要加多一步:

for0<= i < len(s):
    找到以 s[i] 为中心的回文串
    找到以 s[i] 和s[i+1] 为中心的回文串
    更新答案

完整代码如下:

classSolution{
publicStringlongestPalindrome(Strings){

if(s==null||s.length()<2){
             returns;
}

Stringresult="";
for(inti=0;ir2.length()?r1:r2;
result=tempMax.length()>result.length()?tempMax:result;

}
returnresult;

}

privateStringsubLongestPalindrome(Strings,intl,intr){
while(l>=0&&rreturns.substring(l+1,r);
}
}

6.全排列

给定一个不含重复数字的数组 nums ,返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

示例 1:

输入:nums =[1,2,3]
输出:[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

示例 2:

输入:nums =[0,1]
输出:[[0,1],[1,0]]

这道题可以用回溯算法解决,完整代码如下:

classSolution{
//全排列,即所有路径集合
List>allPath=newLinkedList<>();

publicList>permute(int[]nums){
//当前路径,入口路径,path是空的
Listpath=newLinkedList<>();
//递归函数入口,可做选择是nums数组
backTrace(nums,path);
returnallPath;
}

publicvoidbackTrace(int[]nums,Listpath){
//已走路径path的数组长度等于nums的长度,表示走到叶子节点,所以加到全排列集合
if(nums.length==path.size()){
allPath.add(newLinkedList(path));
return;
}

for(inti=0;iif(path.contains(nums[i])){
continue;
}
//做选择,加到当前路径
path.add(nums[i]);
//递归,进入下一层的决策
backTrace(nums,path);
//取消选择
path.remove(path.size()-1);
}
}
}

大家可以看下之前我写的这篇回溯文章哈,有回溯算法的框架套用。

面试必备:回溯算法详解

7. LRU 缓存

请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。

实现 LRUCache 类:

  • LRUCache(int capacity) 以 正整数 作为容量capacity 初始化 LRU 缓存
  • int get(int key) 如果关键字 key 存在于缓存中,则返回关键字的值,否则返回 -1 。
  • void put(int key, int value)如果关键字 key 已经存在,则变更其数据值 value ;如果不存在,则向缓存中插入该组 key-value 。如果插入操作导致关键字数量超过 capacity ,则应该 逐出 最久未使用的关键字。

函数 get 和 put 必须以O(1)的平均时间复杂度运行。

示例:

输入
["LRUCache","put","put","get","put","get","put","get","get","get"]
[[2],[1,1],[2,2],[1],[3,3],[2],[4,4],[1],[3],[4]]
输出
[null,null,null,1,null,-1,null,-1,3,4]

解释
LRUCachelRUCache=newLRUCache(2);
lRUCache.put(1,1);//缓存是{1=1}
lRUCache.put(2,2);//缓存是{1=1,2=2}
lRUCache.get(1);//返回1
lRUCache.put(3,3);//该操作会使得关键字2作废,缓存是{1=1,3=3}
lRUCache.get(2);//返回-1(未找到)
lRUCache.put(4,4);//该操作会使得关键字1作废,缓存是{4=4,3=3}
lRUCache.get(1);//返回-1(未找到)
lRUCache.get(3);//返回3
lRUCache.get(4);//返回4

这道题,出现的频率还是挺高的,很多小伙伴在面试时,都反馈自己遇到过原题

LRU,Least Recently Used,即最近使用过的数据是有用的,可以使用双链表+Hashmap解答,双链表用于存储LRUCache的数据,Hashmap实现O(1)的平均时间复杂度。

2ef0be4e-ae3c-11ec-aa7f-dac502259ad0.png
  • 每次从链表尾部添加元素,靠尾的元素就是最近使用过
  • 某个key可以通过哈希表快速定位到节点。

对于双链表,需要做哪些事呢。

  • 首先是链表初始化,为了方便处理i,虚拟一个头节点和尾结点。
  • 添加元素时,放到链表的尾部,表示该元素最近使用过
  • 删除双向链表的某个节点
  • 删除并返回头节点,表示删除最久未使用的元素
  • 返回链表当前长度

LRU缓存有哪些方法

  • 构造函数初始化方法
  • get和put方法
  • makeRecently 设置某个元素最近使用过的方法,哈希表已经有该元素
  • addRecently 添加最近使用过的元素,同时更新map
  • deleteKey 删除某个key对应的元素,同时删除map上的节点
  • removeLeastRecently 删除最久未使用的元素

完整代码如下:

classNode{

intkey,val;
Nodenext,prev;
publicNode(intkey,intval){
this.key=key;
this.val=val;
}
}

classDoubleList{
//虚拟出头节点和尾结点
privateNodehead,tail;
privateintsize;

//初始化双链表
publicDoubleList(){
//虚拟头结点
head=newNode(0,0);
//虚拟头结点
tail=newNode(0,0);
head.next=tail;
tail.prev=head;
size=0;
}

//要加到链表尾部,且越靠近链表尾部,越表示最近使用过
publicvoidaddLast(Nodex){
//比如当前链表为:head <-> 1 <-> tail,加入结点x = 2
x.prev=tail.prev;
//完成结点2指向两端的箭头head<->1<- 2 ->tail;此时tail.pre=结点1还未断开
x.next=tail;
//head<->1<->2->tail;
tail.prev.next=x;
//head<->1<->2<->tail;
tail.prev=x;
//更新链表长度
size++;
}

//删除指定结点
publicvoidremove(Nodex){
x.prev.next=x.next;
x.next.prev=x.prev;
size--;
}

//删除并返回头结点
publicNoderemoveHead(){
if(head.next==tail){
returnnull;
}
Nodefirst=head.next;
//size在remove中更新了
remove(first);
//用作在哈希表中移除最久未使用的数据值
returnfirst;
}

//获取链表长度
publicintgetSize(){
returnsize;
}
}

publicclassLRUCache{

privateMapmap;
privateDoubleListdoubleList;
privateintcap;

publicLRUCache(intcapacity){
this.map=newHashMap<>();
this.doubleList=newDoubleList();
this.cap=capacity;
}

publicintget(intkey){
if(map.containsKey(key)){
//先将key标记为最近使用,再返回value
makeRecently(key);
returnmap.get(key).val;
}else{
return-1;
}
}

publicvoidput(intkey,intvalue){
if(map.containsKey(key)){
deleteKey(key);//从原map中移除该key
addRecently(key,value);//更新最近使用
return;
}

intsize=doubleList.getSize();
if(size==cap){//说明需要移除最久未使用的元素了
removeLeastRecently();
}
addRecently(key,value);//添加新的元素进来
}


publicvoidmakeRecently(intkey){//将某个key标记为最近使用的元素(map中已存在的)
Nodex=map.get(key);
doubleList.remove(x);//先从双链表删除
doubleList.addLast(x);//再添加到链表末尾,因为尾部是最近使用过的元素
}

publicvoidaddRecently(intkey,intvalue){//添加最近使用过的元素
Nodex=newNode(key,value);
doubleList.addLast(x);
map.put(key,x);//更新map
}

publicvoiddeleteKey(intkey){
Nodex=map.get(key);
map.remove(key);
doubleList.remove(x);//在map中和cache中同时删除
}

//删除最久未使用的元素
publicvoidremoveLeastRecently(){
//最久未使用的一定在链表头部
NodeoldNode=doubleList.removeHead();
intoldKey=oldNode.key;
map.remove(oldKey);
}
}



8. 合并K个升序链表

给你一个链表数组,每个链表都已经按升序排列。请你将所有链表合并到一个升序链表中,返回合并后的链表。

示例 1:

输入:lists =[[1,4,5],[1,3,4],[2,6]]
输出:[1,1,2,3,4,4,5,6]
解释:链表数组如下:
[
1->4->5,
1->3->4,
2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6

合并两个有序链表,是比较简单的,相信大家都会做。那么如何合并K个有序链表呢?其实道理是一样的,我们可以借用优先级队列找出最小节点,完整代码如下:

classSolution{


publicListNodemergeKLists(ListNode[]lists){

if(lists.length==0){
returnnull;
}
//虚拟节点
ListNodehead=newListNode(0);
ListNodetail=head;
//优先队列
PriorityQueuequeue=newPriorityQueue<>(lists.length,(a,b)->(a.val-b.val));

//将K个链表头节点合并最小堆
for(ListNodenode:lists){
if(node!=null){
queue.add(node);
}
}

while(!queue.isEmpty()){
//获取最小节点,放到结果链表中
ListNodenode=queue.poll();
tail.next=node;

if(node.next!=null){
queue.add(node.next);
}
//指针链表一直往前
tail=tail.next;
}
returnhead.next;
}
}

9. 无重复字符的最长子串

给定一个字符串 s ,请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入:s="abcabcbb"
输出:3
解释:因为无重复字符的最长子串是"abc",所以其长度为 3。

示例 2:

输入:s="bbbbb"
输出:1
解释:因为无重复字符的最长子串是"b",所以其长度为 1。

这道题可以使用滑动窗口来实现。滑动窗口就是维护一个窗口,不断滑动,然后更新答案。

滑动窗口的大致逻辑框架,伪代码如下:

intleft=0,right=0;
while(right< s.size()){
  //增大窗口
  window.add(s[right]);
  right++;
  
  while(windowneedsshrink){
//缩小窗口
window.remove(s[left]);
left++;
}
}

解法流程如下:

  • 首先呢,就是获取原字符串的长度。
  • 接着维护一个窗口(数组、哈希、队列)
  • 窗口一步一步向右扩展
  • 窗口在向右扩展滑动过程,需要判断左边是否需要缩减
  • 最后比较更新答案

完整代码如下:

intlengthOfLongestSubstring(Strings){
//获取原字符串的长度
intlen=s.length();
//维护一个哈希集合的窗口
Setwindows=newHashSet<>();
intleft=0,right=0;
intres=0;

while(rightwhile(windows.contains(c)){
windows.remove(s.charAt(left));
left++;
}
windows.add(c);
//比较更新答案
res=Math.max(res,windows.size());
}
returnres;
}

之前写过一篇滑动窗口解析,大家有兴趣可以看下哈:

leetcode必备算法:聊聊滑动窗口

10.删除链表的倒数第 N 个结点

给你一个链表,删除链表的倒数第 n 个结点,并且返回链表的头结点。

2f02740e-ae3c-11ec-aa7f-dac502259ad0.png

示例 :

输入:head =[1,2,3,4,5], n = 2
输出:[1,2,3,5]

这道题可以使用双指针解决。既然我们要找到倒数第n个节点,我们可以使用两个指针first 和 second同时对链表进行遍历,并且first 比second超前n个节点。当first遍历到链表的末尾时,second就恰好处于倒数第n个节点。

classSolution{
publicListNoderemoveNthFromEnd(ListNodehead,intn){
ListNodedummy=newListNode(0,head);
ListNodefirst=head;
ListNodesecond=dummy;
//first比second先走n个节点
for(inti=0;i< n; ++i) {
            first = first.next;
        }
        //直到走到链表尾部
        while(first!=null){
first=first.next;
second=second.next;
}
//删除节点
second.next=second.next.next;
ListNodeans=dummy.next;
returnans;
}
}

审核编辑 :李倩


声明:本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人,不代表电子发烧友网立场。文章及其配图仅供工程师学习之用,如有内容侵权或者其他违规问题,请联系本站处理。 举报投诉
  • 算法
    +关注

    关注

    23

    文章

    4608

    浏览量

    92853
  • 代码
    +关注

    关注

    30

    文章

    4782

    浏览量

    68546
  • 数组
    +关注

    关注

    1

    文章

    417

    浏览量

    25941

原文标题:十道腾讯算法真题解析!

文章出处:【微信号:TheAlgorithm,微信公众号:算法与数据结构】欢迎添加关注!文章转载请注明出处。

收藏 人收藏

    评论

    相关推荐

    嵌入式Linux内核开发必须了解的三十道

    嵌入式系统Linux内核开发工程师必须掌握的三十道 linux内核工程师需要知道的30个问题,看看你能回答出多少个。
    发表于 04-22 08:22 2728次阅读
    嵌入式Linux内核开发必须了解的三<b class='flag-5'>十道</b><b class='flag-5'>题</b>

    单片机8031三:三、四、五。一10元

    单片机8031三:三、四、五。一10元,直接发我qq840921270 ,会给第一个采用的人直接发支付宝,决不食言,食言剁屌!求助大神,小弟谢过了
    发表于 04-16 17:02

    可以大体看出你C语言水平的十道

    可以大体看出你C语言水平的十道 各位,今天给大家搜集了10比较好的面试题,涉及了指针、运算、结构体、函数、内存,应该来说比较全面了,有兴趣的做一下检测一下自己的水平吧! 1.strcpy
    发表于 04-03 16:00

    的寄存器有哪些?

    计算机由哪几部分组成?的寄存器有哪些?
    发表于 10-08 06:04

    PCB生产工艺 | 第十道主流程之电测

    如图,第十道主流程为电测。电测的目的:电测又叫电气性能测试、功能测试或开短路测试等,主要是对PCB的网络通过测试治具或测试针接触网络的测试点位进行开短路检测,将坏板挑选出来。是PCB生产过程中的一
    发表于 03-30 18:19

    基于程序设计主观智能阅卷算法的应用研究

    在程序设计语言考试中,程序设计主观智能评阅是一项具有实用价值的应用。文中在分析主观阅卷算法的基础上,针对程序设计主观的特征,提出了基于阅卷参考点和程序
    发表于 10-10 15:28 12次下载

    考研高频词汇

    考研高频词汇 1. abide by(=be faithful to ; obey)忠于;遵守。2. be absent from…. 缺席,不在3. 
    发表于 05-14 13:59 12次下载

    一考你!这三嵌入式Linux你会吗?来做一下吧

    一: 解释命令ls -a | more具体含义. 思考过后,再到下方寻找答案 二: GCC -g -o
    的头像 发表于 04-03 11:22 5376次阅读

    Linux面试3

    关键词:linux、面试 第一:下面的网络协议中,面向连接的的协议是( ) A 传输控制协议 B 用户数据报协议 C 网际协议 D 网际控制报文协议 第二:. Linux文件权限一共10位长度
    发表于 09-23 11:03 486次阅读

    40道经典JAVA算法和解答

    本文档的主要内容详细介绍的是40道经典JAVA算法和解答。
    发表于 07-02 08:00 0次下载
    40道经典JAVA<b class='flag-5'>算法</b><b class='flag-5'>题</b>和解答

    快来,我出个算法给你做做

    大家一个算法 责任编辑:xj 原文标题:大家一个算法 文章出处:【微信公众号:
    的头像 发表于 10-10 16:55 1400次阅读

    套名校自控考研真电子版下载

    套名校自控考研真电子版下载
    发表于 03-24 10:15 0次下载
    <b class='flag-5'>十</b>套名校自控考研真<b class='flag-5'>题</b>电子版下载

    算法类型以及准备策略

    今天就和大家聊聊大公司的面试环节经常涉及的算法类型以及准备策略。 问题难度首先大家比较关心的就是面试时候出现的算法的难度,从我的个人经验来看,除了有一次和同样有acm获奖经历的面试
    的头像 发表于 09-02 10:50 1485次阅读

    单调栈解题模板如何秒杀三算法

    单调栈实际上就是栈,只是利用了一些巧妙的逻辑,使得 **每次新元素入栈后,栈内的元素都保持有序** (单调递增或单调递减)。 本文就通过几道算法来看看单调栈模板的使用。
    的头像 发表于 04-19 10:52 922次阅读
    单调栈解题模板如何秒杀三<b class='flag-5'>道</b><b class='flag-5'>算法</b><b class='flag-5'>题</b>

    PCB生产工艺 | 第十道主流程之表面处理

    如图,第十道主流程为电测。电测的目的:电测又叫电气性能测试、功能测试或开短路测试等,主要是对PCB的网络通过测试治具或测试针接触网络的测试点位进行开短路检测,将坏板挑选出来。是PCB生产过程中的一
    的头像 发表于 03-30 18:20 821次阅读
    PCB生产工艺 | 第<b class='flag-5'>十道</b>主流程之表面处理