常见的排序-Java详解

最新推荐文章于 2022-08-11 20:11:26 发布
最新推荐文章于 2022-08-11 20:11:26 发布
阅读量671 收藏 3
点赞数 16
分类专栏： Java 数据结构 文章标签： java 排序算法 算法 排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sjp151/article/details/123153666
版权

排序

排序的稳定性

如下图所示：
在这里插入图片描述
通过上面这种方法就能判断排序是否稳定。一个稳定的排序，可以实现为不稳定的排序，但是一个本身不稳定的排序，是不能变成稳定的排序。

直接插入排序

类似于冒泡排序。假设有如下数据：12 5 9 4 10，拿第一个数据，然后用后面的数据和它相比较，放在前面。如下图所示：
在这里插入图片描述
默认第一个数据是有序的，然后用后面的数据和这个数据比较。如果比这个数据小的话，就放在这个数前面，反之就不变。代码如下：

public static void insertSort(int[] array) {
    for (int i = 1; i < array.length; i++) {
        int tmp = array[i];
        int j = i - 1;
        for (j = i - 1; j >= 0; j--) {
            if (array[j] > tmp) {
                array[j + 1] = array[j];
            } else {
                break;
            }
        }
        //j 回退到了小于 0 的情况下
        array[j + 1] = tmp;
    }
}
public static void main(String[] args) {
    int[] arr = {12,5,18,10,4,2};
    insertSort(arr);
    System.out.println(Arrays.toString(arr));
}

运行结果如下：
在这里插入图片描述

复杂度及稳定性

时间复杂度：O(N^2) 最好是O(N)：对于直接插入排序，最好的情况就是数据本身就有序。
空间复杂度：O(1)
稳定性：稳定

希尔排序

假设要给 10000 个数据排序，如果使用直接插入排序的话，就是 10000*10000 = 100000000 排序的计算次数就很大，但是如果把 10000 个数据分为 100组，每次排 100 个，那么就是排 1000000 次，时间复杂度就会小很多。这就是希尔排序，把排序内容分开，然后再去排。主要就是分组。假如要排这些数据：12 5 9 34 6 8 33 56 89 0 7 4 22 55 77 。最后一定要看作一组，也就是说前面大于1组的，都是预排序。分组的组数建议是素数。并且是按照增量来分组的。所以上面数据就是这样分组的：
在这里插入图片描述
按照增量来分组。所以第一次排序的结果就是：
在这里插入图片描述
然后再次分为 3 组进行排序，结果就是：
在这里插入图片描述
最后再按照一组来排序就可以了。代码如下：

public static void shell(int[] arr, int gap) {
    for (int i = gap; i < arr.length; i++) {
        int tmp = arr[i];
        int j = 0;
        for (j = i - gap; j >= 0; j -= gap) {
            if (arr[j] > tmp) {
                arr[j + gap] = arr[j];
            } else {
                break;
            }
        }
        arr[j + gap] = tmp;
    }
}
public static void shellSort(int[] arr) {
    int gap = arr.length;
    while (gap > 1) {
        shell(arr, gap);
        gap /= 2;
    }
    shell(arr, 1);//保证最后是一组
}
public static void main(String[] args) {
    int[] arr = {12,5,18,10,4,2};
    shellSort(arr);
    System.out.println(Arrays.toString(arr));
}

运行结果如下：
在这里插入图片描述

复杂的及稳定性

时间复杂度：O(N^1.3~N^1.5)，因为排序的时候，会有不同的分组情况，所以复杂度是一个范围。
空间复杂度：O(1)
稳定性：不稳定

选择排序

选择排序就是每次都找到一个最小值，然后放在最前面。每次都从 i 后面寻找。直到排序完成。如下图所示：
在这里插入图片描述
所以代码如下：

public static void selectSort(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        int minIndex = i;
        for (int j = i + 1; j < arr.length; j++) {
            //找到最小值
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        int tmp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = tmp;
    }
}
public static void main(String[] args) {
    int[] arr = {12,5,18,10,4,2};
    selectSort(arr);
    System.out.println(Arrays.toString(arr));
}

在这里插入图片描述

复杂度及稳定性

时间复杂度：O(N^2)
空间复杂度：O(1)
稳定性：不稳定

交换方法

这里写一个交换方法，方便下面的排序调用。

public static void swap(int[] array,int i,int j) {
    int tmp = array[i];
    array[i] = array[j];
    array[j] = tmp;
}

堆排序

堆排序要先进行建堆，然后进行交换，最后进行向下调整。堆排序，建的堆是大根堆，然后调整即可。如下图：
在这里插入图片描述
在调整的时候，通过父亲和孩子来进行调整，孩子是父亲的二倍+1。代码如下：

public static void createHeap(int[] array) {
    for (int parent = (array.length-1-1)/2; parent >= 0; parent--) {
        shiftDown(array, parent, array.length);
    }
}
//向下调整
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++;
        }
        //child 下标 就是左右孩子最大值的下标
        if (array[child] > array[parent]) {
            swap(array,child,parent);
            parent = child;
            child = 2*parent+1;
        } else {
            break;
        }
    }
}
public static void main(String[] args) {
    int[] arr = {12,5,18,10,4,2,23,546,97,34,89};
    heapSort(arr);
    System.out.println(Arrays.toString(arr));
}

运行结果如下：
在这里插入图片描述

复杂度及稳定性

时间复杂度：O(N*log N)
空间复杂度：O(1)
稳定性：不稳定

冒泡排序

冒泡排序就是比较两个值的大小，然后互换。直到把最大的元素放到最后面。如图所示：
在这里插入图片描述
每次排序的时候，都要少排一次，因为那个位置已经有序了。代码如下：

public static void bubbleSort(int[] array) {
    for (int i = 0; i < array.length - 1; i++) {
        boolean flg = false;
        for (int j = 0; j < array.length-1-i; j++) {
            if (array[j] > array[j+1]) {
                if (array[j] > array[j+1]) {
                    swap(array, j, j+1);
                    flg = true;
                }
            }
        }
        if (flg == false) {
            break;
        }
    }
}
public static void main(String[] args) {
    int[] arr = {12,5,18,10,4,2,23,546,97,34,89};
    bubbleSort(arr);
    System.out.println(Arrays.toString(arr));
}

运行结果如下：
在这里插入图片描述

复杂度及稳定性

时间复杂度：O(N^2)
空间复杂度：O(1)
稳定性：稳定

快速排序

快速排序是从待排序区间挑一个数，一般是以第一个值为基准。然后遍历排序区间，将比基准值小的放到左边。比基准值大的放到右边。一次快速排序之后，会分为比基准值小的一部分和比基准值大的一部分。然后继续这样排序，直到最后数据有序。这里是用“挖坑法”来做。比如待排数据是：6 1 2 7 9 3 4 5 10 8 。挖坑法如下图：
在这里插入图片描述
在每次排序的时候，都要去找基准，然后比较排序。每次的 left 和 right 都会改变。代码如下：

public static void quickSort(int[] array) {
    quick(array, 0, array.length - 1);
}
public static void insertSort2(int[] array, int start, int end) {
    for (int i = 1; i <= end; i++) {
        int tmp = array[i];
        int j = i - 1;
        for (j = i - 1; j >= 0; j--) {
            if (array[j] > tmp) {
                array[j + 1] = array[j];
            } else {
                break;
            }
        }
        //j 回退到了小于 0 的情况下
        array[j + 1] = tmp;
    }
}
public static void quick(int[] array, int start, int end) {
    if (start >= end) {
        return;
    }
    //如果区间内的数据，在排序过程中，小于某个范围了，可以使用直接插入排序
    if (end - start + 1 <= 40) {
        //使用直接插入排序
        insertSort2(array, start, end);
    }
    //找到基准
    int pivot = partition(array, start, end);
    //处理左边
    quick(array,start,pivot-1);
    //处理右边
    quick(array,pivot+1,end);
}

private static int partition(int[] array, int start, int end) {
    int tmp = array[start];
    while (start < end) {
        while (array[end] >= tmp && start < end) {
            end--;
        }
        //end 下标遇到了小于 tmp 的值
        array[start] = array[end];
        while (array[start] <= tmp && start < end) {
            start++;
        }
        //start 下标遇到了大于 tmp 的值
        array[end] = array[start];
    }
    array[start] = tmp;
    return start;
}
public static void main(String[] args) {
    int[] arr = {12,5,18,10,4,2,23,546,97,34,89};
    quickSort(arr);
    System.out.println(Arrays.toString(arr));
}

主要框架就是，前面找比它小的，后面找比它大的。然后分而治之。运行结果如下：
在这里插入图片描述

复杂度及稳定性

时间复杂度：O(N*log以2为底N) 最大是：O(N^2)。因为最坏情况下是数据有序，那么就变成了单分支的树了。
空间复杂度：O(logN) 最坏是：O(N)
稳定性：不稳定

归并排序

因为内存中无法把所有数据放下，所以需要外部排序，而归并排序是最常用的外部排序（外部是指数据在硬盘）。归并排序就是先将每个子序列有序化，然后再使子序列段间有序。如下图所示：
在这里插入图片描述
每次都是先分解，分解之后再合并，直到最后合并为一个有序序列。

递归方法

递归方法就是，先左边进行排序，然后右边进行排序。最后再合并。代码如下：

public static void mergeSort1(int[] array) {
    mergeSortInternal(array,0, array.length-1);
}
private static void mergeSortInternal(int[] array, int low, int high) {
    if (low >= high) {
        return;
    }
    int mid = low + (high - low)/2;
    //左边
    mergeSortInternal(array, low, mid);
    //右边
    mergeSortInternal(array, mid+1, high);
    //合并
    merge(array,low,mid,high);
}
private static void merge(int[] array, int low, int mid, int high) {
    int[] tmp = new int[high-low+1];
    int index = 0;
    int s1 = low;
    int e1 = mid;
    int s2 = mid+1;
    int e2 = high;
    while (s1 <= e1 && s2 <= e2) {
        if (array[s1] <= array[s2]) {
            tmp[index++] = array[s1++];
        } else {
            tmp[index++] = array[s2++];
        }
    }
    while (s1 <= e1) {
        tmp[index++] = array[s1++];
    }
    while (s2 <= e2) {
        tmp[index++] = array[s2++];
    }
    //说明排好序了，拷贝 tmp 数组的元素放到原来的数组当中
    for (int i = 0; i < index; i++) {
        array[i+low] = tmp[i];
    }
}
public static void main(String[] args) {
    int[] arr = {12,5,18,10,4,2,23,546,97,34,89};
    mergeSort1(arr);
    System.out.println(Arrays.toString(arr));
}

运行结果如下：
在这里插入图片描述

非递归方法

非递归方法就是先以一个数据为一组，然后再换成多个数据为一组，直到有序。要注意不要越界。代码如下：

public static void mergeSort(int[] array) {
    int nums = 1;//代表每组的数据个数
    while (nums < array.length) {
        //数组每次都要进行遍历
        for (int i = 0; i < array.length; i += nums*2) {
            int left = i;
            int mid = left+nums-1;
            //防止越界
            if (mid >= array.length) {
                mid = array.length - 1;
            }
            int right = mid+nums;
            if (right >= array.length) {
                right = array.length - 1;
            }
            //下标确定之后，进行合并
            merge(array, left, mid, right);
        }
        nums *= 2;
    }
}
public static void main(String[] args) {
    int[] arr = {12,5,18,10,4,2,23,546,97,34,89};
    mergeSort(arr);
    System.out.println(Arrays.toString(arr));
}

运行结果如下：
在这里插入图片描述

复杂度及稳定性

时间复杂度：O(N*log以2为底N)
空间复杂度：O(N)
稳定性：稳定
海量数据排序：内存只有1G 排序的数据有100G 。使用归并排序。排序方法如下：

  1. 把 100 G的文件切成 200 分，每个 512 M
  2. 分别对 512 M排序，因为内存已经可以放得下，所以任意排序方式都可以
  3. 进行 200 路归并，同时对 200 份有序文件做归并过程，最终结果就有序了
Lockey-s
关注
  • 16
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 16
    评论
专栏目录
java实现数据结构常见排序算法及详解
11-08
详细讲述了8中常见算法的原理及思想，并用JAVA进行了实现，代码中有详细的注释，解释了算法的实现逻辑和一些小技巧。
c++头文件之Vector(Vector的用法)
热门推荐
C_1223_的博客
03-08 2万+
c++头文件之Vector 开始学习c++,再这个过程中第一个令人头疼的地方就是头文件的含义了,c++头文件的内容会随着我的深入学习进行更新. 首先,我们需要该清楚Vector的定义: C++标准库提供了被封装的动态数组——Vector。大体上讲,就是更容易上手的动态数组.让我们看看Vector的优缺点. 优点: 1). Vector可以存放任意类型的数据 2). 容量可以自动扩展 3). 初始化形式简单,多样 4). 可以插入或删除元素 5). 可以获取数组的长度(是否为空) 6).
LeetCode 2231. 按奇偶性交换后的最大数字
Michael是个半路程序员
04-10 626
文章目录1. 题目2. 解题 1. 题目 给你一个正整数 num 。你可以交换 num 中 奇偶性 相同的任意两位数字（即，都是奇数或者偶数）。 返回交换 任意 次之后 num 的 最大 可能值。 示例 1： 输入：num = 1234 输出：3412 解释：交换数字 3 和数字 1 ，结果得到 3214 。 交换数字 2 和数字 4 ，结果得到 3412 。 注意，可能存在其他交换序列，但是可以证明 3412 是最大可能值。 注意，不能交换数字 4 和数字 1 ，因为它们奇偶性不同。 示例 2： 输入：
按奇偶性交换后的最大数字（c语言）
l5897的博客
08-11 560
2231.按奇偶性交换后的最大数字
leetcode 6037. 按奇偶性交换后的最大数字 java
乾坤未定，你我皆是黑马
04-10 568
https://leetcode-cn.com/problems/largest-number-after-digit-swaps-by-parity/ class Solution { public int largestInteger(int num) { ArrayList<Integer> odds=new ArrayList<>(); ArrayList<Integer> evens=new ArrayList<&g
C++vector 用法整理
QiaoLiu___lq的博客
02-16 1181
c++中vector的用法整理
Java 7大常见排序方法实例详解
08-30
主要通过实例介绍了Java中常用的7种排序方法，需要的朋友可以参考下
常用Java排序算法详解
08-31
本文主要介绍了java的七种常见排序算法的实现，对选择排序、插入排序、冒泡排序、归并排序、快速排序、希尔排序、最小堆排序进行原理分析与实例介绍，具有很好的参考价值。下面就跟着小编一起来看下吧
Java常见经典算法详解-选择排序(Selection Sort)
12-21
选择排序(Selection Sort)算法简介：  选择排序是利用逐个选择的方式进行排序，逐个选择出数组中的最小（或最大）的元素，顺序放在已排好序的序列后面，直到全部记录排序完毕。 选择排序(Selection Sort)算法原理：...
Java数组常见应用详解【创建、遍历、排序、查找】
08-25
主要介绍了Java数组常见应用,结合实例形式详细分析了java数组的基本定义、创建、遍历、排序、查找等相关操作技巧与使用注意事项,需要的朋友可以参考下
leetcode 2231. 按奇偶性交换后的最大数字,617. 合并二叉树
m0_56231540的博客
04-13 785
2231. 按奇偶性交换后的最大数字 给你一个正整数num。你可以交换num中奇偶性相同的任意两位数字（即，都是奇数或者偶数）。 返回交换任意次之后num的最大可能值。 示例 1： 输入：num = 1234 输出：3412 解释：交换数字 3 和数字 1 ，结果得到 3214 。 交换数字 2 和数字 4 ，结果得到 3412 。 注意，可能存在其他交换序列，但是可以证明 3412 是最大可能值。 注意，不能交换数字 4 和数字 1 ，因为它们奇偶性不同。 示例 ...
基于eNSP的校园网
xiaolong1155的博客
03-20 1万+
一 前言 1.1 选题的目的和意义 在传统的校园网网中，网络通常是三层结构。三层网络结构是采用层次化架构的三层网络，有三个层次：核心层(网络的高速交换主干)、汇聚层(提供基于策略的连接)、接入层(将工作站接入网络)。网络结构相对复杂，网络管理人员比较幸苦，需要对各个网络设备进行配置。因此本次设计引入大二层校园网络。 大二层校园网用户全部在核心交换机上认证，汇聚、接入设备不需要维护复杂的网络协议，层次清晰，架构稳定，方便管理，易于扩展和维护。 1.2 主要研究内容 校园网通常包括:校园一卡.....
分组交换
Ingsuifon的博客
10-31 1万+
什么是分组交换？ 电路交换 电路交换最早用于电话网络，两台电话之间用专有电线连接，一台电话只能和连在电线上的另一台电话通信。 但实际上，为了能和其他人通信，专有电线会连接到交换中心。在交换中心，操作员会手工将输入的专有电线连接到待连接的电话的专有电线上。这里的重点是电线从通话开始到结束都是专有的。 今天使用的电路交换网都是自动切换的。 容易想到，打一个电话要经过三个阶段。首先，我们拿起听筒并拨号，拨打的号码说明了我们要连接的地方。这样就形成了从一端到另一端到专有电路，这样一来，专有电路将遍历所有电路，
【组网工程】cisco packet tracer 交换机组网
NingHai's blog
04-30 5959
验证性交换机组网 正文开始@Assassin 目录：验证性交换机组网1. 交换机基础配置：1.1 交换机配置主机名：1.2 登录密码：1.3 虚拟终端密码:1.4 进入特权模式密码:1.5 管理ip：2. 单交换机vlan设置：2.1 主机相互ping2.2 划分不同vlan：3. 跨交换机vlan配置：3.1 划分不同vlan：3.2 配置trunk端口：4. 用svi方式实现跨vlan通信： 一. 实验目的： 能够熟练使用Packet Tracer软件，进行网络仿真，正确配置网络设备，查看网络配置参
数据结构与算法比赛：力扣周赛288
平什么阿的博客
04-13 375
https://leetcode-cn.com/contest/weekly-contest-288/ 文章目录2231. 按奇偶性交换后的最大数字2232. 向表达式添加括号后的最小结果Java String indexOf() 方法Java substring() 方法2233. K 次增加后的最大乘积2234. 花园的最大总美丽值 2231. 按奇偶性交换后的最大数字 每个数和后面数判断是否同为奇同为偶，可以直接两个数相加看是否为奇数，因为奇偶性相同的两个数相加一定是偶数，奇偶数不同的两个数相加一定
物理隔离与数据交换-网闸原理与误区
浮标专栏
11-16 4506
 网闸技术的需求来自内网与外网数据互通的要求，比如政府的电子政务是对公众服务，与互联网连通，而内网的政府办公网络，由于保密的要求，内网若与网连通，则面临来自公网的各种威胁……一、什么是网闸　　网闸技术的需求来自内网与外网数据互通的要求，比如政府的电子政务是对公众服务，与互联网连通，而内网的政府办公网络，由于保密的要求，内网若与网连通，则面临来自公网的各种威胁。安全专家给出的建议是：由于目前
Leetcode第 285 & 288 场周赛 题解
DeathYmz的博客
04-10 419
第 285 场周赛 2210. 统计数组中峰和谷的数量 int countHillValley(vector<int>& nums) { vector<int> v; int n = 0; for(int i=0;i<nums.size();i++){ if(n==0) v.push_back(nums[i]),n++; else if(v[n-1]!=nums[i]) v.push_back
6037. 按奇偶性交换后的最大数字
qq_51134950的博客
04-10 279
6037. 按奇偶性交换后的最大数字 题目描述： 解法：分别记录奇数、偶数，然后排序，最后将奇数、偶数放到合适位置 class Solution { public int largestInteger(int num) { List<Integer> odd = new ArrayList<>();//记录偶数元素 List<Integer> even = new ArrayList<>();//记录奇数元素
vector容器小结
qq_50917103的博客
10-25 237
vector 一、概念 vector本质就是一个封装好的数组（也就是数组描述的线性表），使用vector可以方便快捷的实现对数组中元素进行某些操作。 二、vector的声明 1、一维数组的声明 a、vector<T> vec(n) 声明一个有n个元素的数组，数组中的元素为T类型 vector<char> vec(10); b、vector<T> vec(n,a) 声明一个有n个元素的数组，数组中元素为T类型，而且将数组中所有元素 初始...
java排序算法详解
最新发布
01-07
在Java中，常见的排序算法包括冒泡排序、选择排序、插入排序、快速排序、归并排序等。 冒泡排序是一种比较简单的排序算法，它通过对相邻的元素进行比较和交换来实现排序。该算法的时间复杂度为O(n^2)，属于比较低效...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 16
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Lockey-s

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值