这里showDetails标志表示是否输出算法排序的过程
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* @Classname SortMethodStudy
* @Description TODO
* @Date 2021/5/19 15:22
* @Created by yin
*/
public class SortMethodStudy {
static boolean showDetails = true;
public static void main(String[] args) {
int[] ints = {35, 84, 21, 47, 15, 27, 68, 25, 20};
quickSort(ints,0,ints.length-1);
System.out.println(Arrays.toString(ints));
}
static void swap(int[] data, int i, int j) {
int temp = data[i];
data[i] = data[j];
data[j] = temp;
}
// 冒泡排序:注意冒泡排序有一个剪枝逻辑
static void bubbleSort(int[] data) {
boolean changeFlag;
for (int i = 1; i < data.length; i++) {
changeFlag = false;
for (int j = 1; j < data.length; j++) {
if (data[j] < data[j - 1]) {
swap(data, j - 1, j);
changeFlag = true;
}
}
if(showDetails) System.out.println(Arrays.toString(data)); // 显示路径
if (!changeFlag) break; //本趟排序没有发生元素交换则整个序列已经有序，直接结束
}
}
// 插入排序
static void insertSort(int[] data) {
for (int i = 1; i < data.length; i++) {
for (int j = i - 1; j >= 0; j--) {
if (data[j] > data[j + 1]) {
swap(data, j, j + 1);
} else {
break;
}
}
if(showDetails) System.out.println(Arrays.toString(data)); // 显示路径
}
}
//选择排序
static void chooseSort(int[] data) {
for (int i = 0; i < data.length; i++) {
int tempIndex = i;
for (int j = i + 1; j < data.length; j++) {
if (data[tempIndex] > data[j]) {
tempIndex = j;
}
}
if (tempIndex != i) { //如果最小元素的索引不是i则交换索引为tempIndex和i的两个元素
swap(data, tempIndex, i);
}
if(showDetails) System.out.println(Arrays.toString(data)); // 显示路径
}
}
/**
* 快速排序：
* 通过一趟排序将待排记录按照一个基准值分隔成独立的两部分，其中一部分记录的值均比另一部分的值小
* 对这两部分记录继续进行快速排序，以达到整个序列有序。
**/
public static void quickSort(int[] data, int low, int high) {
int i, j, temp;
if (low > high) {
return;
}
i = low;
j = high;
//temp就是基准位
temp = data[low];
while (i < j) {
// 从后往前找到第一个比temp小的值
while (temp <= data[j] && i < j) {
j--;
}
// 从左往右找到第一个比temp大的值
while (temp >= data[i] && i < j) {
i++;
}
//如果满足条件则交换
if (i < j) {
swap(data, i, j);
}
}
//最后将基准为与i和j相等位置的数字交换
data[low] = data[i];
data[i] = temp;
if(showDetails) System.out.println(Arrays.toString(data)); // 显示路径
//递归调用左半数组
quickSort(data, low, j - 1);
//递归调用右半数组
quickSort(data, j + 1, high);
}
/**
* 希尔排序：
* 希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。
* 希尔排序是把记录按一定增量分组（例如：增量为5，那么索引为0,5,10，15....的这些元素为一组），对每组使用直接插入排序算法排序；
* 随着增量逐渐减少，每组包含的元素越来越多，当增量减至1时，所有元素被分成一组，算法便终止。
*/
static void heerSort(int[] data) {
heerSubSort(data, 5);
heerSubSort(data, 2);
heerSubSort(data, 1);
}
static void heerSubSort(int[] data, int step) {
for (int i = 0; i < data.length; i += step) {
for (int j = i - step; j >= 0; j -= step) {
if (data[j] > data[j + step]) {
swap(data, j, j + step);
} else {
break;
}
}
}
if(showDetails) System.out.println(Arrays.toString(data)); // 显示路径
}
/**
* 计数排序：
* 空间换时间，将值对应为index, 如果有重复，则记录数量。所以叫计数排序
*/
public static void countingSort(int[] data) {
int min = data[0];//待排数组最小值
int max = data[0];//待排数组最大值
for (int datum : data) {//查找最小值和最大值
if (datum < min) {
min = datum;
}
if (datum > max) {
max = datum;
}
}
int[] rateArray = new int[max - min + 1];//创建频数数组,大小为待排数组中数据出现的所有可能情况，也即是：max-min+1
Arrays.fill(rateArray, 0);//全部填充为0
for (int datum : data) {//遍历待排数组，统计每个数字出现的次数,每个元素在频数数组中的相对位置为：元素值-最小值
rateArray[datum - min]++;
}
int index = 0;
int index_rate = 0;
while (index_rate < rateArray.length) {//依次取出所有已经排序的元素
if (rateArray[index_rate] != 0) {
data[index++] = min + index_rate;//通过相对位置恢复元素的本来值
rateArray[index_rate]--;
} else {
index_rate++;
}
}
}
/**
* 归并排序:
* 将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序;
* 对于子序列递归采用归并排序，直到子序列元素个数为1
*/
public static int[] mergeSort(int[] data) {
if (data == null || data.length < 2) {
return data;
}
//将序列拆分为两个子序列
int mid = data.length / 2;
int[] left = Arrays.copyOfRange(data, 0, mid);
int[] right = Arrays.copyOfRange(data, mid, data.length);
if(showDetails) System.out.println(Arrays.toString(data)); // 显示路径
//合并两个两个子序列，对于两个子序列递归使用归并排序
return merge(mergeSort(left), mergeSort(right));
}
// 将两个归并排序拆分的两个子序列合并为一个序列
public static int[] merge(int[] left, int[] right) {
int[] result = new int[left.length + right.length];//新建一个数组，大小为两个待合并的数组的长度之和，存放合并结果
for (int index = 0, index_left = 0, index_right = 0; index < result.length; index++) {//开始合并
if (index_left >= left.length) {//左边的序列已经全部合并到了结果中，则直接将右边的序列合并到结果中
result[index] = right[index_right++];
} else if (index_right >= right.length) {//右边的序列已经全部合并到了结果中，则直接将左边的序列合并到结果中
result[index] = left[index_left++];
} else if (left[index_left] < right[index_right]) {//判断左边序列和右边序列当前要合并的元素的大小，保证合并的后的结果依然有序
result[index] = left[index_left++];
} else {
result[index] = right[index_right++];
}
}
return result;
}
/**
* 基数排序：
* 基数排序是分别对每一位（个，十，百...）进行排序，
* 每次排序都在前一位已经排序的基础上进行，首先从最低位（个位）开始排序。
*/
public static void radixSort(int[] data) {
int max = data[0];
for (int j : data) {//取得待排数组中的最大值
if (j > max) {
max = j;
}
}
int maxDigit = 0;//最大值的位数
while (max != 0) {//获取最大值的位数
max = max / 10;
maxDigit++;
}
List<List<Integer>> bucket = new ArrayList<>();
for (int i = 0; i < 10; i++) {//每一位只可能是0-9，所以只需要建立10个桶
bucket.add(new ArrayList<Integer>());
}
int mod = 10;
int div = 1;
for (int i = 0; i < maxDigit; i++, mod *= 10, div *= 10) {//从个位开始针对每一位的大小进行排序，直到最高位
for (int k : data) {
int bucketIndex = (k % mod) / div;//获取数据映射的桶的索引，桶的索引就是数据在当前排序的位的值
bucket.get(bucketIndex).add(k);
}
int index = 0;
for (List<Integer> integers : bucket) {//收集本次的排序结果并清空桶，方便下一次的排序
for (Integer integer : integers) {
data[index++] = integer;
}
integers.clear();
}
}
}
/**
* 堆排序：
* 利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足小（大）根堆的性质：即父结点的键值或索引总是小于（或者大于）等于它的子节点。
* 将所有待排序的元素序列构造大根堆，然后将根节点（此时根节点最大）与序列最后一个元素交换位置，此时最后一个元素最大，然后将最后一个元素剔除，也就是放到有序序列中。
* 针对剩下的元素不断重复上述步骤，直到剩下的元素为1
*/
public static int[] heapSort(int[] data) {
if (data == null || data.length < 2) {
return data;
}
for (int i = data.length / 2 - 1; i >= 0; i--) {//从最后一个非叶子节点开始向上构造大根堆，最后一个非叶子节点的索引为sortArray.length/2-1
adjustHeap(data, i, data.length);
}
for (int j = data.length - 1; j > 0; j--) {//经过前面的构造，此时根节点已经是最大的元素
swap(data, 0, j);//将根节点和最后一个节点交换位置
adjustHeap(data, 0, j);//对剩下的元素继续构造大根堆
}
return data;
}
/**
* 调整该节点使之符合大根堆（该节点的值比左右孩子都大）
*
* @param adjustNodeIndex 待调整的节点索引
* @param length 调整的范围
*/
public static void adjustHeap(int[] data, int adjustNodeIndex, int length) {
int maxIndex = adjustNodeIndex;//最大元素的索引，默认为当前调整的节点索引
int leftIndex = 2 * adjustNodeIndex + 1;//当前节点的左孩子索引
int rightIndex = 2 * adjustNodeIndex + 2;//当前节点的右孩子索引
if (leftIndex < length && data[leftIndex] > data[maxIndex]) {//若左孩子的值比最大元素大，则更新最大元素的索引
maxIndex = leftIndex;
}
if (rightIndex < length && data[rightIndex] > data[maxIndex]) {//若右孩子的值比最大元素大，则更新最大元素的索引
maxIndex = rightIndex;
}
if (maxIndex != adjustNodeIndex) {//如果父节点不是最大值，调整父节点为最大值并且调整与父节点交换的节点符合大根堆
swap(data, maxIndex, adjustNodeIndex);
adjustHeap(data, maxIndex, length);
}
if(showDetails) System.out.println(Arrays.toString(data)); // 显示路径
}
/**
* 桶排序:
* 桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。
* 桶排序 假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别使用别的排序算法排序。
*/
public static int[] bucketSort(int[] sortArray, int bucketSize) {
if (sortArray == null || sortArray.length < 2) {
return sortArray;
}
int min = sortArray[0];
int max = sortArray[0];
for (int value : sortArray) {
if (value < min) {
min = value;
}
if (value > max) {
max = value;
}
}
int bucketCount = (max - min) / bucketSize + 1;//桶的个数
List<List<Integer>> bucket = new ArrayList<>();//每个桶是一个List
for (int i = 0; i < bucketCount; i++) {//初始化桶
bucket.add(new ArrayList<Integer>());
}
for (int value : sortArray) {//将数据放入每一个桶中
List<Integer> temp_bucket = bucket.get((value - min) / bucketSize);
temp_bucket.add(value);
}
int index = 0;
for (int i = 0; i < bucketCount; i++) {//遍历所有桶分别进行排序，然后将数据拼接起来
List<Integer> temp_bucket = bucket.get(i);
if (temp_bucket.size() > 0) {
int[] temp_bucket_array = new int[temp_bucket.size()];
for (int j = 0; j < temp_bucket_array.length; j++) {
temp_bucket_array[j] = temp_bucket.get(j);
}
quickSort(temp_bucket_array, 0, temp_bucket_array.length - 1);//每个桶采用快速排序
for (int j : temp_bucket_array) {
sortArray[index] = j;
index++;
}
}
}
return sortArray;
}
}
扫一扫
5396
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
