常见的几种排序算法

直接插入法排序

每趟从无序序列中取出第一个数插入到有序序列的合适位置,元素的最终位置在最后一趟插入后才能确定位置。也可先用循环查找插入位置,从前往后或从后往前,再将插入位置之后的元素,有序列中逐个后移一个位置,最后完成插入。该算法的特点是在寻找插入位置的同时完成元素的移动。因为元素的移动必须从后往前,则可将两个操作结合在一起完成，提高算法效率。仍可进行升序或降序排序。

int[] arr = new int[]{54,5,95,68,22,6,0,99,85,68};
		
		int length = arr.length;	//计算数组的长度

		for(int i = 1; i < length;i++)
		{				
				
				if(arr[i]<arr[i-1])		//如果索引的值小于前一个索引的值		
				{
				
					int temp = arr[i];		//定义一个临时变量存储当前索引的值。
				
					int j;

					for(j =i-1;j>=0&&temp<arr[j];j--)	//循环遍历当前索引之前的所有值，并进行比较是否对应索引的值是否小于当前索引的值。
					{
						arr[j+1]= arr[j];
					}							
					
					arr[j+1]=temp;			//因为上面的循环，这个时候其实已经j--，所以j+1索引才是我们的目标位置		
					
				}			
		}

		for(int i = 0;i<length;i++)		//循环遍历数组
		{
			System.out.print(arr[i]+",");
		}

希尔排序

先取一个小于n的整数d1作为第一个增量，把文件的全部记录分组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量 =1( < …<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。
该方法实质上是一种分组插入方法

int[] arr = new int[]{54,5,95,68,22,6,0,99,85,68};
		int length = arr.length;
		int Incremental = length/3+1;	//增量，用数组的长度除以三加一
		
		for(int i=Incremental;i>=1;i=i/3+1)		//外层增量循环
		{
			for(int j = 0;j<length-i;j++)		//内层循环
			{
				if(arr[j]>arr[j+i])				//如果索引值大于增量索引值
				{
					int temp = arr[j+i];
					int k;
					for(k=j+i;k>j;k--)
					{
						arr[k] = arr[k-1];		//索引值后移
					}
					
					arr[k] = temp;
				}				
			}
			
			if(i==1)
			{
				break;
			}
		}
		
		for(int i = 0;i<length;i++)		//循环遍历数组
		{
			System.out.print(arr[i]+",");；
		}

冒泡法排序

比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

int[] arr = new int[]{54,5,95,68,22,6,0,99,85,68};
		int length = arr.length;
		
		for(int i = 0;i < length;i++)		//循环n（数组长度）-1 次
		{
			for(int j =0;j < length-i-1;j++)
			{
				if(arr[j]>arr[j+1])
				{
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
		
		
		for(int i = 0;i<length;i++)		//循环遍历数组
		{
			System.out.print(arr[i]+",");
		}

快速排序

设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，然后将所有比它小的数都放到它左边，所有比它大的数都放到它右边，这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。
一趟快速排序的算法是：
1）设置两个变量i、j，排序开始的时候：i=0，j=N-1；
2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]；
3）从j开始向前搜索，即由后开始向前搜索(j–)，找到第一个小于key的值A[j]，将A[j]和A[i]的值交换；
4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]的值交换；
5）重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。

int[] arr = new int[]{54,5,95,68,22,6,0,99,85,68};	//定义数组
		int length = arr.length;	//数组长度
		
		Sort(arr,0,length-1);		//执行快速排序
		
		for(int i = 0;i<length;i++)		//循环遍历数组
		{
			System.out.print(arr[i]+",");
		}

static void Sort(int[] arr,int low,int heigh)
	{
		int temp = arr[low];	//将数组第一个索引值作为基数，用于后续对比
		
		while(low<heigh)
		{		
			while(low<heigh&&temp<=arr[heigh])		//从高位索引值开始比较，如果小于基数值，则移到左边。
			{
				heigh--;
			}			
			if(low<heigh)
			{
				arr[low] =arr[heigh];
			}
			
			while(low<heigh&&temp>arr[low])			//从低位索引值开始比较，如果大于基数值，则移到右边。
			{
				low++;
			}			
			if(low<heigh)
			{
				arr[heigh]=arr[low];
			}
		}
		
		arr[low] = temp;		//移动基数值到最终目标位置（左边所有值小于基数，右边所有值大于基数）。
		
		//将数组切割为两部分，小于基数值和大于基数值。进行递归
		if(low<heigh)
		Sort(arr,0,low-1);
		if(heigh<(arr.length-1))
		Sort(arr,heigh+1,arr.length-1);
	}

以上。
如有不合理的地方或更好的建议，请不吝赐教，谢谢！