Java岗大厂面试百日冲刺 - 日积月累，每日三题【Day23】—— 算法1

最新推荐文章于 2024-10-01 18:51:18 发布

2401_84412738

最新推荐文章于 2024-10-01 18:51:18 发布

阅读量541

点赞数 9

分类专栏：程序员文章标签： java 面试算法

本文链接：https://blog.csdn.net/2401_84412738/article/details/137935502

版权

程序员专栏收录该内容

310 篇文章 0 订阅

订阅专栏

本文详细解释了快速排序算法的工作原理，包括基准值的选择和分区过程，以及递归的运用。同时讨论了递归的优缺点，并提及了topK问题的解决方案，如使用堆排序。

摘要由CSDN通过智能技术生成

在这里插入图片描述

左边有坑，从右边Arr[R-1]继续匹配，Arr[R-1] = 1，小于基准值，则插入到Arr[L]的坑中；

在这里插入图片描述

右边有坑了，继续从左边取值继续匹配，则取到Arr[L+1] = 9,小于基准值，则忽略并跳过，继续找Arr[L + 1]继续匹配。

在这里插入图片描述

继续从左边坐标 + 1 取值继续匹配，则取到Arr[L] = 17，又小于基准值，则忽略并跳过，继续找Arr[L + 1]继续匹配。

在这里插入图片描述

最后L坐标和R坐标重合了，将Pivot基准值填入

在这里插入图片描述

至此，快速排序第一轮完整流程结束，分出了左右子序列，左边都是小于Pivot基准值的，右边都是大于Pivot基准值的。

在这里插入图片描述

继续对左、右子序列递归进行处理，一直缩小到左、右都是一个值，则快速排序结束，最终得出顺序数组{1,8,9,17,19,97}；中间递归流程这里不再赘述。

在这里插入图片描述

追问2：来吧！给我手敲一个快排

package com.softsec.demo;

/**

Created with IDEA
@Author Chensj
@Date 2020/5/17 19:04
@Description
@Version 1.0

public class quickSortDemo {

public static void main(String[] args) {

// 创建测试数组

int[] arr = new int[]{19,97,9,17,1,8};

System.out.println(“排序前：”);

showArray(arr); // 打印数组

// 调用快排接口

quickSort(arr);

System.out.println(“\n” + “排序后：”);

showArray(arr);// 打印数组

}

/**

快速排序
@param array

public static void quickSort(int[] array) {

int len;

if(array == null

|| (len = array.length) == 0

|| len == 1) {

return ;

}

sort(array, 0, len - 1);

}

/**

快排核心算法，递归实现
@param array
@param left
@param right

public static void sort(int[] array, int left, int right) {

if(left > right) {

return;

}

// base中存放基准数

int base = array[left];

int i = left, j = right;

while(i != j) {

// 顺序很重要，先从右边开始往左找，直到找到比base值小的数

while(array[j] >= base && i < j) {

j–;

}

// 再从左往右边找，直到找到比base值大的数

while(array[i] <= base && i < j) {

i++;

}

// 上面的循环结束表示找到了位置或者(i>=j)了，交换两个数在数组中的位置

if(i < j) {

int tmp = array[i];

array[i] = array[j];

array[j] = tmp;

}

// 将基准数放到中间的位置（基准数归位）

array[left] = array[i];

array[i] = base;

// 递归，继续向基准的左右两边执行和上面同样的操作

// i的索引处为上面已确定好的基准值的位置，无需再处理

sort(array, left, i - 1);

sort(array, i + 1, right);

}

/**

数组打印
@param num

private static void showArray(int[] num) {

for (int i = 0; i < num.length; i++) {

System.out.print(num[i] + " ");

}

在这里插入图片描述

坐标：深圳

作者：對你何止一句钟意

面试题2：来！再给我手撸一个Spring

===================================================================================

我：？？？

追问1：哦，咳咳…说一下构成递归的前提条件有啥？

函数内部调用的自身函数的编程技巧称为递归（recursion）。

构成递归的条件：

子问题须与原始问题为同样的事，且更为简单；
不能无限制地调用本身，须有个出口，化简为非递归状况处理。

追问2：递归都有哪些优缺点？

优点：

简洁
在树的前序，中序，后序遍历算法中，递归的实现明显要比循环简单得多。

缺点：

递归由于是函数调用自身，而函数调用是有时间和空间的消耗的：每一次函数调用，都需要在内存栈中分配空间以保存参数、返回地址以及临时变量，而往栈中压入数据和弹出数据都需要时间。（效率）
递归中很多计算都是重复的，由于其本质是把一个问题分解成两个或者多个小问题，多个小问题存在相互重叠的部分，则存在重复计算，如fibonacci斐波那契数列的递归实现。（效率）
调用栈可能会溢出，其实每一次函数调用会在内存栈中分配空间，而每个进程的栈的容量是有限的，当调用的层次太多时，就会超出栈的容量，从而导致栈溢出。（性能）

追问3：给我手写一个简单的递归算法的实现吧

例如递归计算一下n的阶乘

package com.softsec;

/**

递归计算n的阶乘
@author Chenhh

public class demo {

public static void main(String[] args) {

System.out.println(recursion(5));

}

/**

递归计算n的阶乘

private static int recursion(int n) {

if (n <1) {

throw new IllegalArgumentException(“参数必须大于0”);

} else if (n == 1) {

return 1;

} else {

return n * recursion(n - 1);

}

在这里插入图片描述

课间休息，又来秀一下来自咱们群里同学的搬砖工地，坐标：大连。

作者：Onlooker

面试题3： 10亿个数中找出最大的100000个数（top K问题）

=================================================================================================

先拿100000个数建堆，然后一次添加剩余元素，如果大于堆顶的数（100000中最小的），将这个数替换堆顶，并调整结构使之仍然是一个最小堆，这样，遍历完后，堆中的100000个数就是所需的最大的100000个。建堆时间复杂度是O(m)，算法的时间复杂度为1次建堆时间+n次堆调整时间=O(m+nlogm)=O(nlogm)（n为10亿，m为100000）。

优化的方法：可以把所有10亿个数据分组存放，比如分别放在1000个文件中。这样处理就可以分别在每个文件的10^6个数据中找出最大的100000个数，合并到一起在再找出最终的结果。

top K问题

在大规模数据处理中，经常会遇到的一类问题：在海量数据中找出出现频率最好的前k个数，或者从海量数据中找出最大的前k个数，这类问题通常被称为top K问题。例如，在搜索引擎中，统计搜索最热门的10个查询词；在歌曲库中统计下载最高的前10首歌等。

针对top K类问题，通常比较好的方案是分治+Trie树/hash+小顶堆（就是上面提到的最小堆），即先将数据集按照Hash方法分解成多个小数据集，然后使用Trie树活着Hash统计每个小数据集中的query词频，之后用小顶堆求出每个数据集中出现频率最高的前K个数，最后在所有top K中求出最终的top K。