堆排序
//堆排序
public static void heapSort(int[] arr) {
for (int i = arr.length / 2 - 1; i >= 0; i--) {
adjustHeap(arr, i, arr.length);
}
for (int j = arr.length - 1; j > 0; j--) {
swap(arr, 0, j);
adjustHeap(arr, 0, j);
}
}
//整理堆
private static void adjustHeap(int[] arr, int i, int length) {
int temp = arr[i];
for (int k = 2 * i + 1; k < length; k = 2 * k + 1) {
if ((k + 1) < length && arr[k +1] > arr[k]) {
k++;
}
if (arr[k] > temp) {
arr[i] = arr[k];
i = k;
}
}
arr[i] = temp;
}
//交换数据
private static void swap(int[] arr, int a, int b) {
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
快速排序
/**
* 快速排序
* @param array
* @param left
* @param right
*/
public static void quickSort(int[] array, int low, int high) {
if (low >= high) {
return;
}
int middle = partition(array, low, high);
quickSort(array, low, middle - 1);
quickSort(array, middle + 1, high);
}
private static int partition(int[] array, int low, int high) {
int temp = array[low];
while (low < high) {
while (low < high && array[high] >= temp) {
high--;
}
array[low] = array[high];
while (low < high && array[low] <= temp) {
low++;
}
array[high] = array[low];
}
array[low] = temp;
return low;
}
冒泡排序
//冒泡排序
public static void bubbleSort(int[] array){
for (int i = 0; i < array.length; i++) {
for (int j = i; j < array.length; j++) {
if (array[j] < array[i]) {
int sample = array[j];
array[j] = array[i];
array[i] = sample;
}
}
}
}
####插入排序
//插入排序
public static void insertionSort(int[] array) {
for (int i = 1; i < array.length; i++) {
int key = array[i];
int value = i - 1;
while (value >= 0 && array[value] > key) {
array[value + 1] = array[value];
value--;
}
array[value + 1] = key;
}
}
####选择排序
//选择排序
public static void selectSoft(int[] array) {
for (int i = 0; i < array.length; i++) {
int min = i;
for (int j = i + 1; j < array.length; j++) {
if (array[j] < array[min]) {
min = j;
}
}
if (i != min) {
int temp = array[i];
array[i] = array[min];
array[min] = temp;
}
}
}
####归并排序
//归并排序
public static int[] mergeSort(int[] arrayInt, int low, int high) {
if (low < high) {
int mid = (low + high) / 2;
mergeSort(arrayInt, low, mid);
mergeSort(arrayInt, mid + 1, high);
merge(arrayInt, low, mid, high);
}
return arrayInt;
}
//将两个排列好的数组合并成一个有序数组
private static void merge(int[] arrayInt, int low, int mid, int high) {
int a = mid - low + 1;
int b = high - mid;
int[] xx = new int[a + 1];
int[] yy = new int[b + 1];
for (int i = 0; i < xx.length - 1; i++) {
xx[i] = arrayInt[low + i];
}
for (int i = 0; i < yy.length - 1; i++) {
yy[i] = arrayInt[mid + 1 + i];
}
//设置哨兵
xx[a] = Integer.MAX_VALUE;
yy[b] = Integer.MAX_VALUE;
int n = 0;
int m = 0;
for (int i = low; i <= high; i++) {
if (xx[n] < yy[m]) {
arrayInt[i] = xx[n];
n = n + 1;
} else {
arrayInt[i] = yy[m];
m = m + 1;
}
}
}
####希尔排序
//希尔排序
public static void shellSort(int[] array) {
for (int gap = array.length / 2; gap > 0; gap = gap / 2) {
for (int i = gap; i < array.length; i++) {
int j = i;
while (j - gap >= 0 && array[j] < array[j - gap]) {
int temp = array[j];
array[j] = array[j - gap];
array[j - gap] = temp;
j = j - gap;
}
}
}
}