常用排序算法
package sort;
import java.util.Arrays;
import java.util.Random;
public class SortTest {
public static void main(String[] args) {
Random random = new Random(2);
int[] a = new int[10];
for(int i = 0; i < 10; i++){
a[i] = random.nextInt();
}
System.out.println(Arrays.toString(a));
bubbleSort(a);
insertSort(a);
shellSort(a);
selectSort(a);
int[] b = a.clone();
quickSort(b,0,b.length-1);
System.out.println(Arrays.toString(b));
int[] c = a.clone();
mergeSort(c,0,c.length-1);
System.out.println(Arrays.toString(c));
int[] d = a.clone();
heapifySort(d);
System.out.println(Arrays.toString(d));
}
/** 冒泡 **/
public static void bubbleSort(int[] arrays){
int[] arr = arrays.clone();
int len = arr.length;
boolean isChange = true;
for(int i = 0; i < len-1; i++){
isChange = false;
for(int j = 0; j < len - i - 1; j++){
if(arr[j+1] < arr[j]){
isChange = true;
int tmp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = tmp;
}
}
if(!isChange){
break;
}
}
System.out.println(Arrays.toString(arr));
}
/** 插入 **/
public static void insertSort(int[] arrays){
int[] arr = arrays.clone();
int len = arr.length;
for(int i = 1; i < len; i++){
int j = i;
int tmp = arr[j];
while(j > 0 && arr[j-1] > tmp){
arr[j] = arr[j-1];
j--;
}
arr[j] = tmp;
}
System.out.println(Arrays.toString(arr));
}
/** 希尔排序 **/
public static void shellSort(int[] arrays){
int[] arr = arrays.clone();
for(int step = arr.length / 2; step > 0; step /= 2){
for(int i = step; i < arr.length; i++){
int j = i;
int tmp = arr[j];
while (j - step >= 0 && arr[j - step] > tmp){
arr[j] = arr[j - step];
j = j - step;
}
arr[j] = tmp;
}
}
System.out.println(Arrays.toString(arr));
}
/** 选择 **/
public static void selectSort(int[] arrays){
int[] arr = arrays.clone();
int len = arr.length;
for(int i = 0; i < len-1; i++){
int maxIndex = 0;
for(int j = 0; j < len - i; j++){
if(arr[j] > arr[maxIndex]){
maxIndex = j;
}
}
int tmp = arr[len - i - 1];
arr[len - i - 1] = arr[maxIndex];
arr[maxIndex] = tmp;
}
System.out.println(Arrays.toString(arr));
}
/** 快排 **/
public static void quickSort(int[] arr, int L, int R){
int i = L;
int j = R;
int t = arr[L];
while (i < j){
while (i < j && arr[j] >= t){
j--;
}
arr[i] = arr[j];
while(i < j && arr[i] <= t){
i++;
}
arr[j] = arr[i];
}
arr[i] = t;
if(L < R){
quickSort(arr,L,i-1);
quickSort(arr,i+1,R);
}
}
/** 归并 **/
public static void mergeSort(int[] arr, int L, int R){
if(L==R) return;
int M = (L + R) / 2;
mergeSort(arr,L,M);
mergeSort(arr,M+1,R);
merge(arr,L,M+1,R);
}
public static void merge(int[] arr, int L, int M, int R){
int[] left = new int[M - L];
int[] right = new int[R - M + 1];
for(int i = L; i < M; i++){
left[i- L] = arr[i];
}
for(int i = M; i <= R; i++){
right[i - M] = arr[i];
}
int i = 0;
int j = 0;
int k = L;
while (i < left.length && j < right.length){
if(left[i] < right[j]){
arr[k++] = left[i++];
}else{
arr[k++] = right[j++];
}
}
while(i < left.length){
arr[k++] = left[i++];
}
while (j < right.length){
arr[k++] = right[j++];
}
}
/** 堆排序 **/
public static void heapifySort(int[] arr){
maxHeapify(arr,arr.length-1);
int size = arr.length-1;
for (int i = 0; i < arr.length; i++){
int tmp = arr[0];
arr[0] = arr[arr.length-1 - i];
arr[arr.length-1 -i] = tmp;
heapify(arr, 0, size);
size--;
}
}
public static void maxHeapify(int[] arr, int size){
for (int i = size - 1; i >= 0; i--){
heapify(arr, i, size);
}
}
public static void heapify(int[] arr, int currentRootNode, int size){
if(currentRootNode < size){
int left = 2 * currentRootNode + 1;
int right = 2 * currentRootNode + 2;
int max = currentRootNode;
if(left < size){
if(arr[max] < arr[left]) max = left;
}
if(right < size){
if(arr[max] < arr[right]) max = right;
}
if(max != currentRootNode){
int tmp = arr[max];
arr[max] = arr[currentRootNode];
arr[currentRootNode] = tmp;
heapify(arr, max, size);
}
}
}
}