✨前言✨
📘 博客主页:to Keep博客主页
🙆欢迎关注,👍点赞,📝留言评论
⏳首发时间:2022年2月27日
📨 博主码云地址:博主码云地址
📕参考书籍:java核心技术 卷1
📢编程练习:牛客网+力扣网
由于博主目前也是处于一个学习的状态,如有讲的不对的地方,请一定联系我予以改正!!!
🌍排序的相关概念:
1 排序:
就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作。
2 稳定性:
两个相等的数据,如果经过排序后,排序算法能保证其相对位置不发生变化,则我们称该算法是具备稳定性的排序算法。
例如:
🌎插入排序
插入排序的核心思想就是把数组中的第一个数据是作为有序的,从第二个数据开始,就要与前面的数据进行比较,在合适的位置进行插入;
代码如下:
public class TestSort {
public static void main(String[] args) {
int[] array = {12,23,43,52,24,64,78,0,1,4};
InsertSort(array);
System.out.println(Arrays.toString(array));
}
/**
*时间复杂度:O(N^2) 最好情况下O(N)
* 空间复杂度:O(1)
* 稳定性:稳定
* @param array 待排序数组
*/
public static void InsertSort(int[] array){
for (int i = 1; i <array.length ; i++) {
//取出当前要进行比较的数据
int tmp = array[i];
//需要从i与前面的数据比较,就从最近的i-1开始
int j = i-1;
//j要大于等于零
for (;j>=0;j--){
//如果j位置上数据大于tmp,那么就需要将j+1上的数据覆盖成j位置上的数据
if(array[j]>tmp){
array[j+1]=array[j];
}else{
//说明此时数据是有序的,直接退出循环
break;
}
}
//将tmp放在j+1位置上
array[j+1]=tmp;
}
}
}
**特点:**时间复杂度为O(N)是在数据有序的情况下,所以对于插入排序而言,数据越有序就越快!
🌏 希尔排序
希尔排序其实就是在插入排序的基础上,进行了优化,它所利用的也是直接插入排序,但是它采用了数据分组的思想,接下来就简单的来了解一下什么是希尔排序!
代码如下:
public class TestSort {
public static void main(String[] args) {
int[] array = {12,23,43,52,24,64,78,0,1,4};
ShellSort(array);
System.out.println(Arrays.toString(array));
}
//交换元素位置
public static void Swap(int[] array,int i,int j){
int tmp = array[i];
array[i]=array[j];
array[j]=tmp;
}
/**
* 时间复杂度:0(N^1.3)~O(N^1.5)
* 空间复杂度:O(1)
* 稳定性:不稳定
* @param array 待排序序列
*/
public static void ShellSort(int[] array){
int gap = array.length;
while(gap!=1){
Shell(array,gap);
gap=gap/2;
}
Shell(array,1);
}
//插入排序
public static void Shell(int[] array,int gap){
for(int i=gap;i<array.length;i++){
int tmp = array[i];
int j = i-gap;
for (;j>=0;j-=gap){
if(array[j]>tmp){
array[j+gap]=array[j];
}else{
break;
}
}
array[j+gap]=tmp;
}
}
}
🌳 选择排序
选择排序其实就是,每一次都要将数组中,最小的元素放置到第一位
代码如下:
public class TestSort {
public static void main(String[] args) {
int[] array = {12,23,43,52,24,64,78,0,1,4};
selection(array);
System.out.println(Arrays.toString(array));
}
//交换元素位置
public static void Swap(int[] array,int i,int j){
int tmp = array[i];
array[i]=array[j];
array[j]=tmp;
}
/**
* 时间复杂度:O(N^2)
* 空间复杂度:O(1)
* 稳定性:不稳定
* @param array 待排序数组
*/
public static void selection(int[] array){
for(int i = 0;i<array.length;i++){
int minIndex = i;//假设最小值下标一开始是i
for(int j = i+1;j<array.length;j++){
if(array[minIndex]>array[j]){
minIndex=j;//找到最小值小标
}
}
//如果不是i所在位置元素是最小,那么就要交换元素
if(minIndex!=i){
Swap(array,i,minIndex);
}
}
}
}
对于选择排序而言,无论数组是否有序,时间复杂度都为O(N^2)!
🍀 堆排序
堆排序就是就是我们之前讲过堆的调整。
代码如下:
public class TestSort {
public static void main(String[] args) {
int[] array = {12,23,43,52,24,64,78,0,1,4};
HeapSort(array);
System.out.println(Arrays.toString(array));
}
//交换元素位置
public static void Swap(int[] array,int i,int j){
int tmp = array[i];
array[i]=array[j];
array[j]=tmp;
}
/**
* 时间复杂度:O(N*logN)
* 空间复杂度:O(1)
* 稳定性:不稳定
* @param array 待排序数组
*/
public static void HeapSort(int[] array){
//调整建大堆
for(int parent = (array.length-1-1)/2;parent>=0;parent--){
shiftDown(array,parent,array.length);
}
//开始排序
int end = array.length-1;
while (end>0){
//将最大的放到最后
Swap(array,0,end);
end--;
//除去最大的之后,堆重新调整,对0位置调整
shiftDown(array,0,end);
}
}
public static void shiftDown(int[] array,int parent,int len){
int child = 2*parent+1;
while (child<len){
//找到左右节点的最大值
if(child+1<len&&array[child]<array[child+1]){
child++;
}
if(array[child]>array[parent]){
Swap(array,parent,child);
parent=child;
child=2*parent+1;
}else{
break;
}
}
}
}
🌱 冒泡排序
冒泡排序的时间复杂度:O(N^2)
空间复杂度:O(1)
稳定性:稳定
图解冒泡排序