import java.util.Arrays;
/**
* @program: complex
* @description:
* @author: DRY
* @create: 2022-08-02 14:41
**/
public class MySort {
/**
* 插入排序 稳定 O(n)
* @param arr
*/
public static void insertSort(int[] arr) {
for (int i = 1; i < arr.length; i++) {
int tmp = arr[i];
int j = i - 1;
for (; j >= 0 ; j--) {
if(arr[j] > tmp) {
arr[j + 1] = arr[j];
} else{
break;
}
}
arr[j + 1] = tmp;
}
}
/**
* 希尔排序 不稳定 O^1.3 ~ 1.5
* @param arr
*/
public static void shellSort(int[] arr) {
int gap = arr.length;
while(gap > 1) {
shell(arr, gap);
gap /= 2;
}
shell(arr,1);
}
private static void shell(int[] arr, int gap) {
for (int i = 1; i < arr.length; i++) {
int tmp = arr[i];
int j = i - gap;
for(; j >= 0; j -= gap) {
if(arr[j] > tmp) {
arr[j + gap] = arr[j];
} else{
break;
}
}
arr[j + gap] = tmp;
}
}
/**
* 选择排序 不稳定 O(n^2)
* @param arr
*/
public static void selectSort(int[] arr) {
for (int i = 0; i < arr.length; i++) {
for (int j = i + 1; j < arr.length; j++) {
if(arr[j] < arr[i]) {
swap(arr,i,j);
}
}
}
}
/**
* 堆排序 不稳定O(NlogN)
* @param arr
*/
public static void heapSort(int[] arr) {
createHeap(arr);//将数组变为大根堆
int end = arr.length - 1;
while(end > 0) {
swap(arr,0,end);
shiftDown(arr,0,end);
end--;
}
}
private static void createHeap(int[] arr) {
for (int parent = (arr.length - 1 - 1) / 2; parent >= 0 ; parent--) {
shiftDown(arr,parent,arr.length);
}
}
private static void shiftDown(int[] arr, int parent, int length) {
int child = 2 * parent + 1;
while( child < length) {
if(child + 1 < length && arr[child] < arr[child + 1]) {
child = child + 1;
}
if(arr[child] > arr[parent]) {
swap(arr,child,parent);
parent = child;
child = 2 * parent + 1;
} else {
break;
}
}
}
/**
* 冒泡排序 稳定 O(n^2)
* @param arr
*/
public static void bubbleSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
boolean flag = false;
for (int j = 0; j < arr.length - i - 1; j++) {
if(arr[j] > arr[j + 1]) {
swap(arr,j + 1,j);
flag = true;
}
}
if(flag == false) {
break;
}
}
}
/**
* 快速排序 不稳定 O(NlogN)
* @param arr
*/
public static void quickSort(int[] arr) {
quick(arr,0,arr.length - 1);
}
private static void quick(int[] arr, int left, int right) {
if(left > right) {
return;
}
int pivot = partition(arr,left, right); //找到基准值
quick(arr,left, pivot - 1);
quick(arr,pivot + 1,right);
}
private static int partition(int[] arr, int left, int right) {
int tmp = arr[left];
while(left < right) {
while(left < right && arr[right] >= tmp) {
right--;
}
arr[left] = arr[right];
while(left < right && arr[left] <= tmp) {
left++;
}
arr[right] = arr[left];
}
arr[left] = tmp;
return left;
}
/**
* 归并排序 稳定 O(NlogN)
* @param arr
*/
public static void mergeSort(int[] arr) {
mergeSortInternal(arr,0,arr.length - 1);
}
private static void mergeSortInternal(int[] arr, int low, int high) {
if(low >= high) {
return;
}
int mid = low + ((high - low) >>> 1);
mergeSortInternal(arr, low, mid);
mergeSortInternal(arr,mid +1, high);
merge(arr,low,mid,high);
}
private static void merge(int[] arr, int low, int mid, int high) {
int[] tmp = new int[high - low + 1];
int k = 0;
int s1 = low;
int e1 = mid;
int s2 = mid + 1;
int e2 = high;
while(s1 <= e1 && s2 <= e2) {
if(arr[s1] <= arr[s2]) {
tmp[k++] = arr[s1++];
} else {
tmp[k++] = arr[s2++];
}
}
while(s1 <= e1) {
tmp[k++] = arr[s1++];
}
while(s2 <= e2) {
tmp[k++] = arr[s2++];
}
for (int i = 0; i < k; i++) {
arr[i + low] = tmp[i];
}
}
private static void swap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
public static void main(String[] args) {
MySort mySort = new MySort();
int[] data = {2,1,4,6,3,9,8,5,7};
mySort.mergeSort(data);
System.out.println(Arrays.toString(data));
}
}
Common sorting algorithms (7 types)
Guess you like
Origin blog.csdn.net/m0_48273471/article/details/126120986
Recommended
Ranking