@[toc]归并排序
归并排序
java排序
import java.util.Arrays;
/**
* @Author:w
* @Modified By:
* @Desc: 归并排序
*/
public class MergetSort {
public static void main(String[] args) {
int[] arr = {1, 2, 25, 11, 66, 89, 552, 52, 13, 65, 2, 66, 22, 6, 9, 333, 2, 36};
int[] temp = new int[arr.length];
mergeSore(arr, 0, arr.length - 1, temp);
System.out.println("mergeSore : " + Arrays.toString(arr));
}
/**
* 归并排序 的 分+治 方法
*
* @param arr
* @param left
* @param right
* @param temp
*/
public static void mergeSore(int[] arr, int left, int right, int[] temp) {
if (left < right) {
int mid = (left + right) / 2;
//向左递归进行分解
mergeSore(arr, left, mid, temp);
//向右递归进行分解
mergeSore(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;//左边有序序列的初始索引
int j = mid + 1;//右边有序序列的初始索引
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;
while (tempLeft <= right) {
arr[tempLeft] = temp[t];
t += 1;
tempLeft += 1;
}
}
}
基数排序
import java.util.Arrays;
import java.util.HashMap;
/**
* @Author:w
* @Date:Created in 17:47 2021/8/20
* @Modified By:
* @Desc: 基数排序
*/
public class RadixSort {
public static void main(String[] args) {
int[] arr = {1, 2, 25, 11, 66, 89, 5521 , 52, 13, 65, 232, 6667, 22, 6, 9, 333, 12, 36};
radixSort(arr);
System.out.println("radixSort"+ Arrays.toString(arr));
}
/**
* 基数排序
* 空间换时间的经典排序算法
*
* @param arr
*/
public static void radixSort(int[] arr) {
//1.获取数组中最大的数的位数
//1.1获取数组中最大的元素
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
//1.2获取最大数的位数
int maxLength = (max + "").length();
//定义一个二维数组,表示10个桶,每个桶就是一个一维数组,这个一维数据的长度 定义为 需要排序的数组的长度
int[][] bucket = new int[10][arr.length];
//为了记录每个桶中实际放了多少数据,定义一个一维数组来记录各个桶每次放入的数据个数
int[] bucketElementCounts = new int[10];
//排序实现
for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {
//按位数进行,排序处理
for (int j = 0; j < arr.length; j++) {
//取出每个元素的对应位的值
int digitOfElement = arr[j] / n % 10;
//放到对应的桶中
bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
bucketElementCounts[digitOfElement]++;
}
//按照这个桶的顺序(一维数组的下表依次取出数据,放入原来数组)
int index = 0;
// 遍历每一个桶,并将桶中是数据的,放入到原数组
for (int k = 0; k < bucketElementCounts.length; k++) {
//如果桶中有数据,我们才放到原数组]
if (bucketElementCounts[k] != 0) {
//循环该桶即 第k桶 ,放入到arr
for (int l = 0; l < bucketElementCounts[k]; l++) {
//取出元素放入到 arr
arr[index++] = bucket[k][l];
}
}
bucketElementCounts[k] = 0;
}
}
}
}