待更新，未完待续......
import java.util.Arrays;
public class Sort {
public static void main(String[] args) {
/* 均实现升序排序 */
int[] arr = new int[] { 5, 4, 3, 2, 1, 0 };
bubbleSort(arr);
for (int val : arr) {
System.out.print(val + " ");
}
System.out.println();
arr = new int[] { 5, 4, 3, 2, 1, 0 };
selectionSort(arr);
for (int val : arr) {
System.out.print(val + " ");
}
System.out.println();
arr = new int[] { 5, 4, 3, 2, 1, 0 };
insertSort(arr);
for (int val : arr) {
System.out.print(val + " ");
}
System.out.println();
arr = new int[] { 5, 4, 3, 2, 1, 0 };
shellSort(arr);
for (int val : arr) {
System.out.print(val + " ");
}
System.out.println();
arr = new int[] { 5, 4, 3, 2, 1, 0 };
int[] mergeArr = mergeSort(arr);
for (int val : mergeArr) {
System.out.print(val + " ");
}
System.out.println();
arr = new int[] { 5, 4, 3, 2, 1, 0 };
quickSort(arr, 0, arr.length - 1);
for (int val : arr) {
System.out.print(val + " ");
}
}
/**
* 核心思想：每轮将该轮的最大值冒泡到该轮末尾
*
* @Description 冒泡排序 平均时间复杂度:O(n^2) 稳定排序
* @author wukangning
* @date 2022年1月21日下午7:19:45
* @param arr
*/
public static void bubbleSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) { // arr.length - 1个元素都要冒泡一下: 当arr.length - 1个元素都排好序了，最后一个也就排好了
boolean flag = true;// 设定一个标记，若为true，则表示此次循环没有进行交换，也就是待排序列已经有序，排序已经完成
for (int j = 0; j < arr.length - 1 - i; j++) { // 当前元素arr[j]需要和(arr.length - 1 - i)个元素比较
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
flag = false;
}
}
if (flag) {
break;
}
}
}
/**
* 1. 首次在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
* 2. 之后每次再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
* 3. 重复第二步，直到所有元素均排序完毕。
* 4. 外循环要经过（arr.length - 1）轮比较
*
* 核心思想: 每次从未排序序列中选择该未排序序列中最小的元素，放到排序序列的末尾
*
* @Description 选择排序 平均时间复杂度:O(n^2) 非稳定排序
* @author wukangning
* @date 2022年1月21日下午7:28:51
* @param arr
*/
public static void selectionSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) { // 未排序序列一共有arr.length - 1个
int minIndex = i; // 记录每次未排序序列中最小值的索引位置
for (int j = i + 1; j < arr.length; j++) {
minIndex = arr[minIndex] > arr[j] ? j : minIndex;
}
if (minIndex != i) {
int temp = arr[minIndex];
arr[minIndex] = arr[i];
arr[i] = temp;
}
}
}
/**
* 1. 将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
* 2. 从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）
* 4. 外循环要经过（arr.length - 1）轮比较
*
* 核心思想：每次选择未排序序列的第一个元素，在排序序列中选择插入的位置
*
* @Description 插入排序 平均时间复杂度:O(n^2) 稳定排序
* @author wukangning
* @date 2022年1月21日下午7:33:51
* @param arr
*/
public static void insertSort(int[] arr) {
for (int i = 1; i < arr.length; i++) { // 未排序
int temp = arr[i]; // 当前待插入元素
int insertIndex = i;
for (int j = i - 1; j >= 0; j--) { // 已排序
if (arr[j] > temp) {
arr[j + 1] = arr[j];
insertIndex = j;
} else {
break;
}
}
arr[insertIndex] = temp;
}
}
/**
* 在插入排序的基础上改进，所以代码有相似之处
*
* @Description 希尔排序 平均时间复杂度：O(nlogn) 不稳定排序
* @author wukangning
* @date 2022年1月21日下午8:43:48
* @param arr
*/
public static void shellSort(int[] arr) {
int length = arr.length;
for (int step = length / 2; step >= 1; step = step / 2) { // 根据初始增量和每次减少的增量，最后的增量为1时进行的是插入排序
for (int i = step; i < length; i++) { // 未排序
int temp = arr[i];
int insertIndex = i;
for (int j = i - step; j >= 0; j = j - step) { // 已排序
if (arr[j] > temp) {
arr[j + step] = arr[j];
insertIndex = j;
} else {
break;
}
}
arr[insertIndex] = temp;
}
}
}
/**
* 两两合并且排序的算法步骤：
* 1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列。
* 2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置。
* 3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置。
* 4. 重复步骤 3 直到某一指针达到序列尾。
* 5. 将另一序列剩下的所有元素直接复制到合并序列尾。
*
* 核心思想：先向下递归(二分数组),直到每个数组元素个数为1,然后归上去，两两归并的同时进行排序
*
* @Description 归并排序 平均时间复杂度：O(nlogn) 稳定排序
* @author wukangning
* @date 2022年2月22日下午3:47:52
* @param arr
* @return
*/
public static int[] mergeSort(int[] arr) {
if (arr.length == 1) {
return arr;
}
int middle = arr.length / 2;
int[] left = Arrays.copyOfRange(arr, 0, middle);
int[] right = Arrays.copyOfRange(arr, middle, arr.length);
int[] leftVal = mergeSort(left);
int[] rightVal = mergeSort(right);
return merge(leftVal, rightVal);
}
public static int[] merge(int[] left, int[] right) {
int[] result = new int[left.length + right.length];
int k = 0;// result数组的指针
int i = 0;// left数组指针
int j = 0;// right数组指针
while(i < left.length && j < right.length){
if(left[i] < right[j]){
result[k] = left[i];
i++;
}else{
result[k] = right[j];
j++;
}
k++;
}
//将剩下的直接全部移过去
while(i < left.length){
result[k] = left[i];
i++;
k++;
}
while (j < right.length){
result[k] = right[j];
j++;
k++;
}
return result;//result已经是排好序的
}
/**
* 算法：通过不断递下去，将每个分区的基点数据放到每个分区的正确位置，最后顺序就排好了
*
* 核心：如何和把选定的基点数据挪到正确位置上。
*
* @Description 固定基点的快速排序
* @author wukangning
* @date 2022年2月22日下午4:15:33
* @param arr
*/
public static void quickSort(int[] arr, int left, int right) {
if(left < right) {
int partition = partition(arr, left, right);
quickSort(arr, left, partition - 1);
quickSort(arr, partition + 1, right);
}
}
public static int partition(int[] arr, int left, int right) {
int pivot = left; //设置固定的基点
int index = left + 1; //index指向的一定是第一个大于基准元素值的位置 或者 最后一个小于基准元素值的位置
for(int i = index; i <= right; i++) { //[left, right]
if(arr[i] < arr[pivot]) { //如果当前区间的数组中的元素小于基准元素值,放到基点左边
swap(arr, i, index);
index++;
}
}
swap(arr, pivot, index - 1);
return index - 1;
}
public static void swap(int[] arr, int left, int right) {
int temp = arr[left];
arr[left] = arr[right];
arr[right] = temp;
}
public static void heapSort(int[] arr) {
}
public static void countingSort() {
}
public static void bucketSort() {
}
public static void radixSort() {
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
