面试笔试手撕代码 -- 排序+查找算法总结（Java+JS实现）

min = array[j];

flag = j;

}

}

if (flag != i) {

array[flag] = array[i];

array[i] = min;

}

}

// System.out.println(Arrays.toString(array));

}

public static void main(String[] args) {

int arr[] = {2, 4, 7, 6, 8, 5, 9};

selectSort(arr);

System.out.println(Arrays.toString(arr));

}

function selectionSort(arr) {

var len = arr.length;

var minIndex, temp;

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

minIndex = i;

for(var j = i+1;j<len;j++) {

if(arr[j] < arr[minIndex]) {// 寻找最小的数

minIndex = j;

}

}

temp = arr[i];

arr[i] = arr[minIndex];

arr[minIndex] = temp;

}

return arr;

}

3. 直接插入排序

---

**思路：**在要排序的一组数中，假设前面(n-1)个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。从最后一个数开始向前循环，如果插入数小于当前数，就将当前数向后移动一位。如此反复循环，直到全部排好顺序。

public static void insertSort(int[] data) {

int temp;

for(int i = 1;i < data.length; i++){// 取第i个数,插入前边的有序的序列

temp = data[i];

int j;

for(j = i - 1; j>=0; j–) {// 从第i-1的位置上开始比较

if(data[j] > temp) {// 若前面的数大，则往后挪一位

data[j+1] = data[j];

} else {

break;// 否则，说明要插入的数比较大

}

}

data[j+1] = temp;// 找到这个位置，插入数据

}

}

public static void main(String[] args) {

int arr[] = {2, 4, 7, 6, 8, 5, 9};

insertSort(arr);

System.out.println(Arrays.toString(arr));

}

function insertSort(arr){

for(var i = 1; i <= arr.length - 1; i++){

var temp = arr[i];

var j = i;

while(j > 0 && (arr[j - 1] >= temp)){

arr[j] = arr[j - 1];

j–;

}

arr[j] = temp;

}

return arr;

}

4. 归并排序

---

**思路：**归并排序采用经典的分治（divide-and-conquer）策略。分阶段可以理解为就是递归拆分子序列的过程，递归深度为log2n。治阶段，我们需要将两个已经有序的子序列合并成一个有序序列

**概括：**主要需要两个辅助函数：mergeSort用来递归划分区间，merge用来合并两个数组。

public static void main(String[] args) {

int arr[] = {2, 4, 7, 6, 8, 5, 9};

mergeSort(arr);

System.out.println(Arrays.toString(arr));

}

public static void mergeSort(int[] array) {

int[] temp = new int[array.length];// 在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间

mergeSort(array, 0, array.length-1, temp);

// System.out.println(Arrays.toString(array));

}

private static void mergeSort(int[] arr, int left, int right, int []temp) {

if(left < right) {

int mid = (left+right) / 2;

mergeSort(arr, left, mid, temp);// 左边归并排序，使得左子序列有序

mergeSort(arr, mid+1, right, temp);// 右边归并排序，使得右子序列有序

merge(arr, left, mid, right, temp);// 将两个有序子数组合并操作

}

}

private static void merge(int[] arr, int left, int mid, int right, int[] temp) {

int i = left;// 左序列指针

int j = mid+1;// 右序列指针

int t = 0;// 临时数组指针

while (i <= mid && j <= right) {

if(arr[i] <= arr[j]) {

temp[t++] = arr[i++];

} else {

temp[t++] = arr[j++];

}

}

while(i <= mid) {// 将左边剩余元素填充进temp中

temp[t++] = arr[i++];

}

while(j <= right) {// 将右序列剩余元素填充进temp中

temp[t++] = arr[j++];

}

t = 0;

// 将temp中的元素全部拷贝到原数组中

while(left <= right) {

arr[left++] = temp[t++];

}

}

function mergeSort(arr) { //采用自上而下的递归方法

var len = arr.length;

if(len < 2) {

return arr;

}

var middle = Math.floor(len / 2),

left = arr.slice(0, middle),

right = arr.slice(middle);

return merge(mergeSort(left), mergeSort(right));

}

function merge(left, right) {

var result = [];

while (left.length && right.length) {

if (left[0] <= right[0]) {

result.push(left.shift());

} else {

result.push(right.shift());

}

}

while (left.length)

result.push(left.shift());

while (right.length)

result.push(right.shift());

return result;

}

5. 快速排序

---

思路：快速排序使用分治策略来把一个序列（list）分为两个子序列（sub-lists）

（1）选择主元（基准）；（2）划分：左指针指向数组第一个元素，右指针指向数组最后一个元素。移动左指针直到比主元大的元素，移动右指针，直到比主元小的元素，交换他们。直到左指针超过右指针。此时主元位于中间位置（3）递归两个小数组。

public static void quickSort(int[] array) {

sort(array, 0, array.length - 1);

// System.out.println(Arrays.toString(array));

}

private static void sort(int[] a, int low, int high) {

int i = low;

int j = high;

if (a.length <= 1) {

return;

}

if (i >= j) {

return;

}

int index = a[i]; // 选择第一个位置元素为主元

while (i < j) {

while (i < j && a[j] >= index)

j–;

if (a[j] < index)

a[i++] = a[j];

while (i < j && a[i] <= index)

i++;

if (a[i] > index)

a[j–] = a[i];

}

a[i] = index; // 将主元放在中心位置

sort(a, low, i - 1);

sort(a, i + 1, high);

}

public static void main(String[] args) {

int arr[] = {2, 4, 7, 6, 8, 5, 9};

quickSort(arr);

System.out.println(Arrays.toString(arr));

}

function quickSort2(arr,start,end){

if(end - start < 1){return }

const target = arr[start];

let [l,r] = [start,end];

while(l < r){

while(l < r && arr[r]>=target){

r–;

}

arr[l] = arr[r];

while(l < r && arr[l] < target){

l++;

}

arr[r] = arr[l]

}

arr[l] = target;

quickSort2(arr,start,l-1);

quickSort2(arr,l+1,end);

return arr;

}

二、查找算法

==========

1. 线性查找

---

线性查找就是从数组的起始位置a[0]开始依次比较数组中的每一个值直到找到目标值

public class SeqSearch {

public static void main(String[] args) {

int[] data = {2, 1, 4, 6, 12, 7};

int target = 12;

int searchIndex = search(data, target);

if (searchIndex != -1) {

System.out.println("found at: " + searchIndex);

}else {

System.out.println(“not found”);

}

}

public static int search(int[] data, int target) {

int length = data.length;

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

if (data[i] == target) {

return i;

}

}

return -1;

}

}

function listSearch(arr,data) {

var result;

for (var i = 0;i<arr.length; i++) {

if (arr[i] === data) {

result = i;

break;

}

}

if (result === undefined) {

result = -1;

}

return result

}

2. 二分查找

---

二分法查找适用于大的数据，但前提条件是数据必须是有序的，他的原理是先和中间的比较，如果等于就直接返回，如果小于就在前半部分继续使用二分法进行查找，如果大于则在后半部分继续使用二分法进行查找

public class BinarySearch {

public static void main(String[] args) {

int[] data = {1, 5, 6, 12, 15, 19, 23, 26, 30, 33, 37, 42, 53, 60};

int target = 19;

int index = binarySearch2(data, target);

if (index > -1) {

System.out.println(“found ：” + index);

}else {

System.out.println(“not found”);

}

}

// 非递归实现

public static int binarySearch2(int[] array, int value) {

int low = 0;

int high = array.length - 1;

while (low <= high) {

int middle = low + ((high - low) >> 1);

if (value == array[middle]) {

return middle;

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

总结

蚂蚁面试比较重视基础，所以Java那些基本功一定要扎实。蚂蚁的工作环境还是挺赞的，因为我面的是稳定性保障部门，还有许多单独的小组，什么三年1班，很有青春的感觉。面试官基本水平都比较高，基本都P7以上，除了基础还问了不少架构设计方面的问题，收获还是挺大的。

---

经历这次面试我还通过一些渠道发现了需要大厂真实面试主要有：蚂蚁金服、拼多多、阿里云、百度、唯品会、携程、丰巢科技、乐信、软通动力、OPPO、银盛支付、中国平安等初，中级，高级Java面试题集合，附带超详细答案，希望能帮助到大家。

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！
目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！**

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

总结

蚂蚁面试比较重视基础，所以Java那些基本功一定要扎实。蚂蚁的工作环境还是挺赞的，因为我面的是稳定性保障部门，还有许多单独的小组，什么三年1班，很有青春的感觉。面试官基本水平都比较高，基本都P7以上，除了基础还问了不少架构设计方面的问题，收获还是挺大的。

---

经历这次面试我还通过一些渠道发现了需要大厂真实面试主要有：蚂蚁金服、拼多多、阿里云、百度、唯品会、携程、丰巢科技、乐信、软通动力、OPPO、银盛支付、中国平安等初，中级，高级Java面试题集合，附带超详细答案，希望能帮助到大家。

[外链图片转存中…(img-y4OY3Jyq-1712535103908)]

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！