总结
面试建议是,一定要自信,敢于表达,面试的时候我们对知识的掌握有时候很难面面俱到,把自己的思路说出来,而不是直接告诉面试官自己不懂,这也是可以加分的。
以上就是蚂蚁技术四面和HR面试题目,以下最新总结的最全,范围包含最全MySQL、Spring、Redis、JVM等最全面试题和答案,仅用于参考
int N = (int)pow(2, h) - 1;//与该二叉树深度相同的满二叉树的结点总数
int space = N - 1;//记录每一行前面的空格数
int row = 1;//当前打印的行数
int pos = 0;//待打印数据的下标
while (1)
{
//打印前面的空格
int i = 0;
for (i = 0; i < space; i++)
{
printf(" ");
}
//打印数据和间距
int count = (int)pow(2, row - 1);//每一行的数字个数
while (count–)//打印一行
{
printf(“%02d”, php->a[pos++]);//打印数据
if (pos >= php->size)//数据打印完毕
{
printf(“\n”);
return;
}
int distance = (space + 1) * 2;//两个数之间的空格数
while (distance–)//打印两个数之间的空格
{
printf(" ");
}
}
printf(“\n”);
row++;
space = space / 2 - 1;
}
}
堆的插入
数据插入时是插入到数组的末尾,即树形结构的最后一层的最后一个结点,所以插入数据后我们需要运用堆的向上调整算法对堆进行调整,使其在插入数据后仍然保持堆的结构。
//堆的插入
void HeapPush(HP* php, HPDataType x)
{
assert(php);
if (php->size == php->capacity)
{
HPDataType* tmp = (HPDataType*)realloc(php->a, 2 * php->capacity*sizeof(HPDataType));
if (tmp == NULL)
{
printf(“realloc fail\n”);
exit(-1);
}
php->a = tmp;
php->capacity *= 2;
}
php->a[php->size] = x;
php->size++;
//向上调整
AdjustUp(php->a, php->size - 1);
}
堆的删除
堆的删除,删除的是堆顶的元素,但是这个删除过程可并不是直接删除堆顶的数据,而是先将堆顶的数据与最后一个结点的位置交换,然后再删除最后一个结点,再对堆进行一次向下调整。
原因:我们若是直接删除堆顶的数据,那么原堆后面数据的父子关系就全部打乱了,需要全体重新建堆,时间复杂度为 O ( N ) 。若是用上述方法,那么只需要对堆进行一次向下调整即可,因为此时根结点的左右子树都是小堆,我们只需要在根结点处进行一次向下调整即可,时间复杂度为 O ( log ( N ) ) 。
//堆的删除
void HeapPop(HP* php)
{
assert(php);
assert(!HeapEmpty(php));
Swap(&php->a[0], &php->a[php->size - 1]);//交换堆顶和最后一个结点的位置
php->size–;//删除最后一个结点(也就是删除原来堆顶的元素)
AdjustDown(php->a, php->size, 0);//向下调整
}
获取堆顶的数据
获取堆顶的数据,即返回数组下标为0的数据。
//获取堆顶的数据
HPDataType HeapTop(HP* php)
{
assert(php);
assert(!HeapEmpty(php));
return php->a[0];//返回堆顶数据
}
获取堆的数据个数
获取堆的数据个数,即返回堆结构体中的size变量。
//获取堆中数据个数
int HeapSize(HP* php)
{
assert(php);
return php->size;//返回堆中数据个数
}
堆的判空
堆的判空,即判断堆结构体中的size变量是否为0。
//堆的判空
bool HeapEmpty(HP* php)
{
assert(php);
return php->size == 0;//判断堆中数据是否为0
}
3.3 堆的应用
3.3.1 堆排序
堆排序即利用堆的思想来进行排序,总共分为两个步骤:
- 建堆
- 排升序:建大堆
- 排降序:建小堆
- 利用堆删除思想来进行排序
建堆和堆删除中都用到了向下调整,因此掌握了向下调整,就可以完成堆排序。
以排升序(建大堆)为例:
1.先利用向下调整法建堆:
//建堆(大堆)
for (int i = (n - 1 - 1) / 2; i >= 0; i–)
{
AdjustDown(php->a, php->size, i);
}
2.再利用堆删除思想来进行排序:
步骤如下:
1、将堆顶数据与堆的最后一个数据交换,然后对根位置进行一次堆的向下调整,但是调整时被交换到最后的那个最大的数不参与向下调整。
2、完成步骤1后,这棵树除最后一个数之外,其余数又成一个大堆,然后又将堆顶数据与堆的最后一个数据交换,这样一来,第二大的数就被放到了倒数第二个位置上,然后该数又不参与堆的向下调整…反复执行下去,直到堆中只有一个数据时便结束。此时该序列就是一个升序。
实例:
将下面这组数先建大堆,再排升序
动图演示:(动图来自菜鸟网站->堆排序)
堆排序代码:
//堆排序
void HeapSort(int* a, int n)
{
//排升序,建大堆
//从第一个非叶子结点开始向下调整,一直到根
int i = 0;
for (i = (n - 1 - 1) / 2; i >= 0; i–)
{
AdjustDown(a, n, i);
}
int end = n - 1;//记录堆的最后一个数据的下标
while (end)
{
Swap(&a[0], &a[end]);//将堆顶的数据和堆的最后一个数据交换
AdjustDown(a, end, 0);//对根进行一次向下调整
end–;//堆的最后一个数据的下标减一
}
}
时间复杂度: O ( N l o g N ) 空间复杂度: O ( 1 )
3.3.2 TOP-K问题
TOP-K问题:即求数据集合中前K个最大的元素或者最小的元素,一般情况下数据量都比较大。
比如:专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等
我们从时间和空间的角度逐步来看:
假设当前我们输入数组
arr[2,7,4,6,2,3,9,8]
,找出其中最大的k
个数。
例如,将k设为4,则在这8个数字中,最大的
k
个数是6、7、8 、9。
这就是所谓的TOP-K问题
角度一
对于Top-K问题,能想到的最简单直接的方式就是排序,利用时间复杂度较低的堆排序将数组排为降序,然后输出前k个数就可以了
代码:
//交换函数
void Swap(int* x, int* y)
{
int tmp = *x;
*x = *y;
*y = tmp;
}
//堆的向下调整(小堆)
void AdjustDown(int* a, int n, int parent)
{
//child记录左右孩子中值较小的孩子的下标
int child = 2 * parent + 1;//先默认其左孩子的值较小
while (child < n)
{
if (child + 1 < n&&a[child + 1] < a[child])//右孩子存在并且右孩子比左孩子还小
{
child++;//较小的孩子改为右孩子
}
if (a[child] < a[parent])//左右孩子中较小孩子的值比父结点还小
{
//将父结点与较小的子结点交换
Swap(&a[child], &a[parent]);
//继续向下进行调整
parent = child;
child = 2 * parent + 1;
}
else//已成堆
{
break;
}
}
}
int* getLeastNumbers(int* arr, int arrSize, int k, int* returnSize)
{
*returnSize = k;
int i = 0;
//建小堆
for (i = (arrSize - 1 - 1) / 2; i >= 0; i–)
{
AdjustDown(arr, arrSize, i);
}
//排降序
int end = arrSize - 1;
while (end > 0)
{
Swap(&arr[0], &arr[end]);
AdjustDown(arr, end, 0);
end–;
}
//将最大的k个数存入数组
int* retArr = (int*)malloc(sizeof(int)*k);
for (i = 0; i < k; i++)
{
retArr[i] = arr[i];
}
return retArr;//返回最大的k个数
}
时间复杂度: O ( N + N l o g N )
【建堆为N,向下调整一次为log N,调整N次为NlogN,所以时间复杂度为O ( N + N l o g N ) 】
空间复杂度: O ( N )
————————————————
角度二
在角度一的基础上,我们可不可以将时间复杂度再降低一些?
我们可以将数组建成一个大堆,因为堆顶的元素最大,所以我们取k次堆顶的元素就可以实现要求了,即把N个数建堆,取出前k个
注意:
1.取出数据后要让其与最后的元素替换,因为你已经取出这个元素了,所以不需要它了,这时让它去堆尾,不让它算入堆的个数中就行了。
2. 如果在取到堆顶数据后直接删除数据,那么就要重新建堆了。正确的做法应该是上面所说的方法,因为那样只要进行一次向下调整,就可以保证堆的结构了。要知道建堆的复杂度为O(N),而一次向下调整的复杂度仅为O(logn),这样大大提升了效率。
代码:
//交换函数
void Swap(int* x, int* y)
{
int tmp = *x;
*x = *y;
*y = tmp;
}
//堆的向下调整(大堆)
void AdjustDown(int* a, int n, int parent)
{
//child记录左右孩子中值较大的孩子的下标
int child = 2 * parent + 1;//先默认其左孩子的值较大
while (child < n)
{
if (child + 1 < n&&a[child + 1] > a[child])//右孩子存在并且右孩子比左孩子还大
{
child++;//较大的孩子改为右孩子
}
if (a[child] > a[parent])//左右孩子中较大孩子的值比父结点还大
{
//将父结点与较大的子结点交换
Swap(&a[child], &a[parent]);
//继续向下进行调整
parent = child;
child = 2 * parent + 1;
}
else//已成堆
{
break;
}
}
}
int* getLeastNumbers(int* arr, int arrSize, int k, int* returnSize)
{
*returnSize = k;
int i = 0;
//建大堆
for (i = (arrSize - 1 - 1) / 2; i >= 0; i–)
{
AdjustDown(arr, arrSize, i);
}
//将最大的k个数存入数组
int* retArr = (int*)malloc(sizeof(int)*k);
int end = arrSize - 1;
for (i = 0; i < k; i++)
{
retArr[i] = arr[0];//取堆顶数据
Swap(&arr[0], &arr[end]);//交换堆顶数据与最后一个数据
//进行一次向下调整,不把最后一个数据看作待调整的数据,所以待调整数据为end=arrSize-1
AdjustDown(arr, end, 0);
end–;//最后一个数据的下标改变
}
return retArr;//返回最大的k个数
}
时间复杂度:O(N+klogN)
空间复杂度:O(N)
角度三
如果数据量非常大,将会占用的内存是巨大的,上面的排序就不太可取了。
我们可以用下面的方法:
- 用数据集合中前K个元素来建堆
- 前k个最大的元素,则建小堆
- 前k个最小的元素,则建大堆
- 用剩余的N-K个元素依次与堆顶元素来比较,不满足则替换堆顶元素
我们以找出最大的k个数为例:先建一个k个数的小堆,然后将数组中n-k个元素依次与堆顶的元素比较,若比堆顶元素大,则把堆顶元素换为该元素,然后再进行一次向下调整,使其仍为小堆。那么问题来了,为什么不用大堆呢,其实这很容易理解,如果建一个大堆,万一堆顶的数据就是我们所求的k个数中的一个,那么我们所求的k个数中比它小的数就永远不可能入堆,因此要用小堆来解决这个问题。
代码:
//交换函数
void Swap(int* x, int* y)
{
int tmp = *x;
*x = *y;
*y = tmp;
}
//堆的向下调整(小堆)
void AdjustDown(int* a, int n, int parent)
{
//child记录左右孩子中值较小的孩子的下标
int child = 2 * parent + 1;//先默认其左孩子的值较小
while (child < n)
{
if (child + 1 < n&&a[child + 1] < a[child])//右孩子存在并且右孩子比左孩子还小
{
child++;//较小的孩子改为右孩子
}
if (a[child] < a[parent])//左右孩子中较小孩子的值比父结点还小
{
//将父结点与较小的子结点交换
Swap(&a[child], &a[parent]);
//继续向下进行调整
parent = child;
child = 2 * parent + 1;
}
else//已成堆
{
break;
}
}
}
int* getLeastNumbers(int* arr, int arrSize, int k, int* returnSize)
{
*returnSize = k;
if (k == 0)
return NULL;
//用数组的前K个数建小堆
int i = 0;
int* retArr = (int*)malloc(sizeof(int)*k);
for (i = 0; i < k; i++)
{
retArr[i] = arr[i];
}
for (i = (k - 1 - 1) / 2; i >= 0; i–)
{
AdjustDown(retArr, k, i);
}
//剩下的N-k个数依次与堆顶数据比较
for (i = k; i < arrSize; i++)
{
if (arr[i]>retArr[0])
{
retArr[0] = arr[i];//堆顶数据替换
}
AdjustDown(retArr, k, 0);//进行一次向下调整
}
return retArr;//返回最大的k个数
}
时间复杂度:O(k+n*logk)
空间复杂度:O(n)
与之前两种方法对比,这种方法大大提高了效率。
链式二叉树,那必须得有自己的结点类型,以下是链式二叉树结点类型的定义,下面的问题都统一使用该结点类型。
//二叉树的链式结构
typedef int BTDataType;//结点中存储的元素类型(以int为例)
typedef struct BinaryTreeNode
{
BTDataType data;//结点中存储的元素类型
struct BinaryTreeNode* left;//左指针域(指向左孩子)
struct BinaryTreeNode* right;//右指针域(指向右孩子)
}BTNode;
在学习二叉树的基本操作前,需先要创建一棵二叉树,然后才能学习其相关的基本操作。由于现在大家对二叉树结构掌握还不够深入,此处先手动快速创建一棵简单的二叉树,方便我们学习。
BTNode* BuyNode(BTDataType x)
{
BTNode* node = (BTNode*)malloc(sizeof(BTNode));
node->data = x;
node->left = NULL;
node->right = NULL;
return node;
}
//自建二叉树
BTNode* CreatBinaryTree()
{
BTNode* node1 = BuyNode(‘A’);
BTNode* node2 = BuyNode(‘B’);
BTNode* node3 = BuyNode(‘C’);
BTNode* node4 = BuyNode(‘D’);
BTNode* node5 = BuyNode(‘E’);
BTNode* node6 = BuyNode(‘F’);
BTNode* node7 = BuyNode(‘G’);
node1->left = node2;
node1->right = node3;
node2->left = node4;
node3->left = node5;
node3->right = node6;
node4->left = node7;
return node1;
}
下面的学习以上面自建的二叉树为准
4.1二叉树的深度优先遍历
前序遍历
前序遍历,又叫先根遍历。
遍历顺序:根 -> 左子树 -> 右子树
代码:
//二叉树前序遍历
void PreOrder(BTNode* root) {
if (root == NULL)
{
printf("NULL ");
return;
}
printf("%c ", root->data);
PreOrder(root->left);
PreOrder(root->right);
}
中序遍历
中序遍历,又叫中根遍历。
遍历顺序:左子树 -> 根 -> 右子树
代码:
// 二叉树中序遍历
void InOrder(BTNode* root)
{
if (root == NULL) {
printf("NULL ");
return;
}
InOrder(root->left);
printf("%c ", root->data);
InOrder(root->right);
}
后序遍历
后序遍历,又叫后根遍历。
遍历顺序:左子树 -> 右子树 -> 根
代码:
// 二叉树后序遍历
void PostOrder(BTNode* root)
{
if (root == NULL) {
printf("NULL ");
return;
}
PostOrder(root->left);
PostOrder(root->right);
printf("%c ", root->data);
}
4.2二叉树的广度优先遍历
层序遍历
层序遍历,从左往右逐层访问树的结点的过程就是层序遍历。
设二叉树的根节点所在层数为1,层序遍历就是从所在二叉树的根节点出发,首先访问第一层的树根节点,然后从左到右访问第2层上的节点,接着是第三层的节点,以此类推。
思路(借助一个队列):
借助队列先进先出的性质
1.先把根入队列,然后开始从队头出数据。
2.出队头的数据,把它的左孩子和右孩子依次从队尾入队列(NULL不入队列)。
3.重复进行步骤2,直到队列为空为止。
代码:(自己先写队列及相关功能)
//层序遍历
void BinaryLevelOrder(BTNode* root)
{
Queue q;
QueueInit(&q);//初始化队列
if (root != NULL)
QueuePush(&q, root);
while (!QueueEmpty(&q))//当队列不为空时,循环继续
{
BTNode* front = QueueFront(&q);//读取队头元素
QueuePop(&q);//删除队头元素
printf("%c ", front->data);//打印出队的元素
if (front->left)
{
QueuePush(&q, front->left);//出队元素的左孩子入队列
}
if (front->right)
{
QueuePush(&q, front->right);//出队元素的右孩子入队列
}
}
QueueDestroy(&q);//销毁队列
}
4.3 求节点个数以及高度等
4.3.1求二叉树节点个数
//1、遍历(前序) – 全局变量
int size = 0;
void BinaryTreeSize(BTNode* root)
{
if (root == NULL)
return;
else
++size;
BinaryTreeSize(root->left);
BinaryTreeSize(root->right);
}
int main()
{
BTNode* root = CreatBinaryTree();
//1.全局–缺点:第二次使用(例如查看另一颗树节点个数),size值会继承上一次
BinaryTreeSize(root);
printf(“BinaryTreeSize:%d\n”, size);
BinaryTreeSize(root);
printf(“BinaryTreeSize:%d\n”, size);
}
// 2、遍历(前序) – 局部变量
传参时注意不能使用传值传参
void BinaryTreeSize(BTNode* root, int* psize)
{
if (root == NULL)
return;
else
++(*psize);
BinaryTreeSize(root->left, psize);
BinaryTreeSize(root->right, psize);
}
int main()
{
BTNode* root = CreatBinaryTree();
int size1 = 0;//局部
BinaryTreeSize(root, &size1);
printf(“BinaryTreeSize:%d\n”, size1);
int size2 = 0;//局部
BinaryTreeSize(root, &size2);
printf(“BinaryTreeSize:%d\n”, size2);
}
// 3.分治–利用递归(推荐使用)
int BinaryTreeSize(BTNode* root)
{
return root == NULL ? 0 : 1
-
BinaryTreeSize(root->left)
-
BinaryTreeSize(root->right);
}
int main()
{
BTNode* root = CreatBinaryTree();
BinaryTreeSize(root);
printf(“BinaryTreeSize:%d\n”, BinaryTreeSize(root));
BinaryTreeSize(root);
printf(“BinaryTreeSize:%d\n”, BinaryTreeSize(root));
}
4.3.2二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root)
{
if (root == NULL)//空树无叶子结点
{
return 0;
}
else if (root->left == NULL && root->right == NULL)//是叶子结点
{
return 1;
}
else
{
return BinaryTreeLeafSize(root->left)
- BinaryTreeLeafSize(root->right);
}
}
int main()
{
BTNode* root = CreatBinaryTree();
printf(“BinaryTreeLeafSize:%d\n”, BinaryTreeLeafSize(root));
}
4.3.2二叉树第k层节点个数
思路:
相对于根结点的第k层结点的个数 = 相对于以其左孩子为根的第k-1层结点的个数 + 相对于以其右孩子为根的第k-1层结点的个数。
int BinaryTreeLevelKSize(BTNode* root, int k)
{
if (root == NULL)
return 0;
if (k == 1)
return 1;
return BinaryTreeLevelKSize(root->left, k - 1)
- BinaryTreeLevelKSize(root->right, k - 1);
}
int main()
{
BTNode* root = CreatBinaryTree();
printf(“BinaryTreeLevelKSize:%d\n”, BinaryTreeLevelKSize(root, 4));
}
4.3.3 二叉树深度/高度
核心思想:max(左子树的深度,右子树的深度)+1
int BinaryTreeDepth(BTNode* root)
{
if (root == NULL)
{
return 0;
}
int leftDepth = BinaryTreeDepth(root->left);
int rightDepth = BinaryTreeDepth(root->right);
return leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;
}
int main()
{
BTNode* root = CreatBinaryTree();
printf(“BinaryTreeDepth:%d\n”, BinaryTreeDepth(root));
}
4.3.4 二叉树查找值为x的节点
1.先判断根结点是否是目标结点。
2.再去左子树中寻找。
3.最后去右子树中寻找。
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
if (root == NULL)
return NULL;
if (root->data == x)
return root;
BTNode* retLeft = BinaryTreeFind(root->left, x);
if (retLeft)
{
return retLeft;
}
BTNode* retRight = BinaryTreeFind(root->right, x);
if (retRight)
{
return retRight;
}
return NULL;
}
int main()
{
BTNode* root = CreatBinaryTree();
BTNode* ret = BinaryTreeFind(root, ‘N’);//找 N节点
if (ret)
{
printf(“找到了\n”);
}
总结
虽然面试套路众多,但对于技术面试来说,主要还是考察一个人的技术能力和沟通能力。不同类型的面试官根据自身的理解问的问题也不尽相同,没有规律可循。
上面提到的关于这些JAVA基础、三大框架、项目经验、并发编程、JVM及调优、网络、设计模式、spring+mybatis源码解读、Mysql调优、分布式监控、消息队列、分布式存储等等面试题笔记及资料
有些面试官喜欢问自己擅长的问题,比如在实际编程中遇到的或者他自己一直在琢磨的这方面的问题,还有些面试官,尤其是大厂的比如 BAT 的面试官喜欢问面试者认为自己擅长的,然后通过提问的方式深挖细节,刨根到底。
rightDepth = BinaryTreeDepth(root->right);
return leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;
}
int main()
{
BTNode* root = CreatBinaryTree();
printf(“BinaryTreeDepth:%d\n”, BinaryTreeDepth(root));
}
4.3.4 二叉树查找值为x的节点
1.先判断根结点是否是目标结点。
2.再去左子树中寻找。
3.最后去右子树中寻找。
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
if (root == NULL)
return NULL;
if (root->data == x)
return root;
BTNode* retLeft = BinaryTreeFind(root->left, x);
if (retLeft)
{
return retLeft;
}
BTNode* retRight = BinaryTreeFind(root->right, x);
if (retRight)
{
return retRight;
}
return NULL;
}
int main()
{
BTNode* root = CreatBinaryTree();
BTNode* ret = BinaryTreeFind(root, ‘N’);//找 N节点
if (ret)
{
printf(“找到了\n”);
}
总结
虽然面试套路众多,但对于技术面试来说,主要还是考察一个人的技术能力和沟通能力。不同类型的面试官根据自身的理解问的问题也不尽相同,没有规律可循。
[外链图片转存中…(img-4tgkf226-1715589302525)]
[外链图片转存中…(img-ac02GPvh-1715589302526)]
上面提到的关于这些JAVA基础、三大框架、项目经验、并发编程、JVM及调优、网络、设计模式、spring+mybatis源码解读、Mysql调优、分布式监控、消息队列、分布式存储等等面试题笔记及资料
有些面试官喜欢问自己擅长的问题,比如在实际编程中遇到的或者他自己一直在琢磨的这方面的问题,还有些面试官,尤其是大厂的比如 BAT 的面试官喜欢问面试者认为自己擅长的,然后通过提问的方式深挖细节,刨根到底。