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

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

/**
* 冒泡排序
* 算法：每一趟从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;
}
}
}
}

/**
* 选择排序
* 算法：每一趟从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;
}
}

/**
* 插入排序
* 算法:从小标为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;
}
}

/**
* 归并排序
* 算法：将数组从中间分成两块，对左边递归，右边递归，借助辅助数组归并
* @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++;
}
}

/**
* 希尔排序
* 算法：设置增量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;
}
}

/**
* 快速排序
* 算法:
* @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);
}