一些常用的排序算法（JAVA版）

稍微尝试写了一下一些排序算法，仅供参考：

//插入排序
<span style="white-space:pre">	</span>public static void insectionSortSmalltoLarge(double[] arr)
	{
		for(int i=1;i<arr.length;i++)
		{
			int k=i;
			for(int j=i-1;j>=0;j--)
			{
				if(arr[k]<arr[j])
				{
					double a=arr[k];
					arr[k]=arr[j];
					arr[j]=a;
					k--;
				}
				else
					break;
			}
		}
	}
	public static void insectionSortLargetoSmall(double[] arr)
	{
		for(int i=1;i<arr.length;i++)
		{
			int k=i;
			for(int j=i-1;j>=0;j--)
			{
				if(arr[k]>arr[j])
				{
					double a=arr[k];
					arr[k]=arr[j];
					arr[j]=a;
					k--;
				}
				else
					break;
			}
		}
	}

//希尔排序
public static void ShellSortSmalltoLarge(double[] arr)
	{
		int h=(int) Math.floor(arr.length/2);
		while(h!=0)
		{
			for(int j=0;j<=h;j++)
				for(int i=j;i+h<arr.length;i=i+h)
				{
					if(arr[i]<arr[i+h])
						continue;
					else
					{
						double a=arr[i];
						arr[i]=arr[i+h];
						arr[i+h]=a;
					}
				}
			h=(int)Math.floor(h/2);
		}
	}
	public static void ShellSortLargetoSmall(double[] arr)
	{
		int h=(int) Math.floor(arr.length/2);
		while(h!=0)
		{
			for(int j=0;j<=h;j++)
				for(int i=j;i+h<arr.length;i=i+h)
				{
					if(arr[i]>arr[i+h])
						continue;
					else
					{
						double a=arr[i];
						arr[i]=arr[i+h];
						arr[i+h]=a;
					}
				}
			h=(int)Math.floor(h/2);
		}
	}

<pre name="code" class="java">//堆排序
<span style="white-space:pre">	</span>public static void heapSortLargetoSmall(double[] arr)
	{
		double[] heap=new double[arr.length+1];
		heap[1]=arr[0];
		for(int i=1;i<arr.length;i++)
		{
			heap[i+1]=arr[i];
			HeapAdjust(heap,i+1);
		}
		
		for(int len=arr.length;len>1;len--)
		{
			double a=heap[1];
			heap[1]=heap[len];
			heap[len]=a;
			subHeapSort(heap,1, len-1);
		}
		for(int i=0;i<arr.length;i++)
			arr[i]=heap[i+1];
	}
	public static void heapSortSmalltoLarge(double[] arr)
	{
		double[] heap=new double[arr.length+1];
		heap[1]=arr[0];
		for(int i=1;i<arr.length;i++)
		{
			heap[i+1]=arr[i];
			HeapAdjust(heap,i+1);
		}
		
		for(int len=arr.length;len>1;len--)
		{
			double a=heap[1];
			heap[1]=heap[len];
			heap[len]=a;
			subHeapSort(heap,1, len-1);
		}
		for(int i=0;i<arr.length;i++)
			arr[i]=heap[arr.length-i];
	}
	private static void subHeapSort(double[] arr, int index,int len)//用于出堆调整，每次删除顶端节点，将最后一个元素放于顶部，自顶部向下调整
	{
		int leftson=index*2,rightson=leftson+1;
		if(leftson>len)
			return;
		else if(rightson>len)
		{
			if(arr[leftson]<arr[index])
			{
				double a=arr[leftson];
				arr[leftson]=arr[index];
				arr[index]=a;
			}
			else
				return;
		}
		else 
		{
			if(arr[leftson]>=arr[index]&&arr[rightson]>=arr[index])
				return;
			else
			{
				if(arr[leftson]<arr[rightson])
				{
					double a=arr[index];
					arr[index]=arr[leftson];
					arr[leftson]=a;
					subHeapSort(arr,leftson, len);
				}
				else
				{
					double a=arr[index];
					arr[index]=arr[rightson];
					arr[rightson]=a;
					subHeapSort(arr,rightson, len);
				}
			}
		}
		
	}
	private static void HeapAdjust(double[] arr, int index) //用于自下而上的堆调整，每次加入一个点，就从这个点开始向上调整
	{
		int motherindex=index/2;
		if(arr[motherindex]<=arr[index])
			return;
		else
		{
			double a=arr[motherindex];
			arr[motherindex]=arr[index];
			arr[index]=a;
			HeapAdjust(arr,motherindex);
		}
	}

//归并排序
public static void mergeSort(double[] arr)
	{
		double[] tmp=new double[arr.length];
		mergeSort(arr,tmp,0,arr.length-1);
	}
	private static void mergeSort(double[] arr,double[] tmp,int left,int right)
	{
		if(left<right)
		{
			int center=(left+right)/2;
			mergeSort(arr, tmp, left, center);
			mergeSort(arr, tmp, center+1, right);
			subMerge(arr, tmp, left, center+1, right);
		}
	}
	private static void subMerge(double[] a,double[] tmp,int leftPos,int rightPos,int rightEnd)
	{
		int leftEnd=rightPos-1;//左边数组的终点
		int tmpPos=leftPos;//缓存数组起点
		int numElemnt=rightEnd-leftPos+1;//数组长度
		//Main Loop
		//比较直到一个数组比较到终点
		while(leftPos<=leftEnd&&rightPos<=rightEnd)
			if(a[leftPos]<=a[rightPos])
				tmp[tmpPos++]=a[leftPos++];
			else
				tmp[tmpPos++]=a[rightPos++];
		//将未比较完的数据直接存放到tmp里面
		while(leftPos<=leftEnd)
			tmp[tmpPos++]=a[leftPos++];
		while(rightPos<=rightEnd)
			tmp[tmpPos++]=a[rightPos++];
		//缓存数组复制返回a数组
		for(int i=0;i<numElemnt;i++,rightEnd--)
			a[rightEnd]=tmp[rightEnd];
	}

代码仅仅通过较少数量的调试，不保证绝对正确性，如果有什么bug希望你们能告知~