数据结构之排序

}

六、选择排序

---

package com.atguigu.sort;

import java.text.SimpleDateFormat;

import java.util.Arrays;

import java.util.Date;

//选择排序

public class SelectSort {

public static void main(String[] args) {

//int [] arr = {101, 34, 119, 1, -1, 90, 123};

//创建要给80000个的随机的数组

int[] arr = new int[80000];

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

arr[i] = (int) (Math.random() * 8000000); // 生成一个[0, 8000000) 数

}

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

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

Date data1 = new Date();

SimpleDateFormat simpleDateFormat = new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);

String date1Str = simpleDateFormat.format(data1);

System.out.println(“排序前的时间是=” + date1Str);

selectSort(arr);

Date data2 = new Date();

String date2Str = simpleDateFormat.format(data2);

System.out.println(“排序前的时间是=” + date2Str);

//System.out.println(“排序后”);

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

}

//选择排序

public static void selectSort(int[] arr) {

//在推导的过程，我们发现了规律，因此，可以使用for来解决

//选择排序时间复杂度是 O(n^2)

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

int minIndex = i;

int min = arr[i];

for (int j = i + 1; j < arr.length; j++) {

if (min > arr[j]) { // 说明假定的最小值，并不是最小

min = arr[j]; // 重置min

minIndex = j; // 重置minIndex

}

}

// 将最小值，放在arr[0], 即交换

if (minIndex != i) {

arr[minIndex] = arr[i];

arr[i] = min;

}

//System.out.println(“第”+(i+1)+“轮后~~”);

//System.out.println(Arrays.toString(arr));// 1, 34, 119, 101

}

/*

//使用逐步推导的方式来，讲解选择排序

//第1轮

//原始的数组 ： 101, 34, 119, 1

//第一轮排序 : 1, 34, 119, 101

//算法 先简单–》 做复杂， 就是可以把一个复杂的算法，拆分成简单的问题-》逐步解决

//第1轮

int minIndex = 0;

int min = arr[0];

for(int j = 0 + 1; j < arr.length; j++) {

if (min > arr[j]) { //说明假定的最小值，并不是最小

min = arr[j]; //重置min

minIndex = j; //重置minIndex

}

}

//将最小值，放在arr[0], 即交换

if(minIndex != 0) {

arr[minIndex] = arr[0];

arr[0] = min;

}

System.out.println(“第1轮后~~”);

System.out.println(Arrays.toString(arr));// 1, 34, 119, 101

//第2轮

minIndex = 1;

min = arr[1];

for (int j = 1 + 1; j < arr.length; j++) {

if (min > arr[j]) { // 说明假定的最小值，并不是最小

min = arr[j]; // 重置min

minIndex = j; // 重置minIndex

}

}

// 将最小值，放在arr[0], 即交换

if(minIndex != 1) {

arr[minIndex] = arr[1];

arr[1] = min;

}

System.out.println(“第2轮后~~”);

System.out.println(Arrays.toString(arr));// 1, 34, 119, 101

//第3轮

minIndex = 2;

min = arr[2];

for (int j = 2 + 1; j < arr.length; j++) {

if (min > arr[j]) { // 说明假定的最小值，并不是最小

min = arr[j]; // 重置min

minIndex = j; // 重置minIndex

}

}

// 将最小值，放在arr[0], 即交换

if (minIndex != 2) {

arr[minIndex] = arr[2];

arr[2] = min;

}

System.out.println(“第3轮后~~”);

System.out.println(Arrays.toString(arr));// 1, 34, 101, 119 */

}

}

七、插入排序

---

package com.atguigu.sort;

import java.text.SimpleDateFormat;

import java.util.Arrays;

import java.util.Date;

public class InsertSort {

public static void main(String[] args) {

//int[] arr = {101, 34, 119, 1, -1, 89};

// 创建要给80000个的随机的数组

int[] arr = new int[80000];

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

arr[i] = (int) (Math.random() * 8000000); // 生成一个[0, 8000000) 数

}

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

Date data1 = new Date();

SimpleDateFormat simpleDateFormat = new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);

String date1Str = simpleDateFormat.format(data1);

System.out.println(“排序前的时间是=” + date1Str);

insertSort(arr); //调用插入排序算法

Date data2 = new Date();

String date2Str = simpleDateFormat.format(data2);

System.out.println(“排序前的时间是=” + date2Str);

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

}

//插入排序

public static void insertSort(int[] arr) {

int insertVal = 0;

int insertIndex = 0;

//使用for循环来把代码简化

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

//定义待插入的数

insertVal = arr[i];

insertIndex = i - 1; // 即arr[1]的前面这个数的下标

// 给insertVal 找到插入的位置

// 说明

// 1. insertIndex >= 0 保证在给insertVal 找插入位置，不越界

// 2. insertVal < arr[insertIndex] 待插入的数，还没有找到插入位置

// 3. 就需要将 arr[insertIndex] 后移

while (insertIndex >= 0 && insertVal < arr[insertIndex]) {

arr[insertIndex + 1] = arr[insertIndex];// arr[insertIndex]

insertIndex–;

}

// 当退出while循环时，说明插入的位置找到, insertIndex + 1

// 举例：理解不了，我们一会 debug

//这里我们判断是否需要赋值

if(insertIndex + 1 != i) {

arr[insertIndex + 1] = insertVal;

}

//System.out.println(“第”+i+“轮插入”);

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

}

/*

//使用逐步推导的方式来讲解，便利理解

//第1轮 {101, 34, 119, 1}; => {34, 101, 119, 1}

//{101, 34, 119, 1}; => {101,101,119,1}

//定义待插入的数

int insertVal = arr[1];

int insertIndex = 1 - 1; //即arr[1]的前面这个数的下标

//给insertVal 找到插入的位置

//说明

//1. insertIndex >= 0 保证在给insertVal 找插入位置，不越界

//2. insertVal < arr[insertIndex] 待插入的数，还没有找到插入位置

//3. 就需要将 arr[insertIndex] 后移

while(insertIndex >= 0 && insertVal < arr[insertIndex] ) {

arr[insertIndex + 1] = arr[insertIndex];// arr[insertIndex]

insertIndex–;

}

//当退出while循环时，说明插入的位置找到, insertIndex + 1

//举例：理解不了，我们一会 debug

arr[insertIndex + 1] = insertVal;

System.out.println(“第1轮插入”);

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

//第2轮

insertVal = arr[2];

insertIndex = 2 - 1;

while(insertIndex >= 0 && insertVal < arr[insertIndex] ) {

arr[insertIndex + 1] = arr[insertIndex];// arr[insertIndex]

insertIndex–;

}

arr[insertIndex + 1] = insertVal;

System.out.println(“第2轮插入”);

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

//第3轮

insertVal = arr[3];

insertIndex = 3 - 1;

while (insertIndex >= 0 && insertVal < arr[insertIndex]) {

arr[insertIndex + 1] = arr[insertIndex];// arr[insertIndex]

insertIndex–;

}

arr[insertIndex + 1] = insertVal;

System.out.println(“第3轮插入”);

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

}

}

八、希尔排序

---

package com.atguigu.sort;

import java.text.SimpleDateFormat;

import java.util.Arrays;

import java.util.Date;

public class ShellSort {

public static void main(String[] args) {

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

// 创建要给80000个的随机的数组

int[] arr = new int[8000000];

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

arr[i] = (int) (Math.random() * 8000000); // 生成一个[0, 8000000) 数

}

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

Date data1 = new Date();

SimpleDateFormat simpleDateFormat = new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);

String date1Str = simpleDateFormat.format(data1);

System.out.println(“排序前的时间是=” + date1Str);

//shellSort(arr); //交换式

shellSort2(arr);//移位方式

Date data2 = new Date();

String date2Str = simpleDateFormat.format(data2);

System.out.println(“排序前的时间是=” + date2Str);

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

}

// 使用逐步推导的方式来编写希尔排序

// 希尔排序时， 对有序序列在插入时采用交换法,

// 思路(算法) ===> 代码

public static void shellSort(int[] arr) {

int temp = 0;

int count = 0;

// 根据前面的逐步分析，使用循环处理

for (int gap = arr.length / 2; gap > 0; gap /= 2) {

for (int i = gap; i < arr.length; i++) {

// 遍历各组中所有的元素(共gap组，每组有个元素), 步长gap

for (int j = i - gap; j >= 0; j -= gap) {

// 如果当前元素大于加上步长后的那个元素，说明交换

if (arr[j] > arr[j + gap]) {

temp = arr[j];

arr[j] = arr[j + gap];

arr[j + gap] = temp;

}

}

}

//System.out.println(“希尔排序第” + (++count) + “轮 =” + Arrays.toString(arr));

}

/*

// 希尔排序的第1轮排序

// 因为第1轮排序，是将10个数据分成了 5组

for (int i = 5; i < arr.length; i++) {

// 遍历各组中所有的元素(共5组，每组有2个元素), 步长5

for (int j = i - 5; j >= 0; j -= 5) {

// 如果当前元素大于加上步长后的那个元素，说明交换

if (arr[j] > arr[j + 5]) {

temp = arr[j];

arr[j] = arr[j + 5];

arr[j + 5] = temp;

}

}

}

System.out.println(“希尔排序1轮后=” + Arrays.toString(arr));//

// 希尔排序的第2轮排序

// 因为第2轮排序，是将10个数据分成了 5/2 = 2组

for (int i = 2; i < arr.length; i++) {

// 遍历各组中所有的元素(共5组，每组有2个元素), 步长5

for (int j = i - 2; j >= 0; j -= 2) {

// 如果当前元素大于加上步长后的那个元素，说明交换

if (arr[j] > arr[j + 2]) {

temp = arr[j];

arr[j] = arr[j + 2];

arr[j + 2] = temp;

}

}

}

System.out.println(“希尔排序2轮后=” + Arrays.toString(arr));//

// 希尔排序的第3轮排序

// 因为第3轮排序，是将10个数据分成了 2/2 = 1组

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

// 遍历各组中所有的元素(共5组，每组有2个元素), 步长5

for (int j = i - 1; j >= 0; j -= 1) {

// 如果当前元素大于加上步长后的那个元素，说明交换

if (arr[j] > arr[j + 1]) {

temp = arr[j];

arr[j] = arr[j + 1];

arr[j + 1] = temp;

}

}

}

System.out.println(“希尔排序3轮后=” + Arrays.toString(arr));//

*/

}

//对交换式的希尔排序进行优化->移位法

public static void shellSort2(int[] arr) {

// 增量gap, 并逐步的缩小增量

for (int gap = arr.length / 2; gap > 0; gap /= 2) {

// 从第gap个元素，逐个对其所在的组进行直接插入排序

for (int i = gap; i < arr.length; i++) {

int j = i;

int temp = arr[j];

if (arr[j] < arr[j - gap]) {

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

//移动

arr[j] = arr[j-gap];

j -= gap;

}

//当退出while后，就给temp找到插入的位置

arr[j] = temp;

}

}

}

}

}

九、快速排序

---

package com.atguigu.sort;

import java.text.SimpleDateFormat;

import java.util.Arrays;

import java.util.Date;

public class QuickSort {

public static void main(String[] args) {

//int[] arr = {-9,78,0,23,-567,70, -1,900, 4561};

//测试快排的执行速度

// 创建要给80000个的随机的数组

int[] arr = new int[8000000];

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

arr[i] = (int) (Math.random() * 8000000); // 生成一个[0, 8000000) 数

}

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

Date data1 = new Date();

SimpleDateFormat simpleDateFormat = new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);

String date1Str = simpleDateFormat.format(data1);

System.out.println(“排序前的时间是=” + date1Str);

quickSort(arr, 0, arr.length-1);

Date data2 = new Date();

String date2Str = simpleDateFormat.format(data2);

System.out.println(“排序前的时间是=” + date2Str);

//System.out.println(“arr=” + Arrays.toString(arr));

}

public static void quickSort(int[] arr,int left, int right) {

int l = left; //左下标

int r = right; //右下标

//pivot 中轴值

int pivot = arr[(left + right) / 2];

int temp = 0; //临时变量，作为交换时使用

//while循环的目的是让比pivot 值小放到左边

//比pivot 值大放到右边

while( l < r) {

//在pivot的左边一直找,找到大于等于pivot值,才退出

while( arr[l] < pivot) {

l += 1;

}

//在pivot的右边一直找,找到小于等于pivot值,才退出

while(arr[r] > pivot) {

r -= 1;

}

//如果l >= r说明pivot 的左右两的值，已经按照左边全部是

//小于等于pivot值，右边全部是大于等于pivot值

if( l >= r) {

break;

}

//交换

temp = arr[l];

arr[l] = arr[r];

arr[r] = temp;

//如果交换完后，发现这个arr[l] == pivot值 相等 r–， 前移

if(arr[l] == pivot) {

r -= 1;

}

//如果交换完后，发现这个arr[r] == pivot值 相等 l++， 后移

if(arr[r] == pivot) {

l += 1;

}

}

// 如果 l == r, 必须l++, r–, 否则为出现栈溢出

if (l == r) {

l += 1;

r -= 1;

}

//向左递归

if(left < r) {

quickSort(arr, left, r);

}

//向右递归

if(right > l) {

quickSort(arr, l, right);

}

}

}

十、归并排序

---

package com.atguigu.sort;

import java.text.SimpleDateFormat;

import java.util.Arrays;

import java.util.Date;

public class MergetSort {

public static void main(String[] args) {

//int arr[] = { 8, 4, 5, 7, 1, 3, 6, 2 }; //

//测试快排的执行速度

// 创建要给80000个的随机的数组

int[] arr = new int[8000000];

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

arr[i] = (int) (Math.random() * 8000000); // 生成一个[0, 8000000) 数

}

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

Date data1 = new Date();

SimpleDateFormat simpleDateFormat = new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);

String date1Str = simpleDateFormat.format(data1);

System.out.println(“排序前的时间是=” + date1Str);

int temp[] = new int[arr.length]; //归并排序需要一个额外空间

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

Date data2 = new Date();

String date2Str = simpleDateFormat.format(data2);

System.out.println(“排序前的时间是=” + date2Str);

//System.out.println(“归并排序后=” + Arrays.toString(arr));

}

//分+合方法

public 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);

}

}

//合并的方法

/**

• @param arr 排序的原始数组

• @param left 左边有序序列的初始索引

• @param mid 中间索引

• @param right 右边索引

• @param temp 做中转的数组

*/

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

int i = left; // 初始化i, 左边有序序列的初始索引

int j = mid + 1; //初始化j, 右边有序序列的初始索引

int t = 0; // 指向temp数组的当前索引

//(一)

//先把左右两边(有序)的数据按照规则填充到temp数组

//直到左右两边的有序序列，有一边处理完毕为止

while (i <= mid && j <= right) {//继续

//如果左边的有序序列的当前元素，小于等于右边有序序列的当前元素

//即将左边的当前元素，填充到 temp数组

//然后 t++, i++

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

temp[t] = arr[i];

t += 1;

i += 1;

} else { //反之,将右边有序序列的当前元素，填充到temp数组

temp[t] = arr[j];

t += 1;

j += 1;

}

}

//(二)

//把有剩余数据的一边的数据依次全部填充到temp

while( i <= mid) { //左边的有序序列还有剩余的元素，就全部填充到temp

temp[t] = arr[i];

t += 1;

i += 1;

}

while( j <= right) { //右边的有序序列还有剩余的元素，就全部填充到temp

temp[t] = arr[j];

t += 1;

j += 1;

}

//(三)

//将temp数组的元素拷贝到arr

//注意，并不是每次都拷贝所有

t = 0;

int tempLeft = left; //

//第一次合并 tempLeft = 0 , right = 1 // tempLeft = 2 right = 3 // tL=0 ri=3

//最后一次 tempLeft = 0 right = 7

while(tempLeft <= right) {

arr[tempLeft] = temp[t];

t += 1;

tempLeft += 1;

}

}

}

十一、基数排序

---

package com.atguigu.sort;

import java.text.SimpleDateFormat;

import java.util.Arrays;

import java.util.Date;

public class RadixSort {

public static void main(String[] args) {

int arr[] = { 53, 3, 542, 748, 14, 214};

// 80000000 * 11 * 4 / 1024 / 1024 / 1024 =3.3G

// int[] arr = new int[8000000];

// for (int i = 0; i < 8000000; i++) {
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

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

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

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

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

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

总结

谈到面试，其实说白了就是刷题刷题刷题，天天作死的刷。。。。。

为了准备这个“金三银四”的春招，狂刷一个月的题，狂补超多的漏洞知识，像这次美团面试问的算法、数据库、Redis、设计模式等这些题目都是我刷到过的

并且我也将自己刷的题全部整理成了PDF或者Word文档（含详细答案解析）

66个Java面试知识点

架构专题（MySQL，Java，Redis，线程，并发，设计模式，Nginx，Linux，框架，微服务等）+大厂面试题详解（百度，阿里，腾讯，华为，迅雷，网易，中兴，北京中软等）

算法刷题（PDF）

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
ring[] args) {

int arr[] = { 53, 3, 542, 748, 14, 214};

// 80000000 * 11 * 4 / 1024 / 1024 / 1024 =3.3G

// int[] arr = new int[8000000];

// for (int i = 0; i < 8000000; i++) {
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

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

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。[外链图片转存中…(img-PJyxpPZn-1713713938690)]

[外链图片转存中…(img-B3IeCuSI-1713713938690)]

[外链图片转存中…(img-CQpVSqVs-1713713938691)]

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

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

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

总结

谈到面试，其实说白了就是刷题刷题刷题，天天作死的刷。。。。。

为了准备这个“金三银四”的春招，狂刷一个月的题，狂补超多的漏洞知识，像这次美团面试问的算法、数据库、Redis、设计模式等这些题目都是我刷到过的

并且我也将自己刷的题全部整理成了PDF或者Word文档（含详细答案解析）

[外链图片转存中…(img-oIg8eH7G-1713713938691)]

66个Java面试知识点

架构专题（MySQL，Java，Redis，线程，并发，设计模式，Nginx，Linux，框架，微服务等）+大厂面试题详解（百度，阿里，腾讯，华为，迅雷，网易，中兴，北京中软等）

[外链图片转存中…(img-UMnvzCww-1713713938691)]

算法刷题（PDF）

[外链图片转存中…(img-RhRbN7rG-1713713938691)]

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！