7种基本排序算法--java实现

7种基本排序算法有：
直接插入排序、希尔排序；直接选择排序、堆排序；冒泡排序、快速排序；归并排序。实现如下：import java.util.Arrays;

public class SortAlogrithm {

public static void main(String[] args) {
int[] array1 = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int[] array2 = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
int[] array3 = {1, 3, 4, 2, 0, 11, 1, 15, 7, 6, 5, 13, 18, 20, 12};
int[] array4 = {1, 3, 4, 2, 30, 11, 1, 15, 6, 5, 13, 18, 20, 12};
mergeSort(array1, 0, array1.length-1);
mergeSort(array2, 0, array2.length-1);
mergeSort(array3, 0, array3.length-1);
mergeSort(array4, 0, array4.length-1);
// quickSort(array1, 0, array1.length-1);
// quickSort(array2, 0, array2.length-1);
// quickSort(array3, 0, array3.length-1);
// quickSort(array4, 0, array4.length-1);
// buddleSort(array1);
// buddleSort(array2);
// buddleSort(array3);
// buddleSort(array4);
print(array1);
print(array2);
print(array3);
print(array4);
}

public static void print(int[] inputs){
System.out.println(Arrays.toString(inputs));
}
//直接插入排序
public static void insertSort(int[] inputs){
int size = inputs.length;
for(int i=1; i<size; i++){
int temp = inputs[i];
int j=i-1;
for(; j>=0&&(inputs[j]>temp); j--){
inputs[j+1] = inputs[j];
}
inputs[j+1] = temp;
}
}
//希尔排序
public static void shellSort(int[] inputs){
int size = inputs.length;
int d=1;
while(d < size){
d = 3*d+1;
}
d = (d-1)/3;
while(d > 0){
for(int i=d; i<size; i++){
int temp = inputs[i];
int j = i-d;
for(; j>=0&&(inputs[j]>temp); j-=d){
inputs[j+d] = inputs[j];
}
inputs[j+d] = temp;
}
d = (d-1)/3;
}

}
//直接选择排序
public static void selectSort(int[] inputs){
int size = inputs.length;
for(int i=0; i<size; i++){
int temp = inputs[i];
int min = temp;
int minIndex = i;
for(int j=i+1; j<size; j++){
if(min > inputs[j]){
min = inputs[j];
minIndex = j;
}
}
if(minIndex != i){
inputs[i] = inputs[minIndex];
inputs[minIndex] = temp;
}
}
}
//堆排序
public static void heapSort(int[] inputs){
int size = inputs.length;
for(int i=size; i>0; i--){
heapSortBuildHeap(inputs, i);
heapSortSwap(inputs, i-1);
}

}

private static void heapSortBuildHeap(int[] inputs, int end){
int size = end;
int start = size/2 - 1;
for(int i=start; i>=0; i--){
if(2*i+2<size){
if(inputs[2*i+1] > inputs[2*i+2]){
if(inputs[2*i+1] > inputs[i]){
int temp = inputs[2*i+1];
inputs[2*i+1] = inputs[i];
inputs[i] = temp;
}
}else{
if(inputs[2*i+2] > inputs[i]){
int temp = inputs[2*i+2];
inputs[2*i+2] = inputs[i];
inputs[i] = temp;
}
}
}else{
if(inputs[2*i+1] > inputs[i]){
int temp = inputs[2*i+1];
inputs[2*i+1] = inputs[i];
inputs[i] = temp;
}
}
}
}
private static void heapSortSwap(int[] inputs, int end){
int temp = inputs[end];
inputs[end] = inputs[0];
inputs[0] = temp;
}
//冒泡排序
public static void buddleSort(int[] inputs){
int size = inputs.length;
for(int i=0; i<size; i++){
for(int j=1; j<size-i; j++){
if(inputs[j] < inputs[j-1]){
int temp = inputs[j];
inputs[j] = inputs[j-1];
inputs[j-1] = temp;
}
}
}
}
//快速排序
public static void quickSort(int[] inputs, int left, int right){
if(left >= right)
return;
int base = inputs[left];
int baseIndex = left;
int end = right;
while(left < right){
while(right>left && inputs[right]>=base){
right--;
}
inputs[left] = inputs[right];
while(left<right && inputs[left]<=base){
left++;
}
inputs[right] = inputs[left];
}
inputs[right] = base;
quickSort(inputs, baseIndex, right-1);
quickSort(inputs, right+1, end);
}
//归并排序
public static void mergeSort(int[] inputs, int low, int high){
if(low >= high){
return;
}
int mid = (low+high)/2;
mergeSort(inputs, low, mid);
mergeSort(inputs, mid+1, high);
merge(inputs, low, mid, high);
}

private static void merge(int[] inputs, int low, int mid, int high){
int[] temp = new int[high-low+1];
int i = low;
int j = mid + 1;
int k = 0;
while(i<=mid && j<=high){
if(inputs[i] <= inputs[j]){
temp[k] = inputs[i];
i++;
}else{
temp[k] = inputs[j];
j++;
}
k++;
}
while(i <= mid){
temp[k] = inputs[i];
k++;
i++;
}
while(j <= high){
temp[k] = inputs[j];
k++;
j++;
}
for(int m=0; m<temp.length; m++){
inputs[low+m] = temp[m];
}
}
}