秋招面试题

最新推荐文章于 2024-05-17 17:35:28 发布
最新推荐文章于 2024-05-17 17:35:28 发布
阅读量149 收藏
点赞数
分类专栏： 笔试面试 文章标签： 链表 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42906066/article/details/108572810
版权
  1. 反转链表 （小米开发）
#include <bits/stdc++.h>
using namespace std;
struct ListNode{
    int val;
    struct ListNode *next;
    ListNode(int x):
            val(x), next(nullptr){}
};
ListNode* Reverse(ListNode *head){
    if(!head || !head->next) return head;
    ListNode *pre = nullptr, *cur = head;
    while(cur){
        auto next = cur->next;
        cur->next = pre;
        pre = cur;
        cur = next;
    }
    return pre;
}

int main(){
    auto p1 = new ListNode(1);
    auto p2 = new ListNode(2);
    auto p3 = new ListNode(3);
    auto p4 = new ListNode(4);
    auto p5 = new ListNode(5);
    p1->next = p2;
    p2->next = p3;
    p3->next = p4;
    p4->next = p5;
    p5->next = NULL;
    auto head = Reverse(p1);
    for(auto p = head; p; p = p->next)
        cout << p->val << ' ';
    return 0;
}

补充： 输入数组

1). 需要输入数组长度
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
struct ListNode{
    int val;
    struct ListNode *next;
    ListNode(int x):
            val(x), next(nullptr){}
};
ListNode* Reverse(ListNode *head){
    if(!head || !head->next) return head;
    ListNode *pre = nullptr, *cur = head;
    while(cur){
        auto next = cur->next;
        cur->next = pre;
        pre = cur;
        cur = next;
    }
    return pre;
}
int main(){
    int n, a[N];
    cin >> n;
    ListNode *dummy = new ListNode(-1);
    dummy->next = NULL;
    ListNode *pre = dummy;
    for(int i = 0; i < n; i++){
        cin >> a[i];
        ListNode *p = new ListNode(a[i]);
        p->next = NULL;
        pre->next = p;
        pre = p;
    }
    auto head = Reverse(dummy->next);
    for(auto p = head; p; p = p->next)
        cout << p->val << ' ';
    return 0;
}

2). 不需要输入数组长度
#include <bits/stdc++.h>
using namespace std;
struct ListNode{
    int val;
    struct ListNode *next;
    ListNode(int x):
            val(x), next(nullptr){}
};
ListNode* Reverse(ListNode *head){
    if(!head || !head->next) return head;
    ListNode *pre = nullptr, *cur = head;
    while(cur){
        auto next = cur->next;
        cur->next = pre;
        pre = cur;
        cur = next;
    }
    return pre;
}
int main(){
    vector<int> nums;
    int x;
    while(cin >> x){
        nums.push_back(x);
        if (cin.get() == '\n')//如果是回车符则跳出循环
            break;
    }
    ListNode *dummy = new ListNode(-1);
    dummy->next = NULL;
    ListNode *pre = dummy;
    for(int i = 0; i < nums.size(); i++){
        ListNode *p = new ListNode(nums[i]);
        p->next = NULL;
        pre->next = p;
        pre = p;
    }
    auto head = Reverse(dummy->next);
    for(auto p = head; p; p = p->next)
        cout << p->val << ' ';
    return 0;
}

扩展：合并两个有序链表

#include <bits/stdc++.h>
using namespace std;
struct ListNode{
    int val;
    struct ListNode *next;
    ListNode(int x):
            val(x), next(nullptr){}
};
ListNode* merge(ListNode* l1, ListNode* l2) {
    ListNode *dummy = new ListNode(0);
    ListNode *cur = dummy;
    while (l1 != NULL && l2 != NULL) {
        if (l1 -> val < l2 -> val) {
            cur -> next = l1;
            l1 = l1 -> next;
        }
        else {
            cur -> next = l2;
            l2 = l2 -> next;
        }
        cur = cur -> next;
    }
    cur -> next = (l1 != NULL ? l1 : l2);
    return dummy -> next;
}
ListNode* create(vector<int> &nums){
    ListNode *dummy = new ListNode(-1);
    dummy->next = NULL;
    ListNode *pre = dummy;
    for(int i = 0; i < nums.size(); i++){
        ListNode *p = new ListNode(nums[i]);
        p->next = NULL;
        pre->next = p;
        pre = p;
    }
    return dummy->next;
}
int main(){
    vector<int> nums1;
    vector<int> nums2;
    int x;
    while(cin >> x){
        nums1.push_back(x);
        if (cin.get() == '\n')//如果是回车符则跳出循环
            break;
    }
    int t;
    while(cin >> t){
        nums2.push_back(t);
        if (cin.get() == '\n')//如果是回车符则跳出循环
            break;
    }
    ListNode *l1 = create(nums1);
    ListNode *l2 = create(nums2);
    auto head = merge(l1, l2);
    for(auto p = head; p; p = p->next)
        cout << p->val << ' ';
    return 0;
}

1 6 12 18
3 5 9 20
=> 1 3 5 6 9 12 18 20
  1. 无序数组，二分查找（字节客户端）
    动态二维数组的定义：
    vector<vector<int>> a(nums.size(),vector<int>(2));
    返回行数：a.size()
    返回列数：a[0].size()
    用二维数组保存原数组的值和下标
#include <bits/stdc++.h>
using namespace std;

int main(){
    vector<int> nums = {3,1,2,5,6,4,4};
    int k = 3;
    vector<vector<int>> a(nums.size(),vector<int>(2));
    for(int i = 0; i < nums.size(); i++){
        a[i][0] = nums[i];
        a[i][1] = i;
    } 
    sort(a.begin(), a.end());
    int l  = 0, r = a.size()-1;
    while(l < r){
        int mid = l + r >> 1;
        if(a[mid][0] < k) l = mid+1;
        else r = mid;
    }
    cout << a[l][1]+1;
    return 0;
}
  1. 判断给定的链表中是否有环
    扩展：
    你能给出空间复杂度的解法么？
    思路： 参考链表环的第一个入口结点，快慢指针第一次能相遇，一定有环
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool hasCycle(ListNode *head) {
        if(!head || !head->next) return 0;
        auto i = head, j = head;
        while(i && j){
            i = i->next;
            j = j->next;
            if(j) j = j->next;
            if(i == j){
                return 1;
            }
        }
        return 0;
    }
};

3-2 环的入口结点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
       if(!head || !head->next) return 0;
       auto i = head, j = head;
       while(i && j){
           i = i->next;
           j = j->next;
           if(j) j = j->next;
           if(i == j){
               i = head; 
               while(i != j){
                   i = i->next;
                   j = j->next;
               }
               return i;
           }
       }
       return NULL; 
    }
};
  1. 合并两个有序链表
    将两个有序的链表合并为一个新链表，要求新的链表是通过拼接两个链表的节点来生成的。
/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */

class Solution {
public:
    /**
     * 
     * @param l1 ListNode类 
     * @param l2 ListNode类 
     * @return ListNode类
     */
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        // write code here
        if(!l1) return l2;
        if(!l2) return l1;
        auto dummy = new ListNode(-1), tail = dummy;
        while(l1 && l2){
            if(l1->val < l2->val) tail = tail->next = l1, l1=l1->next;
            else tail = tail->next = l2, l2=l2->next;
        }
        if(l1) tail->next = l1;
        if(l2) tail->next = l2;
        return dummy->next;
    }
};
  1. 寻找第K大
    有一个整数数组，请你根据快速排序的思路，找出数组中第K大的数。
    给定一个整数数组a,同时给定它的大小n和要找的K(K在1到n之间)，请返回第K大的数，保证答案存在。
测试样例：
[1,3,5,2,2],5,3
返回：2

class Finder {
public:
    int q_sort(vector<int> q, int l, int r, int k){
        if(l >= r) return q[l];
        int i = l-1, j =r+1, x = q[l+r>>1]; 
        while(i < j){
            do i++; while(q[i] > x);
            do j--; while(q[j] < x);
            if(i < j) swap(q[i], q[j]);
        }
        if(j-l+1 >= k) return q_sort(q, l, j, k);
        else return q_sort(q,j+1, r,k-(j-l+1));
    }
    int findKth(vector<int> a, int n, int K) {
        // write code here
        return q_sort(a, 0, n-1, K);
    }
};
  1. 两个链表生成相加链表
    假设链表中每一个节点的值都在 0 - 9 之间，那么链表整体就可以代表一个整数。
    给定两个这种链表，请生成代表两个整数相加值的结果链表。
    例如：链表 1 为 9->3->7，链表 2 为 6->3，最后生成新的结果链表为 1->0->0->0。
示例1
输入
[9,3,7],[6,3]
输出
{1,0,0,0}

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */

class Solution {
public:
    /**
     * 
     * @param head1 ListNode类 
     * @param head2 ListNode类 
     * @return ListNode类
     */
    ListNode* Reverse(ListNode *head){
        ListNode *pre = NULL, *cur = head;
        while(cur){
            auto next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
    }
    ListNode* addInList(ListNode* head1, ListNode* head2) {
        // write code here
        auto l1 = Reverse(head1);
        auto l2 = Reverse(head2);
        ListNode *dummy = new ListNode(-1), *cur = dummy;  // dummy为虚拟头结点，cur指向和链表的尾结点
        int t = 0;  // 进位
        while(l1 || l2 || t){  // 某一个链表不为空或进位不为0，一直做
            if(l1) t += l1->val, l1 = l1->next;
            if(l2) t += l2->val, l2 = l2->next;
            cur->next = new ListNode(t % 10);
            t /= 10;
            cur = cur->next;
        }
        return Reverse(dummy->next);  // 返回和链表真正的头结点
    }
};
  1. 字符串转整数（字节开发）
class Solution {
public:
    int myAtoi(string str) {
        // 删掉空白字符
        int k = 0;
        while(k < str.size() && str[k] == ' ') k++;
        if(k == str.size()) return 0;  // 空白字符串

        // 判断正负号，minus默认为正
        int minus = 1;
        if(str[k] == '-') minus = -1, k++;
        else if(str[k] == '+') k++;

        // 转换为整数
        long long res = 0;
        while(k < str.size() && str[k] >= '0' && str[k] <= '9'){
            res = res * 10 + str[k] - '0';
            k++;
            if(res > INT_MAX) break;  // 超出范围，终止
        }

        // 判断溢出
        res *= minus;
        if(res > INT_MAX) res = INT_MAX;
        if(res  < INT_MIN) res = INT_MIN;
        return res;
    }
};
  1. 摆动序列 leetcode 376 （字节测试）

如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为摆动序列。第一个差（如果存在的话）可能是正数或负数。少于两个元素的序列也是摆动序列。
例如， [1,7,4,9,2,5] 是一个摆动序列，因为差值 (6,-3,5,-7,3) 是正负交替出现的。相反, [1,4,7,2,5] 和 [1,7,4,5,5] 不是摆动序列，第一个序列是因为它的前两个差值都是正数，第二个序列是因为它的最后一个差值为零。
给定一个整数序列，返回作为摆动序列的最长子序列的长度。 通过从原始序列中删除一些（也可以不删除）元素来获得子序列，剩下的元素保持其原始顺序。

示例 1:

输入: [1,7,4,9,2,5]
输出: 6 
解释: 整个序列均为摆动序列。
示例 2:

输入: [1,17,5,10,13,15,10,5,16,8]
输出: 7
解释: 这个序列包含几个长度为 7 摆动序列，其中一个可为[1,17,10,13,10,16,8]。
示例 3:

输入: [1,2,3,4,5,6,7,8,9]
输出: 2
谁陪你落日流年
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2021年阿里+美团+腾讯+字节秋招面试题总结，本人已成功入职美团！
weixin_53184798的博客
08-04 264
前言 本人21届渣硕，也算国互联网大部分都面过了，答应群友发一下面经，非互联网和小厂就不发了，有些面完就发到牛客了所以会详细一点，有些面完没记录可能存在遗漏，大家酌情参考。 腾讯（后端） 一面（30分钟） TCP三次握手四次挥手 及状态转移过程 Http和Https的区别 主要S的过程 算法题：求最大质因数 redis的数据结构和具体实现方法 i++语句 系统实现过程 ACID和隔离级别 算法题：链表判断环及求环的位置 二面（40分钟） 聊项目 redis分布式实现原理 三种分布式 以及哨兵模式 一致性ha
人工智能秋招面试题共50题含答案和解析.pdf
04-27
人工智能秋招面试题共50题含答案和解析.pdf 一共50道题 包含答案 包含题目解析 就是会给出答案分析，为什么会选择这个答案
华为秋招面试题整理
weixin_41171614的博客
03-31 1104
华为秋招面试题整理
秋招面试题系列- - -Java工程师（十一）
退役复学在校大学生，目光所至，皆为华夏
10-16 2804
程序分布式的部署在不同的机器上，将程序的配置信息放在 zk的 znode下，当有配置发生改变时，也就是 znode发生变化时，可以通过改变 zk中某个目录节点的内容，利用 watcher通知给各个客户端，从而更改配置。命名服务是指通过指定的名字来获取资源或者服务的地址，利用 zk创建一个全局的路径，这个路径就可以作为一个名字，指向集群中的集群，提供的服务的地址，或者一个远程的对象等等。并携带工作的进度数据，这样汇总的进程可以监控目录子节点的变化获得工作进度的实时的全局情况。
JAVA校园秋招面试题_Java秋招面试题汇总附答案
weixin_36409041的博客
02-24 493
一年一度的秋招即将拉开序幕，又到了大家面试求职的激烈竞争时刻。面试Java开发的求职者要想从众多的优秀者脱颖而出并不容易，因此小编专门汇总了Java秋招面试题并附上答案，希望能让大家在面试前做好更充足的准备。1、hread类的start()和run()方法的区别。答案：start()方法会创建新的线程并启动该线程，所以该方法会调用其他native方法，而run()方法就是：正常的Java方法调用，...
java工程师2024秋招面试题（六）
最新发布
qq__3213559056的博客
05-17 791
多个控制器进程在主节点上运行，但是一起编译为单个进程运行，即Kubernetes控制器管理器。因此，Controller Manager是一个嵌入控制器并执行命名空间创建和垃圾收集的守护程序。它拥有责任并与API服务器通信以管理端点。进程：在操作系统中能够独立运行，并且作为资源分配的基本单位。它表示运行中的程序。系统运行一个程序就是一个进程从创建、运行到消亡的过程。魔数: 确定这个文件是否为一个能被虚拟机接收的 Class 文件。Class 文件版本 ：Class 文件的版本号，保证编译正常执行。
秋招面试题系列- - -Java 工程师（一）
热门推荐
退役复学在校大学生，目光所至，皆为华夏
08-15 11万+
内容涵盖：Java、MyBatis、ZooKeeper、Dubbo、Elasticsearch、Memcached、Linux等技术栈。
android秋招面试题及答案,2021中国移动秋招面试试题附答案（1）
weixin_33669473的博客
05-31 538
【导语】1.为什么将持续经营作为会计假设？请简述持续经营的意义。>>>查看答案<<<1.【答题要点】持续经营是指企业或会计主体的生产经营活动将无限期地延续下去，在可预见的未来，不会进行破产清算。为了使会计核算中使用的会计处理方法保持稳定，保证企业会计记录和会计报表真实可靠，因此，《企业会计准则》规定：“企业会计确认、计量和报告应当以持续经营为前提。”持续经营具有...
阿里和CVTE秋招面试题
技术宅的博客
12-17 4991
从大神那借鉴来的面试题,大神的博客：我没有三颗心脏 CVTE一面 30分钟（挂） 1.自我介绍 2.有没有做过JavaWeb相关的项目？你觉得难点在哪里呢？ 3.你这个博客系统有没有加权限系统？如果被拦截封包获取了账号密码怎么办？（没加，凉拌..） 4.用过事务吗？怎么用的举一个实际的例子？ 5.Spring中的@Transactional放在类级别和方法级别上有什么不同？（不知道..） 6....
非常6！Python精选秋招面试题！
Oner.wv的专栏
08-13 138
Github上面有很多很多经典的项目，最近看到了一个关于面试题的项目，作者 kenwoodjw 准备了 200+道Python面试题，以问答形式展开，大部分问题都包含了对应解决方案与代...
2021年秋招面试真题以及面试技巧分享
zhang09090606的博客
11-10 1513
一、前言 先介绍下自己吧，20届二本院校毕业，java岗，大四上开始实习，毕业一年，两年工作经验，今年秋招也是因为一些原因打算换份工作，我是10月初投的简历，boss投了60多家，面试7家，五家谈offer，一家因为不合适直接放弃了，最终选择是阿里，趁工作交接的空档期总结下整个面试经历吧，方便以后自己看，也是希望帮助到其他人 二、面试时间选择 面试时间选择真的很重要，金三银四，金九银十真的不是没有道理的，可以在三月份和九月份早一些开始投，如果是社招工作一段时间了在年前一个月也是可以的，竞争会小一些，作
2021年数据库秋招面试题常考_数据库考试选择题
11-30
本人2021年数据库秋招面试题个人总结，包括mysql引擎、分库分表、三大范式、覆盖/回表查询、数据库锁等，涵盖大中厂面试题，答案仅供参考。
Javaq备战秋招面试题-重点学习笔记.zip
09-03
备战秋招Java开发工程师实习的面试题学习笔记整理，全部是重点，背好十分有用！
java秋招面试资源
08-05
java面试题 操作系统面试题 计算机网络面试题 数据库面试题 各种面经
2021届秋招面试笔记
10-15
本人博客《2021届秋招面试笔记》资源（https://blog.csdn.net/qq_20247283/article/details/109092804），这是本人在秋招时遇到的一些面试题，还有一些很偏的没做记录。
2021 华为秋招笔试题
weixin_42906066的博客
09-09 3405
题目描述： 学校有一个在线学习系统，没门课程由N个页面组成（0< N<= 10000）个页面组成，学生从第一页开始按顺序学到最后一页提交学习记录。 系统会记录每页停留的时间（单位秒），当学生提交时会分析时间是否满足要求，分析规则如下： 每分钟（60秒）之内学完的页面不能大于4页。 例如系统记录到某学生页面停留时间如下： 10 120 10 20 10 10 50 该学生第一分钟学完1页，第二分钟学完0页，第三分钟学完5页，第四分钟学完1页，则判定为不满足要求。 输入描述： 输入数据包含多个学生的
2019深信服笔试
weixin_42906066的博客
08-29 1453
2019深信服春招笔试 汇总 4. 一个长方体，长宽高分别为x,y,z，都为自然数。现在要把若干个相同的长方体摆成高为N的一根柱形体。每层摆1个，如果两种摆法的高度是一样的，则认为这两种摆法等价，所以每层只有三种摆法。求一共有多少种摆法。 输入描述: 第一行为一个数字N，N>=1且N<=100，表示要摆放的高度 第二行为长方体的长宽高,x、y、z都为无符号整数，按升序排列。 输出描述: 摆法总数，已知该总数会小于10000000 输入例子1: 10 5 6 7 输出例子1: 1 #inc
百度2019校招笔试题
weixin_42906066的博客
09-02 575
百度2019校招笔试题 1. 探险安排 小明要为n个人计划一次火星的探险，其中一个重要的任务是为每个参与者安排食物。仓库里面有m个能用一天的食物包裹，每个食物包裹有不同的类型ai。每个人每天必须用且只能用一个食物包裹。由于某些原因，在整个过程中，每个人只能用同一种类型的食物包裹，但是不同的人用的食物包裹可以不一样。 给出人数以及食物包裹的情况，请你求出这趟探险最多可以持续多少天。 输入描述: 第一行两个整数，n和m，表示人数和食物包裹的个数。第二行m个整数，表示每个食物包裹的类型。满足1 <= n &
跳台阶问题汇总
weixin_42906066的博客
05-16 202
1. 跳台阶 题目描述 一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。 分析： 递推公式如下： f(n)={1n=12n=2f(n−1)+f(n−2)n>2f(n)=\left\{\begin{array}{cc}1 & n=1 \\ 2 & n=2 \\ f(n-1)+f(n-2) & n>2\end{array}\right.f(n)=⎩⎨⎧​12f(n−1)+f(n−2)​n=1n=2n&gt
c/c++秋招面试题
07-29
关于C/C++的秋招面试题，我可以提供一些常见的问题供你参考： 1. C和C++的区别是什么？ 2. 什么是指针，指针有什么作用？ 3. 什么是内存泄漏？如何避免内存泄漏？ 4. 解释一下const关键字的作用。 5. 什么是虚函数...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值