排序
参考文章:
排序算法时间复杂度
注意点:
- 「基数排序」适用于正整数、字符串、特定格式的浮点数排序，kk 为最大数字的位数；「桶排序」中 kk 为桶的数量
- 普通「冒泡排序」的最佳时间复杂度为 O(N^2) ，通过增加标志位实现 提前返回 ，可以将最佳时间复杂度降低至 O(N) 。
- 在输入列表完全倒序下，普通「快速排序」的空间复杂度劣化至 O(N) ，通过代码优化 Tail Call Optimization 保持算法递归较短子数组，可以将最差递归深度降低至 logN 。
- 普通「快速排序」总以最左或最右元素为基准数，因此在输入列表有序或倒序下，时间复杂度劣化至 O(N^2) ；通过 随机选择基准数 ，可极大减少此类最差情况发生，尽可能地保持 O(NlogN) 的时间复杂度。
- 若输入列表是数组，则归并排序的空间复杂度为 O(N) ；而若排序 链表 ，则「归并排序」不需要借助额外辅助空间，空间复杂度可以降低至 O(1) 。
冒泡排序
/**
* 简单冒泡排序
*
* @param nums
*/
public static void bubbleSort(int[] nums) {
int N = nums.length;
// 外循环
for (int i = 0; i < N - 1; i++) {
// 内循环
for (int j = 0; j < N - i - 1; j++) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j], nums[j + 1]
int tmp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = tmp;
}
}
}
}
优化方式:
/**
* 优化的冒泡排序
*
* @param nums
*/
public static void bubbleOptimizedSort(int[] nums) {
int N = nums.length;
for (int i = 0; i < N - 1; i++) {
boolean flag = false; // 初始化标志位
for (int j = 0; j < N - i - 1; j++) {
if (nums[j] > nums[j + 1]) {
int tmp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = tmp;
flag = true; // 记录交换元素
}
}
if (!flag) break; // 内循环未交换任何元素，则跳出
}
}
选择排序
/**
* 选择排序
* @param arr
*/
public static void selectSort(int[] arr){
//1.外循环:每次循环选择一个最小的放到指定位置
for (int i = 0; i < arr.length; i++){
//2.内循环: 每次循环帅选出最小值
int min = arr[i]; //默认i为当前最小值
int index = i; //记录最小值的索引
for (int j = i + 1; j < arr.length; j++ ){
if (arr[j] < min){
index = j;
min = arr[index]; //更新最小值
}
}
//3.将最小值放到(交换)对应位置
if (index != i){
arr[index] = arr[i];
arr[i] = min;
}
}
}
插入排序
//插入排序
public static void insertSort(int[] arr) {
int insertVal = 0; //需要插入的值
int insertIndex = 0; //插入的位置
//1.外部循环 每次循环插入一个数据
for (int i = 1; i < arr.length; i++) {
//2.内部循环 每次while循环查找到插入的位置
insertVal = arr[i]; //定义待插入的数
insertIndex = i - 1; //即arr[i]的前面这个数的下标
// 给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--;
}
//2.当退出while循环时，说明插入的位置找到, insertIndex + 1
if (insertIndex + 1 != i) { //这里我们判断是否需要赋值
//这里为什么要 +1 存在两种场景
//1.while循环未进入 此时因为i - 1 向前移动了一位， 所以需要 + 1
//2.进入了while循环， 此时因为 循环退出时 insertIndex--; 向前移动了一位， 所以需要 + 1
//3.因此最终处理数据时需要+1操作
arr[insertIndex + 1] = insertVal;
}
System.out.println("第" + i + "轮插入");
System.out.println(Arrays.toString(arr));
}
}
希尔排序
//对交换式的希尔排序进行优化->移位法
public static void shellSort2(int[] arr) {
//1.进行分组
for (int gap = arr.length / 2; gap > 0; gap /= 2) {
//2.将所有分组进行插入排序
//此处循环做两件事:1.循环每个组内的数据排序 2.循环每个分组进行插入排序
for (int i = gap; i < arr.length; i++) {
//3.进行插入处理
int j = i;
int temp = arr[j];
if (arr[j] < arr[j - gap]) {
//4.向左移动坐标，查找需要插入的位置
while (j - gap >= 0 && temp < arr[j - gap]) {
//移动
arr[j] = arr[j - gap];
j -= gap;
}
//5.将数据插入到对应位置
arr[j] = temp;
}
}
}
}
快速排序实现代码 (使用递归)
package com.arithmetic;
import java.util.Arrays;
import java.util.stream.Collectors;
/**
* @author mazhiyuan
* @date 2022/01/06
*/
public class QuickSort {
/**
* @param arr
* @param low
* @param high
*/
public static void quickSort(int[] arr, int low, int high) {
// 1.递归截止条件 大于
if (low > high) {
return;
}
// 2.递归具体逻辑
// 2.1递归数据处理逻辑（递归前处理）
int mid = dealData(arr, low, high);
// 2.2递归方法调用切点
//递归调用左半数组
quickSort(arr, low, mid - 1);
//递归调用右半数组
quickSort(arr, mid + 1, high);
}
/**
* @param arr
* @param low
* @param high
* @return int
*/
private static int dealData(int[] arr, int low, int high) {
int i, j, temp, t;
i = low;
j = high;
//temp就是基准位
temp = arr[low];
while (i < j) { // 小于
//当选择左边作为基准 时必须从右边开始移动。 因为交换会将小的值交换到左边，基准值交换到右边 这样才符合从小到大排序。
//先从右边，依次往左递减
while (temp <= arr[j] && i < j) {
j--;
}
//再从左边，依次往右递增
while (temp >= arr[i] && i < j) {
i++;
}
//如果满足条件则交换
if (i < j) {
t = arr[j];
arr[j] = arr[i];
arr[i] = t;
}
}
//最后将基准为与i和j相等位置的数字交换 等于
arr[low] = arr[i];
arr[i] = temp;
// i j 相等此处返回两者都可以， i, j 都为此次循环的中间值 / 中间位置
return j;
}
public static void main(String[] args) {
int[] arr = {10, 7, 2, 4, 7, 62, 3, 4, 2, 1, 8, 9, 19};
// int[] arr = {2, 1};
quickSort(arr, 0, arr.length - 1);
System.out.println(Arrays.stream(arr).boxed().collect(Collectors.toList()));
}
}
归并排序(使用递归)
package com.arithmetic;
import java.util.Arrays;
/**
* @author mazhiyuan
* @date 2022/01/07
*/
public class MergeSort {
/**
* @param arr
*/
public static void sort(int[] arr) {
//在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
int[] temp = new int[arr.length];
mergeSort(arr, 0, arr.length - 1, temp);
}
/**
* @param arr
* @param left
* @param right
* @param temp
*/
private static void mergeSort(int[] arr, int left, int right, int[] temp) {
//1.递归终止条件
if (left >= right){
return;
}
//2.递归方法调用切点
int mid = (left + right) / 2; //设置mid
mergeSort(arr, left, mid, temp); //左边归并排序，使得左子序列有序
mergeSort(arr, mid + 1, right, temp); //右边归并排序，使得右子序列有序
//3.递归数据处理(合并数据)
merge(arr, left, mid, right, temp); //将两个有序子数组合并操作
}
/**
* @param arr
* @param left
* @param mid
* @param right
* @param temp
*/
private static void merge(int[] arr, int left, int mid, int right, int[] temp) {
//1.数据循环比较
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++];
}
}
//2.处理比较循环后剩余剩余数据(因为两边数据个数不一定相等)
while (i <= mid) {//将左边剩余元素填充进temp中
temp[t++] = arr[i++];
}
while (j <= right) {//将右序列剩余元素填充进temp中
temp[t++] = arr[j++];
}
//3.将temp中的元素全部拷贝到原数组中
t = 0; //重置临时数组坐标
while (left <= right) {
arr[left++] = temp[t++];
}
}
/**
* @param args
*/
public static void main(String[] args) {
int[] arr = {9, 8, 7, 6, 5, 4, 3, 2, 1};
sort(arr);
System.out.println(Arrays.toString(arr));
}
}
基数排序
package com.arithmetic.sort;
import java.util.Arrays;
/**
* 基数排序
*
* @author mazhiyuan
* @date 2022/01/13
*/
public class RadixSort {
public static void main(String[] args) {
int arr[] = {53, 3, 542, 748, 14, 214};
//1.定义一个二维数组，表示10个桶, 每个桶就是一个一维数组
int[][] bucket = new int[10][arr.length];
//2.为了记录每个桶中，实际存放了多少个数据,我们定义一个一维数组来记录各个桶的每次放入的数据个数
int[] bucketElementCounts = new int[10];
//3.进行基数排序
radixSort(arr, bucket, bucketElementCounts);
System.out.println("基数排序后 " + Arrays.toString(arr));
}
//基数排序方法
public static void radixSort(int[] arr, int[][] bucket, int[] bucketElementCounts) {
//0. 得到数组中最大的数的位数
int maxLength = getMaxLength(arr);
//1.外循环 基数排序次数
for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {
//2.循环将数据放到不同的桶中
for (int j = 0; j < arr.length; j++) {
//取出每个元素的对应位的值
int digitOfElement = arr[j] / n % 10;
//放入到对应的桶中
bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
bucketElementCounts[digitOfElement]++;
}
//3.遍历每一桶，并将桶中是数据，放入到原数组
int index = 0;
for (int k = 0; k < bucketElementCounts.length; k++) {
//如果桶中，有数据，我们才放入到原数组
if (bucketElementCounts[k] != 0) {
//循环该桶即第k个桶(即第k个一维数组), 放入
for (int l = 0; l < bucketElementCounts[k]; l++) {
//取出元素放入到arr
arr[index++] = bucket[k][l];
}
}
//第i+1轮处理后，需要将每个 bucketElementCounts[k] = 0 ！！！！
bucketElementCounts[k] = 0;
}
System.out.println("第" + (i + 1) + "轮，对个位的排序处理 arr =" + Arrays.toString(arr));
}
}
/**
* 获取长度
*
* @param arr
* @return int
*/
private static int getMaxLength(int[] arr) {
//1. 得到数组中最大的数的位数
int max = arr[0]; //假设第一数就是最大数
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
//得到最大数是几位数
int maxLength = (max + "").length();
return maxLength;
}
}