Java最新Java实现各种内部排序算法(1)，java开发面试简历模板java

最后总结

ActiveMQ+Kafka+RabbitMQ学习笔记PDF

• RabbitMQ实战指南

• 手写RocketMQ笔记

• 手写“Kafka笔记”

关于分布式，限流+缓存+缓存，这三大技术（包含：ZooKeeper+Nginx+MongoDB+memcached+Redis+ActiveMQ+Kafka+RabbitMQ）等等。这些相关的面试也好，还有手写以及学习的笔记PDF，都是啃透分布式技术必不可少的宝藏。以上的每一个专题每一个小分类都有相关的介绍，并且小编也已经将其整理成PDF啦

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

for(int d=array.length/2; d>=1; d=d/2){ //用步长值来控制循环次数

for(int i=d;i<array.length;i++){

int temp = array[i];

if(temp < array[i-d]){ //将array[i]插入到有序增量子表中

int j;

for(j=i-d;j>=0 && temp<array[j];j-=d){

array[j+d]=array[j]; //记录后移，寻找插入位置

}

array[j+d] = temp;

}

}

}

return array;

}

冒泡排序：

思想：对于待排序表，从前往后两两比较相邻元素的值，若为逆序，则交换，直到序列比较完成。如此，每次冒泡即可得到当前待排表中的最大元素，并已放置在相应的位置。

性能：时间复杂度：最好o(n)有序，最坏o(n^{2)逆序,平均o(n}2)，空间复杂度o(1)，稳定

public int[] bubbleSort(int[] array){

boolean flag = false; //用来标记该序列是否已是有序

for(int i=0;i<array.length-1;i++){ //做n-1趟冒泡

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

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

int temp = array[j];

array[j] = array[j+1];

array[j+1] = temp;

flag = true; //有元素交换，则该序列初始状况不是有序的

}

}

if(flag == false){ //本趟遍历后没有发生交换，说明表已经有序

return array;

}

}

return array;

}

快速排序：

思想：基于分治的思想：在待排序表中任取一个元素pivot作为基准，通过一趟排序将待排序表划分为独立的两部分，使得一部分中所有元素小于等于pivot，另一部分中所有元素大于pivot，则pivot放在了其最终位置上，这个过程称为一趟快速排序。而后递归地对两个子表重复上述过程，直到每部分内只有一个元素或空为止。

性能： 空间复杂度：需要递归工作栈：最坏o(n)，平均o(logn)

时间复杂度：最坏:o(n^2)初始表基本有序或基本逆序，平均o(n*logn)

不稳定

public int[] quickSort(int[] array,int low,int high){

if(low<high){ //递归跳出的条件

int mid= partition(array, low, high); //划分，得到枢值所在的下表

quickSort(array,low,mid-1); //依次对两个子表进行递归排序

quickSort(array,mid+1,high);

}

return array;

}

//快速排序的划分函数

public int partition(int[] array,int low, int high){

int pivot = array[low]; //每次取数组中的第一个元素为基准

while(low < high){ //跳出循环的条件

while(low<high && array[high] > pivot){ //从右边开始找到第一个小于或等于pivot的值

high–;

}

while(low<high && array[low] < pivot){ //从左边开始找到第一个大于或等于pivot的值

low++;

}

int temp = array[low]; //交换

array[low] = array[high];

array[high] = temp;

if(low<high && array[low] == pivot && array[high] == pivot){ //特殊情况

low++;

}

}

return low;

}

简单选择排序：

思想：假设排序表array[0,…,n-1]，第 i 趟排序即从array[0,…,n-1]中选择关键字最小的元素与array[i]交换，每一趟排序可以确定一个元素的最终位置，这样经过n-1趟派克就可以使整个序列有序。

性能：时间复杂度：o(n^2)，空间复杂度o(1)，不稳定

public int[] simpleSelectSort(int[] array){

for(int i=0;i<array.length -1;i++){ //一共进行n-1趟

int min = i; //记录最小元素位置

for(int j=i+1;j<array.length;j++){ //在array[i，…，n-1]中选择最小的元素

if(array[j] < array[min]){

min = j; //更新最小元素的位置

}

}

int temp = array[i]; //将最小元素与第i个位置交换

array[i] = array[min];

array[min] = temp;

}

return array;

}

堆排序：Java实现堆排序（大根堆）

归并排序：

思想：“归并”的含义是将两个或两个以上的有序表组合成一个新的有序表。假设待排序表含有n个记录，则可以看成是n个有序的子表，每个子表的长度为1，然后两两归并，得到（n/2）个长度为2或1的有序表；再两两归并，…，如此重复，直到合并成一个长度为n的有序表为止，这种排序方法称为2-路归并排序。

递归形式的2-路归并排序算法是基于分治的，其过程如下：

分解：将含有n个元素的待排序表分成各含有n/2个元素的子表，采用2-路归并排序算法对两个子表递归地进行排序；

合并：合并两个已排序的子表得到排序结果。

性能：空间复杂度：o(n)；时间复杂度:o(nlogn)；稳定

public int[] mergeSort(int[] array,int low, int high){

if(low < high){ //递归结束的条件

int mid = (low + high)/2; //二路归并排序，从中间划分两个子序列【分解过程】

mergeSort(array, low, mid); //对左侧子序列进行递归排序

mergeSort(array, mid+1, high); //对右侧子序列进行递归排序

merge(array,low,mid,high); //归并【合并过程】

}

return array;

}

//将前后相邻的两个有序表归并为一个有序表

private void merge(int[] array,int low, int mid, int high){

int[] tempArray = new int[array.length]; //辅助数组tempArray

for(int i=low;i<=high;i++){ //将array数组中[low…high]的元素复制到辅助数组tempArray中

tempArray[i] = array[i];

}

int i,j,k;

for(i=low,j=mid+1,k=i;i<=mid && j<=high;k++){

if(tempArray[i]>tempArray[j]){ //比较tempArray的左右两端中的元素

array[k] = tempArray[j++]; //将较小值复制到array中

}else{

array[k] = tempArray[i++];

}

}

while(i<=mid){ //若第一个表未检测完，复制

array[k++] = tempArray[i++];

}

while(j<=high){ //若第二个表未检测完，复制

array[k++] = tempArray[j++];

}

}

按 Ctrl+C 复制代码

基数排序：

基于计数排序实现： Java实现基于桶式排序思想和计数排序思想实现的基数排序

基于队列辅助实现：

思想：基数排序不是基于比较进行排序的，而是采用多关键字排序思想，借助“分配”和“收集”两种操作对单逻辑关键字进行排序。

基数排序是利用多关键字先达到局部有序，再调整达到全局有序。

性能：空间复杂度：o®；时间复杂度：o(d(n+r))；稳定

其中，r为基数，d为最大关键字的位数（决定了排序的趟数），n为待排序列表中元素的个数。

//基于队列辅助实现的基数排序

public int[] radixSort(int[] array){

//找到待排序序列中的最大元素

int max = array[0];

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

if(array[i] > max){

max = array[i];

}

}

//确定最大元素的位数maxBits

int maxBits = 0;

while(max > 0){

max = max/10;

maxBits ++;

}

//建立10个队列

Queue[] queue = new LinkedList[10];

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

queue[i] = new LinkedList();

线程、数据库、算法、JVM、分布式、微服务、框架、Spring相关知识

一线互联网P7面试集锦+各种大厂面试集锦

学习笔记以及面试真题解析

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

式、微服务、框架、Spring相关知识

[外链图片转存中…(img-lDemFA8K-1715378004409)]

一线互联网P7面试集锦+各种大厂面试集锦

[外链图片转存中…(img-QJbzzUGY-1715378004409)]

学习笔记以及面试真题解析

[外链图片转存中…(img-EOelgN0d-1715378004410)]

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取