程序员必须掌握的六种基本排序算法

说起排序，可能很多程序员多会想起冒泡和选择，这两种是最基本的排序，也最容易实现，但是当我们需要对海量数据进行排序时，这几种算法是否依然适合呢？没错，他们的时间复杂度是最不起眼的，那么我们应该如何来提高效率呢？这里整理了六种排序算法，时间的优越性能由低到高！

1.冒泡排序

/**
	 * 冒泡排序
	 * 算法：每一趟从0到j 相邻的数进行比较
	 * @param array要排序的数组
	 */
	public static void bubbleSort(int array[],int length)
	{
		int i=0,j=length-1;
		for(;j>0;j--)
		{
			for(i=0;i<j;i++)
			{
				if(array[i]>array[i+1])
				{
					int temp=array[i];
					array[i]=array[i+1];
					array[i+1]=temp;
				}
			}
		}
	}

2.选择排序

/**
	 * 选择排序
	 * 算法：每一趟从i开始，找出最小的数放在i
	 * @param array 要排序的数组
	 * @param length 从0到length要排序的长度
	 */
	public static void selectSort(int array[],int length)
	{
		int i=0,j=0,min=0;
		for(;i<length-1;i++)
		{
			for(min=i,j=i+1;j<length;j++)
				if(array[min]>array[j])
					min=j;
			
				int temp=array[i];
				array[i]=array[min];
				array[min]=temp;
		}
	}

3.插入排序

/**
	 * 插入排序
	 * 算法:从小标为1的数开始，假设前面的数已经排好序，将要排序的数插入其中
	 * @param array 要排序的数组
	 * @param length 从0到length要排序的长度
	 */
	public static void insertSort(int array[],int length)
	{
		int i=1,temp=0;
		for(;i<length;i++)
		{
			temp=array[i];
			while(i>0 && temp<array[i-1])
			{
				array[i]=array[i-1];
				--i; 
			}
			array[i]=temp;
		}
	}

4.归并排序

/**
	 * 归并排序
	 * 算法：将数组从中间分成两块，对左边递归，右边递归，借助辅助数组归并
	 * @param array 要排序的数组
	 * @param tempArray 临时辅助数组
	 * @param low 排序的初始位置
	 * @param high 排序的结尾位置
	 */
	public static void mergeSort(int array[],int tempArray[],int low ,int high)
	{
		if(low>=high)
			return;
		int mid=(low+high)/2;
		mergeSort(array,tempArray,low,mid);
		mergeSort(array,tempArray,mid+1,high);
		
		int leftP=low,rightP=mid+1,i=0,j=low;
		while(leftP<mid+1 && rightP<high+1)
		{
			tempArray[i++]=array[leftP]>array[rightP]?array[rightP++]:array[leftP++];
		}
		while(leftP<mid+1)
		{
			tempArray[i++]=array[leftP++];
		}
		while(rightP<high+1)
		{
			tempArray[i++]=array[rightP++];
		}
		
		while(j<=high)
		{
			array[j]=tempArray[j-low];
			j++;
		}
	}

5.希尔排序

/**
	 * 希尔排序
	 * 算法：设置增量h，将间隔为h的元素排好序，直到将间隔为1的元素排好序为止
	 * @param array 要排序的数组
	 * @param length 从0到length要排序的长度
	 */
	public static void shellSort(int array[],int length)
	{
		int h=1;
		int i=0,j=0,temp=0;
		while(h<=length/3)
		{
			h=h*3-1;
		}
		while(h>0)
		{
			for(i=h;i<length;i++)
			{
				j=i;
				temp=array[j];
				while(j>h-1 && array[j-h]>array[j])
				{
					array[j]=array[j-h];
					j-=h;
				}
				array[j]=temp;
			}
			h=(h+1)/3;
		}
	}

6.快速排序

/**
	 * 快速排序
	 * 算法:
	 * @param array 要排序的数组
	 * @param length 从0到length要排序的长度
	 * @param left 数组初始端
	 * @param right 数组末端
	 */
	public static void quickSort(int array[],int left,int right)
	{
		if(left>=right)
			return;
		int leftP=left,rightP=right,pivot=array[right],temp=0;
		
		while(true)
		{
			while(array[leftP]<=pivot && leftP<right)
			{
				leftP++;
			}
			while(array[rightP]>pivot && rightP>left)
			{
				rightP--;
			}
			if(leftP<rightP)
			{
				temp=array[leftP];
				array[leftP]=array[rightP];
				array[rightP]=temp;
			}
			else break;
		}
		quickSort(array,left,leftP-1);
		quickSort(array,leftP,right);
	}