Several pure hand-code sorting algorithm

Quick Sort
import java.util.Arrays;

public class Test{
public static void main(String[] args)throws Exception {
int[] nums = {9,8,7,4,5,6,3,2,1,0};
quickSort(nums, 0, nums.length-1);
System.out.println(Arrays.toString(nums));

}
public static void quickSort(int[]nums,int low,int high) {
	int i = low ,j = high;
	if(low>high) {
		return;
	}
	
	int temp = nums[low];
	while(i<j) {
		while(i<j&&temp<=nums[j]) {
			j--;
		}
		while(i<j&&temp>=nums[i]) {
			i++;
		}
		
		if(i<j) {
			int a = nums[j];
			nums[j] = nums[i];
			nums[i] = a;
		}
		
	}
	nums[low] = nums[i];
	nums[i]  = temp;
	quickSort(nums, low, i-1);
	quickSort(nums, i+1, high);
	
	
}

}

Merge sort

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;

public class Test{
public static void main(String[] args) throws Exception{
InputStreamReader is = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(is);
String[] arr = br.readLine().split(" ");
int[] nums = new int[arr.length];
for(int i =0;i<arr.length;i++) {
nums[i]=Integer.parseInt(arr[i]);
}
System.out.println(Arrays.toString(nums));
mergeSort(nums, 0, nums.length-1);
for(int i:nums) {
System.out.print(i+ " ");
}
}
}
public static void mergeSort(int[]nums,int low,int high) {
if(low<high) {
int mid = (low+high)/2;
mergeSort(nums,low,mid);
mergeSort(nums,mid+1,high);
mergeSort(nums,low,mid,high);
}
public static void mergeSort(int[]nums ,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(nums[i]<nums[j]) {
temp[k++]=nums[i++];
}else {
temp[k++]=nums[j++];
}
}
while(i<=mid) {
temp[k++] = nums[i++];
}
while(j<=high) {
temp[k++] = nums[j++];
}
for(int a=0;a<temp.length;a++) {
nums[a+low] = temp[a];
}
}
}

Hill sorting
import java.util.Arrays;

public class Test{
public static void main(String[] args) {
int[]arr= {9,8,7,4,5,6,3,2,1,0};
shellSort(arr);
System.out.println(Arrays.toString(arr));
}
public static void shellSort(int[]arr) {
int len = arr.length;
while(len!=0) {
len=len/2;
for(int i =0;i<len;i++) {
for(int j =i+len;j<arr.length;j+=len) {
int k =j-len;
int temp=arr[j];
for(;k>=0&&arr[k]>temp;k-=len) {
arr[k+len]=arr[k];
}
arr[k+len]=temp;
}
}
}
}
}

Bubble Sort
import java.util.Arrays;

public class Test{
public static void main(String[] args) {
int[]arr= {9,8,7,4,5,6,3,2,1,0};
bubbleSort(arr);
System.out.println(Arrays.toString(arr));
}
public static void bubbleSort(int[]arr) {
boolean flag=true;
for(int i=0;i<arr.length&&flag;i++) {
flag=false;
for(int j=i+1;j<arr.length;j++) {
if(arr[j]<arr[i]) {
int a=arr[i];
arr[i]=arr[j];
arr[j]=a;
flag=true;
}
}
}
}
}

Direct insertion sort
import java.util.Arrays;

public class Test{
public static void main(String[] args) {
int[]arr = {9,8,7,4,5,6,3,2,1,0};
insertSort(arr);
System.out.println(Arrays.toString(arr));
}
public static void insertSort(int[]arr) {
for(int i=1;i<arr.length;i++) {
int num = arr[i];
int j=i-1;
for(;j>=0&&arr[j]>num;j–) {
arr[j+1]=arr[j];
}
arr[j+1]=num;
}
}
}

选择排序
import java.util.Arrays;
public class Test{
public static void main(String[] args) {
int[]arr= {9,8,7,4,5,6,3,2,1,0};
selectSort(arr);
System.out.println(Arrays.toString(arr));
}
public static void selectSort(int[]arr) {
for(int i=0;i<arr.length;i++) {
int position = i;
for(int j=i+1;j<arr.length;j++) {
if(arr[j]<arr[i]) {
position = j;
}
}
int temp = arr[position];
arr[position] = arr[i];
arr[i] = temp;

	}
}

}

Heapsort
import java.util.Arrays;

public class Test{
public static void main(String[] args) {
int[]arr = {9,8,7,4,5,6,3,2,1,0};
heapSort(arr);
System.out.println(Arrays.toString(arr));

}
public static void heapSort(int[]arr) {
	int len = arr.length;
	for(int i =0;i<len-1;i++) {
		buildMaxHeap(arr,len-1-i);
		swap(arr,0,len-1-i);
	}
}
public static void swap(int[]arr,int i ,int j) {
	int temp = arr[i];
	arr[i] = arr[j];
	arr[j] = temp;
}
public static void buildMaxHeap(int[]arr,int lastIndex) {
	for(int i =(lastIndex-1)/2;i>=0;i--) {
		int k =i;
		while(k*2+1<=lastIndex) {
			int biggerIndex = 2*k+1;
			if(biggerIndex<lastIndex) {
				if(arr[biggerIndex]<arr[biggerIndex+1]) {
					biggerIndex++;
				}
			}
			if(arr[k]<arr[biggerIndex]) {
				swap(arr,k,biggerIndex);
				k=biggerIndex;
			}else {
				break;
			}
		}
	}
}

}