面试和签约和解约和离职

本文献给跟我一样虽然屁都不会但是谜一样的自信地投了软开岗位的旁友们

希望我们都能获得尘世间的幸福

笔试题和面试题准备

茴字有几种写法(排序啦是排序

参考Boblim的博客
| 排序方法 | 时间复杂度(平均) | 空间复杂度 | 稳定性 | 原理 |
| :——: | :—————-: | :——–: | :—-: | :———————————————————– |
| 冒泡 | O(n²) | O(1) | 稳定 | 在扫描过程中两两比较相邻记录,如果反序则交换,最终,最大记录就被“沉到”了序列的最后一个位置,第二遍扫描将第二大记录“沉到”了倒数第二个位置,重复上述操作,直到n-1 遍扫描后,整个序列就排好序了。 |
| 插入 | O(n²) | O(1) | 稳定 | 对于一个数组A[0,n]的排序问题,假设认为数组在A[0,n-1]排序的问题已经解决了。 考虑A[n]的值,从右向左扫描有序数组A[0,n-1],直到第一个小于等于A[n]的元素,将A[n]插在这个元素的后面。 |
| 归并 | O(nlogn) | O(n) | 稳定 | 采用经典的分治(divide-and-conquer)策略(分治法将问题(divide)成一些小的问题然后递归求解,而治(conquer)的阶段则将分的阶段得到的各答案”修补”在一起,即分而治之)。 |
| | | | | |
| 选择 | O(n²) | O(1) | 不稳定 | 初始时在序列中找到最小(大)元素,放到序列的起始位置作为已排序序列;然后,再从剩余未排序元素中继续寻找最小(大)元素,放到已排序序列的末尾。以此类推,直到所有元素均排序完毕。 |
| 希尔 | O(nlogn) | O(1) | 不稳定 | 希尔排序也是一种插入排序,它是简单插入排序经过改进之后的一个更高效的版本,也称为缩小增量排序,把记录按下标的一定增量分组,对每组使用直接插入排序算法排序;随着增量逐渐减少,每组包含的关键词越来越多,当增量减至1时,整个文件恰被分成一组,算法便终止。 |
| 堆排 | O(nlogn) | O(1) | 不稳定 | 利用堆的性质来进行排序的 |
| 快排 | O(nlogn) | O(nlogn) | 不稳定 | 选一个数作为基准,双指针分别从前后两端遍历数组,当后指针比基准小且前指针比基准大时交换,直到相遇。把相遇位置的数与基准数做交换,继续快排二分后的两个数组。 |

稳定:如果a原本在b前面,而a=b,排序之后a仍然在b的前面。

不稳定:如果a原本在b的前面,而a=b,排序之后 a 可能会出现在 b 的后面。

时间复杂度:对排序数据的总的操作次数。反映当n变化时,操作次数呈现什么规律。

空间复杂度:是指算法在计算机内执行时所需存储空间的度量,它也是数据规模n的函数。

冒泡应该是讲的最多的?底下有个大概示意

int i , j;

for (i = 0; i < len; i++){

​ for (j = 0; j < len - i -1; j++){

​ if (arr[j+1] < arr[j]){

​ swap(arr[j], arr[j+1]); } }}

理解了冒泡那么插入和选择也都很好理解和记忆

稍微进阶一点的记住快排的原理和实现

要点是选一个 前后各一个指针和它比大小

class Solution {

public:

void sort(vector& nums, int start, int end){

​ if (start > end){

​ return; }

​ int temp = nums[start];

​ int i = start;

​ int j = end;

​ while (i != j){

​ while (nums[j] >= temp && i < j){

​ j–; }

​ while (nums[i] <= temp && i < j){

​ i++; }

​ if (i < j){

​ int p = nums[i];

​ nums[i] = nums[j];

​ nums[j] = p; }

​ }

​ nums[start] = nums[i];

​ nums[i] = temp;

​ sort(nums,start,i-1);

​ sort(nums,i+1,end);

}

vector sortArray(vector& nums) {

​ int start = 0;

​ int end = nums.size()-1;

​ sort(nums,start,end);

​ return nums;

}

};

堆排也很重要但是我没记住(ntm

一个非常简陋的时间和空间复杂度计算方法

时间复杂度: 一层for循环就是n的一次方,两层嵌套就是n²,只算最高次的。用了二分法的就跟log有关系。

空间复杂度:用了额外空间就不是O(1)了,具体多少就看开了多少内存。

数据结构

数组和链表的区别

数组的内存空间是连续的,链表在内存空间内是离散的

栈、堆和队列

两个栈做一个队列

两个队列做一个栈

树、堆、二叉树

不记得了等我再看看

哈希表的原理

这玩意我觉得非常之坑,用起来稀里糊涂的,但是消除时间复杂度又很好用显得你很专业

例题:Two Sum

class Solution {

public:

vector twoSum(vector& nums, int target) {
​ map<int,int> mp;
​ vector a(2,-1);
​ int i = 0;

​ for (i = 0; i < nums.size(); i++){
​ mp.insert(pair<int,int>(nums[i],i));

​ if ((mp.count(target - nums[i]) > 0) && (mp[target-nums[i]]) != i){
​ a[1] = i;
​ a[0] = mp[target-nums[i]];
​ }

​ }
​ return a;
}
};

例题:LRU缓存机制

class LRUCache {

public:

struct CacheNode {
​ int key;
​ int value;
​ CacheNode *pre, *next;
​ CacheNode(int key, int value): key(key),value(value),pre(NULL),next(NULL){}
};

map<int, CacheNode*> mp;
CacheNode *head, *tail;
int size;

LRUCache(int capacity) {
​ size = capacity;
​ head = NULL;
​ tail = NULL;
}

void remove(CacheNode* p){
​ if (p->pre != NULL) {
​ p->pre->next = p->next;
​ } else {
​ head = p->next;
​ }
​ if (p->next != NULL) {
​ p->next->pre = p->pre;
​ } else {
​ tail = p->pre;
​ }
}

void setHead(CacheNode*p){
​ p->next = head;
​ p->pre = NULL;
​ if (head != NULL){
​ head->pre = p;
​ }
​ head = p;
​ if (tail == NULL){
​ tail = head;
​ }
}

int get(int key) {
​ map<int,CacheNode>::iterator it = mp.find(key);
​ if (it != mp.end()){
​ CacheNode
p = it->second;
​ remove(p);
​ setHead(p);
​ return p->value;
​ } else {
​ return -1;
​ }
}

void put(int key, int value) {
​ map<int,CacheNode>::iterator it = mp.find(key);
​ if (it != mp.end()){
​ CacheNode
p = it->second;
​ p->value = value;
​ remove(p);
​ setHead(p);
​ } else {
​ CacheNode q = new CacheNode(key,value);
​ if(mp.size() >= size){
​ map<int,CacheNode
>::iterator it2 = mp.find(tail->key);
​ remove(tail);
​ mp.erase(it2);
​ }
​ setHead(q);
​ mp[key] = q;
​ }
}
};

编程基础

多态
虚函数
闭包:java里的概念

操作系统

进程和线程:一个进程可能包括多个线程
进程之间通信:socket;队列;

网络

写了单独的po

算法

算法导论

tbc

签约和三方协议

三方协议是什么

三方协议不是劳动协议,签了不去或者对面不想要你,各自赔钱就行。
三方协议相比两方对学生的约束更大,对于企业……
反正对于大企业还是小毛毛雨(。2019届的企业方大规模毁约的事件应该还挺容易搜索到的

三方协议保证学生权益吗?

虽然最初的目的是为了保护学生,但是目前来看还是偏向企业……

毁约和毁约流程

首先你需要一个耐心等待的下家

然后你需要递交毁约申请连同毁约金一起递给上家

这一步会比较恶心……首先是你的上家可能会卡时间,其次是你的学校为了就业率可能卡你
找学校就业办的老师或是学院负责相关事务的辅导员签字和盖章
所以有一个好说话的辅导员或是平时就和辅导员搞好关系很重要
另外由于学校就业率以及和企业的良好关系的角度出发,你最好有下家并且下家和上家没有明显竞争关系

接着你需要拿到你上家开出的毁约证明或者旧的三方

好啦,现在你可以到学校申请新三方啦

离职

离职手续

沟通离职时间,然后提申请

离职证明

离职当天领

档案社保和公积金

沟通清楚公司交到哪一天,以及是自行办理后续转出还是公司统一办理。

# 杂谈

Comentarios

Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×