- 冒泡排序
//外层循环从后往前len-1->0，内层循环从前往后0->i-1
public static void bubbleSort(int[] arr)
{
int len=arr.length;
for (int i=len-1;i>=0 ;i-- )
{
for (int j=0;j<=i-1 ;j++ )
{
if (arr[j]>arr[j+1])
{
arr[j]=arr[j+1]+(arr[j+1]=arr[j])*0;
}
}
}
}
public static void bubbleSortBetter(int[] arr)
{
int len=arr.length;
boolean flag=true;
for (int i=len-1;i>=0&&flag ;i-- )
{
flag=false;
for (int j=0;j<=i-1 ;j++ )
{
if (arr[j]>arr[j+1])
{
flag=true;
arr[j]=arr[j+1]+(arr[j+1]=arr[j])*0;
}
}
}
}
- 选择排序
//外层循环从后往前0->len-2，内层循环从前往后i+1->len-1
public static void selectSort(int[] arr)
{
int len=arr.length;
for (int i=0;i
- 插入排序和希尔排序
//插入排序
//外层循环从前往后0->len-1，内层循环从后往前i-1->0
public static void insertSort(int[] arr)
{
int len=arr.length;
for (int i=0;i0&&temp0 ;gap/=2 )
{
for (int i=0;i=gap&&arr[k-gap]>temp)
{
arr[k]=arr[k-gap];
k-=gap;
}
arr[k]=temp;
}
}
}
}
- 归并排序
public static void mergeSort(int[] arr)
{
if (arr==null||arr.length==0)
{
return;
}
int[] temp=new int[arr.length];
mergeSortHelper(arr,temp,0,arr.length-1);
}
//归并排序
//先分开再合并
//主要是merge()这一步
public static void mergeSortHelper(int[] arr,int[] temp,int left,int right)
{
if (right>left)
{
int mid=(left+right)/2;
mergeSortHelper(arr,temp,left,mid);
mergeSortHelper(arr,temp,mid+1,right);
merge(arr,temp,left,mid+1,right);
}
}
public static void merge(int[] arr,int[] temp,int left,int mid,int right)
{
int size=right-left+1;
int leftEnd=mid-1;
int tempPos=left;
while (left<=leftEnd&&mid<=right)
{
if (arr[left]<=arr[mid])
{
temp[tempPos++]=arr[left++];
}
else
{
temp[tempPos++]=arr[mid++];
}
}
while (left<=leftEnd)
{
temp[tempPos++]=arr[left++];
}
while (mid<=right)
{
temp[tempPos++]=arr[mid++];
}
for (int i=0;i
- 快速排序
快排的空间复杂度和时间复杂度分析：http://book.51cto.com/art/201108/287089.htm
public static void quickSort(int[] arr)
{
int len=arr.length;
quickSortHelper(arr,0,len-1);
}
//快速排序
//先找到pivot，再快排剩下的部分
//重要的是找的pivot
public static void quickSortHelper(int[] arr,int low,int high)
{
if (high>low)
{
int pivot=partition(arr,low,high);
quickSortHelper(arr,low,pivot-1);
quickSortHelper(arr,pivot+1,high);
}
}
public static int partition(int[] arr,int low,int high)
{
int pivot=arr[low];
int left=low;
int right=high;
while (leftpivot)
{
right--;
}
if (left
- 计数排序
//helper[i]的key是input[i]，value记录的是有几个数比input[i]小，也就是output[]中的index
public static void countSort(int[] input)
{
int size=findMax(input);
int[] output=new int[input.length];
int[] helper=new int[size+1];
for (int i=0;i=0 ;i-- )
{
output[helper[input[i]]-1]=input[i];
helper[input[i]]--;
}
for (int i=0;i
- 桶排序
//桶排序
//buckets[i]中的key记录的是arr[i]，value是arr[i]的个数
public static void bucketSort(int[] arr)
{
int size=findMax(arr);
int[] buckets=new int[size+1];
for (int i=0;i0 ;j-- )
{
arr[index++]=i;
}
}
}
- 堆排序
贴上一个链接：http://jingyan.baidu.com/article/5225f26b057d5de6fa0908f3.html
//堆化，向下渗透
public static void heapify(int[] arr,int index,int size)
{
int left=2*index+1;
int right=2*index+2;
int best=index;
while (leftarr[index])
{
best=left;
}
if (rightarr[best])
{
best=right;
}
if (best!=index)
{
swap(arr,best,index);
}
else
break;
//调整之后，可能会违反堆的性质
//因此需要循环的过程
index=best;
left=2*index+1;
right=2*index+2;
}
}
public static void buildHeap(int[] arr,int size)
{
//size为堆的大小
//size/2-1为第一个非叶节点的索引
//从最后一个非叶节点开始，建立这个堆
for (int i=size/2-1;i>=0 ;i-- )
{
heapify(arr,i,size);
}
}
public static void heapSort(int[] arr)
{
int size=arr.length;
//建立一个大顶堆
buildHeap(arr,size);
for (int i=size-1;i>=0 ;i-- )
{
//讲大顶堆堆顶的值放在最后
swap(arr,0,i);
//堆化
heapify(arr,0,--size);
}
}
- 常见排序算法及对应的时间复杂度和空间复杂度：http://blog.csdn.net/gane_cheng/article/details/52652705
